java 集合框架类_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 strList = new ArrayList();

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;

}

privateEntry addBefore(E e, Entry entry) {

Entry newEntry = new Entry(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、指定位置添加数据

publicvoid 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 entry(int index) {

if (index < 0 || index >= size)

throw new IndexOutOfBoundsException("Index: "+index+

", Size: "+size);

Entry 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 = entry(index);

E oldVal = e.element;

e.element = element;

return oldVal;

}

结论：修改相应节点的值

(4)遍历

略。

2、Set

HashSet(底层由HashMap实现)

public HashSet() {

map = new HashMap();

}

HashSet实现是利用HashMap的Key存储值。Value都是Object。

(1)增加

参考HashMap实现。

(2)删除

参考HashMap实现。

(3)修改

参考HashMap实现。

(4)遍历

参考HashMap实现。

TreeSet(底层由TreeMap实现)

public TreeSet() {

this(new TreeMap());

}

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可以重复。

每对组成一个单元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 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 e = table[bucketIndex];

table[bucketIndex] = new Entry(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 keys = hashMap.keySet();

for(String key : keys){

System.out.print("key: " + key);

System.out.print("value: " + hashMap.get(key));

System.out.println();

}

/**

* 2、第二种遍历方法

*/

Set> entrys1 = hashMap.entrySet();

for(Map.Entry entry : entrys1){

System.out.print("key: " + entry.getKey());

System.out.print("value: " + entry.getValue());

System.out.println();

}

/**

* 3、第三种遍历方法(推荐)

*/

Set> entrys2 = hashMap.entrySet();

Iterator> iter = entrys2.iterator();

while(iter.hasNext()){

Map.Entry entry = iter.next();

System.out.print("key: " + entry.getKey());

System.out.print("value: " + entry.getValue());

System.out.println();

}

2、TreeMap(按Key值的有序排列)

底层由一个红黑树结构构成。每个节点都是一个Entity对象。

(1)增加

publicV put(K key, V value) {

Entry 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(key, value, null);

size = 1;

modCount++;

return null;

}

int cmp;

Entry 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 e = new Entry(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 {

final K key;

final int hash;

volatile V value;

final HashEntry next;

}

可以看到除了value不是final的，其它值都是final的，这意味着不能从hash链的中间或尾部添加或删除节点，因为这需要修改next 引用值，所有的节点的修改只能从头部开始。对于put操作，可以一律添加到Hash链的头部。但是对于remove操作，可能需要从中间删除一个节点，这就需要将要删除节点的前面所有节点整个复制一遍，最后一个节点指向要删除结点的下一个结点。这在讲解删除操作时还会详述。为了确保读操作能够看到最新的值，将value设置成volatile，这避免了加锁

Iterable接口和Comparator、Comparable接口

1、Iterable接口

public interface Iterator {

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)数组的查找(二分查找等)