1 - 概述

        所有的集合类和集合接口都在java.util包下。

        在内存中申请一块空间用来存储数据，在Java中集合就是替换掉定长的数组的一种引用数据类型。

2 - 集合与数组的区别

长度区别

        数组长度固定，定义长了造成内存空间的浪费，定义短了不够用。

        集合大小可以变，用多少空间拿多少空间。

内容区别

        数组可以存储基本数据类型和引用数据类型

        集合中能存储引用数据类型（存储的为对象的内存地址）

       list.add(100);//为自动装箱，100为Integer包装的

元素区别

        数组中只能存储同一种类型成员

        集合中可以存储不同类型数据（一般情况下也只存储同一种类型的数据）

集合结构

        在java中每一个不同的集合，底层会对应不同的数据结构。往不同的集合中
    存储元素，等于将数据放到了不同的数据结构当中。什么是数据结构？数据存储的
    结构就是数据结构。不同的数据结构，数据存储方式不同。

• 单列集合 Collection

  • List可以重复：ArrayList/LinkedList

  • Set不可重复：HashSet/TreeSet

  • 

    ---

    （大量文字插入会导致图片不清，所以在此进行更详细的描述）

  • List特点：此处顺序并不是大小顺序，而是存入数据的先后顺序。有序因为List集合都有下标，下标从0开始，以递增。

  • Set特点：取出顺序不一定为存入顺序，另外Set集合没有下标。

  • ArrayList是非线程安全的。

  • HashSet集合在new的时候，底层实际上new了一个HashMap集合。向HashSet集合中存储元素，实际上是存储到了HashMap的key中了。HashMap集合是一个Hash表数据结构。

  • SortedSet集合存储元素的特点：由于继承了Set集合，所以他的特点也是无序不可重复，但是放在SortedSet集合中的元素可以自动排序。放到该集合中的元素是自动按照大小顺序排序的。

  • TreeSet集合底层实际上是TreeMap。TreeSet集合在new的时候，底层实际上new了一个TreeMap集合。向TreeSet集合中存储元素，实际上是存储到了TreeMap的key中了。TreeMap集合是一个二叉树数据结构。

• 双列集合Map:HashMap/TreeMap

粗体是接口 斜体是实现类

3 - Collection集合

3.1 - 概述

单列集合的顶层接口，既然是接口就不能直接使用，需要通过实现类！~

3.2 - Collection集合的的常用方法

