Java集合包

2019独角兽企业重金招聘Python工程师标准>>>

集合包是java中最常用的包，最常用的有Collection和Map接口的实现类，前者用于存放多个单对象，后者用于存放key-value形式的键值对。

java集合包常用实现类结构图如下所示（I表示接口），更详细可以参考https://img-blog.csdn.net/20160124221843905

 

 

 

 

 

 

1. List

线性表，有序集合，元素可以重复。

1.1 ArrayList

动态数组，底层即数组，可以用来容纳任何对象，要求连续存放。ArrayList的重要成员是Object[] elementDate int Size表示有效元素的个数，数组的初始大小是10，扩容操作示意图如下，之前（上面）这块内存变成垃圾。 因此在初始化时尽量指定初始容量，避免扩容产生的内存垃圾，影响性能。

public ArrayList(int initialCapacity) {
    super();
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    this.elementData = new Object[initialCapacity];
}// 指定初始化大小

特点及使用注意

（1）foreach中能否对其基本类型元素值（包括数字、字符串、布尔）进行赋值改变？

 不能，高级For在JDK 5.0开始引入，用其迭代代码简洁，在foreach中修改的只是元素的副本，并不会改变原值（反编译之后可发现这一点），所以高级For循环可以用来遍历查询，不可修改当前取回的元素本身。

参考链接：http://me2xp.blog.51cto.com/6716920/1630007/

但是对象类型的元素有所不同，如果对对象数组进行遍历，则可以修改元素的状态，在每一轮循环中都可以拿到对象引用对其状态（成员变量、类变量）进行修改。

（2）如何正确遍历并删除ArrayList元素值？

问题背景：给定字符串集合["a","b","b","c"]，删除其中元素"b"。

常见错误写法1：

public static void remove(List<String> list) 
	{
		for (int i = 0; i < list.size(); i++) 
		{
			String s = list.get(i);
			if (s.equals("b")) 
			{
				list.remove(s);
			}
		}
	}
// 错误的原因：这种最普通的循环写法执行后会发现第二个“b”的字符串没有删掉。

常见错误写法2：

public static void remove(List<String> list) 
	{
		for (String s : list)
		{
			if (s.equals("b")) 
			{
				list.remove(s);
			}
		}
	}
// 使用增强的for循环 在循环过程中从List中删除元素以后，继续循环List时会报ConcurrentModificationException，但删除之后马上就跳出的也不会出现异常 

思考及对策

为何和出现错误1，怎么解决？

public boolean remove(Object o) {
		if (o == null) {
			for (int index = 0; index < size; index++)
				if (elementData[index] == null) {
					fastRemove(index);
					return true;
				}
		} else {
			for (int index = 0; index < size; index++)
				if (o.equals(elementData[index])) {
					fastRemove(index);
					return true;
				}
		}
		return false;
	}

private void fastRemove(int index) {
        modCount++;
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,numMoved);
        elementData[--size] = null; // Let gc do its work
    }

可以看到会执行System.arraycopy方法，导致删除元素时涉及到数组元素的移动。针对错误写法1，在遍历第一个字符串b时因为符合删除条件，所以将该元素从数组中删除，并且将后一个元素移动（也就是第二个字符串b）至当前位置，导致下一次循环遍历时后一个字符串b并没有遍历到，所以无法删除。针对这种情况可以倒序删除的方式来避免：

public static void remove(ArrayList<String> list) 
	{
		for (int i = list.size() - 1; i >= 0; i--) 
		{
			String s = list.get(i);
			if (s.equals("b")) 
			{
				list.remove(s);
			}
		}
	}

为何会出现错误2怎么解决？

final void checkForComodification() {
		if (modCount != expectedModCount)
			throw new ConcurrentModificationException();
	}

这里会做迭代器内部修改次数检查，因为上面的remove(Object)方法修改了modCount的值，所以才会报出并发修改异常。要避免这种情况的出现则在使用迭代器迭代时（显示或for-each的隐式）不要使用ArrayList的remove，改为用Iterator的remove即可：

