大数据之路week01--day02_2 初始集合（Collection）

1、对象数组（掌握）

　　（1）数组既可以存储基本数据类型，也可以存储引用类型。它存储引用类型的时候的数组就叫对象数组。

　　（2）案例：

　　　　用数组存储5个学生对象，并遍历数组。(这里添加)

 1 package day02;
 2 
 3 /** 
 4 * @author WYH
 5 * @version 2019年11月12日 下午10:28:33
 6 */
 7 public class test {
 8     public static void main(String[] args) {
 9         Students[] s = new Students[5];
10         
11         Students s1 = new Students("xiao",21);
12         Students s2 = new Students("da",22);
13         
14         s[0] = s1;
15         s[1] = s2;
16         
17         for(int i = 0;i<s.length;i++) {
18             System.out.println(s[i]);
19         }
20         
21         
22     }
23 
24 }

2、集合（Collection）(掌握)

　　（1）集合的由来？

　　　　我们学习的时Java -- 面向对象 --操作很多对象 --存储 -- 容器（数组和StringBuffer）-- 数组而数组得长度固定，所以不适合做变化得需求，Java就提供了集合供我们使用。

　　（2）集合和数组得区别？

　　　　A: 长度区别

　　　　　　数组固定

　　　　　　集合可变

　　　　B: 内容区别

　　　　　　数组可以是基本类型，也可以是引用类型

　　　　　　集合只能是引用类型

　　　　C: 元素内容

　　　　　　数组只能存储同一种类型

　　　　　　集合可以存储不同类型（其实集合一般存储得也是同一种类型）

　　（3）集合的继承体系结构？

　　　　　　由于需求不同，Java就提供了不同得集合类，而这多个集合类得数据结构不同，但是他们都是要提供存储和遍历功能得容器，我们把他们得共性不断向上提取，

最终就形成了集合得继承体系结构。

　　Collection

　　　　|--List

　　　　　　|--ArrayList

　　　　　　|--Vector

　　　　　　|--LinkList

　　　　|--Set

　　　　　　|--HashSet

　　　　　　|--TreeSet

　　(4)Collection得功能概述（自己查询API文档）

　　　　A: 添加功能

　　　　B:删除功能

　　　　C: 判断功能

　　　　D: 获取功能

　　　　E: 长度功能

　　　　F: 交集（了解）

　　　　G: 把集合转数组（了解）

　　（5）Collection集合得遍历

　　　　A: 把集合转数组（了解）

 1 package javaclassset;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Collection;
 5 
 6 public class CollectionDemo3 {
 7 
 8     public static void main(String[] args) {
 9         Collection c1 = new ArrayList();
10         
11         c1.add("Hello"); //Object obj = "Hello"; 
12         c1.add("world");
13         c1.add("java");
14         
15         
16         
17         Object[] obj = c1.toArray();
18         
19         for(int i = 0;i<obj.length;i++) {
20             String s = (String)obj[i];
21             System.out.println(s);
22         }
23 
24     }
25 
26 }

　　　　B: 迭代器（集合专用方式）

 1 package javaclassset;
 2 
 3 import java.util.ArrayList;
 4 
 5 import java.util.Collection;
 6 import java.util.Iterator;
 7 
 8 public class CollectionDemo3 {
 9 
10     public static void main(String[] args) {
11         Collection c1 = new ArrayList();
12         
13         c1.add("Hello"); //Object obj = "Hello"; 
14         c1.add("world");
15         c1.add("java");
16         
17         
18         //转数组for循环遍历
19         Object[] obj = c1.toArray();
20         
21         for(int i = 0;i<obj.length;i++) {
22             String s = (String)obj[i];
23             System.out.println(s);
24         }
25           
26         //迭代器遍历
27         Iterator it = c1.iterator();
28         
29         while(it.hasNext()) {
30             System.out.println(it.next());
31         }
32         }
33 
34     }

（6）迭代器

　　　　A: 是集合得获取元素得方式

　　　　B: 是依赖于集合而存在得

　　　　C:迭代器得原理和源码

　　　　　　a:为什么定义为了一个接口而不是一个实现类（如果是实现类，那么就要提供具体得实现方法，但是我们的集合有很多种，所以是一个接口）

　　　　　　b: 看了看迭代器的内部类实现

　　（7）Collecton集合的案例（遍历方式迭代器）

　　　　集合的操作步骤：

　　　　　　A: 创建集合对象

　　　　　　B: 创建元素对象

　　　　　　C: 把元素添加带集合

　　　　　　D: 遍历集合

　　　　A: 存储字符串并遍历

 1 package com.wyh.Iterator;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Collection;
 5 import java.util.Iterator;
 6 
 7 public class IteratorDemo1 {
 8     public static void main(String[] args) {
 9         Collection c = new ArrayList();
10         c.add("Hello");
11         c.add("World");
12         c.add("java");
13         
14         Iterator it = c.iterator();
15         
16         while(it.hasNext()) {
17             System.out.println(it.next());
18         }
19         
20         
21     }
22 
23 }

