java 集合框架快速预览

集合 链表 队列 栈 数组 映射 java.util.*

Java集合主要可以划分为4个部分：List列表、Set集合、Map映射、工具类(Iterator迭代器、Enumeration枚举类、Arrays和Collections)



Collection

public interface Collection<E> extends Iterable<E>

List

public interface List<E> extends Collection<E>

Set

public interface Set<E> extends Collection<E>

Queue

public interface Queue<E> extends Collection<E>

Map

public interface Map<K,V>

大致说明

看上面的框架图，先抓住它的主干，即Collection和Map

Collection是一个接口，是高度抽象出来的集合，它包含了集合的基本操作和属性

Collection包含了List和Set两大分支

List是一个有序的队列，每一个元素都有它的索引。第一个元素的索引值是0

List的实现类有LinkedList, ArrayList, Vector, Stack

Set是一个不允许有重复元素的集合

Set的实现类有HastSet和TreeSet

HashSet依赖于HashMap，它实际上是通过HashMap实现的

TreeSet依赖于TreeMap，它实际上是通过TreeMap实现的

Map是一个映射接口，即key-value键值对

AbstractMap是个抽象类，它实现了Map接口中的大部分API。而HashMap，TreeMap，WeakHashMap都是继承于AbstractMap

Hashtable虽然继承于Dictionary，但它实现了Map接口

terator 它是遍历集合的工具，即我们通常通过Iterator迭代器来遍历集合

我们说Collection依赖于Iterator，是因为Collection的实现类都要实现iterator()函数，返回一个Iterator对象

ListIterator是专门为遍历List而存在的

Enumeration

它是JDK 1.0引入的抽象类。作用和Iterator一样，也是遍历集合；但是Enumeration的功能要比Iterator少

Collection架构

AbstractCollection抽象类，它实现了Collection中的绝大部分函数,在Collection的实现类中，我们就可以通过继承AbstractCollection省去重复编码

AbstractList和AbstractSet都继承于AbstractCollection，具体的List实现类继承于AbstractList，而Set的实现类则继承于AbstractSet

Collection 介绍

下面是JDK1.8的实现，它是一个接口，是高度抽象出来的集合，它包含了集合的基本操作：添加、删除、清空、遍历(读取)、是否为空、获取大小、是否保护某元素等等

public interface Collection<E> extends Iterable<E> {
int size();

boolean isEmpty();

boolean contains(Object var1);

Iterator<E> iterator();

Object[] toArray();

<T> T[] toArray(T[] var1);

boolean add(E var1);

boolean remove(Object var1);

boolean containsAll(Collection<?> var1);

boolean addAll(Collection<? extends E> var1);

boolean removeAll(Collection<?> var1);

default boolean removeIf(Predicate<? super E> var1) {
Objects.requireNonNull(var1);
boolean var2 = false;
Iterator var3 = this.iterator();

while(var3.hasNext()) {
if (var1.test(var3.next())) {
var3.remove();
var2 = true;
}
}

return var2;
}

boolean retainAll(Collection<?> var1);

void clear();

boolean equals(Object var1);

int hashCode();

default Spliterator<E> spliterator() {
return Spliterators.spliterator(this, 0);
}

default Stream<E> stream() {
return StreamSupport.stream(this.spliterator(), false);
}

default Stream<E> parallelStream() {
return StreamSupport.stream(this.spliterator(), true);
}
}

List简介

public interface List<E> extends Collection<E>

AbstractCollection

实现了Collection 有两个方法 iterator和size没有实现

public abstract Iterator<E> iterator();

public abstract int size();

里面的一些主要实现是基于iterator的，比如toArray()、remove()

public Object[] toArray() {
// Estimate size of array; be prepared to see more or fewer elements
Object[] r = new Object[size()];
Iterator<E> it = iterator();
for (int i = 0; i < r.length; i++) {
if (! it.hasNext()) // fewer elements than expected
return Arrays.copyOf(r, i);
r[i] = it.next();
}
return it.hasNext() ? finishToArray(r, it) : r;
}

public boolean remove(Object o) {
Iterator<E> it = iterator();
if (o==null) {
while (it.hasNext()) {
if (it.next()==null) {
it.remove();
return true;
}
}
} else {
while (it.hasNext()) {
if (o.equals(it.next())) {
it.remove();
return true;
}
}
}
return false;
}

注意点：add方法需要实现类自己具体去重写

/**
* {@inheritDoc}
*
* <p>This implementation always throws an
* <tt>UnsupportedOperationException</tt>.
*
* @throws UnsupportedOperationException {@inheritDoc}
* @throws ClassCastException            {@inheritDoc}
* @throws NullPointerException          {@inheritDoc}
* @throws IllegalArgumentException      {@inheritDoc}
* @throws IllegalStateException         {@inheritDoc}
*/
public boolean add(E e) {
throw new UnsupportedOperationException();
}