public static void remove(List<String> list) 
		{
		Iterator<String> it = list.iterator();
		while (it.hasNext()) 
		{
			String s = it.next();
			if (s.equals("b")) 
			{
				it.remove();
			}
		}
}

部分参考：http://swiftlet.net/archives/743; http://elim.iteye.com/blog/1523785

（3）ArrayList非线程安全，如何解决？

Collections给出了解决方案，提供了synchronizedCollection方法，该方法返回一个线程安全容器。

*Java中常用的集合框架中的实现类HashSet、TreeSet、ArrayList、ArrayDeque、LinkedList、HashMap、TreeMap都是线程不安全的，如果有多个线程同时访问它们，且同时有多个线程修改他们的时候，将会出现如读脏数据等错误。Collections给出了解决方案，提供了synchronizedCollection方法来实现线程安全，该方法返回一个线程安全容器。

（4）contains方法contains()方法是通过将传入的实际参数和集合中已有的元素进行equals()比较来实现的，Object类中的equals()方法比较的是两个对象的地址，因此需要根据实际需要重写equals()方法。

1.2 LinkedList、Vector、Stack

ArrayList和LinkedList是List(线性表)的两种典型实现：基于数组和基于双向链表的线性表。一般而言，由于数组以一块连续内存区来保存所有的数组元素，所以数组在随机访问时性能最好，所有的内部以数组作为底层实现的集合在随机访问时性能都比较好；而内部以链表作为底层实现的集合在执行插入、删除操作时有较好的性能。但总体来说，ArrayList的性能要更好，因此大部分使用时都应该考虑使用ArrayList。

• 如果需要遍历List集合元素，对于ArrayList和Vector（也是以数组形式存储集合元素的一种集合类型）集合，应该使用随机访问方法（get）来遍历集合元素；对于LinkedList集合，则应该采用迭代器（Iterator）来遍历集合元素。
• 如果需要经常执行插入、删除操作来改变包含大量数据的List集合的大小，可以考虑使用LinkedList集合。使用ArrayList和Vector集合可能需要经常重新分配内部数组的大小，效果较差。
• 如果有多个线程需要同时访问List集合的元素，开发者可以考虑使用Collections将集合包装成线程安全的集合。

Vector是基于synchronized机制实现的线程安全的ArrayList，但在插入元素容量扩充时机制略有不同，通过传入的capacityIncrement来控制容量的扩充。

Stack继承自Vector，在此基础上实现了栈的弹出以及压入和弹出操作，push、pop、peek（只返回，不出栈）

2. Map

键值对、键唯一、值不唯一

2.1 HashMap

底层实现

JDK7实现，数组+链表；JDK8实现，数组+红黑树。

可参考：https://my.oschina.net/hosee/blog/618953

存储过程

当程序试图将一个 key-value 对放入 HashMap 中时，程序首先根据该 key 的 hashCode() 返回值决定该 Entry 的存储位置：如果两个 Entry 的 key 的 hashCode() 返回值相同，那它们的存储位置相同。如果这两个 Entry 的 key 通过 equals 比较返回 true，新添加 Entry 的 value 将覆盖集合中原有 Entry 的 value，但 key 不会覆盖。如果这两个 Entry 的 key 通过 equals 比较返回 false，新添加的 Entry 将与集合中原有 Entry 形成 Entry 链，而且新添加的 Entry 位于 Entry 链的头部。流程图如下所示：

读取实现