　　　　B: 存储自定义对象并遍历（Student类自己写，这个不难）　　

 1 package javaclassset;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Collection;
 5 import java.util.Iterator;
 6 
 7 import com.wyh.Iterator.Student;
 8 
 9 public class ColletionStudentDemo {
10 
11     public static void main(String[] args) {
12         
13         Collection c = new ArrayList();
14         
15         
16         Student s1 = new Student("王友虎",22);
17         Student s2 = new Student("李宏灿",21);
18         Student s3 = new Student("赵以浩",23);
19         Student s4 = new Student("李先锋",24);
20         Student s5 = new Student("齐博源",25);
21         
22         
23         c.add(s1);
24         c.add(s2);
25         c.add(s3);
26         c.add(s4);
27         c.add(s5);
28         
29         //转数组for循环遍历
30         Object[] objs = c.toArray();
31         for(int i = 0;i<objs.length;i++) {
32             
33             Student s = (Student) objs[i];
34             System.out.println("姓名："+s.getName()+"  年龄："+s.getAge());
35         }
36         
37         
38         //迭代器遍历
39         Iterator it = c.iterator();
40         while(it.hasNext()) {
41             Student s = (Student)it.next();
42             System.out.println(s.getName()+"-----"+s.getAge());
43         }
44                 
45     
46         
47         
48 
49     }
50 
51 }

3、集合（List）(掌握)

　　（1）List是Collection的子接口

　　　　特点：有序（存储顺序和取出顺序一致），可重复。

　　（2）List的特有功能：（下面的程序中有，自己拷贝进行实验）

　　　　A: 添加功能

　　　　B: 删除功能

　　　　C: 获取功能

　　　　D: 迭代器功能

　　　　E: 修改功能

　　（3）List集合的特有遍历功能

　　　　A: 由size()和get()结合。

　　　　B: 代码演示

 1 package com.wyh.Iterator;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Iterator;
 5 import java.util.List;
 6 
 7 /** 
 8 * @author WYH
 9 * @version 2019年11月9日 下午4:39:09
10 * 
11 * List:
12 * 有序集合（也称为序列(“存储与取出的顺序一致”) ）。 该界面的用户可以精确控制列表中每个元素的插入位置。 用户可以通过整数索引（列表中的位置）访问元素，并搜索列表中的元素。 
13 * 与集合不同，列表通常允许重复的元素。
14 * 更正式地，列表通常允许元素e1和e2成对使得e1.equals(e2) ，并且如果它们允许空元素，它们通常允许多个空元素。 
15 * 有人可能希望实现一个禁止重复的列表，当用户尝试插入时会抛出运行时异常，但是我们预计这种使用是罕见的。 
16 */
17 public class ListDemo1 {
18     
19         static void show(List list) {
20         Iterator it = list.iterator();
21         while(it.hasNext()) {
22             String s = (String)it.next();
23             System.out.println(s);
24         }
25     }
26     
27     public static void main(String[] args) {
28         //创建List集合
29         List l1 = new ArrayList();
30         
31         //创建字符串对象并进行添加
32         l1.add("a");
33         l1.add("b");
34         
35         System.out.println("add(int index, E element):**********************************");
36         
37         //add(int index, E element):将指定的元素插入此列表中的指定位置（可选操作）下标从0开始
38         l1.add(1,"xiaowang");//没有问题
39         //l1.add(11,"li");//IndexOutOfBoundsException 报错，下表越界！
40         l1.add(3,"xiaoli");//在集合界后面一个可以添加
41         //l1.add(5,"asd"); //IndexOutOfBoundsException 报错，下表越界！
42         show(l1);
43         
44         System.out.println("获取功能 Object get(int index) :******************************");
45         
46         //B:获取功能 get(int index) 返回此列表中指定位置的元素。
47         System.out.println("get:"+l1.get(2));
48         //IndexOutOfBoundsException 报错，下表越界！
49         //System.out.println("get:"+l1.get(11));
50         
51         System.out.println(" Object remove(int index)删除该列表中指定位置的元素（可选操作）。****");
52         //remove(int index) 删除该列表中指定位置的元素（可选操作）。 
53         System.out.println("remove:"+l1.remove(1)); //返回移除的元素
54         show(l1);
55         //System.out.println("remove:"+l1.remove(11)); //IndexOutOfBoundsException 报错，下表越界！
56         
57         System.out.println("Object set(int index, E element) 用指定的元素（可选操作）替换此列表中指定位置的元素。 ****");
58         System.out.println("set:"+l1.set(1, "xiaowangya")); //返回被修改的元素
59         show(l1);
60         System.out.println("List集合特有的遍历方式******************");
61         
62         //List集合特有的遍历方式
63         for(int i = 0;i<l1.size();i++) {
64             String s = (String)l1.get(i);
65             System.out.println(s);
66         }
67         
68         //用Iterator迭代器遍历
69         show(l1);
70 
71         
72     }
73 }

　　（4）列表迭代器的特有功能：（了解）

