java的集合学习

最新推荐文章于 2024-08-26 10:00:00 发布

chongliu1196

最新推荐文章于 2024-08-26 10:00:00 发布

阅读量88

点赞数

原文链接：https://my.oschina.net/yaojianpeng/blog/3054545

版权

说到集合，通常初学者会想到数组，可以说数组和集合还是有着根本的区别。初学者不妨了解一下这些区别：

一、数组声明了它容纳的元素的类型，而集合不声明，如

   int[] array = new int[3] 或者 int[] array = new int[]{1,2,3};

二、数组是静态的，一个数组实例具有固定的大小，一旦创建了就无法改变容量了。而集合是可以动态扩展容量，可以根据需要动态改变大小，集合提供更多的成员方法，能满足更多的需求。

三、数组的存放的类型只能是一种（基本类型/引用类型）,集合存放的类型可以不是一种(不加泛型时添加的类型是Object)。

四、数组是java语言中内置的数据类型,是线性排列的,执行效率或者类型检查都是最快的。

让我们直接深入主题，所有集合都是位于java.util包下，他们主要可以由两个接口派生成的：Collection和Map,Collection和Map是Java集合的框架的根接口，Collection框架接口树形图如下图所示：

其中Set和List接口分别代表了无序集合和有序集合，Queue是java提供的队列的实现。

而Map框架的树形图如图下所示：

下面我们就来一一介绍这些集合。

Set

HashSet类

HashSet是Set接口典型的实现，我们一般要使用到Set集合的时候就用HashSet这个类，HashSet按Hash算法存储集合中的元素，具有很好的存取和查找性能。HashSet具有以下特点。

1.无序，不会按照添加的顺序排列；

2.线程不安全，多个线程操作hashSet会产生线程安全问题；

3.无重复数据，添加多个相同的对象（equals()和hashCode()都相等）,只保留一个值；

4.集合元素可以是null;

当向HashSet集合存入一个元素时，HashSet会根据这个元素的hashCode()的值来确定该元素在hashSet中的位置，如果两个元素通过equals()比较相等，但是hashCode()不相等，那么hashSet会将这两个元素保存在不同的位置。如果两个元素的hashCode()相等，但是equals()不相等，hashSet会用链式结构来保存多个元素。如果HashSet有两个以上的元素具有相同的hashCode()值，这会很影响HashSet的性能。对于HashSet而言，它是基于HashMap实现的，HashSet底层使用HashMap来保存所有元素，因此HashSet 的实现比较简单，相关HashSet的操作，基本上都是直接调用底层HashMap的相关方法来完成。

LinkedHashSet

由上图可知linkedHashSet是hashSet的一个子类，和hashSet类似，也是通过hashCode()来确定元素的位置，唯一一点不同的是linkedHashSet使用链表来维护了元素的顺序，使元素插入linkedHashSet集合的顺序有保证，linkedHashSet的性能略低于HashSet，但是迭代访问它时会有很好的性能，因为它是有序的。

TreeSet

TreeSet是Set接口下的SortedSet的子类，TreeSet可以保证集合中的元素处于排序状态。和linkedHashSet相比较，treeSet采用红黑树的数据结构来存储集合元素。treeSet支持两种排序方式：自然排序和定制排序。默认为自然排序。(TreeSet不能添加null元素)

自然排序：java提供一个接口comparable，该接口定义一个方法compareTo(Object object);该方法返回一个整数值。当想要把某个对象加入treeSet集合中时，这个对象必须需要实现comparable接口，treeSet会根据加入的对象和集合中对象做conpareTo()比较，如果等于0，则相等(不会做任何添加动作)，如果小于0，则往前排，如大于0，则往后排，以此类推。

定制排序：定制排序需要在创建TreeSet时，提供一个Comparator对象和TreeSet关联，由Comparator完成集合内部的排序逻辑。如：

Set<String> set = new TreeSet<>((o1,o2)->{
        String a = (String)o1;
        String b = (String)o2;
      return a.length()>b.length()?-1:a.length()<b.length()?-1:0;
});

EnumSet

