Java集合框架总结

本文主要是介绍Java集合框架总结，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

 

1、Collection接口

(1) 常用方法

• add(Object obj),添加obj时，需要重写equals()方法。添加基本数据类型，会自动装箱，像Interger、Double类已经自动重写了equals()方法，若自定义类，需要自己重写
• addAll(Collection coll),
• size(),
• isEmpty(),
• clear();
• contains(Object obj),调用obj所在类的equals()方法，一般自定义类需要重写equals()方法。调用equal方法来比较，若obj重写，则调用obj重写的equal
• containsAll(Collection coll),
• remove(Object obj),也会调用equals()方法
• removeAll(Collection coll),删除的是当前集合与coll的交集
• retainsAll(Collection coll),得到当前集合与coll的交集，结果给当前集合
• equals(Object obj);要想返回true，要求当前对象与形参对象是否相同。有序无序看list还是set
• hashCode(),返回当前对象的hash值
• toArray(),集合-->数组。   数组-->集合：Array.asList(object[]);
• iterator();返回iterator接口的实例，用于遍历集合的元素

(2) Iterator接口

        Iterator对象称为迭代器(设计模式：迭代器模式)，主要用于遍历Collection集合中的元素。

• hasNext()
• next()
• remove()： 遍历过程中通过迭代器对象的remove方法， 不是集合对象的remove方法

(3) 增强for循环：foreach

    遍历集合的底层调用Iterator完成操作  

2、List接口

• List集合类中元素有序、且可重复，即按照添加的顺序存放到集合里。
• List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。
• JDK API中List接口的实现类常用的有： ArrayList、 LinkedList和Vector。

(1)  List接口自己的方法

• void add(int index, Object ele)：在index位置插入ele元素
• boolean addAll(int index, Collection eles)：从index位置开始将eles中的所有元素添加进来
• Object get(int index)：获取指定index位置的元素
• int indexOf(Object obj)：返回obj在集合中首次出现的位置
• int lastIndexOf(Object obj)：返回obj在当前集合中末次出现的位置
• Object remove(int index)：移除指定index位置的元素，并返回此元素
• Object set(int index, Object ele)：设置指定index位置的元素为ele
• List subList(int fromIndex, int toIndex)：返回从fromIndex到toIndex位置的子集合

(2)  ArrayList

1. ArrayList的JDK1.8之前与之后的实现区别？
• JDK1.7： ArrayList像饿汉式，直接创建一个初始容量为10的数组
• JDK1.8： ArrayList像懒汉式，一开始创建一个长度为0的数组，当添加第一个元素时再创建一个始容量为10的数组
2. Arrays.asList(…) 方法返回的 List 集合， 既不是 ArrayList 实例，也不是Vector 实例。 Arrays.asList(…) 返回值是一个固定长度的List集合
3. 线程不安全

(3) LinkedList

• 对于频繁的插入或删除元素的操作，建议使用LinkedList类，效率较高。底层是双向非循环链表
• 线程不安全

void linkLast(E e) {
    final Node<E> l = last;
    final Node<E> newNode = new Node<>(l, e, null);    //new Node(Node prev,E e,Node next);
    last = newNode;
    if (l == null)
        first = newNode;
    else
        l.next = newNode;
    size++;
    modCount++;
}
private static class Node<E> {
    E item;
    Node<E> next;
    Node<E> prev;
 
    Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

新增方法：

• void addFirst(Object obj)
• void addLast(Object obj)
• Object getFirst()
• Object getLast()
• Object removeFirst()
• Object removeLast()

(4) Vector

• JDK1.0就有了。大多数操作与ArrayList相同，区别之处在于Vector是线程安全的。
• 最好把ArrayList作为缺省选择。当插入、删除频繁时，使用LinkedList； Vector总是比ArrayList慢，所以尽量避免使用。
• 新增方法
• void addElement(Object obj)
• void insertElementAt(Object obj,int index)
• void setElementAt(Object obj,int index)
• void removeElement(Object obj)
• void removeAllElements()

(5) ArrayList和LinkedList线程不安全替代方案

