Java 集合及底层源码分析

文章目录

List集合

集合类中元素有序(即添加顺序和取出顺序一致)、且可重复
List集合中的每个元素都有其对应的顺序索引，即支持索引索引是从0开始的

ArrayList

ArrayList是由数组来实现数据存储的

ArrayList 基本等同于Vector，除了ArrayList是线程不安全的（执行效率高），在多线程的情况不建议使用ArrayList

源码分析结论：

ArrayList中底层一直维护一个Object类型的数组 elementData(transient Object[] elementData 表示瞬间，短暂的，表示该属性不会被序列化)
ArrayList如果使用无参构造，则初始elementData 容量为0，第一次扩容容量为10，如需要再次扩容，则扩容为原来的1.5倍，即 newCapacity = oldCapacity + oldCapacity>>1
如果使用的是有参构造，则初始elementData容量为指定大小，如果需要扩容，则扩容为原来的1.5倍

 //源代码是jdk1.8版本
private void grow(int minCapacity) {
    
    
        // overflow-conscious code
        int oldCapacity = elementData.length;//无参构造下初始值为0，如果是有参构造，值为指定的值
        int newCapacity = oldCapacity + (oldCapacity >> 1);//>>表示右移一位 相当于除以2
        if (newCapacity - minCapacity < 0) //此处无参构造下第一次扩容，newCapacity为0，而minCapacity为10，故做一下处理
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)//此处针对与扩容量很大的情况
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity); //使用Copyof的话，使得在原先的数组值不变的情况下进行扩容
    }

Vector

Vector 底层也是一个对象数组，protect Object [] element Data;

Vector 是线程同步的，即线程安全，Vector类的操作方式带有Synchronied

在开发中，如果需要线程同步安全，则应该考虑Vector

源码分析结论：

Vector 如果使用无参构造的，默认容量为10，如需要再次扩容，就按2倍扩容
如果使用有参构造，或有参时只指定初始容量，未指定需要增加的容量，则初始容量为指定的容量，如需再次扩容，则扩容后的容量为原来的两倍
如果使用有参构造，构造时既指定初始容量，又指定需要增加的容量，则初始容量为指定的容量，如需再次扩容，则扩容后的容量为原来的加上增加容量，详细如下

 //源代码是jdk1.8版本    
private void grow(int minCapacity) {
    
    //minCapacity 实际容量
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);//capacityIncrement为有参构造时传入的值，不传的话默认为0
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

LinkedList

LinkedList 底层实现了双向链表和双端队列特点

LinkedList 可以重复添加任意元素，包括null

LinkedList 线程不安全，没有实现同步

LinkedList底层维护了一个双向链表，还维护了两个属性first和last分别指向首结点和尾结点

每个节点(Node对象)，里面又维护了prev、next、item三个属性,其中通过prev指向前一个，通过next指向后一个节点。最终实现双向链表.

LinkedList的元素的添加删除，不是通过数组来完成的，所以效率很高.

ArrayList和LinkedList比较

	底层结构	增删的效率	改查的效率
ArrayList	可变数组	较低，数组扩容	较高
LinkedList	双向链表	较高，链表追加	较低