EnumSet是一个专门为枚举设计的类，EnumSet中的元素必须是枚举类型，集合中的元素也是有序的，EnumSet以枚举值在Enum类内的定义顺序来决定集合元素的顺序。EnumSet内部是以位向量的形式存储的，这种存储形式非常的高效，紧凑，因为EnumSet的运行速度比较快，占用内存很小。

Set的比较和分析

HashSet和TreeSet时Set接口中两个典型的实现，总体上HashSet的性能要优于TreeSet(特别是添加和查询的操作)，TreeSet额外的红黑树算法维护集合元素的次序。只有当需要使用到保证set次序时用TreeSet，否则都应该使用HashSet。HashSet的子类LinkedHashSet对于普通的插入删除的操作比HashSet慢一点，这是需要额外维护链表造成的，但是有了链表，linkedHashSet的遍历更快。EnumSet的性能时所有Set中最好的，但是EnumSet只能保存同一个枚举类的集合元素。(HashSet,TreeSet,EnumSet都不是线程安全的，多线程的时候谨慎)

List

ArrayList

ArrayList是我们工作中使用的比较多的一个集合，是一个可储存有序可重复元素的集合，一般用add方法将对象存进集合中，内部是用数组实现，当我们new ArrayList()时，实际上是new Object[10]来存储我们add的对象。一般面试中常问的Arraylist和Vector的区别：其实Vector是JKD1.2之前的集合，一些方法和之后的ArraysList都有重复，ArrayList是线程不安全的，Vector是线程安全的，线程不安全性能当然要高些。还有就是Vector下提供一个Stack子类，相当于栈的功能(后进先出)。

Queue

queue是相当于队列数据结构的集合，通常是先进先出操作顺序，一般使用Queue接口下面的PriorityQueue实现类。除此之外Queue还有一个接口Deque(双端队列),可以在对头和队尾双端进行操作，增加了很多灵活性。

LinkedList

LinkedList类是List接口下的一个实现类，同时也实现了Deque接口，这意味着LinkedList既可以通过索引来访问集合中的对象，又可以通过offer(),push(),peekFirst(),peekLast()等API实现压栈弹栈等功能，LinkedList和ArrayList ArrayDeque的实现方式不同，ArrayList ArrayDeque都是通过数组的形式来保存数据的，因此他们随机访问集合数据时性能很好；而LinkList是以链表的形式来保存元素，所以查找功能差一些，但是增删改的性能很好。

List性能比较和分析

List是一个线性表接口，ArrayList和LinkedList分别是数组的线性表和链的线性表。而Queue代表着队列，PriorityQueue是单端队列，而Deque是双端队列。一般来说，由于数组以一块连续内存区来保存所有数组元素，所以数组的随机访问性能最好，而内部以链表实现的集合对于增删的性能较好。但总体来说ArrayList的性能比LinkedList要好，这也是我们在工作中使用比较多的原因。如果有多个线程访问List集合元素，可以使用Collections将集合包装成线程安全集合。

Map

Map用于保存具有映射关系的数据，一个key对应一个value，key不能重复(注意：实现类中有的key可以为null，比如hashmap，有的不能为null 如hashtable。)。其中可以将Map中所有的key看作一个set集合，value看作一个List集合，只不过key和value之间必须一一对应。

HashMap

在Jdk7的时候hashMap使用数组实现的，jdk8之后，改用了红黑树实现。hashMap也是我们工作中使用比较多的，他不能保证key-value的顺序，类似于hashSet，判断两个key相等的标准也是：两个key通过equals()方法比较返回true，两个key的hashcode值也想等。如果使用可变对象作为hashMap的key，并且修改了作为key的可变对象，也会出现程序再也无法精准访问map中被修改过的key。
源码很重要（原文：https://blog.csdn.net/goosson/article/details/81029729 ）：
put方法：