    顺序：Vector > SynchronizedList > CopyOnWriteArrayList

1. java.util.Collections.SynchronizedList

• 把所有 List 接口的实现类转换成线程安全的List，比 Vector 有更好的扩展性和兼容性。
• 所有方法都是带同步对象锁的，和 Vector 一样，它不是性能最优的。
• 在读多写少的情况，SynchronizedList这种集合性能非常差。

2. java.util.concurrent.CopyOnWriteArrayList

• Java 1.5 开始加入，适合读多写少的情况。
• 复制再写入，就是在添加元素的时候，先加锁，把原 List 列表复制一份，再添加新的元素，最后再释放锁。
• 获取元素没有加锁，提高读取性能。

3. java.util.concurrent.CopyOnWriteArraySet

• 跟CopyOnWriteArrayList类似。
• 添加元素的时候判断对象是否已经存在，不存在才添加进集合。

(6) 面试题

请问ArrayList/LinkedList/Vector的异同？ 谈谈你的理解？ ArrayList底层是什么？扩容机制？ Vector和ArrayList的最大区别?

1. ArrayList和LinkedList的异同

• 二者都线程不安全，相对线程安全的Vector，执行效率高。
• ArrayList是实现了基于动态数组的数据结构， LinkedList基于链表的数据结构。对于随机访问get和set， ArrayList觉得优于LinkedList，因为LinkedList要移动指针。对于新增和删除操作add(特指插入)和remove， LinkedList比较占优势，因为ArrayList要移动数据。

2. ArrayList和Vector的区别

• Vector和ArrayList几乎是完全相同的,唯一的区别在于Vector是同步类(synchronized)，属于强同步类。因此开销就比ArrayList要大，访问要慢。正常情况下,大多数的Java程序员使用ArrayList而不是Vector,因为同步完全可以由程序员自己来控制。
• Vector每次扩容请求其大小的2倍空间，而ArrayList是1.5倍。 Vector还有一个子类Stack。

3、Set接口

• Set接口是Collection的子接口， set接口没有提供额外的方法
• Set集合不允许包含相同的元素，如果试把两个相同的元素加入同一个Set 集合中，则添加操作失败。
• Set判断两个对象是否相同不是使用 == 运算符，而是根据 equals() 方法
• Set有两个实现类：HashSet和TreeSet，HashSet有LinkedHashSet实现类

(1) HashSet

• 大多数时候使用 Set 集合时都使用这个实现类。
• 特点：
• 不能保证元素的排列顺序
• HashSet 不是线程安全的
• 集合元素可以是 null
• HashSet集合判断两个元素相等的标准：两个对象通过 hashCode()方法比较相等，并且两个对象的 equals() 方法返回值也相等。
• 对于存放在Set容器中的对象， 对应的类一定要重写equals()和hashCode(Object obj)方法，以实现对象相等规则。即：“相等的对象必须具有相等的散列码” 。如果不重写equals()和hashCode(Object obj)，HashSet可能存放相同值的对象。
• 底层实现方式：
• jdk7：数组+链表，新增元素放到数组中，指向原来的元素。
• jdk8：数组+链表+红黑树，原来的元素在数组中，指向新增元素。

1. 向HashSet中添加元素的过程：

• 当向 HashSet 集合中存入一个元素时， HashSet 会调用该对象的 hashCode() 方法来得到该对象的 hashCode 值， 然后根据 hashCode 值， 通过某种散列函数决定该对象在 HashSet 底层数组中的存储位置。 （这个散列函数会与底层数组的长度相计算得到在数组中的下标， 并且这种散列函数计算还尽可能保证能均匀存储元素， 越是散列分布，该散列函数设计的越好）
• 如果两个元素的hashCode()值相等， 会再继续调用equals方法， 如果equals方法结果为true， 添加失败； 如果为false， 那么会保存该元素， 但是该数组的位置已经有元素了，那么会通过链表的方式继续链接。
• 如果两个元素的 equals() 方法返回 true，但它们的 hashCode() 返回值不相等，hashSet 将会把它们存储在不同的位置，但依然可以添加成功。（可能由于没有重写hashCode方法）

2. 扩容机制

• 底层也是数组， 初始容量为16， 当如果使用率超过0.75， （16*0.75=12）就会扩大容量为原来的2倍。 （16扩容为32， 依次为64,128....等）

(2) hashCode()与equals()方法

