Java集合详解

集合

集合框架图

集合接口

集合框架定义了一些接口。本节提供了每个接口的概述：序号接口描述

Collection 接口 Collection 是最基本的集合接口，一个 Collection 代表一组 Object，即 Collection 的元素, Java不提供直接继承自Collection的类，只提供继承于的子接口(如List和set)。 Collection 接口存储一组不唯一，无序的对象。
List 接口 List接口是一个有序的 Collection，使用此接口能够精确的控制每个元素插入的位置，能够通过索引(元素在List中位置，类似于数组的下标)来访问List中的元素，第一个元素的索引为 0，而且允许有相同的元素。 List 接口存储一组不唯一，有序（插入顺序）的对象。
Set Set 具有与 Collection 完全一样的接口，只是行为上不同，Set 不保存重复的元素。 Set 接口存储一组唯一，无序的对象。
SortedSet 继承于Set保存有序的集合。
Map Map 接口存储一组键值对象，提供key（键）到value（值）的映射。
Map.Entry 描述在一个Map中的一个元素（键/值对）。是一个Map的内部类。
SortedMap 继承于 Map，使 Key 保持在升序排列。
Enumeration 这是一个传统的接口和定义的方法，通过它可以枚举（一次获得一个）对象集合中的元素。这个传统接口已被迭代器取代。

集合实现类（集合类）

Java提供了一套实现了Collection接口的标准集合类。其中一些是具体类，这些类可以直接拿来使用，而另外一些是抽象类，提供了接口的部分实现。

标准集合类汇总于下：

AbstractCollection 实现了大部分的集合接口。
AbstractList 继承于AbstractCollection 并且实现了大部分List接口。
AbstractSequentialList 继承于 AbstractList ，提供了对数据元素的链式访问而不是随机访问。
LinkedList 该类实现了List接口，允许有null（空）元素。主要用于创建链表数据结构，该类没有同步方法，如果多个线程同时访问一个List，则必须自己实现访问同步，解决方法就是在创建List时候构造一个同步的List。例如：
```
List list=Collections.synchronizedList(newLinkedList(…));
```
LinkedList 查找效率低。
ArrayList 该类也是实现了List的接口，实现了可变大小的数组，随机访问和遍历元素时，提供更好的性能。该类也是非同步的,在多线程的情况下不要使用。ArrayList 增长当前长度的50%，插入删除效率低。
AbstractSet 继承于AbstractCollection 并且实现了大部分Set接口。
HashSet 该类实现了Set接口，不允许出现重复元素，不保证集合中元素的顺序，允许包含值为null的元素，但最多只能一个。
LinkedHashSet 具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。
TreeSet 该类实现了Set接口，可以实现排序等功能。
AbstractMap 实现了大部分的Map接口。
HashMap HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。该类实现了Map接口，根据键的HashCode值存储数据，具有很快的访问速度，最多允许一条记录的键为null，不支持线程同步。
TreeMap 继承了AbstractMap，并且使用一颗树。
WeakHashMap 继承AbstractMap类，使用弱密钥的哈希表。
LinkedHashMap 继承于HashMap，使用元素的自然顺序对元素进行排序.
IdentityHashMap 继承AbstractMap类，比较文档时使用引用相等。
Vector 该类和ArrayList非常相似，但是该类是同步的，可以用在多线程的情况，该类允许设置默认的增长长度，默认扩容方式为原来的2倍。
Stack 栈是Vector的一个子类，它实现了一个标准的后进先出的栈。
Dictionary Dictionary 类是一个抽象类，用来存储键/值对，作用和Map类相似。
Hashtable Hashtable 是 Dictionary(字典) 类的子类，位于 java.util 包中。
Properties Properties 继承于 Hashtable，表示一个持久的属性集，属性列表中每个键及其对应值都是一个字符
BitSet 一个Bitset类创建一种特殊类型的数组来保存位值。BitSet中数组大小会随需要增加。

集合算法

集合框架定义了几种算法，可用于集合和映射。这些算法被定义为集合类的静态方法。

在尝试比较不兼容的类型时，一些方法能够抛出 ClassCastException异常。当试图修改一个不可修改的集合时，抛出UnsupportedOperationException异常。