//对外开发使用
public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}
//存值的真正执行者
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
    
    //定义一个数组，一个链表，n永远存放数组长度，i用于存放key的hash计算后的值，即key在数组中的索引        
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    
    //判断table是否为空或数组长度为0，如果为空则通过resize()实例化一个数组并让tab作为其引用，并且让n等于实例化tab后的长度        
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    
    //根据key经过hash()方法得到的hash值与数组最大索引做与运算得到当前key所在的索引值，并且将当前索引上的Node赋予给p并判断是否该Node是否存在
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);//若tab[i]不存在，则直接将key-value插入该位置上。
    
        //该位置存在数据的情况  
    else {
        Node<K,V> e; K k; //重新定义一个Node，和一个k
        
        // 该位置上数据Key计算后的hash等于要存放的Key计算后的hash并且该位置上的Key等于要存放的Key     
        if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))
            e = p;    //true，将该位置的Node赋予给e
    else if (p instanceof TreeNode)  //判断当前桶类型是否是TreeNode
        //ture，进行红黑树插值法,写入数据
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);     
        else {    
        //false, 遍历当前位置链表
            for (int binCount = 0; ; ++binCount) {
                //查找当前位置链表上的表尾，表尾的next节点必然为null,找到表尾将数据赋给下一个节点
                if ((e = p.next) == null) {
                     p.next = newNode(hash, key, value, null);    //是，直接将数据写到下个节点
                    // 如果此时已经到第八个了，还没找个表尾，那么从第八个开始就要进行红黑树操作
            if (binCount >= TREEIFY_THRESHOLD - 1)
                        treeifyBin(tab, hash);    //红黑树插值具体操作
                        break;
                }
                //如果当前位置的key与要存放的key的相同，直接跳出，不做任何操作   
                if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                //将下一个给到p进行逐个查找节点为空的Node
        p = e;
            }
        }
        //如果e不为空，即找到了一个去存储Key-value的Node 
    if (e != null) { // existing mapping for key
            V oldValue = e.value;    
        if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    //当最后一次调整之后Size大于了临界值，需要调整数组的容量
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

get()方法：

//对外公开方法
public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }
 
//实际逻辑控制方法
final Node<K,V> getNode(int hash, Object key) {
    //定义相关变量
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    //保证Map中的数组不为空，并且存储的有值，并且查找的key对应的索引位置上有值
    if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) {
        // always check first node 第一次就找到了对应的值
    if (first.hash == hash && ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
    //判断下一个节点是否存在
    if ((e = first.next) != null) {
            //true,检测是否是TreeNode
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key); //通过TreeNode的get方法获取值
            //否，遍历链表
        do {
        //判断下一个节点是否是要查找的对象
                if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            }while ((e = e.next) != null);
        }
    }//未找到，返回null
    return null;
}