如果 HashMap 的每个 bucket 里只有一个 Entry 时，HashMap 可以根据索引、快速地取出该 bucket 里的 Entry；在发生“Hash 冲突”的情况下，单个 bucket 里存储的不是一个 Entry，而是一个 Entry 链，系统只能必须按顺序遍历每个 Entry，直到找到想搜索的 Entry 为止——如果恰好要搜索的 Entry 位于该 Entry 链的最末端（该 Entry 是最早放入该 bucket 中），那系统必须循环到最后才能找到该元素，时间复杂度取决于链表的长度，为 O(n)。为了降低这部分的开销，在 Java8 中当链表中的元素超过了 8 个以后会将链表转换为红黑树，在这些位置进行查找的时候可以降低时间复杂度为 O(logN)。

HashMap 在底层将 key-value 当成一个整体进行处理，这个整体就是一个 Entry 对象。HashMap 底层采用一个 Entry[] 数组来保存所有的 key-value 对，当需要存储一个 Entry 对象时，会根据 Hash 算法来决定其存储位置；当需要取出一个 Entry 时，也会根据 Hash 算法找到其存储位置，直接取出该 Entry。

性能选项

实际容量（capacity）:大于initial capacity最小的2的n次方，如10<16

初始容量（initial capacity）：可以通过HashMap的构造函数指定

size:变量保存了该 HashMap 中所包含的 key-value 对的数量

threshold：该变量包含了 HashMap 能容纳的 key-value 对的极限，它的值等于 HashMap 的容量乘以负载因子（load factor）

负载因子（load factor）：决定了Hash表的最大填满程度

当创建 HashMap 时，有一个默认的负载因子（load factor），其默认值为 0.75，这是时间和空间成本上一种折衷：增大负载因子可以减少 Hash 表（就是那个 Entry 数组）所占用的内存空间，但会增加查询数据的时间开销，而查询是最频繁的的操作（HashMap 的 get() 与 put() 方法都要用到查询）；减小负载因子会提高数据查询的性能，但会增加 Hash 表所占用的内存空间。掌握了上面知识之后，我们可以在创建 HashMap 时根据实际需要适当地调整 load factor 的值；如果程序比较关心空间开销、内存比较紧张，可以适当地增加负载因子；如果程序比较关心时间开销，内存比较宽裕则可以适当的减少负载因子。通常情况下，程序员无需改变负载因子的值。

2.2 TreeMap

采用红黑树的数据结构来管理key-value对（红黑树的每个节点就是一个key-value对）

存储key-value对需要根据key排序，排序方式与TreeSet相同（两种排序方式）。

判断两个key相等的标准是：通过compareTo()返回0即认为这两个key相等。

对于自定义类作为key的情况，最好做到：两个key通过equals()方法比较返回true时，compareTo()方法也返回0。

两种排序的比较器：

java.lang.Comparable，TreeMap使用无参构造函数，那么容纳的对象必须实现Comparable接口。

public int compareTo(T o);

java.util.Comparator，TreeSet在构造时使用Comparator作为构造函数的参数。（两种排序方式同时存在时，该方式优先权更高）

int compare(T o1, T o2);

public class LRUCache extends LinkedHashMap
{
    public LRUCache(int maxSize)
    {
        super(maxSize, 0.75F, true);
        maxElements = maxSize;
    }

    protected boolean removeEldestEntry(java.util.Map.Entry eldest)
    {
        return size() > maxElements;
    }

    private static final long serialVersionUID = 1L;
    protected int maxElements;
}

2.3 LinkedHashMap

LinkedHashMap是HashMap的一个子类，保存了记录的插入顺序，HashMap+LinkedList，即它既使用HashMap操作数据结构，又使用LinkedList维护插入元素的先后顺序，通过维护一个运行于所有条目的双向链表，LinkedHashMap保证了元素迭代的顺序。该迭代顺序可以是插入顺序或者是访问顺序。

可以通过LinkedHashMap实现LRU算法缓存。构造参数accessOrder为true则所有的Entry按照访问的顺序排列，为false则所有的Entry按照插入的顺序排列，如果设置为true，每次访问都把访问的那个数据移到双向队列的尾部去，那么每次要淘汰数据的时候，双向链表最头的那个数据就是要淘汰的数据。

2.4 Hashtable

