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

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。