已经有数组了,为什么还要使用集合?
Java中数组长度不可变,然而实际情况中数据量往往不确定,这类数据不适合用数组存储,这时候就需要使用集合。
1 Java Collection 接口
表示集合的接口:
接口是集合的抽象数据类型,提供对集合中所表示的内容进行单独操作的可能。
- Collection 接口:该接口是最基本的集合接口,一个 Collection 代表一个元素。
- 线性表List :该接口实现了 Collection 接口。List 是有序集合,允许有相同的元素。使用 List 能够精确地控制每个元素插入的位置,用户能够使用索引(元素在 List 中的位置,类似于数组下标)来访问 List 中的元素,与数组类似。
- Set 接口:该接口也实现了 Collection 接口。它不能包含重复的元素,SortedSet 是按升序排列的 Set 集合。
- Map 接口:包含键值对,Map 不能包含重复的键。SortedMap 是一个按升序排列的 Map 集合。
接口实现类:
- 实现 Set 接口的常用类有 HashSet 和 TreeSet,它们都可以容纳所有类型的对象,但是不能保证序列顺序永久不变。
HashSet:为优化査询速度而设计的 Set。它是基于 HashMap 实现的,HashSet 底层使用 HashMap 来保存所有元素,实现比较简单。
TreeSet:该类不仅实现了 Set 接口,还实现了 java.util.SortedSet 接口,该实现类是一个有序的 Set,这样就能从 Set 里面提取一个有序序列。 - 实现 List 接口的常用类有 ArrayList 和 LinkedList,它们也可以容纳所有类型的对象包括 null,并且都保证元素的存储位置。
ArrayList:一个用数组实现的 List,能进行快速的随机访问,效率高而且实现了可变大小的数组。(Vector也实现了List接口,与ArrayList相比,访问和修改向量的方法为同步方法,其他的两者都相同。如果不需要同步,ArrayList效率更高。)
LinkedList:对顺序访问进行了优化,但随机访问的速度相对较慢。此外它还有 addFirst()、addLast()、getFirst()、getLast()、removeFirst() 和 removeLast() 等方法,能把它当成栈(Stack)或队列(Queue)来用。 - 实现 Map 映射的类是 HashMap,可实现一个键到值的映射。
Collection 接口是 List 接口和 Set 接口的父接口,通常情况下不被直接使用。Collection 接口定义了一些通用的方法,通过这些方法可以实现对集合的基本操作。因为 List 接口和 Set 接口继承自 Collection 接口,所以也可以调用这些方法。
方法名称 | 说明 |
---|---|
boolean add(E e) | 向集合中添加一个元素,E 是元素的数据类型 |
boolean addAll(Collection c) | 向集合中添加集合 c 中的所有元素 |
void clear() | 删除集合中的所有元素 |
boolean contains(Object o) | 判断集合中是否存在指定元素 |
boolean containsAll(Collection c) | 判断集合中是否包含集合 c 中的所有元素 |
boolean isEmpty() | 判断集合是否为空 |
Iteratoriterator() | 返回一个 Iterator 对象,用于遍历集合中的元素 |
boolean remove(Object o) | 从集合中删除一个指定元素 |
boolean removeAll(Collection c) | 从集合中删除所有在集合 c 中出现的元素 |
boolean retainAll(Collection c) | 仅仅保留集合中所有在集合 c 中出现的元素 |
int size() | 返回集合中元素的个数 |
Object[] toArray() | 返回包含此集合中所有元素的数组 |
2 线性表 — List
常用的线性表List的实现类有两个:数组线性表类(ArrayList)、链表类(LinkedList)。
- ArrayList 类用数组存储元素。若想通过下标随机访问元素,且不会频繁地在线性表的起始位置插入和删除元素,那么ArrayList效率最高。
- LinkedList 类用链表存储元素。若需要在线性表的起始位置上频繁地插入或删除元素,应该使用LinkedList。
遍历LinkedList不要使用get(i),太耗时,应使用迭代器。foreach()隐式地实现了迭代器。
注意:ArrayList、LinkedList在中间或末尾位置上插入或删除元素,具有同样的性能。
ArrayList为了进行快速随机访问,专门提供了以下方法:
方法名称 | 说明 |
---|---|
E get(int index) | 获取此集合中指定索引位置的元素,E 为集合中元素的数据类型 |
int index(Object o) | 返回此集合中第一次出现指定元素的索引,如果此集合不包含该元素,则返回 -1 |
int lastIndexOf(Object o) | 返回此集合中最后一次出现指定元素的索引,如果此集合不包含该元素,则返回 -1 |
E set(int index, E element) | 将此集合中指定索引位置的元素修改为 element 参数指定的对象。此方法返回此集合中指定索引位置的原元素 |
List subList(int fromlndex, int tolndex) | 返回一个新的集合,新集合中包含fromlndex 和 tolndex 索引之间的所有元素。包含 fromlndex 处的元素,不包含 tolndex 索引处的元素 |
LinkedList为了更好地支持插入删除元素,专门提供了以下方法,可以看出LinkedList特别适合于经常处理首尾元素的场景。
方法名称 | 说明 |
---|---|
void addFirst(E e) | 将指定元素添加到此集合的开头 |
void addLast(E e) | 将指定元素添加到此集合的末尾 |
E getFirst() | 返回此集合的第一个元素 |
E getLast() | 返回此集合的最后一个元素 |
E removeFirst() | 删除此集合中的第一个元素 |
E removeLast() | 删除此集合中的最后一个元素 |
3 Set
- 散列类 HashSet
HashSet其中的元素是无序的。是按照哈希算法来存储集合中的元素,使用哈希算法可以提高集合元素的存储速度,当向 Set 集合中添加一个元素时,HashSet 会调用该元素的 hashCode() 方法,获取其哈希码,然后根据这个哈希码计算出该元素在集合中的存储位置。
适用场景:无序列表,底层使用哈希树实现。 - 链式散列集 LinkedHashSet
LinkedHashSet使用链表实现,其中的元素保持了插入时的顺序。 - 树形集 TreeSet
类中的元素可以按照自然顺序进行排序。同时实现了 Set 接口和 SortedSet 接口。SortedSet 接口是 Set 接口的子接口,可以实现对集合进行自然排序,因此使用 TreeSet 类实现的 Set 接口默认情况下是自然排序的,这里的自然排序指的是升序排序。
适用场景:有序列表,底层使用红黑树实现,通过对红黑树的后推得到顺序集合。
.
TreeSet 只能对实现了 Comparable 接口的类对象进行排序,因为 Comparable 接口中有一个 compareTo(Object o) 方法用于比较两个对象的大小。例如 a.compareTo(b),如果 a 和 b 相等,则该方法返回 0;如果 a 大于 b,则该方法返回大于 0 的值;如果 a 小于 b,则该方法返回小于 0 的值。
.
TreeSet为了方便有序数据的场景,专门定义了下面的方法:
方法名称 | 说明 |
---|---|
E first() | 返回此集合中的第一个元素。其中,E 表示集合中元素的数据 类型 |
E last() | 返回此集合中的最后一个元素 |
E poolFirst() | 获取并移除此集合中的第一个元素 |
E poolLast() | 获取并移除此集合中的最后一个元素 |
SortedSet subSet(E fromElement,E toElement) | 返回一个新的集合,新集合包含原集合中 fromElement 对象与 toElement对象之间的所有对象。包含 fromElemen t对象,不包含 toElement 对象 |
SortedSet headSet<E toElement〉 | 返回一个新的集合,新集合包含原集合中 toElement 对象之前的所有对象。不包含 toElement 对象 |
SortedSet tailSet(E fromElement) | 返回一个新的集合,新集合包含原集合中 fromElement 对象之后的所有对象。包含 fromElement 对象 |
如何选择HashSet与TreeSet?
需要排序功能时才使用TreeSet,不需要排序时都使用HashSet。
HashSet与TreeSet的底层运行方式:
-
TreeSet集合对象的加入过程
TreeSet的底层是通过二叉树(红黑树)来完成存储的,无序的集合
当我们将一个对象加入treeset中,treeset会将第一个对象作为根对象,然后调用对象的compareTo方法拿第二个对象和第一个比较,当返回至=0时,说明2个对象内容相等,treeset就不把第二个对象加入集合。返回>1时,说明第二个对象大于第一个对象,将第二个对象放在右边,返回-1时,则将第二个对象放在左边,依次类推 -
HashSet集合对象的加入过程
hashset底层是hash值的地址,它里面存的对象是无序的。
第一个对象进入集合时,hashset会调用object类的hashcode根据对象在堆内存里的地址调用对象重写的hashcode计算出一个hash值,然后第一个对象就进入hashset集合中的任意一个位置。
第二个对象开始进入集合,hashset先根据第二个对象在堆内存的地址调用对象的hashcode计算出一个hash值,如果第二个对象和第一个对象在堆内存里的地址是相同的,那么得到的hash值也是相同的,直接返回true,hash得到true后就不把第二个元素加入集合(这段是hash源码程序中的操作)。如果第二个对象和第一个对象在堆内存里地址是不同的,这时hashset类会先调用自己的方法遍历集合中的元素,当遍历到某个元素时,调用对象的equals方法,如果相等,返回true,则说明这两个对象的内容是相同的,hashset得到true后不会把第二个对象加入集合。
最重要:
- TreeSet 是二差树实现的,Treeset中的数据是自动排好序的,不允许放入null值。
- HashSet 是哈希表实现的,HashSet中的数据是无序的,可以放入null,但只能放入一个null,两者中的值都不能重复,就如数据库中唯一约束。
- HashSet要求放入的对象必须实现HashCode()方法,放入的对象,是以hashcode码作为标识的,而具有相同内容的 String对象,hashcode是一样,所以放入的内容不能重复。但是同一个类的对象可以放入不同的实例 。
参考文献:HashSet与TreeSet 区别
4 映射表 Map
Map 接口常用的实现类有三个:散列映射表HashMap、链式散列映射表LinkedHashMap、树形映射表TreeMap。
- HashMap
元素无序。 - LinkedHashMap
元素有两种顺序:插入顺序,访问顺序。
插入顺序:元素按照插入映射表的顺序排序。使用无参构造方法创建LinkedHashMap对象。
访问顺序:元素按最后一次被访问的顺序排序。 - TreeMap
键可以使用Comparable或Comparator接口实现排序。
Map 接口中提供的常用方法如表 1 所示。
方法名称 | 说明 |
---|---|
V get(Object key) | 返回 Map 集合中指定键对象所对应的值。V 表示值的数据类型 |
V put(K key, V value) | 向 Map 集合中添加键-值对,返回 key 以前对应的 value,如果没有, 则返回 null |
V remove(Object key) | 从 Map 集合中删除 key 对应的键-值对,返回 key 对应的 value,如 果没有,则返回null |
Set entrySet() | 返回 Map 集合中所有键-值对的 Set 集合,此 Set 集合中元素的数据 类型为 Map.Entry |
Set keySet() | 返回 Map 集合中所有键对象的 Set 集合 |
HashMap与TreeMap的底层实现与选择方法与HashSet、TreeSet相似。
- 使用HashMap要求添加的键类明确定义了HashCode()和equals()方法(可以重写这两个方法),为了优化HashMap空间的使用,你可以调优初始容量和负载因子。
- TreeMap是SortedMap接口基于红黑树的实现。TreeMap没有调优选项,因为该树总处于平衡状态;
- TreeMap是非线程安全的,可以通过如下方式实现线程安全。
Map m=Collections.synchronizedSortedMap(new TreeMap())
5 List、Set、Map的线程安全问题
5.1 如何保证线程安全?
1 使用Vector/Stack/HashTable
Hashtable解析:
Hashtable在jdk1.1就有了,那么它是怎样实现线程安全的呢?主要看put、remove、get方法猜它肯定进行的同步控制的。于是看源码:
//put、remove、get都搞成了同步方法,保证了get的安全性
public synchronized V put(K key, V value) {……}
public synchronized V get(Object key) {……}
public synchronized V remove(Object key) {……}
所以为什么Hashtable是线程安全的,因为它的remove,put,get做成了同步方法,保证了Hashtable的线程安全性。
Vector解析
Vector也是用同步方法保证线程安全的。看源码:
public synchronized void addElement(E obj) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = obj;
}
public synchronized boolean removeElement(Object obj) {
modCount++;
int i = indexOf(obj);
if (i >= 0) {
removeElementAt(i);
return true;
}
return false;
}
源码中的modCount是什么?
我们知道 java.util.HashMap 不是线程安全的,因此如果在使用迭代器的过程中有其他线程修改了map,那么将抛出 ConcurrentModificationgException,这就是所谓 fail-fast 策略
fail-fast 机制是java集合(Collection)中的一种错误机制。当多个线程对同一个集合的内容进行操作时,就可能会产生fail-fast 事件。
若在多线程环境下使用 fail-fast机制的集合,建议使 “java.util.concurrent 包下的类” 去取代 “java.util 包下的类”。
建议阅读:java.util.Concurrent包下面的常见类
2 将非线程安全的集合转换为线程安全
– 使用Collections.synchronizedXX()方法构建
例如Collections.synchronizedList、Collections.synchronizedMap()、Collections.SynchronizedSortedMap
//make thread-safe list
List MyStrList = Collections.synchronizedList(new ArrayList());
MyStrList.add("123");
MyStrList.add("abc");
//make thread-safe hashset
Set set=Collections.synchronizedSet(new HashSet());
set.add(123);
set.add(456);
//make thread-safe hashmap
Map map=Collections.synchronizedMap(new HashMap());
map.put(1, "thb");
map.put(12, "bill tang");
Collections.synchronizedMap()解析
源码:
public int size() {
synchronized (mutex) {return m.size();}
}
public boolean isEmpty() {
synchronized (mutex) {return m.isEmpty();}
}
public boolean containsKey(Object key) {
synchronized (mutex) {return m.containsKey(key);}
}
public boolean containsValue(Object value) {
synchronized (mutex) {return m.containsValue(value);}
}
public V get(Object key) {
synchronized (mutex) {return m.get(key);}
}
public V put(K key, V value) {
synchronized (mutex) {return m.put(key, value);}
}
public V remove(Object key) {
synchronized (mutex) {return m.remove(key);}
}
public void putAll(Map<? extends K, ? extends V> map) {
synchronized (mutex) {m.putAll(map);}
}
public void clear() {
synchronized (mutex) {m.clear();}
}
我们惊人的发现,synchronizedMap只是将HashMap的操纵放在了同步代码块中来保证SynchronizedMap的线程安全性。因此,SynchronizedMap也可以允许key和value为null。这样带来的问题也是任何一个时刻只能有一个线程可以操纵synchronizedMap,所以其效率比较低。
—使用ThreadLocal构建