如何选择ArrayList和LinkedList:(因为是两个都是线程不安全的，所以在单线程的情况下考虑这两种集合）

如果我们改查的操作多，选择ArrayList.
如果我们增删的操作多，选择LinkedList.
一般来说，在程序中，80%-90%都是查询，因此大部分情况下会选择ArrayList
在一个项目中，根据业务灵活选择，也可能这样，一个模块使用的是ArrayList,另
外个模块是LinkedList.

Set集合

无序（添加和取出的顺序不一样）
不允许添加重复元素，所以最多包含一个null

HashSet

HashSet实际上是new 了一个HashMap

可以存放nul值，但是只能有一个null

HashSet不保证元素是有序的，取决于hash后，再确定索引的结果，（即，不保证存放元素的顺序和取出的顺序一致）

不能有重复的元素/对象

源码分析结论：

HashSet底层是HashMap,第一次添加时，table数组扩容到16，临界值(threshold)是16 * 加载因子
(loadFactor)是0.75 =12
如果table数组使用到了临界值12,就会扩容到16 * 2 = 32,新的临界值就是32*0.75 = 24,依次类推
在Java8中,如果一条链表的元素个数到达TREEIFY_THRESHOLD(默认是8).并且table的大小>=
MIN TREEIFY CAPACITY(默认64),就会进行树化(红黑树)，否则仍然采用数组扩容机制

注意：扩容时，达到临界值12是指添加元素的个数达到12，不是单指tab表的个数
添加一个元素是，会先调用hash算法得到一个hash值，再根据hash值确定一个索引值
添加元素是，先判断当前元素对应的索引位置是否有为空，如果没有则添加元素
如果该索引位置元素对应的hash值和待插入的元素的hash值相同，且是同一个引用或者是内容相同的话就不能添加
如果索引位置有值且满足一颗红黑树的话，则调用红黑树的算法进行添加
如果索引位置有值且是一个链表的话，则循环比较链表，如果存在相同元素的话，则不允许添加，否则添加到链尾即可

//1.执行HashSet()
   public HashSet() {
        map = new HashMap<>();
    }
//2.执行add()
    public boolean add(E e) {
            return map.put(e, PRESENT)==null;
        }
//3.执行put()
 public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }
     static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);//对hash值进行无符号右移16位，防止冲突
    }
//4.执行putVal()
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        //tab其实HashMap的一个数组，类型是 Node[],第一次扩容，到16个空间
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //根据Key得到一个hash值，然后计算该key在tab中所对应的索引下标，并把这个索引对应的元素赋给p
        //if p == null 表示该位置还没有存放元素，就创建一个Node
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            //判断当前添加的对象的引用或者内容是否相同，前提是他们的hash值要相同，如果满足条件的话则不嫩加入
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
                //否则再判断是否是一颗红黑树，如果是一颗红黑树，则采用红黑树的算法进行
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
            //否则如果是一个链表，则依次循环比较，如果找到相同的就退出，否则把当前对象放在尾部即可
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

LinkedHashSet

LinkedHashSet 底层是一个LInkedHashMap,底层维护了一个数组+双向链表

LInkedHashSet根据元素的HashCode值来决定元素的位置，同时使用链表维护元素的次序，这使得元素看起来是以插入的顺序保存的

LInkedHashSet 不允许添加重复元素

Map集合

Map与Collection并列存在。用时于保存具有映射关系的数据:Key-Value
Map中的key 和value可以是任何引用类型的数据，会封装到HashMap $Node对象中
Map中的key 不允许重复，原因和HashSet一样，前面分析过源码,Map 中的value可以重复
Map 的key可以为null, value 也可以为null，注意key为null,只能有一个，value为null ,可以多个
常用String类作为Map的key,但并不是所有只能用String作为key,kev和value之间存在单向一对一关系，即通过指定的 kev总能找到对应的value
k-v形式最终会是 HashMap $Node node = newNode(hash， key,value,null)
k-v为了方便程序员的遍历，还会创建 EntrySet集合，该集合存放的元素的类型 Entry，而一个Entry对象就有k,v ，EntrySet<Entry<K,V>>即:transient Set<Map. Entry<K,V>> entrySet;
entrySet中，定义的类型是 Map.Entry ，但是实际上存放的还是 HashMap $Node
这是因为static class Node<K,V> implements Map.Entry<K, V>，当把 HashMap $Node对象存放到entrySet时就方便我们的遍历

Map 接口的遍历方式

通过keySet获取map里所有的键，获取键后返回一个集合，可采用集合的遍历增强for或者迭代器 iterator进行遍历
通过values获取所有的value集合，可通过集合的方式遍历
通过entrySet获取所有的关系k-v,可通过集合的遍历

HashMap

HashMap底层维护了Node类型的数组table，默认为null