resize()扩容方法：

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;    //未扩容时数组的容量
    int oldThr = threshold;
    int newCap, newThr = 0;//定义新的容量和临界值
    //当前Map容量大于零，非第一次put值
    if (oldCap > 0) {
        if (oldCap >= MAXIMUM_CAPACITY) {    //超过最大容量:2^30
            //临界值等于Integer类型的最大值 0x7fffffff=2^31-1
            threshold = Integer.MAX_VALUE;    
            return oldTab;
        }
        //当前容量在默认值和最大值的一半之间
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1;    //新临界值为当前临界值的两倍
    }
    //当前容量为0，但是当前临界值不为0，让新的容量等于当前临界值
    else if (oldThr > 0) 
        newCap = oldThr;
    //当前容量和临界值都为0,让新的容量为默认值，临界值=初始容量*默认加载因子
    else {
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    //如果新的临界值为0
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE);
    }
    //临界值赋值
    threshold = newThr;
    //扩容table
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    if (oldTab != null) {
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;//此时newCap = oldCap*2
                else if (e instanceof TreeNode) //节点为红黑树，进行切割操作
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { //链表的下一个节点还有值，但节点位置又没有超过8
                    //lo就是扩容后仍然在原地的元素链表
                    //hi就是扩容后下标为  原位置+原容量  的元素链表，从而不需要重新计算hash。
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    //循环链表直到链表末再无节点
                    do {
                        next = e.next;
                        //e.hash&oldCap == 0 判断元素位置是否还在原位置
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    //循环链表结束，通过判断loTail是否为空来拷贝整个链表到扩容后table
                    if (loTail != null) {
                       loTail.next = null;
                        newTab[j] = loHead;
                    }
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;

}

Hashtable

hashtable总是被拿来和hashMap作比较，hashtable是很早就出现的类，他和hashMap最主要的区别就是他是线程安全的，并且不允许把null作为他的key和value，一般情况下如果多线程下要保证线程安全，可以用hashtable，否则都用hashMap。与hashMap一般，不要使用可变对象作为hashMap，hashtable的key，尽量不要在程序中修改作为key的可变对象。

LinkedHashMap

与linkedHashSet类是，HashMap也有一个LinkedHashMap子类，LinkedHashMap也是使用双向链表来维护key-value元素的次序的，只需要考虑key的次序，该链表负责维护Map的迭代顺序，迭代顺序与插入时的顺序保持一致。LinkedHashMap需要维护元素的插入顺序，因此性能略低于HashMap的性能；但是他是与链表来维护内部顺序，所以迭代访问map里面元素时有较好的性能。

TreeMap

与TreeSet一样，Set接口派生出SortedSet子接口，SortedSet有一个TreeSet实现类一样，Map接口也派生出一个SortedMap子接口，SortedMap也有一个TreeMap实现类。TreeMap就是一个红黑树数据结构，每个key-value对即作为红黑树的一个节点，TreeMap可以保证所有的key-value对处于有序状态。TreeMap也有两种排序方式：

自然排序：TreeMap的所有key必须实现Comparable接口，而且所有的kye应该是同一个类的对象，否则会报错。

定制排序：创建TreeMap时，传入一个Comparator对象对有个的key进行比较排序，采用定制排序时不要求key必须实现Comparable接口。

WeakHashMap

WeakHashMap与HashMap的用法基本相似，与HashMap不同的是hashMap的key保留了对实际对象的强引用，这意味着只要该HashMap对象不被销毁，该HashMap的key所引用的对象就不会被回收，hashMap也不会删除这些key所对应的key-value对；但WeakHashMap的key只保留了对实际对象的弱引用，这就意味着如果WeakHashMap对象的key所引用对象没有被其他强引用变量所引用，则这些key所引用的对象可能会被垃圾回收，WeakHashMap也可能删除这些key所对应的key-value对。

IdentityHashMap

IdentityHashmap和HashMap基本相似，但它在处理两个key相等时比较独特：在IdenityHashMap中，当且仅当两个key严格相等时（key1==key2）时，IdentityHashMap才认为两个key相等；但是HashMap只要key1和key2通过equals（）方法比较返回true，且他们的hashcode值相等即可。

EnumMap

EnumMap是一个枚举Map,他的所有key必须是单个的枚举类的枚举值，创建EnumMap时必须显式或者隐式指定它对应的枚举类。特性如下：

1.EnumMap在内部以数组形式保存，所以个他非常高效，紧凑。

2.EnumMap根据key的自然顺序来维护key-value对的顺序。即枚举值在枚举类中定义的顺序。

3.EnumMap不允许null作为key值，但是可以作为value值。

Map性能分析

一般来说，程序应该多考虑使用HashMap，因为HashMap正是为了快讯查询设计的，即使对于线程来说，也没有必要使用HashTable，可以使用Collections 工具类把HashMap变成线程安全的。TreeMap通常比HashMap，Hashtable要慢，特别是插入，删除时更慢，但是TreeMap中key-value总处于有序状态，无需专门的排序操作，需要对key-value中的key进行排序时，可以使用TreeMap,LinkedHashMap性能比HashMap要慢一些，因为他需要维护链表来保持map中key-value时的添加顺序。IdentityHashMap也不常用，唯一和HashMap不同之处是采用==而不是equals()方法判断元素相等。EnumMap的性能最好，但它只能使用同一个枚举类的枚举作为key。

Hash的解读

对于hashSet，hashMap，Hashtbale而言，他们采用hash算法决定几何中元素的存储位置，并通过hash算法来控制集合的大小。

hash表里面可以存储元素的位置被称为“桶”，通常情况下，单个“桶”里面存储一个元素，此时有最好的性能：hash算法可以根据hashCode计算出“桶”的存储位置，并且取出数据。但是当发生hash冲突时，单个桶会有多个元素，这些元素以链表形式存储，想得到数据必须按hash出桶位置，然后顺序搜索才能找到数据。如图：