　　　　可以逆向遍历，但是要先正向遍历，所以毫无意义，基本不会使用。

 1 package com.wyh.Iterator;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Iterator;
 5 import java.util.List;
 6 import java.util.ListIterator;
 7 
 8 /** 
 9 * @author WYH
10 * @version 2019年11月9日 下午7:31:41
11 * 
12 * ListIterator : List集合特有的迭代器
13 * 
14 */
15 public class ListIteratorDemo1 {
16     public static void main(String[] args) {
17         //创建集合
18         List i = new ArrayList();
19         
20         //创建字符串对象并将其添加到集合中
21         i.add("王友虎");
22         i.add("李宏灿");
23         i.add("赵以浩");
24         i.add("齐博源");
25         i.add("李先锋");
26         
27         //ListIterator 继承了 Iterator,所以可以用它的实现
28         Iterator it = i.iterator();
29         while(it.hasNext()) {
30             String s = (String)it.next();
31             System.out.println(s);
32         }
33         System.out.println("----------------------");
34 
35         
36         // previous()逆向打印
37         ListIterator list = i.listIterator();
38         /*//如果逆向打印处于第一个位置，输出为空
39          * System.out.println("------------逆向打印------------------");
40         while(list.hasPrevious()) {
41             String s3 = (String)list.previous();
42             System.out.println(s3);
43         }*/
44         while(list.hasNext()) {
45             String s2 = (String)list.next();
46             System.out.println(s2);
47         }
48         System.out.println("------------逆向打印------------------");
49         while(list.hasPrevious()) {
50             String s3 = (String)list.previous();
51             System.out.println(s3);
52         }
53         
54         
55         
56     }
57 
58 }

　　（5）并发修改异常

　　　　A: 出现的异常

　　　　　　迭代器遍历集合，集合修改集合元素

　　　　B: 原因

　　　　　　迭代器是依赖集合二点，而集合的改变，迭代器并不知道。

　　　　C: 解决方案

　　　　　　a: 迭代器遍历，迭代器修改（ListIterator）

　　　　　　　　元素添加在刚刚迭代器的位置

　　　　　　b: 集合遍历，集合修改（size()和get()）

　　　　　　　　元素添加在集合的末尾

　　　　两种方式如下：

 1 package com.wyh.Iterator;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 import java.util.ListIterator;
 6 
 7 /** 
 8 * @author WYH
 9 * @version 2019年11月9日 下午7:51:26
10 * 
11 * 并发修改异常:ConcurrentModificationException
12 * 
13 */
14 public class ListIteratorDemo2 {
15     public static void main(String[] args) {
16         //创建集合对象
17         List list = new ArrayList();
18         
19         //创建字符串对象并将其添加到集合中去
20         list.add("王友虎");
21         list.add("李宏灿");
22         list.add("赵以浩");
23         list.add("齐博源");
24         list.add("李先锋");
25         
26         /*//创建迭代器（Iterator迭代器）（错误示范-----------------）
27         Iterator it = list.iterator();
28         //找到元素并进行添加张国兴
29         while(it.hasNext()) {
30             String s = (String)it.next();
31             if("李宏灿".equals(s)) {
32                 list.add("123");
33             }
34         }
35         System.out.println("list:"+list);*/
36         
37         //方法1:创建ListIterator迭代器，迭代器调用add方法进行添加
38         ListIterator listt = list.listIterator();
39         while(listt.hasNext()) {
40             String s = (String)listt.next();
41             if("李宏灿".equals(s)) {
42                 listt.add("张国兴"); //在找到的元素后面进行添加
43             }
44         }
45         System.out.println("list:"+list);
46         
47         //方法2:利用for循环直接对集合进行遍历，集合中有添加的方法
48         for(int i = 0;i<list.size();i++) {
49             String s = (String)list.get(i);
50             if(s.equals("李宏灿")) {
51                 list.add("张果喜"); //在末尾进行添加
52             }
53         }
54         System.out.println("list:"+list);
55         
56         
57         
58     }
59 
60 }

　　（6）常见数据结构

　　　　A: 栈先进后出

　　　　B: 队列先进先出

　　　　C: 数组查询快，增删慢

　　　　D: 链表查询吗，慢，增删快

　　（7）List的子类特点（面试题）

　　　　ArrayList

　　　　　　底层数据结构是数组，查询快，增删慢。

　　　　　　线程不安全，效率高。

　　　　Vector

　　　　　　底层数据结构是数组，查询快，增删慢。

　　　　　　线程安全，效率低。

　　　　LinkedList

　　　　　　底层数据结构是链表，查询慢，增删快。

　　　　　　线程不安全，效率高。

　　　　到底使用谁呢？看需求？

　　　　分析：

　　　　　　要安全吗？

　　　　　　　　要：Vector（即使要，也不适用这个，后面再说）

　　　　　　　　不要：ArrayLIst或者LinkedList

　　　　　　　　　　查询多：ArrayList

　　　　　　　　　　增删多：LinkedList

　　　　　　都不知道选啥的时候，选ArrayList。