import java.util.ArrayList;import java.util.Collection;public class Collection_01 {    public static void main(String[] args) {        //父类的引用指向子类的对象，形成多态        Collection con = new ArrayList<>();        //追加的方式添加元素        con.add("东邪");        con.add("西毒");        con.add("南帝");        con.add("北丐");        con.add("中神通");        //删除,通过元素名称删除元素        System.out.println(con.remove("西毒"));        //判断集合中是否包含指定参数元素        System.out.println(con.contains("西毒"));  //false        System.out.println(con.contains("东邪"));    //true        //获取集合中元素个数        System.out.println(con.size());        //判断是否为空        System.out.println(con.isEmpty());//false        //清空集合        con.clear();        //判断是否为空        System.out.println(con.isEmpty());//true        System.out.println(con);//打印集合的元素    }}

3.3 - Collection集合的遍历

        以下迭代方式，是所有Collection通用的一种方式。在Map集合中不能使用，在所有的Collection以及子类中使用。

import java.util.ArrayList;import java.util.Collection;import java.util.Iterator;public class Connection_02 {    public static void main(String[] args) {        //多态        Collection con = new ArrayList<>();        //添加元素        con.add("abc");        con.add("def");        con.add("100");        con.add("444");        //Collection集合的遍历方式        //因为没有索引的概念，所以Collection集合不能使用fori进行遍历        //增强版for循环，其实底层使用的也是迭代器，在字节码文件中查看        for (String str : con) {            System.out.print(str + "\t");        }        System.out.println();//换行        //迭代器，集合专属的遍历工具        Iterator it = con.iterator();//创建迭代器对象        while (it.hasNext()){//判断下一个位置是否有元素            System.out.print(it.next() + "\t");//获取到下一个位置的元素        }    }}

3.4 -  Iterator的remove

import java.util.ArrayList;import java.util.Collection;import java.util.Iterator;public class Connection_remove {    public static void main(String[] args) {        // 创建集合        Collection c = new ArrayList();        // 注意：此时获取的迭代器，指向的是那是集合中没有元素状态下的迭代器。        // 一定要注意：集合结构只要发生改变，迭代器必须重新获取。        // 当集合结构发生了改变，迭代器没有重新获取时，调用next()方法时：java.util.ConcurrentModificationException        Iterator it = c.iterator();        // 添加元素        c.add(1); // Integer类型        c.add(2);        c.add(3);        // 获取迭代器        //Iterator it = c.iterator();                Collection c2 = new ArrayList();        c2.add("abc");        c2.add("def");        c2.add("xyz");        Iterator it2 = c2.iterator();        while(it2.hasNext()){            Object o = it2.next();            // 删除元素            // 删除元素之后，集合的结构发生了变化，应该重新去获取迭代器            // 但是，循环下一次的时候并没有重新获取迭代器，所以会出现异常：java.util.ConcurrentModificationException            // 出异常根本原因是：集合中元素删除了，但是没有更新迭代器（迭代器不知道集合变化了）            //c2.remove(o); // 直接通过集合去删除元素，没有通知迭代器。（导致迭代器的快照和原集合状态不同。）            // 使用迭代器来删除可以吗？            // 迭代器去删除时，会自动更新迭代器，并且更新集合（删除集合中的元素）。            it2.remove(); // 删除的一定是迭代器指向的当前元素。            System.out.println(o);        }        System.out.println(c2.size()); //0    }}

4 -List

原型ArrayList

• ArrayList是一个List接口的实现类，底层使用的是一个可以调整大小的数组实现的。

• :是一种特殊的数据类型（引用数据类型） -- 泛型

  • ArrayList 或者 ArrayList 或者 ArrayList

4.1 - ArrayList构造和添加方法

public class ArrayList_01 {    public static void main(String[] args) {        //创建空集合        ArrayList list = new ArrayList<>();//泛型定义为String        //采用默认追加的方式添加元素        System.out.println(list.add("刘德华"));        System.out.println(list.add("张学友"));        System.out.println(list.add("郭富城"));        System.out.println(list.add("黎明"));        //插入的方式添加元素//        list.add(10,"谭咏麟");//插入元素方法索引值不能大于集合中元素个数//        list.add(4,"谭咏麟");//表示在集合中最后位置插入元素，与追加相同        list.add(1,"谭咏麟");//指定位置插入元素，索引位置之后的元素会自动向后进行移动        ArrayList newList = new ArrayList<>();//创建新的集合        newList.add("小沈阳");        newList.add("宋小宝");        newList.add("赵四");        newList.add("刘能");        //查看集合中的元素        System.out.println("原集合内部元素：" + list);        System.out.println("新集合内部元素：" + newList);        list.addAll(newList); //将新集合全部元素添加到原集合中        System.out.println("原集合内部元素：" + list);    }}

4.2 - ArrayList集合常用方法

import java.util.ArrayList;import java.util.Iterator;public class ArrayList_02 {    public static void main(String[] args) {        ArrayList list = new ArrayList<>();        //追加方式添加元素        list.add("东邪");        list.add("西毒");        list.add("南帝");        list.add("北丐");        list.add("中神通");        //删除        System.out.println(list.remove("西毒"));//通过元素名称删除，返回boolean        System.out.println(list.remove(1));//通过索引删除元素，返回被删除元素名        //修改        System.out.println(list.set(1,"西毒"));//指定索引位置修改元素，并返回被修改元素        System.out.println("原集合中元素有：" + list);        //获取方法        System.out.println(list.get(1));//通过指定索引位置获取集合元素        //获取集合元素个数        System.out.println(list.size());        //集合的遍历,普通for循环        for (int i = 0; i < list.size(); i++) {            System.out.print(list.get(i) + "\t");        }        System.out.println();        //增强版for循环        for (String name : list) {            System.out.print(name+ "\t");        }        System.out.println();        //迭代器        Iterator it = list.iterator();//创建迭代器        while (it.hasNext()){//判断下一个位置是否有元素            System.out.print(it.next() + "\t");  //next方法表示获取下一个位置的元素        }        System.out.println();        //Stream流        list.stream().forEach(System.out::println);    }}

4.3 -ArrayList实现原理

底层代码：

        属性：

DEFAULT_CAPACITY = 10 默认长度，初始化容量为10Object[] EMPTY_ELEMENTDATA = {} //有参构造所创建Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {} //无参构造所创建的Object[] elementData;底层为Object类型的数组，存储的元素都在此。int size 实际存放的个数

         构造方法 ：

//一个参数的构造public ArrayList(int initialCapacity) {        if (initialCapacity > 0) {            this.elementData = new Object[initialCapacity];        } else if (initialCapacity == 0) {            this.elementData = EMPTY_ELEMENTDATA;        } else {            throw new IllegalArgumentException("Illegal Capacity: "+                   initialCapacity);        }    }//参数如果大于零，则为创建数组的长度；//参数如果等于零，EMPTY_ELEMENTDATA；//参数如果小于0，抛出异常。//无参构造  public ArrayList() {        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;    }//DEFAULTCAPACITY_EMPTY_ELEMENTDATA  new对象时默认为0 当添加第一个元素的时候，数组扩容至10

        add方法源码：（jdk1.8与之不同，此处为jdk16）

//源码public boolean add(E e) {        modCount++;//操作次数        add(e, elementData, size);//e 操作对象;  elementData 底层操作的数组;size 默认大小0        return true;    }------------------------------------------------ private void add(E e, Object[] elementData, int s) {        if (s == elementData.length)//ture            elementData = grow();        elementData[s] = e;  //存数据        size = s + 1; //最小需要长度    }---------------------------------------------------------- private Object[] grow() {        return grow(size + 1);    }----------------------------------------------------- private Object[] grow(int minCapacity) { //初始传入为size+1  为1        int oldCapacity = elementData.length; //初始为0        if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {       //if条件为初始数组长度>0或者数组不是无参构造构建的            int newCapacity = ArraysSupport.newLength(oldCapacity, //旧数组的长度                    minCapacity - oldCapacity,                       //最小需要长度-旧数组的长度  大于0代表空间不足                    oldCapacity >> 1           );                   //二进制位右移1位  位旧数组长度/2            return elementData = Arrays.copyOf(elementData, newCapacity);            将数据放入新数组中        } else {            return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];            //数组长度  DEFAULT_CAPACITY为10  此处代表无参构造默认长度为10        }    }---------------------------------------------------- public static int newLength(int oldLength, int minGrowth, int prefGrowth) {        // assert oldLength >= 0        // assert minGrowth > 0                  int newLength = Math.max(minGrowth, prefGrowth) + oldLength;         //如果prefGrowth>minGrowth  扩容1.5倍    minGrowth>prefGrowth为需要多少给多少        if (newLength - MAX_ARRAY_LENGTH <= 0) {     //MAX_ARRAY_LENGTH为int最大值   表示新数组长度如果小于int的最大值            return newLength;        }        return hugeLength(oldLength, minGrowth);         //返回int最大值    }

ArrayList集合底层是数组，怎么优化？        尽可能少的扩容。因为数组扩容效率比较低，建议在使用ArrayList集合 的时候预估计元素的个数，给定一个初始化容量。数组优点：    检索效率比较高。（每个元素占用空间大小相同，内存地址是连续的，知道首元素内存地址，    然后知道下标，通过数学表达式计算出元素的内存地址，所以检索效率最高。）数组缺点：    随机增删元素效率比较低。    另外数组无法存储大数据量。（很难找到一块非常巨大的连续的内存空间。）向数组末尾添加元素，效率很高，不受影响。

4.4 -LinkedList实现原理

底层代码

        属性：

    transient int size = 0;//初始长度    transient Node first;//头节点    transient Node last;//尾节点

        add方法源码：（jdk1.8与之不同，此处为jdk16）

public boolean add(E e) {        linkLast(e);        return true;    }--------------------------------------void linkLast(E e) {        final Node l = last; //初始为null        final Node newNode = new Node<>(l, e, null);    //参数1：位上一个节点的内存地址,参数2：e为插入的数据,参数3：下一个节点的内存地址        last = newNode; // 最后节点为新节点        if (l == null)  //如果newNode的前一个节点为null,则将新节点赋给first            first = newNode;        else            l.next = newNode;  //尾节点下一个节点为新节点        size++;//大小        modCount++;//操作数    }

4.5 -LinkedList和ArrayList 

        LinkedList和ArrayList方法一样，只是底层实现不一样。ArrayList底层为数组存储，LinkedList是以双向链表存储。LinkedList集合没有初始化容量。最初这个链表中没有任何元素。first和last引用都是null。

链表的优点：    由于链表上的元素在空间存储上内存地址不连续。    所以随机增删元素的时候不会有大量元素位移，因此随机增删效率较高。    在以后的开发中，如果遇到随机增删集合中元素的业务比较多时，建议    使用LinkedList。链表的缺点：    不能通过数学表达式计算被查找元素的内存地址，每一次查找都是从头    节点开始遍历，直到找到为止。所以LinkedList集合检索/查找的效率    较低。    ArrayList：把检索发挥到极致。（末尾添加元素效率还是很高的。）    LinkedList：把随机增删发挥到极致。    加元素都是往末尾添加，所以ArrayList用的比LinkedList多。

 4.6  -Vector

1、底层也是一个数组。2、初始化容量：103、怎么扩容的？    扩容之后是原容量的2倍。    10--> 20 --> 40 --> 804、Vector中所有的方法都是线程同步的，都带有synchronized关键字，是线程安全的。效率比较低，使用较少了。5、怎么将一个线程不安全的ArrayList集合转换成线程安全的呢？    使用集合工具类：        java.util.Collections;        java.util.Collection 是集合接口。        java.util.Collections 是集合工具类。Collections.synchronizedList();//将及格转换为线程安全的。

5 -Set

5.1 -概述

• Set集合也是一个接口，继承自Collection，与List类似，都需要通过实现类来进行操作。

• 特点

  • 不允许包含重复的值

  • 没有索引（就不能使用普通的for循环进行遍历）

import java.util.HashSet;import java.util.Set;public class Demo01 {    public static void main(String[] args) {        //使用多态，父类的引用指向子类对象        Set set = new HashSet<>();        //添加元素        set.add("黄固");        set.add("欧阳锋");        set.add("段智兴");        set.add("洪七公");        set.add("段智兴");        System.out.println(set);//打印集合         //[洪七公, 黄固, 欧阳锋, 段智兴]        //HashSet集合对于元素的读写顺序不做保证        //相同的元素，多次存储，只能保留一个，并且不会报错        //List集合可以存储重复元素，Set集合不行    }}

         例：双色球

import java.util.Random;import java.util.TreeSet;public class Demo02 {    public static void main(String[] args) {        Random ran = new Random();//创建随机类对象        int blueBall = ran.nextInt(16) + 1;//        HashSet redBalls = new HashSet<>();//创建集合用来存储红球        TreeSet