集合的整理

放一张集合关系图

1、开始

java集合就像个容器把多个对象丢进去（所以会有人称这个为java的容器）存在于java.util包下总的来说由Collection 进行延伸的也就是根接口

2、Collection接口

继承Iterable接口

注意：Iterable（java.lang）和 terator（java.util）区别

Iterable是接口 terator是迭代器实现Iterable接口才可以调用Iterator方法对象才可以使用foreach

Iterable 接口在java.lang包下这个接口下有Iterator<T> iterator();方法

Iterator 是迭代器迭代器有两个核心的方法 boolean hasNext()和E next() 可以用这个遍历ArrayList Set LinkedList

List<String> str=new ArrayList<>();
str.add("aaa");
str.add("bbbb");
Iterator<String> it=str.iterator();
while(it.hasNext()){
System.err.println("需要先next 然后再remove 否则会报错 java.lang.IllegalStateException==="+it.next());
it.remove();

Iterator 迭代器可以一边遍历一边进行删除操作

Iterable 可以调用Iterator()方法实现功能返回迭代器Iterator 另外还有增强for循环的方法（forEach(Consumer<? super T> action)）

为啥Collection不直接实现Iterator而是先实现Iterable

Iterator接口的核心方法依赖于迭代器当前迭代位置，如果Collection直接实现Iterator接口会导致集合对象中包含当前迭代位置的数据当集合被不同方法使用时迭代位置就不能预置

每一次调用Iterable的Iterator()方法，都会返回一个从头开始的Iterator对象，各个Iterator对象之间不会相互干扰，这样保证了可以同时对一个数据结构进行多个遍历。这是因为每个循环都是用了独立的迭代器Iterator对象。(为啥collection继承Iterable而不是Iterator)

继承Collection接口的有三个：List Set Queue

3、List 集合

有序的容器保持每个元素的插入顺序可以允许重复的对象可以插入多个null元素常用的实现类有ArrayList LinkedList Vector

关键是查看源代码

1）ArrayList

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

动态数组可以快速查询数组型的集合有索引查询比较快但是删除后需要重新排序所以速度比较慢（看下面源码）

查询很快的原因（通过下标进行读取）

@SuppressWarnings("unchecked")
    E elementData(int index) {
        return (E) elementData[index];
    }

    /**
     * Returns the element at the specified position in this list.
     *
     * @param  index index of the element to return
     * @return the element at the specified position in this list
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
    public E get(int index) {
        rangeCheck(index);

        return elementData(index);
    }

移除很慢的原因（删除之后需要排序）

 public E remove(int index) {
        rangeCheck(index);

        modCount++;
        E oldValue = elementData(index);

        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to 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;
    }
 private void fastRemove(int index) {
        modCount++;
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
//这里用了这个方法  也就是删除某个位置元素  后面的往前复制
//public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);
        elementData[--size] = null; // clear to let GC do its work
    }

ArrayList插入之前需要判断容量进行扩容处理如果没有超过容量（初始容量为10）增加数据 ArrayList速度还是很快的超过容量涉及到大量数据的复制过程所以速度会很慢

ArrayList 是非同步的如果多个线程在同一个位置对它进行操作会容易出错线程不安全

2）LinkedList

基于链表实现的实现了Deque接口可以被当做堆栈队列或者双向队列使用可以快速插入和删除也是线程不安全的

重要的是节点的操作

 public boolean remove(Object o) {
        if (o == null) {
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null) {
                    unlink(x);
                    return true;
                }
            }
        } else {
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item)) {
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }
private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }
E unlink(Node<E> x) {
        // assert x != null;
        final E element = x.item;
        final Node<E> next = x.next;
        final Node<E> prev = x.prev;

        if (prev == null) {
            first = next;
        } else {
            prev.next = next;
            x.prev = null;
        }

        if (next == null) {
            last = prev;
        } else {
            next.prev = prev;
            x.next = null;
        }

        x.item = null;
        size--;
        modCount++;
        return element;
    }

3）Vector

当集合中有多线程对集合元素进行操作时用这个但是现在一般使用CopyOnWriteArrayList

有synchronized 修饰可以同步线程安全允许元素为null

4、Set集合

无序不可重复只能允许最多为一个null

1）HashSet

2）TreeSet

5、Queue 队列集合

Map 映射关系键值对存储

Set 不包含重复元素的Collection 允许为null 但是有且仅有一个人null

的实现类都是基于Map来实现的例如HashSet集合里面有一个方法 HashSet 含有HashMap类型的成员变量map

public HashSet() {
        map = new HashMap<>();
    }

ConcurrentMap和ConcurrentHashMap

HashMap 通过哈希表存储k-v的键值对允许key 和value为nullHashMap 的实例有两个参数影响其性能初始容量和加载因子

猜你喜欢