------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------
###08.01_集合框架(对象数组的概述和使用)
首先我们定义一个数组，将数组中的元素全部存为对象
* 案例演示
* 需求：我有5个学生，请把这个5个学生的信息存储到数组中，并遍历数组，获取得到每一个学生信息。
<span style="font-size:14px;"> Student[] arr = new Student[5]; //存储学生对象
arr[0] = new Student("张三", 23);
arr[1] = new Student("李四", 24);
arr[2] = new Student("王五", 25);
arr[3] = new Student("赵六", 26);
arr[4] = new Student("马哥", 20);
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
</span>
从以上代码中我们可以看到Student对象都被加入到一个数组arr中，但是我们如果要想再增加一个Student对象的话，arr数组中是不能实现的，因为数组的长度是固定的，那么我们应该如何实现这个功能呢？集合正好可以完成我们的这个需求。
###08.02_集合框架(集合的概述)
*A;集合的概述：
在java中，有多个容器， 比如有 数组， 字符串缓冲区， 还有我们要学习的集合， 其实集合它就是个容器，用来存储多个数据的
* B:集合的原理：
* 数组和集合存储引用数据类型,存的都是地址值
###08.03_集合框架(集合的由来及集合继承体系)
* A:集合的由来
* 数组长度是固定,当需要增加和减少元素时需要对数组重新定义,太麻烦,java内部给我们提供了集合类,能存储任意对象,长度是可以改变的,随着元素的增加而增加,随着元素的减少而减少
* B:数组和集合的区别
* 区别1 :
* 数组既可以存储基本数据类型,又可以存储引用数据类型
* 集合只能存储引用数据类型(对象)
* 区别2:
* 数组长度是固定的,不能自动增长
* 集合的长度的是可变的,可以根据元素的增加而增长
* 数组和集合什么时候用
* 1,如果元素个数是固定的推荐用数组
* 2,如果元素个数不是固定的推荐用集合
###08.04_集合框架(Collection集合的基本功能测试)
* A:集合的基本方法：
添加功能:
* boolean add(Object e) 向当前集合中添加给定的元素对象
* boolean addAll(Collection c) 向当前集合中添加给定的集合元素
删除功能：
void clear() 把当前集合中的元素清空
boolean remove(Object o) 把当前集合中，给定的元素对象删除
boolean removeAll(Collection c) 在当前集合中， 将给定的集合元素 删除
判断功能：
boolean contains(Object o) 判断当前集合中，是否包含给定的元素对象
boolean containsAll(Collection c) 判断当前集合中，是否包含给定的集合中的元素对象
boolean isEmpty() 判断当前集合是否为空的集合
遍历功能：
Iterator iterator() 迭代器, 作用就是用来遍历集合的， 得到集合中的每一个元素
交集功能：
boolean retainAll(Collection c) 获取当前集合与给定集合中 交集的元素对象
长度功能：
int size() 获取集合中元素的个数
转换功能：
Object[] toArray() 把当前集合中的元素， 转存到 数组中
我们用代码实现以下：
<span style="font-size:14px;"> //创建集合对象
Collection c = new ArrayList();
//向当前集合中添加给定的元素对象
c.add("Hello");
c.add("World");
//把当前集合中的元素清空
//c.clear();
//把当前集合中，给定的元素对象删除
//boolean flag = c.remove("Hello");
//boolean flag = c.remove("Java");
//判断当前集合中，是否包含给定的元素对象
//boolean flag = c.contains("Java");;
// 判断当前集合是否为空的集合
//boolean flag = c.isEmpty();
//System.out.println(flag);
//int size() 获取集合中元素的个数
//int length = c.size();
//System.out.println(length);
//把当前集合中的元素， 转存到 数组中
Object[] objs = c.toArray();
for (int i = 0; i<objs.length; i++) {
System.out.println(objs[i]);
}
//显示
System.out.println(c);</span>
* B:注意:
* collectionXxx.java使用了未经检查或不安全的操作.
注意:要了解详细信息,请使用 -Xlint:unchecked重新编译.
java编译器认为该程序存在安全隐患
温馨提示:这不是编译失败,所以先不用理会,等学了泛型你就知道了
###08.05_集合框架(集合的遍历之集合转数组遍历)
* A:集合的遍历
* 其实就是依次获取集合中的每一个元素。
* B:案例演示
* 把集合转成数组，可以实现集合的遍历
<span style="font-size:14px;"> *
Collection coll = new ArrayList();
coll.add(new Student("张三",23)); //相当于Object obj = new Student("张三",23);
coll.add(new Student("李四",24));
coll.add(new Student("王五",25));
coll.add(new Student("赵六",26));
Object[] arr = coll.toArray(); //将集合转换成数组
for (int i = 0; i < arr.length; i++) {
Student s = (Student)arr[i]; //强转成Student
System.out.println(s.getName() + "," + s.getAge());
}
</span>
###.08.06_集合框架(Collection集合的高级功能测试)
* A:案例演示
boolean addAll(Collection c) 向当前集合中添加给定的集合元素
* boolean removeAll(Collection c) 在当前集合中， 将给定的集合元素 删除
* 返回值 true, 在当前集合中 删除了 参数集合的部分元素
* 返回值false, 在当前集合中 没有删除 参数集合中元素
* 当前集合中的元素会发生改变
* 参数集合中元素不改变
*
boolean containsAll(Collection c) 判断当前集合中，是否包含给定的集合中的元素对象
* 返回值true, 在当前集合中 包含 参数集合中的所有元素
* 返回值false, 在当前集合中 不包含 参数集合中的所有元素
* 当前集合中的元素不改变
* 参数集合中元素不改变
*
boolean retainAll(Collection c) 获取当前集合与给定集合中 交集的元素对象
* 返回值true， 说明当前集合中的元素，发生了改变
* 返回值false, 说明当前集合中的元素，没有改变
* 当前集合中的元素会发生改变， （存储的是交集的元素对象）
* 参数集合中元素不改变
案例：
<span style="font-size:14px;"> //创建当前集合
Collection c1 = new ArrayList();
c1.add("hello1");
//创建参数的集合
Collection c2 = new ArrayList();
c2.add("hello2");
// 向当前集合中添加给定的集合元素
boolean flag = c1.addAll(c2);
//在当前集合中， 将给定的集合元素 删除
boolean flag = c1.removeAll(c2);
// 判断当前集合中，是否包含给定的集合中的元素对象
boolean flag = c1.containsAll(c2);
//System.out.println(flag);
//获取当前集合与给定集合中 交集的元素对象
boolean flag = c1.retainAll(c2);
System.out.println(flag);
//显示
System.out.println("c1:" + c1);
System.out.println("c2:" + c2);
</span>
###08.07_集合框架(集合的遍历之迭代器遍历)
* A:迭代器概述
* 集合是用来存储元素,存储的元素需要查看,那么就需要迭代(遍历)
* B:案例演示
* 迭代器的使用：遍历功能：
Iterator iterator() 迭代器,
作用就是用来遍历集合的， 得到集合中的每一个元素
Iterator接口:
boolean hasNext() 判断当前集合对象中，是否还有下一个元素，可以获取
Object next() 获取集合中的下一个元素
如：
<span style="font-size:14px;"> //创建集合
Collection c = new ArrayList();
//添加元素到集合
c.add("java");
c.add("爪哇");
c.add("吉娃");
//遍历
Iterator it = c.iterator();//多态 ,返回的是一个现实了该Iterator接口的对象
//判断当前集合对象中，是否还有下一个元素，可以获取
while (it.hasNext()) {
//获取集合中的下一个元素
Object obj = it.next();
System.out.println(obj);
}</span>
<span style="font-size:14px;"></span>
###08.08_集合框架(Collection存储自定义对象并遍历)
* A:案例演示
* Collection存储自定义对象并用迭代器遍历
<span style="font-size:14px;"> // 创建集合对象
Collection c = new ArrayList();
// 创建 自定义元素对象
Person p1 = new Person("小明",20);
Person p2 = new Person("小华",21);
Person p3 = new Person("小张",22);
// 添加元素对象 到集合
c.add(p1);
c.add(p2);
c.add(p3);
// 遍历集合
//a: 把集合转换成数组
Object[] objs = c.toArray();
//b: 遍历数组
for (int i =0; i<objs.length; i++){
//c: 打印输出元素
//System.out.println(objs[i]);
//Object obj = objs[i];
//System.out.println(obj);
//强制转换
Person p = (Person)objs[i];
System.out.println(p.getName() +"--"+ p.getAge());
}</span>
###08.09_集合框架(迭代器的原理及源码解析)
* A:迭代器原理
* 迭代器原理:迭代器是对集合进行遍历,而每一个集合内部的存储结构都是不同的,所以每一个集合存和取都是不一样,那么就需要在每一个类中定义hasNext()和next()方法,这样做是可以的,但是会让整个集合体系过于臃肿,迭代器是将这样的方法向上抽取出接口,然后在每个类的内部,定义自己迭代方式,这样做的好处有二,第一规定了整个集合体系的遍历方式都是hasNext()和next()方法,第二,代码有底层内部实现,使用者不用管怎么实现的,会用即可
* B:迭代器源码解析
* 1,在eclipse中ctrl + shift + t找到ArrayList类
* 2,ctrl+o查找iterator()方法
* 3,查看返回值类型是new Itr(),说明Itr这个类实现Iterator接口
* 4,查找Itr这个内部类,发现重写了Iterator中的所有抽象方法
对于迭代器的原理我们可要通过下面的图例来表示：
###08.10_集合框架(List集合的特有功能概述和测试)
* A:List集合的特有功能概述
void add(int index, Object element) 在当前集合中的指定位置上，添加给定的元素对象
* Object get(int index) 获取当前集合中指定位置上的元素对象
* int indexOf(Object o) 获取指定对象 在当前集合中第一次出现的位置
* int lastIndexOf(Object o) 获取指定对象 在当前集合中最后一次出现的位置
* Object remove(int index) 删除当前集合中指定位置上的元素对象, 返回被删除的元素对象
* Object set(int index, Object element) 在当前集合中，为给定位置上的元素，赋值, 返回值是原有的元素对象
* List<E> subList(int fromIndex, int toIndex) 截取子集合， 包左不包含右
* ListIterator<E> listIterator() List集合特有的迭代器
功能演示：
<span style="font-size:14px;">//创建集合对象
List list = new ArrayList();
list.add(10);//Integer
//在当前集合中的指定位置上，添加给定的元素对象
list.add(1, 15);
// 获取当前集合中指定位置上的元素对象
System.out.println( list.get(2) );
// 获取指定对象 在当前集合中第一次出现的位置
System.out.println(list.indexOf(20) );
//获取指定对象 在当前集合中最后一次出现的位置
System.out.println(list.lastIndexOf(20));
//删除当前集合中指定位置上的元素对象, 返回被删除的元素对象
System.out.println( list.remove(1));
//在当前集合中，为给定位置上的元素，赋值
System.out.println(list.set(0, 30));
//截取子集合， 包左不包含右
//List result = list.subList(1, 3);
List result = list.subList(1, list.size());</span>
###08.11_集合框架(List集合的特有遍历功能)
* A:案例演示
* 通过size()和get()方法结合使用遍历。
<span style="font-size:14px;"> List list = new ArrayList();
//添加元素
list.add("李斯特");
list.add("利斯塔");
//遍历List集合的方式
//方式1 toArray()
//方式2 iterator() 迭代器方式
//方式3 listIterator() 列表迭代器方式
ListIterator lit = list.listIterator();
while (lit.hasNext()) {
Object obj = lit.next();
System.out.println(obj);
}
System.out.println("------------");
//反着迭代
//判断是否有上一个元素
while (lit.hasPrevious()) {
//获取上一个元素对象
Object obj = lit.previous();
System.out.println(obj);
}</span>
以上代码中我们可以看到ArrayList集合中有一个新的迭代方法hasPrevious，但是它的使用必须有一个前提，那就是该集合必须先使用hasNext遍历之后再使用hasPrevious，因为它的实现原理是从集合的最后一位开始往前面遍历，如果没有hasNext提前遍历的话，它的指针将为空，无法实现遍历
###08.12_集合框架(List集合存储学生对象并遍历)
* A:案例演示
* List集合存储学生对象并遍历。
* 通过size()和get()方法结合使用遍历。
<span style="font-size:14px;"> List list = new ArrayList();
list.add(new Student("马哥", 18));
list.add(new Student("马粉1", 18));
list.add(new Student("马粉2", 18));
list.add(new Student("马粉3", 18));
list.add(new Student("马粉4", 18));
for(int i = 0; i < list.size(); i++) {
Student s = (Student)list.get(i);
System.out.println(s.getName() + "," + s.getAge());
}
</span>
这里并没有定义学生对象，需要我们自己去定义一个，这里只将Student对象添加到集合中的代码体现了出来
###08.13_集合框架(并发修改异常产生的原因及解决方案)
首先我们先看一个例子：
* 需求：我有一个集合，请问，我想判断里面有没有"world"这个元素，如果有，我就添加一个"java"对象，请用代码实现：
<span style="font-size:14px;"> List list = new ArrayList();
list.add("a");
list.add("b");
list.add("world");
list.add("d");
list.add("e");
/*Iterator it = list.iterator();
while(it.hasNext()) {
String str = (String)it.next();
if(str.equals("world")) {
list.add("javaee"); //这里会抛出ConcurrentModificationException并发修改异常
}
}*/
</span>
从以上代码中我们可以知道，在集合的遍历过程中，集合的元素是不能发生更改的，这个时候会产生一个ConcurrentModficationException异常，也就是并发修改异常
* B:ConcurrentModificationException出现
* 迭代器遍历，集合修改集合
* C:解决方案
* a:迭代器迭代元素，迭代器修改元素(ListIterator的特有功能add)
* b:集合遍历元素，集合修改元素
如果想在遍历的过程中添加元素,可以用ListIterator中的add方法如：
<span style="font-size:14px;"> ListIterator lit = list.listIterator(); //如果想在遍历的过程中添加元素,可以用ListIterator中的add方法
while(lit.hasNext()) {
String str = (String)lit.next();
if(str.equals("world")) {
lit.add("javaee");
}
}
</span>
###08.14_集合框架(ListIterator)
List集合特有的迭代器：ListIterator
* boolean hasNext()是否有下一个
* boolean hasPrevious()是否有前一个
* Object next()返回下一个元素
* Object previous();返回上一个元素
以上功能我们在上面代码中都有所体现，大家都可以看一下上面代码
###08.15_集合框架(Vector的特有功能)
* A:Vector类概述
* B:Vector类特有功能
* public void addElement(E obj)
* public E elementAt(int index)
* public Enumeration elements()
* C:案例演示
<span style="font-size:14px;"> * Vector的迭代
Vector v = new Vector(); //创建集合对象,List的子类
v.addElement("a");
v.addElement("b");
v.addElement("c");
v.addElement("d");
//Vector迭代
Enumeration en = v.elements(); //获取枚举
while(en.hasMoreElements()) { //判断集合中是否有元素
System.out.println(en.nextElement());//获取集合中的元素
}
</span>
Vector 类可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。但是，Vector 的大小可以根据需要增大或缩小，以适应创建Vector 后进行添加或移除项的操作。
###08.16_集合框架(数据结构之数组和链表)
* A:数组
* 查询快修改也快
* 增删慢
* B:链表
* 查询慢,修改也慢
* 增删快
数组的链表的原理，我们通过图例表示一下：
###08.17_集合框架(List的三个子类的特点)
* A:List的三个子类的特点
*
ArrayList:
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高。
Vector:
底层数据结构是数组，查询快，增删慢。
线程安全，效率低。
Vector相对ArrayList查询慢(线程安全的)
Vector相对LinkedList增删慢(数组结构)
LinkedList:
底层数据结构是链表，查询慢，增删快。
线程不安全，效率高。
Vector和ArrayList的区别
Vector是线程安全的,效率低
ArrayList是线程不安全的,效率高
ArrayList和LinkedList的区别
ArrayList底层是数组结果,查询和修改快
LinkedList底层是链表结构的,增和删比较快,查询和修改比较慢
* B:List有三个子类，我们到底使用谁呢?
查询多用ArrayList
增删多用LinkedList
如果都多ArrayList
