Java集合框架类
java集合框架类图
Collection接口（List、Set、Queue、Stack）：
Map接口：
Collection集合
1、List
ArrayList(数组)
（1） 增加
1、末尾插入
public boolean add(E e) {
ensureCapacity(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
2、指定位置插入
public void add(int index, E element) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(
"Index: "+index+", Size: "+size);
ensureCapacity(size+1); // Increments modCount!!
System.arraycopy(elementData, index, elementData, index + 1,size - index);
elementData[index] = element;
size++;
}
结论：指定位置插入需要移动大量元素的位置，所以效率不高。
（2） 修改
public E set(int index, E element) {
RangeCheck(index);
E oldValue = (E) elementData[index];
elementData[index] = element;
return oldValue;
}
结论：只能修改已经存在的对象。
（3） 删除
public E remove(int index) {
RangeCheck(index);
modCount++;
E oldValue = (E) elementData[index];
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; // Let gc do its work
return oldValue;
}
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;
}
结论：删除也会移动大量的元素。效率不高
（4） 遍历
List<String> strList = new ArrayList<String>();
strList.add(“123”);
for（String str ：strList）{
System.out.println(str);
}
总结：为了提高效率。最好为ArrayList的大小赋个初值。
LinkedList(双向链表)
（1） 增加
1、public boolean add(E e) {
addBefore(e, header);
return true;
}
private Entry<E> addBefore(E e, Entry<E> entry) {
Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
newEntry.previous.next = newEntry;
newEntry.next.previous = newEntry;
size++;
modCount++;
return newEntry;
}
2、 public void addFirst(E e) {
addBefore(e, header.next);
}
public void addLast(E e) {
addBefore(e, header);
}
3、指定位置添加数据
public void add(int index, E element) {
addBefore(element, (index==size ? header : entry(index)));
}
结论：正常Add（E e）方法就是在链表尾部添加节点。指定位置添加数据不需要移动大量数据。
只需改变带插入位置前后节点的指针即可。
（2） 删除
public E remove(int index) {
return remove(entry(index));
}
/**
* Returns the indexed entry.
*/
private Entry<E> entry(int index) {
if (index < 0 || index >= size)
throw new IndexOutOfBoundsException("Index: "+index+
", Size: "+size);
Entry<E> e = header;
if (index < (size >> 1)) {
for (int i = 0; i <= index; i++)
e = e.next;
} else {
for (int i = size; i > index; i--)
e = e.previous;
}
return e;
}
结论：从前向后遍历删除数据。删除和添加数据时候。不需要移动大量数据。只需遍历，
所以相对于ArrayList效率较高。
（3） 修改
public E set(int index, E element) {
Entry<E> e = entry(index);
E oldVal = e.element;
e.element = element;
return oldVal;
}
结论：修改相应节点的值
（4） 遍历
略。
2、Set
HashSet（底层由HashMap实现）
public HashSet() {
map = new HashMap<E,Object>();
}
HashSet实现是利用HashMap的Key存储值。Value都是Object。
（1） 增加
参考HashMap实现。
（2） 删除
参考HashMap实现。
（3） 修改
参考HashMap实现。
（4） 遍历
参考HashMap实现。
TreeSet（底层由TreeMap实现）
public TreeSet() {
this(new TreeMap<E,Object>());
}
TreeSet实现是利用TreeMap的Key存储值。Value都是Object。
（1） 增加
参考TreeMap实现。
（2） 删除
参考TreeMap实现。
（3） 修改
参考TreeMap实现。
（4） 遍历
参考TreeMap实现。
LinkedHashSet（底层由LinkedHashMap实现）
（1） 增加
参考LinkedHashMap实现。
（2） 删除
参考LinkedHashMap实现。
（3） 修改
参考LinkedHashMap实现。
（4） 遍历
参考LinkedHashMap实现。
3、Queue（先进先出）
底层数据结构是堆。
4、Stack（后进先出）
底层有数组实现。
(1) public synchronized E pop()
弹出栈顶元素,并删除栈顶元素。
(2) public synchronized E peek()
只弹出栈顶元素，不删除。
Map集合
<Key,value>的映射。Key不能重复。Value可以重复。
每对<Key,Value>组成一个单元Entity对象。
将Entity做为一个对象进行存储。
1、HashMap
底层维护一个Entity[]。
（1）增加
public V put(K key, V value) {
if (key == null)
return putForNullKey(value);
int hash = hash(key.hashCode());
int i = indexFor(hash, table.length);
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(hash, key, value, i);
return null;
}
void addEntry(int hash, K key, V value, int bucketIndex) {
Entry<K,V> e = table[bucketIndex];
table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
if (size++ >= threshold)
resize(2 * table.length);
}
结论：1允许key为Null，2根据key的hashcode值确定该Entity在数组中的位置。3若该位置存在Key得用newValue替换oldValue。否则插入链表头部
（2）删除、修改
根据key的hashCode值找到对应的Entity对象。进行修改和删除操作。
（3）遍历
/**
* 1、第一种遍历方法
*/
Set<String> keys = hashMap.keySet();
for(String key : keys){
System.out.print("key: " + key);
System.out.print("value: " + hashMap.get(key));
System.out.println();
}
/**
* 2、第二种遍历方法
*/
Set<Map.Entry<String, String>> entrys1 = hashMap.entrySet();
for(Map.Entry<String, String> entry : entrys1){
System.out.print("key: " + entry.getKey());
System.out.print("value: " + entry.getValue());
System.out.println();
}
/**
* 3、第三种遍历方法（推荐）
*/
Set<Map.Entry<String, String>> entrys2 = hashMap.entrySet();
Iterator<Map.Entry<String, String>> iter = entrys2.iterator();
while(iter.hasNext()){
Map.Entry<String, String> entry = iter.next();
System.out.print("key: " + entry.getKey());
System.out.print("value: " + entry.getValue());
System.out.println();
}
2、TreeMap（按Key值的有序排列）
底层由一个红黑树结构构成。每个节点都是一个Entity对象。
（1） 增加
public V put(K key, V value) {
Entry<K,V> t = root;
if (t == null) {
// TBD:
// 5045147: (coll) Adding null to an empty TreeSet should
// throw NullPointerException
//
// compare(key, key); // type check
root = new Entry<K,V>(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);
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();
Comparable<? super K> k = (Comparable<? super K>) key;
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<K,V>(key, value, parent);
if (cmp < 0)
parent.left = e;
else
parent.right = e;
fixAfterInsertion(e);
size++;
modCount++;
return null;
}
结论：1、TreeMap支持自定义排序。可以设置实现Comparator接口的自定义排序类。
如果没有设置自定义排序规则。则按照key值升序排序。
2、插入数据会进行比较找到待插入的位置。
（2） 删除
删除一个树节点，也会重新调整树结构。所以效率不高。
（3） 修改
略。
（4） 遍历
参考HashMap的遍历
3、LinkedHashMap
继承自HashMap，底层的数据结构与HashMap相似。只不过HashMap是数组中存储单向链表，LinkedHashMap是数组中存储双向链表
LinkedHashMap保存了记录的插入顺序，在用Iterator遍历LinkedHashMap时，先得到的记录肯定是先插入的。
(1) 增加
略
(2) 删除
略
(3) 修改
略
(4) 遍历
略
4、IdentityHashMap
Map由 key-value组成，key用于检索value的内容。在正常情况下，可以不允许重复；重复在java中分为 2中情况，
一是内存地址重复，另一个是不同的地址但内容相等，而IdentityHashMap用于后者，即内容相等。
更详细的解释如下：在 IdentityHashMap 中，当且仅当 (k1==k2) 时，才认为两个键 k1 和 k2 相等（在正常 Map 实现（如 HashMap）中，当且仅当满足下列条件时才认为两个键 k1 和 k2 相等：(k1==null ? k2==null : e1.equals(e2))）。
此类不是 通用 Map 实现！此类实现 Map 接口时，它有意违反 Map 的常规协定，该协定在比较对象时强制使用 equals 方法。此类设计仅用于其中需要引用相等性语义的罕见情况
5、ConcurrentHashMap
concurrenthashmap是一个非常好的map实现，在高并发操作的场景下会有非常好的效率。实现的目的主要是为了避免同步操作时对整个map对象进行锁定从而提高并发访问能力。
ConcurrentHashMap允许多个修改操作并发进行，其关键在于使用了锁分离技术。它使用了多个锁来控制对hash表的不同部分进行的修 改。ConcurrentHashMap内部使用段(Segment)来表示这些不同的部分，每个段其实就是一个小的hash table，它们有自己的锁。只要多个修改操作发生在不同的段上，它们就可以并发进行。
ConcurrentHashMap完全允许多个读操作并发进行，读操作并不需要加锁。如果使用传统的技术，如HashMap中的实现，如果允许可 以在hash链的中间添加或删除元素，读操作不加锁将得到不一致的数据。ConcurrentHashMap实现技术是保证HashEntry几乎是不可 变的。HashEntry代表每个hash链中的一个节点，其结构如下所示：
Java代码
- static final class HashEntry<K,V> {
- final K key;
- final int hash;
- volatile V value;
- final HashEntry<K,V> next;
- }
可以看到除了value不是final的，其它值都是final的，这意味着不能从hash链的中间或尾部添加或删除节点，因为这需要修改next 引用值，所有的节点的修改只能从头部开始。对于put操作，可以一律添加到Hash链的头部。但是对于remove操作，可能需要从中间删除一个节点，这就需要将要删除节点的前面所有节点整个复制一遍，最后一个节点指向要删除结点的下一个结点。这在讲解删除操作时还会详述。为了确保读操作能够看到最新的值，将value设置成volatile，这避免了加锁
Iterable接口和Comparator、Comparable接口
1、Iterable接口
public interface Iterator<E> {
boolean hasNext();
E next();
void remove();
}
集合中增强for循环。实际是利用Iterable接口。实现Iterable接口的集合或对象可以使用增强for循环。
2、Comparator、Comparable接口
实现Comparator、Comparable接口的类。可以自定义排序。
集合常用工具类
1、Collections
1）集合的排序
2）集合的二分查找。
3）集合的拷贝
4）集合的反转和旋转。
2、Arrays
Arrays.asList(数组对象) 将Array转化为List类型对象。
用Collection接口中的toArray方法，将集合转化为数组。
1）数组的排序
2）数组的交换
3）数组的拷贝
4）数组的查找（二分查找等）