当创建对象时，将加载因子(loadfactor)初始化为0.75.
当添加key-val时，通过key的哈希值得到在table的索引。然后判断该索引处是否有元素,如果没有元素直接添加。如果该索引处有元素,继续判断该元素的key和准备加入的key相是否等,如果相等，则直接替换val;如果不相等需要判断是树结构还是链表结构，做出相应处理。如果添加时发现容量不够，则需要扩容。
第1次添加，则需要扩容table容量为16，临界值(threshold)为12(16*0.75)
以后再扩容，则需要扩容table容量为原来的2倍(32)，临界值为原来的2倍,即24.依次类推

在Java8中,如果一条链表的元素个数超过 TREEIFY_THRESHOLD(默认是8)，table的大小 >= MIN_TREEIFY_ CAPACITY(默认64),就会进行树化(红黑树)

源代码分析及结论

同HashSet一样，因为HashSet底层是HashMap

Hashtable

存放的元素是键值对:即K-V

hashtable的键和值都不能为null，否则会抛出NullPointerException3) hashTable使用方法基本上和HashMap一样

hashTable是线程安全的(synchronized), hashMap是线程不安全的

源代码分析及结论：

Hashtable底层维护的也是一个数组Hashtable$Entry[] 初始化大小为11
临界值等于11*0.75 =8
扩容机制：当加入的数量到达临界值是，扩容量为原来的2倍+1，即：newCapacity = (oldCapacity << 1) + 1;
当加入相同相同key对应的value时，则进行value替换

 private void addEntry(int hash, K key, V value, int index) {
    
    
        modCount++;

        Entry<?,?> tab[] = table;
        if (count >= threshold) {
    
    
            // Rehash the table if the threshold is exceeded
            rehash();

            tab = table;
            hash = key.hashCode();
            index = (hash & 0x7FFFFFFF) % tab.length;
        }

        // Creates the new entry.
        @SuppressWarnings("unchecked")
        Entry<K,V> e = (Entry<K,V>) tab[index];
        tab[index] = new Entry<>(hash, key, value, e);
        count++;
    }

    protected void rehash() {
    
    
        int oldCapacity = table.length;
        Entry<?,?>[] oldMap = table;

        // overflow-conscious code
        int newCapacity = (oldCapacity << 1) + 1;//扩容机制
        if (newCapacity - MAX_ARRAY_SIZE > 0) {
    
    
            if (oldCapacity == MAX_ARRAY_SIZE)
                // Keep running with MAX_ARRAY_SIZE buckets
                return;
            newCapacity = MAX_ARRAY_SIZE;
        }
        Entry<?,?>[] newMap = new Entry<?,?>[newCapacity];

        modCount++;
        threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
        table = newMap;

        for (int i = oldCapacity ; i-- > 0 ;) {
    
    
            for (Entry<K,V> old = (Entry<K,V>)oldMap[i] ; old != null ; ) {
    
    
                Entry<K,V> e = old;
                old = old.next;

                int index = (e.hash & 0x7FFFFFFF) % newCapacity;
                e.next = (Entry<K,V>)newMap[index];
                newMap[index] = e;
            }
        }
    }

关于Hashtable和HashMap的对比：

	版本	线程安全（同步）	效率	允许null键null值
Hashtable	1.0	安全	不高	不允许
HashMap	1.2	不安全	高	允许

Properties

Properties类继承自Hashtable类并且实现了Map接口，也是使用一种键值对的形
式来保存数据，他的使用特点和Hashtable类似
Properties 还可以用于从 xxx.properties 文件中，加载数据到Properties类对象,
并讲行卖取和修改

相关知识点：https://www.cnblogs.com/xudong-bupt/p/3758136.html

TreeSet

TreeSet底层实际上是TreeMap