集合定义三个静态的变量：EMPTY_SET，EMPTY_LIST，EMPTY_MAP的。这些变量都不可改变。

Collection Algorithms 这里是一个列表中的所有算法实现。
下面通过代码反射得到集合底层进行剖析

package com.zhibang.sk.kqfx;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;

public class ListandFanxing <T>{
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        ArrayList<Integer> list2 = new ArrayList<>();
        list2.add(123);
        list2.add(1232);
        list2.add(3);
        list2.add(999);
//        list2.add(new StringBuffer());
//		list2.add(20);//错误
        Class class1 = list.getClass();
        Class class2 = list2.getClass();
        System.out.println("class1==class2??"+(class1==class2));
        //反射的操作都是编译之后的操作
        /*
         * class1==class2的比较结果返回true说明集合的.class是去除泛型的
         * 也就是说集合编译之后没有了泛型
         * Java中集合的泛型，是防止错误输入的，绕过编译就无效了
         */
        try {
            Method method = class1.getMethod("add", Object.class);
            method.invoke(list2, "我进去了！！！");//反射后可以加进去String型的
            System.out.println(list2.size());
            //绕过编译操作就绕过了泛型
            System.out.println("list2:"+list2);
//
//			//那么就不能使用正常的forEach遍历了 //ClassCastException
//			for(Integer integer:list2){
//				System.out.println(integer);
//			}
            // 需要用到 Object 遍历了
//            for (Object integer : list2) {
//                System.out.println(integer);
//            }
            // 这里通过反射拿到集合底层字段给大家演示
            Field elementData = class2.getDeclaredField("elementData");
            elementData.setAccessible(true);//暴力反射拿到访问权限 破封装
            // java 8 以上 使用这段代表都会报红色警告 这里是正常现象
            Object[] objects = (Object[]) elementData.get(list2);
            // 这里拿到集合的底层 Object 数组 打印
            // 可以看出我们的集合底层就是一个 object数组 然后通过扩容和构造方法实现动态数组
            System.out.println(Arrays.toString(objects));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

通过上述代码可以知道集合的长度是10 可以通过源码进行查看

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

在源码中集合初始化时是无长度的那么他是怎么进行扩容的呢？通过添加数据的外部方法只有add 那么我们先看看 add方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oMiuOoTR-1606212776517)(C:UsershuAppDataRoamingTypora ypora-user-images1606211574798.png)]

实际上集合源码中有3个add 方法 2个public 1个private修饰

private void add(E e, Object[] elementData, int s) {
        if (s == elementData.length)
            elementData = grow();
        elementData[s] = e;
        size = s + 1;
    }
public boolean add(E e) {
        modCount++;
        add(e, elementData, size);
        return true;
    }
public void add(int index, E element) {
        rangeCheckForAdd(index);
        modCount++;
        final int s;
        Object[] elementData;
        if ((s = size) == (elementData = this.elementData).length)
            elementData = grow();
        System.arraycopy(elementData, index,
                         elementData, index + 1,
                         s - index);
        elementData[index] = element;
        size = s + 1;
    }

通过源码可以看到这么一个方法 elementData = grow();

grow（）

private Object[] grow() {    
    return grow(size + 1);
}
private Object[] grow(int minCapacity) {
        return elementData = Arrays.copyOf(elementData,
                                           newCapacity(minCapacity));
    }
// 这个方法最终指向 这么一个方法 newCapacity（int minCapacity）
private int newCapacity(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;//这里得到老长度
        int newCapacity = oldCapacity + (oldCapacity >> 1);
    	//这里可以看作 新长度 等于 老长度扩容50% 1= 1+1x0.5
        if (newCapacity - minCapacity <= 0) {
            if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
                return Math.max(DEFAULT_CAPACITY, minCapacity);
            if (minCapacity < 0) // overflow
                throw new OutOfMemoryError();
            return minCapacity;
        }
        return (newCapacity - MAX_ARRAY_SIZE <= 0)
            ? newCapacity
            : hugeCapacity(minCapacity);
    }

集合的方法进行内部方法调用判断是否扩容从而实现动态扩容

每次数据存储最后一个元素时才进行扩容

扩容长度 = 原来的长度 + （原长x1.5）