Hashtable 是遗留类，很多映射的常用功能与 HashMap 类似，不同的是它承自 Dictionary 类，并且是线程安全的，任一时间只有一个线程能写 Hashtable，并发性不如 ConcurrentHashMap，因为 ConcurrentHashMap 引入了分段锁。Hashtable 不建议在新代码中使用，不需要线程安全的场合可以用 HashMap 替换，需要线程安全的场合可以用 ConcurrentHashMap 替换。

3. Set

无序、元素不可重复

3.1 HashSet

HashSet的底层实现用到HashMap，HashSet操作的就是HashMap。（Java源码就是先实现HashMap、TreeMap，然后包装一个value为null的Map集合来实现Set集合的）

存储过程

两个对象的equals()方法返回true，但是hashCode值不相等，这时HashSet会把这两个对象存储在Hash表的不同位置，两个对象均可以添加成功，但这会与Set集合的规则相冲突。(这就是不重写相应hashCode()方法的后果，也可阅读参考：http://blog.chinaunix.net/uid-26602509-id-3355659.html)

所以阿里Java规范这样写道：

HashSet如何判断对象是否是相同

两个对象通过equals()方法比较相等，并且两个对象的hashCode方法的返回值也相等。

因此需要注意：

当把一个对象放入HashSet中时，如果需要重写此对象对应类的equals()方法，则同时需要重写其hashCode()方法。具体规则是：如果两个对象通过equals()方法比较返回true时，则它们的hashCode值也应该相等（Object规范：相等的对象必须具有相等的hashcode）。

3.2 TreeSet

底层是TreeMap，集合中的元素处于排序状态。采用红黑树的数据结构来存储集合元素。TreeSet支持两种排序方式：自然排序（默认情况）和定制排序。

当把一个对象添加到TreeSet中时，TreeSet会调用该对象的compareTo(Object obj)方法与容器中的其它对象比较大小，然后根据红黑树结构找到它的存储位置。如果compareTo(Object obj)返回0，意味着两个对象相同将无法添加到TreeSet集合中。

3.3 LinkedHashSet

LikedHashSet是HashSet的子类，它也是根据元素的HashCode值进来决定元素的存储位置，但它能够同时使用链表来维护元素的添加次序，使得元素能以插入顺序保存。

附：阿里Java规范-集合

List／Set／Map判断对象相同方式的区别

import java.util.*;

class A {
    @Override
    public int hashCode() {
        return UUID.randomUUID().hashCode();
    }

    @Override
    public boolean equals(Object obj) {
        return true;
    }
}

public class Main {

    public static void main(String[] args) throws Exception {
        List<A> list = new ArrayList<>();
        A a1 = new A();
        A a2 = new A();
        list.add(a1);
        // list contains()方法是通过将传入的实际参数和集合中已有的元素进行equals()比较来实现的
        System.out.println(list.contains(a2));
        Map<A, Object> map = new HashMap<>();
        map.put(a1, null);
        System.out.println(map.containsKey(a2));
        Set<A> set = new HashSet<>();
        set.add(a1);
        System.out.println(set.contains(a2));
    }
}
// output:
true
false
false

那么HashSet是如何判断对象是否是相同的呢？

两个对象通过equals()方法比较相等，并且两个对象的hashCode方法的返回值也相等。

因此需要注意：

当把一个对象放入HashSet中时，如果需要重写此对象对应类的equals()方法，则同时需要重写其hashCode()方法。具体规则是：如果两个对象通过equals()方法比较返回true时，则它们的hashCode值也应该相等（Object规范：相等的对象必须具有相等的hashcode）。

Map与Set类似，List稍有不同，其contains()方法是通过将传入的实际参数和集合中已有的元素进行equals()比较来实现的，Object类中的equals()方法比较的是两个对象的地址，因此需要根据实际需要重写equals()方法。

 

 

转载于:https://my.oschina.net/u/2939155/blog/1486806