大数据之路week01--day02_2 集合方面的总结

1、对象数组（掌握）

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

　　（2）案例：

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

 package day02;

 /**
 * @author WYH
 * @version 2019年11月12日 下午10:28:33
 */
 public class test {
     public static void main(String[] args) {
         Students[] s = new Students[5];

         Students s1 = new Students("xiao",21);
         Students s2 = new Students("da",22);

         s[0] = s1;
         s[1] = s2;

         for(int i = 0;i<s.length;i++) {
             System.out.println(s[i]);
         }

     }

 }

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: 把集合转数组（了解）

 package javaclassset;

 import java.util.ArrayList;
 import java.util.Collection;

 public class CollectionDemo3 {

     public static void main(String[] args) {
         Collection c1 = new ArrayList();

         c1.add("Hello"); //Object obj = "Hello";
         c1.add("world");
         c1.add("java");

         Object[] obj = c1.toArray();

         for(int i = 0;i<obj.length;i++) {
             String s = (String)obj[i];
             System.out.println(s);
         }

     }

 }

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

 package javaclassset;

 import java.util.ArrayList;

 import java.util.Collection;
 import java.util.Iterator;

 public class CollectionDemo3 {

     public static void main(String[] args) {
         Collection c1 = new ArrayList();

         c1.add("Hello"); //Object obj = "Hello";
         c1.add("world");
         c1.add("java");

         //转数组for循环遍历
         Object[] obj = c1.toArray();

         for(int i = 0;i<obj.length;i++) {
             String s = (String)obj[i];
             System.out.println(s);
         }

         //迭代器遍历
         Iterator it = c1.iterator();

         while(it.hasNext()) {
             System.out.println(it.next());
         }
         }

     }

       （6）迭代器

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

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

　　　　C:迭代器得原理和源码

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

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

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

　　　　集合的操作步骤：

　　　　　　A: 创建集合对象

　　　　　　B: 创建元素对象

　　　　　　C: 把元素添加带集合

　　　　　　D: 遍历集合

　　　　A: 存储字符串并遍历

 package com.wyh.Iterator;

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Iterator;

 public class IteratorDemo1 {
     public static void main(String[] args) {
         Collection c = new ArrayList();
         c.add("Hello");
         c.add("World");
         c.add("java");

         Iterator it = c.iterator();

         while(it.hasNext()) {
             System.out.println(it.next());
         }

     }

 }

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

 package javaclassset;

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Iterator;

 import com.wyh.Iterator.Student;

 public class ColletionStudentDemo {

     public static void main(String[] args) {

         Collection c = new ArrayList();

         Student s1 = new Student("王友虎",22);
         Student s2 = new Student("李宏灿",21);
         Student s3 = new Student("赵以浩",23);
         Student s4 = new Student("李先锋",24);
         Student s5 = new Student("齐博源",25);

         c.add(s1);
         c.add(s2);
         c.add(s3);
         c.add(s4);
         c.add(s5);

         //转数组for循环遍历
         Object[] objs = c.toArray();
         for(int i = 0;i<objs.length;i++) {

             Student s = (Student) objs[i];
             System.out.println("姓名："+s.getName()+"  年龄："+s.getAge());
         }

         //迭代器遍历
         Iterator it = c.iterator();
         while(it.hasNext()) {
             Student s = (Student)it.next();
             System.out.println(s.getName()+"-----"+s.getAge());
         }

     }

 }

3、集合（List）(掌握)

　　（1）List是Collection的子接口

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

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

　　　　A: 添加功能

　　　　B: 删除功能

　　　　C: 获取功能

　　　　D: 迭代器功能

　　　　E: 修改功能

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

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