可排序(可安自定义的方式进行排序输出）

源代码分析及结论：

当使用无参构造创建一个对象是，会默认将key转成比较器对象（前提是该key必须实现Comparable且实现了compareTo方法），使用默认的compareTo方法进行自然排序
当使用有参构造时，需要传入一个含有compare方法的比较器对象，然后TreeSet底层会将其封装给TreeMap对象中的comparator，底层加入是会自动调用该方法进行排序
如果TreeSet存放的是Integer对象，默认排序方法为小到大；
如果TreeSet存放的是String对象，默认排序方法为字符串首字母开始比较，按Unicode值大小排序；
如果TreeSet存放的是自定义类；如果不指定指定比较器，那么就会报异常；

    public V put(K key, V value) {
    
    
        Entry<K,V> t = root;
        if (t == null) {
    
    
            compare(key, key); // type (and possibly null) check//第一次添加的时候调用比较，判断是不是能进行比较

            root = new Entry<>(key, value, null);
            size = 1;
            modCount++;
            return null;
        }
        int cmp;
        Entry<K,V> parent;
        // split comparator and comparable paths
        Comparator<? super K> cpr = comparator;
        if (cpr != null) {
    
    
            do {
    
    
                parent = t;
                cmp = cpr.compare(key, t.key);//传入的比较器对象，含有自定义的compare方法
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);
            } while (t != null);
        }
        else {
    
    
            if (key == null)
                throw new NullPointerException();
            @SuppressWarnings("unchecked")
                Comparable<? super K> k = (Comparable<? super K>) key;//默认比较方法，前提是key必须实现Comparable接口
            do {
    
    
                parent = t;
                cmp = k.compareTo(t.key);
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);
            } while (t != null);
        }
        Entry<K,V> e = new Entry<>(key, value, parent);
        if (cmp < 0)
            parent.left = e;
        else
            parent.right = e;
        fixAfterInsertion(e);
        size++;
        modCount++;
        return null;
    }

TreeMap

TreeMap的底层原理如上，只是TreeSet在put的时候value是固定的

开发中如何选择集合实现类

在开发中，选择什么集合实现类，主要取决于业务操作特点，然后根据集合实现类特性进行选择,分析如下:

先判断存储的类型（一组对象[单列]或一组键值对[双列])

一组对象[单列]:Collection接口
允许重复:List
增删多:LinkedList [底层维护了一个双向链表]
改查多: ArrayList[底层维护Object类型的可变数组]
不允许重复:Set
无序: HashSet [底层是HashMap，维护了一个哈希表即(数组+链表+红黑树)] （插入和取出的顺序不一致）

排序:TreeSet
插入和取出顺序一致: LinkedHashSet，维护数组+双向链表
一组键值对[双列]:Map
键无序: HashMap [底层是:哈希表 jdk7:数组+链表，jdk8:数组+链表+红黑树]

键排序:TreeMap
键插入和取出顺序一致:LinkedHashMap

读取文件Properties

Iterator遍历

当退出while循环后，这时iterator迭代器，指向最后的元素，如果希望再次遍历，需要重置我们的迭代器

//idea 快捷点 itit
iterator = col.itreator();

增强for（底层还是迭代器，看作一个增强版的迭代器）

//idea 快捷键 it
for (Object object ： col)
{
    
    
    
}

Collection工具类

Collections是一个操作 Set、List 和 Map 等集合的工具类
Collections中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作

排序操作:(均为static方法)
reverse(List):反转List中元素的顺序
shuffle(List):对List 集合元素进行随机排序
sort(List):根据元素的自然顺序对指定List集合元素按升序排序
sort(List, Comparator):根据指定的Comparator产生的顺序对List集合元素进行排序
swap(List, int, int):将指定 list集合中的i处元素和j处元素进行交换

查询，替换操作
Object max(Collection):根据元素的自然顺序，返回给定集合中的最大元素
Object max(Collection,Comparator):根据Comparator指定的顺序,返回给定集合中的最大元素
Object min(Collection)
Object min(Collection, Comparator)
int frequency(Collection, Object):返回指定集合中指定元素的出现次数
void copy(List dest,List src):将src中的内容复制到dest中
boolean replaceAll(List list, Object oldVal, Object newVal)使用新值替换List对象的所有旧值