Collection集合

1. java集合笔记一
2. java集合笔记二
3. java集合笔记三

List集合

Vector:

与ArrayList实现一致,只不过通过synchronized保持线程安全.

ArrayList:

能够存放null且自动扩展大小的数组,数据的查询方面会很快，而在插入删除这些方面，性能下降很多

            1.结构属性
            public LinkedList extends AbstractSequentialList<E>
            implements List<E>, Deque<E>, Cloneable, java.io.Serializable{//不仅实现了List 相关方法,也实现了队列的相关方法
                transient Node<E> first;//首节点
                transient Node<E> last;//尾节点
                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;
                    }
                }
            }
            2.//添加元素
                public boolean add(E e) {
                    linkLast(e);
                    return true;
                }
                //链表最后一个节点指向一个新节点,新节点中存放新加元素
                void linkLast(E e) {
                    final Node<E> l = last;
                    final Node<E> newNode = new Node<>(l, e, null);
                    last = newNode;
                    if (l == null)
                        first = newNode;
                    else
                        l.next = newNode;
                    size++;
                    modCount++;
                }
            3.//获取元素
                public E get(int index) {
                    checkElementIndex(index);//检查下标index >= 0 && index < size;
                    return node(index).item;
                }
                Node<E> node(int index) {
                    if (index < (size >> 1)) {//小于一半从前面向后循环查找
                        Node<E> x = first;
                        for (int i = 0; i < index; i++)
                            x = x.next;
                        return x;
                    } else {//从链表后面向前循环查找
                        Node<E> x = last;
                        for (int i = size - 1; i > index; i--)
                            x = x.prev;
                        return x;
                    }
                }
            4.//linkedList 实现了Deque,Deque继承Queue
                //Queue队列,一种常用的数据结构
                    boolean offer(E e)://将元素追加到队列末尾,若添加成功则返回true。 
                    E poll()://从队首删除并返回该元素。 E = unlinkFirst(Node f)
                    E peek()://返回队首元素，但是不删除 E = Node first.value
                //Deque双向队列，指该队列两端的元素既能入队(offer)也能出队(poll),如果将Deque限制为只能从一端入队和出队，则可实现栈的数据结构
                    void push(E e)://将给定元素”压入”栈中。存入的元素会在栈首。即:栈的第一个元素 
                    E pop()://将栈首元素删除并返回。//E = unlinkFirst(Node f)
                
                private E unlinkFirst(Node<E> f) {//传入首节点
                    // assert f == first && f != null;
                    final E element = f.item;//首节点的值
                    final Node<E> next = f.next;//首节点指向的下一个节点
                    f.item = null;
                    f.next = null; // 内存回收
                    first = next;//首节点赋值原首节点指向的下一个节点
                    if (next == null)
                        last = null;
                    else
                        next.prev = null;
                    size--;//长度减一
                    modCount++;
                    return element;//返回首节点值
                }

Set集合

HashSet:

值不能重复且无序的

            public HashSet() {
                map = new HashMap<>();//初始化一个HashMap保存元素
            }
            public boolean add(E e) {
                return map.put(e, PRESENT)==null;//PRESENT=new Object();//使用HashMap中的键保存
            }

TreeSet:

值不重复且可以按照某种规则排序,(元素实现接口Comparable并重写compareTo()方法)

            private transient NavigableMap<E,Object> m;
            public TreeSet() {//无参构造使用treeMap存储:NavigableMap的实现
                this(new TreeMap<E,Object>());
            }
            public boolean add(E e) {
                return m.put(e, PRESENT)==null;使用NavigableMap中的键保存
            }