　　　　B: 代码演示

 package com.wyh.Iterator;

 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;

 /**
 * @author WYH
 * @version 2019年11月9日 下午4:39:09
 *
 * List:
 * 有序集合（也称为序列(“存储与取出的顺序一致”) ）。 该界面的用户可以精确控制列表中每个元素的插入位置。 用户可以通过整数索引（列表中的位置）访问元素，并搜索列表中的元素。
 * 与集合不同，列表通常允许重复的元素。
 * 更正式地，列表通常允许元素e1和e2成对使得e1.equals(e2) ，并且如果它们允许空元素，它们通常允许多个空元素。
 * 有人可能希望实现一个禁止重复的列表，当用户尝试插入时会抛出运行时异常，但是我们预计这种使用是罕见的。
 */
 public class ListDemo1 {

         static void show(List list) {
         Iterator it = list.iterator();
         while(it.hasNext()) {
             String s = (String)it.next();
             System.out.println(s);
         }
     }

     public static void main(String[] args) {
         //创建List集合
         List l1 = new ArrayList();

         //创建字符串对象并进行添加
         l1.add("a");
         l1.add("b");

         System.out.println("add(int index, E element):**********************************");

         //add(int index, E element):将指定的元素插入此列表中的指定位置（可选操作）下标从0开始
         l1.add(1,"xiaowang");//没有问题
         //l1.add(11,"li");//IndexOutOfBoundsException 报错，下表越界！
         l1.add(3,"xiaoli");//在集合界后面一个可以添加
         //l1.add(5,"asd"); //IndexOutOfBoundsException 报错，下表越界！
         show(l1);

         System.out.println("获取功能 Object get(int index) :******************************");

         //B:获取功能 get(int index) 返回此列表中指定位置的元素。
         System.out.println("get:"+l1.get(2));
         //IndexOutOfBoundsException 报错，下表越界！
         //System.out.println("get:"+l1.get(11));

         System.out.println(" Object remove(int index)删除该列表中指定位置的元素（可选操作）。****");
         //remove(int index) 删除该列表中指定位置的元素（可选操作）。
         System.out.println("remove:"+l1.remove(1)); //返回移除的元素
         show(l1);
         //System.out.println("remove:"+l1.remove(11)); //IndexOutOfBoundsException 报错，下表越界！

         System.out.println("Object set(int index, E element) 用指定的元素（可选操作）替换此列表中指定位置的元素。 ****");
         System.out.println("set:"+l1.set(1, "xiaowangya")); //返回被修改的元素
         show(l1);
         System.out.println("List集合特有的遍历方式******************");

         //List集合特有的遍历方式
         for(int i = 0;i<l1.size();i++) {
             String s = (String)l1.get(i);
             System.out.println(s);
         }

         //用Iterator迭代器遍历
         show(l1);

     }
 }

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

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

 package com.wyh.Iterator;

 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 import java.util.ListIterator;

 /**
 * @author WYH
 * @version 2019年11月9日 下午7:31:41
 *
 * ListIterator : List集合特有的迭代器
 *
 */
 public class ListIteratorDemo1 {
     public static void main(String[] args) {
         //创建集合
         List i = new ArrayList();

         //创建字符串对象并将其添加到集合中
         i.add("王友虎");
         i.add("李宏灿");
         i.add("赵以浩");
         i.add("齐博源");
         i.add("李先锋");

         //ListIterator 继承了 Iterator,所以可以用它的实现
         Iterator it = i.iterator();
         while(it.hasNext()) {
             String s = (String)it.next();
             System.out.println(s);
         }
         System.out.println("----------------------");

         // previous()逆向打印
         ListIterator list = i.listIterator();
         /*//如果逆向打印处于第一个位置，输出为空
          * System.out.println("------------逆向打印------------------");
         while(list.hasPrevious()) {
             String s3 = (String)list.previous();
             System.out.println(s3);
         }*/
         while(list.hasNext()) {
             String s2 = (String)list.next();
             System.out.println(s2);
         }
         System.out.println("------------逆向打印------------------");
         while(list.hasPrevious()) {
             String s3 = (String)list.previous();
             System.out.println(s3);
         }

     }

 }

　　（5）并发修改异常

　　　　A: 出现的异常

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

　　　　B: 原因

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

　　　　C: 解决方案

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

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

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

　　　　　　　　元素添加在集合的末尾

　　　　两种方式如下：

 package com.wyh.Iterator;

 import java.util.ArrayList;
 import java.util.List;
 import java.util.ListIterator;

 /**
 * @author WYH
 * @version 2019年11月9日 下午7:51:26
 *
 * 并发修改异常:ConcurrentModificationException
 *
 */
 public class ListIteratorDemo2 {
     public static void main(String[] args) {
         //创建集合对象
         List list = new ArrayList();

         //创建字符串对象并将其添加到集合中去
         list.add("王友虎");
         list.add("李宏灿");
         list.add("赵以浩");
         list.add("齐博源");
         list.add("李先锋");

         /*//创建迭代器（Iterator迭代器）（错误示范-----------------）
         Iterator it = list.iterator();
         //找到元素并进行添加张国兴
         while(it.hasNext()) {
             String s = (String)it.next();
             if("李宏灿".equals(s)) {
                 list.add("123");
             }
         }
         System.out.println("list:"+list);*/

         //方法1:创建ListIterator迭代器，迭代器调用add方法进行添加
         ListIterator listt = list.listIterator();
         while(listt.hasNext()) {
             String s = (String)listt.next();
             if("李宏灿".equals(s)) {
                 listt.add("张国兴"); //在找到的元素后面进行添加
             }
         }
         System.out.println("list:"+list);

         //方法2:利用for循环直接对集合进行遍历，集合中有添加的方法
         for(int i = 0;i<list.size();i++) {
             String s = (String)list.get(i);
             if(s.equals("李宏灿")) {
                 list.add("张果喜"); //在末尾进行添加
             }
         }
         System.out.println("list:"+list);

     }

 }

　　（6）常见数据结构

　　　　A: 栈 先进后出

　　　　B: 队列 先进先出

　　　　C: 数组 查询快，增删慢

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

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

　　　　ArrayList

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

　　　　　　线程不安全，效率高。

　　　　Vector

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

　　　　　　线程安全，效率低。

　　　　LinkedList

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

　　　　　　线程不安全，效率高。

　　　　到底使用谁呢？看需求？

　　　　分析：

　　　　　　要安全吗？

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

　　　　　　　　不要：ArrayLIst或者LinkedList

　　　　　　　　　　查询多：ArrayList

　　　　　　　　　　增删多：LinkedList

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