a.
对象数组 --自定义对象类
概述
* 创建一个自定义类用于存储学生信息,并且获取到每个学生信息 。
使用
Student[] s = new Student[5]; //创建student类,用于存储数组对象。
s[0] = new Student("hah", 2); //第一个Student数组的元素,且每个地址值有所不同
s[1] = new Student("fas", 4); // 数组中存储的元素记录的都是地址值,通过每个地址值找到一个个的new的元素对象。
s[2] = new Student("fasd",34);
s[3] = new Student("we", 43);
s[4] = new Student("ad", 23);
for (int i = 0; i < s.length; i++) {
System.out.println(s[i]);
}
注意
* 数组和集合存储 引用数据类型 的时候,存储都是地址值,且每个地址值都有所不同,通过地址值来查找每个元素对象。
* 自定义对象数组中 存储的元素记录的其实都是地址值,即每个元素对象的地址值。 通过每个索引地址值找到每个 new的元素对象。
b.
集合
--由来
* 前提:数组和集合都是容器。
* 因为数组的长度是固定的,当添加的元素超过数组的长度需要对数组进行重新定义,这样太麻烦。 所以Java在jdk1.2的时候为我们提供了集合类。集合:用于存储任意对象,而且长度可以改变,是随着元素的增加而增加,随着元素的减少而减少的,即随着元素个数的变化而变化。
--概述
* 数组和集合都是容器。
* 集合于jdk1.2时被提出,长度可改变,是随着元素个数的变化而变化。
数组和集合区别
* 可以从两方面来说:A存储的类型 和 B存储的长度:
* 区别:
区别1:
* 数组既可以存储基本数据类型,也可存储引用数据类型。基本数据类型存储的是值,而引用数据类型存储的是地址值。
* 集合只能存储引用数据类型(对象)集合也可以存储基本数据类型,但存储的时候会自动装箱变成对象,即int类型的100,存储到集合中就变成了new Integer(100)。
区别2:
* 数组的长度是固定的,不可自动增加。
* 集合的长度是可变的,是根据元素个数的变化而变化。
--数组和集合什么时候使用
* 如果元素个数固定,就用数组。
* 如果元素个数未知,不是固定,就用集合。 --部分集合底层代码还是用数组来实现的,如果超出了数组的范围,就创建一个 大于前者的1.5倍长度的数组。增长后,将原数组变成垃圾,以此类推。
--集合继承体系关系图
-Collection --单列集合根接口
* List -存取有序,和数组相同。有索引,可存储重复元素。
* ArrayList 底层 数组实现。
* LinkedList 底层 链表实现。
* Vector(jdk1.0) 底层 数组实现。 --已被ArrayList替代。 之所以和集合命名规则不同,是集合体系是jdk1.2时候被提出,而jdk1.0的时候已经有了Vector,因为Vector中的功能和集合一样,所以让Vector也实现了List接口并且并入到了集合体系中。
* Set -存取无序,无索引,不可存储重复元素。
* HashSet 底层 Hash算法。 元素无序。
* LinkedHashSet 底层 链表结构,是set集合中唯一一个怎么存怎么取的集合,又因为是HashSet的子类,所以同样保证了元素的唯一性。
* TreeSet 底层 二叉树算法。 元素可以进行排序。
-Map --双列集合根接口
* HashMap 底层 哈希算法。 保证键的唯一性。
* TreeMap 底层 二叉树。 键可以排序。
c.
Collection
--概述
* Collection是所有 单列集合 的根类接口。
* Map是所有 双列集合 的根接口。
* 集合是jdk1.2的时候提出。
* 集合的命名都有一定的规范:底层是怎么实现的,前者单词就是什么,后者是哪个继承体系下的。后者单词就是什么。
如:
ArrayList 底层数组实现,属于List集合下。
LinkedList 底层链表实现,所以List集合下。
--体系结构图:
Collection(单列集合根接口)
* List(有序,有索引,可重复元素)
* ArrayList 数组实现。存取有序,和数组一样。有索引,可存储重复元素。
* LinkedList 链表实现。
* Vector(jdk1.0) 数组实现。之所以和集合命名规则不同,是因为在jdk1.0时候出现,而集合体系是jdk1.2时候出现,已被ArrayList替代。
* Set (无序,无索引,不可重复元素)
* HastSet 哈希算法。
* TreeSet 二叉树算法。
注意:List是一个不可插队的插入对象。
d.
Collection集合的基本功能
概述
* util包下,用时需导包。
* Collection 是接口,用时只能:父类引用指向子类对象,即: Collection c = new ArrayList();
* Collection 单列集合 中的根接口。
* Collection 表示一组对象,这些对象也称为 collection 的元素。一些 collection 允许有重复的元素(list),而另一些则不允许(set)。一些collection 是有序的(list),而另一些则是无序的(set)。
* JDK不提供此接口的任何直接 实现:它提供更具体的子接口(如 Set 和 List)实现。
常用方法
* boolean add(Object obj); 添加对象 可添加任意对象。
* 结果Boolean永远都是true。那什么时候是false? 只有当set集合存储重复元素的时候,返回false。
* 所以一般我们不用返回值类型,自己将对象添加到集合中即可。即:c.add("sfa");
*
* boolean remove(Object obj); 删除对象 可删除任意对象。可以是基本数据类型,到时候会自动装箱成对象。
* void clear(); 清空集合元素
* boolean contains(Object o); 判断是否包含指定元素
* boolean isEmpty(); 判断集合是否为空,为空就返回true,否则为false。
* int size(); 获取集合中的元素个数
注意:1)add如果是List集合,就一直返回true,因为list集合中是可以存储重复元素的。
如果是set集合用add存储重复元素,就会返回false。
2)ArrayList的父类的父类重写了toString方法,所以在打印对象的引用时输出的结果不是Object的 toString 的结果,而是集合特有的:[元素]的形式。
collectionXxx.java使用了未经检查或不安全的操作.
注意:要了解详细信息,请使用 -Xlint:unchecked重新编译.
java编译器认为该程序存在安全隐患
温馨提示:这不是编译失败,所以先不用理会,等 学了泛型你就知道了
toArray() 集合的遍历之集合转数组遍历的功能
集合遍历
* 就是依次获取集合中的每个元素。
* 集合转数组,就可以实现对集合的遍历。
* Object[] toArray(); 集合转数组的方式就可以遍历集合中的每个元素。
代码
//自定义 Bean对象 的遍历方式。
Collection c2 = new ArrayList(); //创建单列集合对象。
c2.add(new Student("哈哈",23)); //等同于 Object o = new Student("哈哈",23);
c2.add(new Student("嘻嘻",25));
c2.add(new Student("么么",332));
c2.add(new Student("啦啦",645));
Object[] array2 = c2.toArray();
for (int i = 0; i < array2.length; i++) {
System.out.println(array2[i]); //获取集合中所有的元素对象。
// 如果想获取每个元素对象中的Name 或 age,就要向下转型,即Object转成Student对象。现在的array2[i] 就是Ojbect对象。
// (看左边的类型,如果左边是Object对象 就是向上转型,如果左边是Student对象,就是向下转型)
Student st =(Student)array2[i]; //向下转型。将Object的array2转成Student。
System.out.println("姓名:"+st.getName()+" 年龄:"+st.getAge());
}
Collection集合中方法带有All后缀的功能
* boolean addAll(Collection c); 添加集合。
* 如:
* c1集合有对象:abcd c2集合有对象:ef
* c1.addAll(c2); 将c2集合中的每个对象添加c1中,结果为:[a,b,c,d,e,f]
* c1.add(c2); 将c2看做是一个整个对象添加到c1中,结果为:[a,b,c,d,[e,f]]
* boolean removeAll(Collection c); 删除集合或删除集合的元素,删除的是两个集合的交集为true,如果删除的是两个集合没有的交集,就是false。
* boolean containsAll(Collection c); 是否一个集合包含另一个集合的所有元素。如果全包含就为true,否之为false。
* boolean retainAll(Collection c); 取出两个集合之间的交集。
* 注意:如果调用的集合改变就返回true, 如果调用的集合没有改变就返回false。
如:
1) c1集合有:abcd c2集合有 ab c1.retainAll(c2); 取交集c1结果为:ab,c1改变了,所以返回true。
2) c1集合有:abcd c2集合有 z c1.retainAll(c2); 取交集c1结果为:[], 但c1还是改变,所以也返回true。
3) c1集合有:abcd c2集合有 abcdefg c1.retainAll(c2); 取交集c1结果为:abcd,c1没有改变,所以为false。
这就是retainAll的特殊之处,主要是 前者跟后者比较,前者的结果是否改变,如果改变就是true,如果没变就是false。
Collection集合的Iterator迭代器的遍历方式
概述
* 集合用于存储元素,存储的元素如果需要查看,就要使用迭代器的方式。
使用
* 使用 Iterator 的方式来迭代。
* 关键方法:
* hasNext(); 判断是否还有下一个元素,如果有就返回true。
* next(); 返回迭代的下一个元素,即将集合中的元素取出。
* next具有将指针向下移一位的功能。
Collection存储自定义对象并遍历
Collection c = new ArrayList(); // 创建集合对象。父类引用指向子类对象
c.add(new Student("赵白石",43)); //等等于: Object obj = new Student("赵白石",43); 即父类引用指向子类对象,obj不能使用子类特有的属性和行为,即使用只能靠向下转型的方式才能够子类特有的属性和行为。
c.add(new Student("沈星移",33));
c.add(new Student("周莹",40));
c.add(new Student("吴聘",42));
// 方式一:while来做
/* Iterator it = c.iterator();
while(it.hasNext()){
Student st = (Student)it.next(); //向下强转。 将it.next的Iterator的对象向下强转成Student对象。只有向下转型,才能使用子类特有的属性和行为。
String name = st.getName();
int age = st.getAge();
System.out.println("姓名:"+name+".....年龄:"+age);
}*/
//【注意:向下转型,才能使用子类特有的属性和行为】
// 方式二:for循环来做
for (Iterator it = c.iterator(); it.hasNext();) {
Student s = (Student)it.next(); //向下强转。将it.next的Iterator的对象向下强转成Student对象。这样就能获取子类特有的属性和行为。
System.out.println(s.getName()+"..."+s.getAge());
}
}
--迭代器的原理及源码解析
原理
迭代器是对集合进行遍历的,而每个集合内部的存储结构都是不同,所以每个集合的存和取的方式也都不同的。那么就需要在每一个类中都去定义hasNext()方法 和 next()方法,这样做可以方便的判断是否有下一个元素和返回集合中的当前元素。但是这样整个集合体系看起来就会过于臃肿。所以就将迭代器向上抽取出一个接口,然后在每个类的内部去定义自己的迭代方式。 这样做的好处有二:
第一:规定了整个集合体系的遍历方式通过通过hasNext()和next()方法来实现的。第二:代码由底层内部实现,使用者无需关心怎么实现的,会用即可。
迭代器的原理:
迭代器是用来遍历集合。因为集合的底层数据结构不同,就导致集合存取元素的方式不同,如果每个集合类都定义自己的存取方式,这样做是可以的,但是会让整个继承体系很冗余,臃肿。所以我们经过不断的向上抽取,最终定义成了接口。
这样做的好处有两个:
A:更规范。
B:我们不用管底层是怎么实现,只要会用就可以了。
迭代器源码解析
* 1,在eclipse中ctrl + shift + t找到ArrayList类
* 2,ctrl+o查找iterator()方法
* 3,查看返回值类型是new Itr(),说明Itr这个类实现Iterator接口
* 4,查找Itr这个内部类,发现重写了Iterator中的所有抽象方法
Iterator iterator(); 该对象必须依赖具体的集合容器,因为每个集合容器的内部数据结构不同,所以该迭代器对象是在集合容器中进行内部实现的,也就是说iterator()方法在每个集合容器中的实现方式时不同的。
对于调用者来说,具体的实现过程无需知道,只要通过该集合容器获取到该实现的迭代器对象即可,也就是iterator方法。
Iterator接口就是对所有单列集合根接口Collection容器进行元素取出的公共接口。
e.
List集合
概述
* List是一个接口,在util包下,使用的话,只能父类引用指向子类对象,如下:
* List i = new ArrayList(); 但这样做存在弊端,不能使用子类特有的属性和方法。
* 建议:ArrayList al = new ArrayList(); // 这样写。直接new对象即可直接使用子类属性和方法。
* 因为多态当 [参数] 用是比较合适。因为可以更好的扩展代码功能。
* 有序集合,有索引,可存储重复元素。
* ArrayList底层 数组实现。
方法
* void add(int index, E element); 在集合的指定索引位置上添加E对象。E表示泛型表示任意对象。
* 注意:
* 当添加时使用不存在的索引,就会出现:IndexOutOfBoundsException 角标越界异常。
* 添加的索引是: index<=size 并且index>=0 在这个范围内 就都不会出错报异常。
* E remove(int index); 通过集合的索引删除元素,将被删除的元素返回。
* * remove的过程不会将索引自动装箱成对象。
* E get(int index); 获取集合指定索引上的元素对象。
* get(int index)方法可作为for循环变量集合的其中一个条件,配合size()方法便可遍历出具体集合元素对象。
* E set(int index, E element); 设置集合索引上的元素。
* int indexOf(Object o); 返回此列表中第一次出现指定元素的索引位置,如果没有就返回-1
* List subList(int fromIndex. int toIndex); 返回列表中从指定位置开始到指定位置结束之间的部分视图。含头不含尾的。
List集合的遍历
概述
* 通过get() 和 size()方法结合使用遍历。
* 代码
List list = new ArrayList(); //创建集合对象。
list.add(new Student("aa",33)); //添加Student元素对象,等于 Ojbect o = new Student("aa",33)
list.add(new Student("bb",23));
list.add(new Student("cc",13));
//遍历集合,使用size()和get()方法去遍历。
for(int i=0;i
Object obj = list.get(i); //获取每个集合元素对象。
sop(obj);
//如果想获取具体Student对象的name和age属性,就要向下强转对象,再获取。因为父类不能使用子类特有的属性和行为。
Student st = (Student)obj; //向下强转对象。
sop(st.getName()+"..."+st.getAge());
}
List集合 --并发修改异常产生的原因及解决方案
* 需求
* 我有一个集合,请问,我想判断里面有没有"world"这个元素,如果有,我就添加一个"javaee"元素,请写代码实现。
* 问题出现
* 如果使用Iterator普通迭代器 来遍历集合且同时添加元素对象时,就会出现 并发修改异常,即ConCurrentModificationException。
* 当使用Iterator普通迭代器 来作为遍历的方式时,一边遍历元素对象并且一边添加元素对象,就会出现这样的异常。
* 解决方案
* 使用List集合特有的一种迭代方式:ListIterator。
* ListIterator迭代器可以 一边遍历集合,一边使用ListIterator迭代器可以特有的add方法添加元素(不是ArrayList的add方法),这样才不会有 并发修改异常 的出现。
List集合中特有的迭代器 ListIterator 的了解:
* boolean hasNext(); 正向顺序判断是否还有下一个元素。
* boolean hasPrevious(); 逆向顺序判断是否还有前一个元素。
* Object next(); 正向顺序返回下一个元素。
* next()获取元素并将指针向后移动一次。
* Object previous(); 逆向顺序返回上一个元素。
* previous()获取元素并将指针向前移动一次
注意:必须先有正向遍历,才可以逆向遍历。
Vector(1.0)
概述
* 有序集合,在util包下,是一个类。
* 在jdk1.2出现后的集合体系将Vector并入里面,且用 ArrayList代替这个集合了。
* 底层 数组实现。
* 同样具有 Iterator 迭代器,但该迭代器不是自己的,而是从父类接口List继承下来的。
* 他有自己遍历集合的方式:Enumeration
特有功能
* void addElement(E obj); 在没有并入集合系统时,使用的是这个方法添加元素,当并入以后就是用 add() 去添加元素。
* E elementAt(int index); 在没有并入集合系统时,使用的是这个方法添加元素,当并入以后就是用 nextElement() 去添加元素。
* Enumeration elements(); 获取枚举 等同于 Iterator迭代器。
【遍历集合的几种方式】
list
* 使用 toArray() 集合转数组的方式 + 普通for循环。
* 使用 List中的 size() 和 get(int index) 的方式for循环获取集合元素。
* 使用 Iterator迭代器, 直接遍历集合获取元素,如果普通迭代器 一边遍历集合元素,一边添加元素,这样会一定出现:并发修改异常:ConcurrentModificationException。
* 使用 List集合中特有的:ListIterator迭代器,一边遍历集合元素,一边使用ListIterato特有的add()方法添加(修改)元素的方式,这样就不会出现 并发修改异常。
vector
* Iterator迭代器
* Vector vec = new Vector(); Enumeration ele = vec.elements(); 获取枚举的方式。
f.
数组结构之数组和链表 2017/10/5 0:24:53
概述
* 底层:数组 --ArrayList,Vector
* 查询快,修改快,但增删慢。(这些都是相对而言的)
* 底层:链表 --LinkedList
* 查询慢,修改慢,但增删快。
解析:
--集合中的 底层:数组结构 是怎样的一个流程??
* 因为部分集合底层结构是由 数组 来实现的,所以会在底层创建一个数组为10的初始长度,如果要存储的数据超过了这个数组初始长度时即11个时,会再创建一个比原来大50%的数组长度,将原数组中的数据copy到这个新数组当中,将原数组扔掉...以此类推。 因为数组一旦创建,长度就不能被改变,所以随着存储数据的个数越多,数组的长度不够用,就要创建更多的新数组,这样会导致废弃的旧数组越来越多成为垃圾,而占用内存空间。
* 底层结构:数组
* 什么是数组?就是一个容器,里面规定了初始容量是多少的一个器皿。比如初始容量就是一个可以存储10个元素的容器,这就是数组,数组一旦创建就不可被修改。
* 查询快,修改快。是因为数组有索引,根据索引可以方便的 查找 和 修改 对应的数据。
* 增删慢。因为都要对索引对应的数据进行操作,所以慢,如下:。
* 增加慢,如:在索引2的位置上添加一个元素E,就要将索引2包含2的元素整体往后移动一位。将索引2的元素置出,并放入新添加的E元素。
* 删除慢,如:将索引3的元素删除,就是将3+1的索引位置开始往后的元素往前移动一位,移动的最末尾的那个空出来的索引上的元素置为null即可。
--集合中的 底层:链表结构 是怎样的一个流程??
* 底层结构:链表
* 什么是链表? 比如就是一段段自行车的小链条。 他们的链接就是通过 中间链条记录住前面链条的地址值,和再记录住后面链条的地址值,通过这样的形式将链串联起来,就是链表。
* 前提?链表不像数组是一个容器有规矩的索引编号,增和删 索引都要变化。而链表只是通过记录前后地址值来排列索引而记录数据。
* 增加快。所以如果想添加一个元素,可在任意的链条中间添加即可,但增加的同样要记录住它前后的元素的地址值,从而形成一个新的链表。
* 删除快。如果想删除一个元素,直接删除,删除后的其他两个的前后重新拼接一个新的中间链条即可。
* 查询慢:因为要先判断要查找的元素距离开头近还是末尾近,确定后。再通过Next(下一个)还是previous(前一个)的方式查询,这样对比数组直接通过拿索引找元素肯定会慢些。
* 修改慢:因为要先判断要查找的元素距离开头近还是末尾近,确定后。再通过Next(下一个)还是previous(前一个)的方式查询,查到后再修改。这样对比数组直接通过拿索引找到元素并修改它肯定会慢些。
List集合的三个子类的特点
概述
* ArrayList
* 底层数据结构:数组。因为是数组,所以:查询快,修改快。但增删慢。
* 它是 线程不安全 的,不同步。所以操作速度快,效率高。(最后通过StringBuilder来记录元素)
* Vector
* 底层数据结构:数组。因为是数组,所以:CURD都慢。
* 它是 线程安全 的,同步。所以操作速度慢,效率低。
* LinkedList
* 底层数据结构:链表,因为是链表,所以:查询慢,修改慢,但增删快。
* 它是 线程不安全,不同步,所以执行效率高。
Vector要比ArrayList查询慢,因为Vector是线程安全的。
Vector要比LinkedList增删慢,因为Vectory是数组结构的,LinkedList是链表结构的,链表结构增删快,数组增删慢。
Vector和ArrayList的区别
* Vector是 线程安全,所以执行效率低。
* ArrayList是 线程不安全的,所以执行效率高。
* 共同点:底层都是 数组 实现的。
ArrayList和LinkedList的区别
* ArrayList底层是 数组结构,所以查询快,修改快,增删慢。
* LinkedList底层是 链表结构,所以查询慢,修改慢,增删快。
单列集合Collection下的List有三个子类,我们到底使用谁?
* 查改多,用ArrayList
* 增删多,用LinkedList
* 如果都多,就用ArrayList。
【线程安全,意味着有 锁。】
【面试题】
1、集合的继承体系结构?
总:
集合体系有两大部分: 单列集合Collection 双列集合Map
分:
单列结构Collection 下有 List 和 Set
List 有序 有索引,可存储重复元素。
* List下有三个子类
* ArrayList
* 底层结构:数组。查询快,修改快,增删慢。
* 线程不安全的,执行效率高。
* LinkedList
* 底层结构:链表。查询慢,修改慢,增删快。
* 线程不安全的,执行效率高。
* Vector
* 底层结构:数组,查询快,修改快,增删慢。
* 线程安全的,执行效率低。
Set 无序,无索引,不可存储重复元素。
总:
2、数组和集合区别?
数组,既可以存储基本数据类型,也可存储引用数据类型,当存储基本数据类型存储的是值,存储引用数据类型时存储的是地址值。
而集合,只能存储引用数据类型(对象),当集合存储基本数据类型时,会自动装箱封装为对象。(如:int变成Integer对象, char变成Character对象,boolean变Boolean对象)
数组的长度是固定的,一旦初始化不可更改,不可增长。
集合的长度是可变的,可以根据元素的增长而增长,随着元素的减少而减少 --(由元素个数决定)。
3、如何获取字符串、数组、集合的长度?
* 字符串: "".length();
* 数 组: Length属性;
* 集 合: size()方法;
4、遍历集合有哪几种方式?
List
1) 使用 toArray() 将集合转数组的方式 + 普通for循环。
2) 使用 List中size()和get(int index)的方法for循环获取集合元素。
3) 使用 Iterator迭代器,直接遍历集合获取元素。如果使用普通迭代器Iterator 来一边遍历集合元素,一边添加集合元素。一定会出现:并发修改异常。即:ConcurrentModificationException
4) 使用 List中特有的ListIterator 迭代器,就可以一边遍历集合元素,一边使用ListIterator中特有的add方法添加元素,这样就不会有 并发修改异常 的出现。
Vector
1) 使用 Iterator迭代器、
2) Vector vec = new Vector(); Enumeration e = evc.elements(); 获取枚举的方式。
5、什么时候用数组?什么时候用集合?
查改多,用ArrayList
增删多,用LinkedList
如果都多,用ArrayList
6、来说说你对 ArrayList、LinkedList、Vector的理解?