java 集合框架快速预览

为什么80%的码农都做不了架构师？>>>   

集合 链表 队列 栈 数组 映射 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

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

Collection包含了List和Set两大分支

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

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

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

Set的实现类有HastSet和TreeSet

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

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

2. 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();
    }

转载于:https://my.oschina.net/kipeng/blog/1836988