        hashCode()方法给对象返回一个hash code值。这个方法被用于hash tables，例如HashMap。

1. 性质

• 在程序运行时，同一个对象多次调用 hashCode() 方法应该返回相同的值。
• 当两个对象的 equals() 方法比较返回 true 时，这两个对象的 hashCode()方法的返回值也应相等。
• 对象中用作 equals() 方法比较的属性，都应该用来计算 hashCode 值。

2. hashCode()的设计来源

• 问题：要想保证元素不重复，可两个元素是否重复应该依据什么来判断呢？
• 这就是Object.equals方法了。但是，如果集合中现在已经有1000个元素，那么第1001个元素加入集合时，它就要调用1000次equals方法。这显然会大大降低效率。   
• 于是，Java采用了哈希表的原理。哈希算法也称为散列算法，是将数据依特定算法直接指定到一个地址上，当集合要添加新的元素时，先调用这个元素的hashCode方法，就一下子能定位到它应该放置的物理位置上。如果这个位置上没有元素，它就可以直接存储在这个位置上，不用再进行任何比较了；如果这个位置上已经有元素了，就调用它的equals方法与新元素进行比较，相同的话就不存了，不相同就散列其它的地址。所以这里存在一个冲突解决的问题。这样一来实际调用equals方法的次数就大大降低了，几乎只需要一两次。

3. hashCode系数为什么选择31？

• 选择系数的时候要选择尽量大的系数。因为如果计算出来的hash地址越大，所谓的“冲突”就越少，查找起来效率也会提高。（减少冲突）
• 并且31只占用5bits,相乘造成数据溢出的概率较小。
• 31可以 由i*31== (i<<5)-1来表示,现在很多虚拟机里面都有做相关优化。 （提高算法效率）
• 31是一个素数，素数作用就是如果我用一个数字来乘以这个素数，那么最终出来的结果只能被素数本身和被乘数还有1来整除！ (减少冲突)

4. 结论

• equals()相等的两个对象，hashcode()一定相等；hashcode()相等的两个对象，equals()不一定相等。
• 如果重写equals()了，就必须重写hasCode()，因为hasCode()能够提高比较的效率

(3)  LinkedHashSet

• LinkedHashSet 是 HashSet 的子类
• LinkedHashSet 根据元素的 hashCode 值来决定元素的存储位置，但它同时使用双向链表维护元素的次序，每个元素都是双向链表节点，这使得元素看起来是以插入顺序保存的。
• LinkedHashSet插入性能略低于 HashSet， 但对于频繁的遍历操作有很好的性能。
• LinkedHashSet 不允许集合元素重复。

(4)  TreeSet

• TreeSet 是 SortedSet 接口的实现类， TreeSet 可以确保集合元素处于排序状态。
• TreeSet底层使用红黑树结构存储数据
• 新增方法
• Comparator comparator()
• Object first()
• Object last()
• Object lower(Object e)
• Object higher(Object e)
• SortedSet subSet(fromElement, toElement)
• SortedSet headSet(toElement)
• SortedSet tailSet(fromElement)
• TreeSet 两种排序方法： 自然排序和定制排序。默认情况下， TreeSet 采用自然排序。
• 自然排序：要在自定义类中实现Comparerable<T>接口  ，并且重写compareTo方法
• 定制排序：在自定义类中实现Comparetor<t>接口，重写compare方法

4、Map接口

• Map与Collection并列存在。用于保存具有映射关系的数据:key-value
• Map 中的 key 和 value 都可以是任何引用类型的数据，key 和 value 之间存在单向一对一关系，即通过指定的 key 总能找到唯一的、确定的 value
• Map 中的 key 用Set来存放，不允许重复，key对象所对应的类，须重写hashCode()和equals()方法。
• Map中的value用Collection来存放，可重复，value所在的类要重写equals()方法。
• key-value构成了一个Entry对象。Map中的entry:无序的、不可重复的，使用Set存储所有的entry
• Map接口的常用实现类： HashMap、 TreeMap、 LinkedHashMap和Properties。 其中， HashMap是 Map 接口使用频率最高的实现类

(1) 常用方法

增删改操作

• bject put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
• void putAll(Map m):将m中的所有key-value对存放到当前map中
• Object remove(Object key)：移除指定key的key-value对，并返回value
• void clear()：清空当前map中的所有数据

元素查询的操作：

• Object get(Object key)：获取指定key对应的value
• boolean containsKey(Object key)：是否包含指定的key
• boolean containsValue(Object value)：是否包含指定的value
• int size()：返回map中key-value对的个数
• boolean isEmpty()：判断当前map是否为空
• boolean equals(Object obj)：判断当前map和参数对象obj是否相等

元视图操作的方法：

• Set keySet()：返回所有key构成的Set集合
• Collection values()：返回所有value构成的Collection集合
• Set entrySet()：返回所有key-value对构成的Set集合

5、HashMap类

• HashMap是 Map 接口使用频率最高的实现类。
• 允许使用null键和null值，与HashSet一样，不保证映射的顺序。
• key-value构成一个entry，所有的entry构成的集合是Set:无序的、不可重复的
• 所有的key构成的集合是Set：无序的、不可重复的。key所在的类要重写：equals()和hashCode()。key相等的标准是： equals() 方法返回 true，hashCode 值也相等。
• 所有的value构成的集合是Collection：无序的、可以重复的。value所在的类要重写： equals()。value相等的标准是：equals() 方法返回 true。

   

(1) JDK1.7底层原理

1. HashMap内部结构 

• HashMap的内部存储结构其实是数组和链表的结合。 当实例化一个HashMap时，系统会创建一个长度为Capacity（16）的Entry数组， 这个长度在哈希表中被称为容量(Capacity)， 在这个数组中可以存放元素的位置我们称之为“桶” (bucket)， 每个bucket都有自己的索引， 系统可以根据索引快速的查找bucket中的元素。
• 每个bucket中存储一个元素， 即一个Entry对象， 但每一个Entry对象可以带一个引用变量， 用于指向下一个元素， 因此， 在一个桶中， 就有可能生成一个Entry链。而且新添加的元素作为链表的head。

2. 添加元素过程

• 向HashMap中添加entry1(key， value)， 需要首先计算entry1中key的哈希值(根据key所在类的hashCode()计算得到)， 此哈希值经过处理以后， 得到在底层Entry[]数组中要存储的位置i。
• 如果位置i上没有元素， 则entry1直接添加成功。 如果位置i上已经存在entry2(或还有链表存在的entry3， entry4)， 则需要通过循环的方法， 依次比较entry1中key和其他的entry。 如果彼此hash值不同， 则直接添加成功。
• 如果hash值相同， 继续比较二者是否equals。 如果返回值为true， 则使用entry1的value去替换equals为true的entry的value。 如果遍历一遍以后， 发现所有的equals返回都为false,则entry1仍可添加成功。 entry1指向原有的entry元素。

3. 扩容机制

• 当HashMap中的元素越来越多的时候， hash冲突的几率也就越来越高， 因为数组的长度是固定的。 所以为了提高查询的效率， 就要对HashMap的数组进行扩容， 而在HashMap数组扩容之后， 最消耗性能的点就出现了：原数组中的数据必须重新计算其在新数组中的位置， 并放进去， 这就是resize。
• 当HashMap中的元素个数超过数组大小(数组总大小length，不是数组中个数(size)*loadFactor 时，就会进行数组扩容，loadFactor的默认值(DEFAULT_LOAD_FACTOR)为0.75， 这是一个折中的取值。 也就是说，默认情况下，数组大小(DEFAULT_INITIAL_CAPACITY)为16， 那么当HashMap中元素个数超过16*0.75=12（这个值就是代码中的threshold值， 也叫做临界值）的时候，就把数组的大小扩展为2*16=32，即扩大一倍，然后重新计算每个元素在数组中的位置，而这是一个非常消耗性能的操作，所以如果我们已经预知HashMap中元素的个数，那么预设元素的个数能够有效的提高HashMap的性能。

 

(2) JDK1.8底层原理

源码属性说明：

• DEFAULT_INITIAL_CAPACITY : HashMap的默认容量，16
• DEFAULT_LOAD_FACTOR：HashMap的默认加载因子：0.75
• threshold：扩容的临界值，=容量*填充因子：16 * 0.75 =>  12
• TREEIFY_THRESHOLD：Bucket中链表长度大于该默认值，转化为红黑树:8
• MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量:64

1. 内部结构

• HashMap的内部存储结构其实是数组+链表+树的结合。 当实例化一个HashMap时， 会初始化initialCapacity和loadFactor， 在put第一对映射关系时， 系统会创建一个长度为initialCapacity的Node数组， 这个长度在哈希表中被称为容量(Capacity)， 在这个数组中可以存放元素的位置我们称之为“桶” (bucket)， 每个bucket都有自己的索引， 系统可以根据索引快速的查找bucket中的元素。
• 每个bucket中存储一个元素， 即一个Node对象， 但每一个Node对象可以带一个引用变量next， 用于指向下一个元素， 因此， 在一个桶中， 就有可能生成一个Node链。 也可能是一个一个TreeNode对象， 每一个TreeNode对象可以有两个叶子结点left和right， 因此， 在一个桶中， 就有可能生成一个TreeNode树。 而新添加的元素作为链表的last， 或树的叶子结点。

2. 扩容机制

• 当HashMap中的元素个数超过数组大小(数组总大小length，不是数组中个数(size)*loadFactor 时，就会进行数组扩容，loadFactor的默认值(DEFAULT_LOAD_FACTOR)为0.75， 这是一个折中的取值。 也就是说，默认情况下，数组大小(DEFAULT_INITIAL_CAPACITY)为16， 那么当HashMap中元素个数超过16*0.75=12（这个值就是代码中的threshold值， 也叫做临界值）的时候，就把数组的大小扩展为2*16=32，即扩大一倍，然后重新计算每个元素在数组中的位置，而这是一个非常消耗性能的操作，所以如果我们已经预知HashMap中元素的个数，那么预设元素的个数能够有效的提高HashMap的性能。
• 当HashMap中的其中一个链的对象个数如果达到了8个，此时如果capacity没有达到64，那么HashMap会先扩容解决，如果已经达到了64，那么这个链会变成树，结点类型由Node变成TreeNode类型。当然，如果当映射关系被移除后，下次resize方法时判断树的结点个数低于6个，也会把树再转为链表。

3. 关于映射关系的key是否可以修改？ answer：不要修改

• 映射关系存储到HashMap中会存储key的hash值，这样就不用在每次查找时重新计算每一个Entry或Node（TreeNode）的hash值了，因此如果已经put到Map中的映射关系，再修改key的属性，而这个属性又参与hashcode值的计算，那么会导致匹配不上。

4. 负载因子

• 负载因子的大小决定了HashMap的数据密度。
• 负载因子越大密度越大，发生碰撞的几率越高，数组中的链表越容易长,造成查询或插入时的比较次数增多，性能会下降。
• 负载因子越小，就越容易触发扩容，数据密度也越小，意味着发生碰撞的几率越小，数组中的链表也就越短，查询和插入时比较的次数也越小，性能会更高。但是会浪费一定的内容空间。而且经常扩容也会影响性能，建议初始化预设大一点的空间。
• 按照其他语言的参考及研究经验，会考虑将负载因子设置为0.7~0.75，此时平均检索长度接近于常数。

(3) JDK1.8与JDK1.7的不同

• HashMap map = new HashMap();//默认情况下，先不创建长度为16的数组当首次调用map.put()时，再创建长度为16的数组
• 数组为Node类型，在jdk7中称为Entry类型
• 形成链表结构时，新添加的key-value对在链表的尾部（七上八下）
• 当数组指定索引位置的链表长度大于8时，且map中的数组的长度大于64时，此索引位置上的所有key-value对使用红黑树进行存储。

(4) LinkedHashMap

• LinkedHashMap 是 HashMap 的子类
• 在HashMap存储结构的基础上，使用了一对双向链表来记录添加元素的顺序。与HashMap不同的是使用Entry存储元素
• 与LinkedHashSet类似， LinkedHashMap 可以维护 Map 的迭代。顺序：迭代顺序与 Key-Value 对的插入顺序一致

(5) 面试题：

1. HashMap的底层实现原理？
2. HashMap 和 Hashtable的异同？
3. CurrentHashMap 与 Hashtable的异同？（暂时不讲)

6、TreeMap类

• TreeMap存储 Key-Value 对时， 需要根据 key-value 对进行排序。TreeMap 可以保证所有的 Key-Value 对处于有序状态。
• TreeSet底层使用红黑树结构存储数据
• TreeMap 的 Key 的排序：
• 自然排序： TreeMap 的所有的 Key 必须实现 Comparable 接口，而且所有的 Key 应该是同一个类的对象，否则将会抛出 ClasssCastException
• 定制排序：创建 TreeMap 时，传入一个 Comparator 对象，该对象负责对TreeMap 中的所有 key 进行排序。此时不需要 Map 的 Key 实现Comparable 接口
• TreeMap判断两个key相等的标准：两个key通过compareTo()方法或者compare()方法返回0。

7、HashTable类

• Hashtable是个古老的 Map 实现类， JDK1.0就提供了。不同于HashMap，Hashtable是线程安全的。

(1) 与HashMap比较

1. 相同点
• 实现原理相同，功能相同。底层都使用哈希表结构，查询速度快，很多情况下可以互用。
• Hashtable也不能保证其中 Key-Value 对的顺序
• Hashtable判断两个key相等、两个value相等的标准， 与HashMap一致。
2. 不同点
• Hashtable 不允许使用 null 作为 key 和 value

(2) Properties

• Properties 类是 Hashtable 的子类，该对象用于处理属性文件
• 由于属性文件里的 key、 value 都是字符串类型，所以 Properties 里的 key和 value 都是字符串类型
• 存取数据时，建议使用setProperty(String key,String value)方法和getProperty(String key)方法

8、Collections工具类

• Collections 是一个操作 Set、 List 和 Map 等集合的工具类
• Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法

(1) 排序方法：

• reverse(List)： 反转 List 中元素的顺序
• shuffle(List)： 对 List 集合元素进行随机排序
• sort(List)： 根据元素的自然顺序对指定 List 集合元素按升序排序
• sort(List，Comparator)： 根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
• swap(List，int，int)： 将指定 list 集合中的 i 处元素和 j 处元素进行交换

(2) 查找替换方法：

• 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 对象的所有旧值

(3) 线程同步控制方法：

ArrayList和HashMap都是线程不安全的，如果程序要求线程安全，我们可以将ArrayList、HashMap转换为线程的。使用synchronizedList(List list） 和  synchronizedMap(Map map）

这篇关于Java集合框架总结的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！