day19 集合 list 链表

1. 集合
    1.1 概述
        Java集合是使程序能够存储和操纵元素不固定的一组数据。所以的java集合类都位于 java.util 包中。
        数组                                    集合
        长度固定                                长度不固定
        存放任意类型                            不能存放基本数据类型，只能存放对象的引用
    1.2继承体系
        Collection ——> List ——> ArrayList类
        Collection ——> List ——> LinkedList类
        Collection ——> Set ——> HashSet类
        Collection ——> Set ——> SortedSet接口 ——> TreeSet类
        Map ——> HashMap类
        Map ——> SortedMap ——> TreeMap类
2. Collection
    2.1 方法
        boolean add(Object obj)                该方法用于向集合里添加一个元素，添加成功返回 true    
        void clear()                        清除集合里的所有元素，将集合长度变为0
        boolean contains(Object obj)        返回集合里是否包含指定元素
        boolean containsAll(Collection c)    返回集合里是否包含集合c里的所有元素
        int hashCode()                        返回此 Collection 的哈希码值
        boolean isEmpty()                    返回集合是否为空，当集合长度为0时，返回 true
        Iterator iterator()                    返回一个 Iterator 对象，用于遍历集合里的元素
        boolean remove(Object obj)            删除集合中指定元素obj，当集合中有多个obj元素时，全部删除，方法返回 true
        int size()                            返回集合中的元素个数
        Object[] toArray()                    该方法把集合转换成一个数组，所以集合元素编程对应的数组元素
    2.2使用
        import java.util.ArrayList;
        import java.util.Collection;

        public class Test{
            public static void main(String[] args){
                //创建集合
                Collection c = new ArrayList();
                //判断是否为空
                System.out.println(c.isEmpty());    //true
                //向集合中添加数据
                c.add(1);
                //判断结合中是否为空
                System.out.println(c.isEmpty());    //flase
                //查看集合中的个数
                System.out.println(c.size());    // 1
                c.add(2);
                System.out.println(c.size());    // 2
                //转成数组进行遍历
                    Object[] obj = c.toArray();
                    for(Object i:obj){
                        System.out.println(i);    // 1 2
                    }
                //删除
                    c.remove(2);
                    System.out.println(c.size());    // 1
                    Object[] objs = c.toArray();
                    for(Object i:objs){
                        System.out.println(i);    // 1
                    }
                //清空集合
                    c.clear();
                    System.out.println(c.size());    //0
                    System.out.println(c.isEmpty());    // true
            }
        }
    2.3 注意
        boolean contains(Object obj)        判断是否包含某个元素
        boolean remove(Object obj)            删除指定元素
        这两个方法，底层都会调用 equals 方法进行比较
            如果我们存储的不是 Object 而是自定义的类型，比如User，那么使用 contains 和 remove 就需要覆写 equals 方法。
3. Iterator
    3.1 概述
        1. Collection 接口的 iterator() 和 toArray()方法都用于获得集合的所有元素，前者返回一个 Iterator 对象，后者返回一个包含集合中的所以元素的数组。
        2. Iterator 接口隐藏底层集合中的数据结构，提供遍历各种类型集合的统一接口。
    3.2 方法
        Boolean hasNext()            如果被迭代的集合有下一个元素，则返回 true
        Object next()                返回集合里下一个元素
        void remove()                删除集合里上一次next方法返回的元素
    3.3使用
        import java.util.ArrayList;
        import java.util.Collection;
        import java.util.Iterator;

        public class Test{
            public static void main(String[] args){
                //创建集合
                Collection c = new ArrayList();
                c.add(11);
                c.add("勇敢牛牛");
                c.add("sss");
                //生成迭代器
                Iterator it = c.iterator();
                //迭代器一旦生成，集合中的元素不能进行删除和添加，否则需要重新生成迭代器
                while(it.hasNext()){
                    Object obj = it.next();
                    System.out.println(obj);
                }
            }
        }        
4. List
    4.1 概述
        List: 有序可重复
                存入顺序和取出顺序一样
        ArrayList: 底层是数组，查询和更改效率较高，添加和删除效率较低。
        LinkedList: 底层是双向链表，查询效率较低，添加和删除效率较高。
        Vector: 已经过时了，底层也是数组    ArrayList 是 Vector 的升级版
            Vector 默认容量是 10； 扩大容量是 2倍，线程安全，效率较低
            ArrayList: 默认容量是 10， 扩大容量是 1.5倍，非线程安全，效率较高。
    4.2 ArrayList
        import java.util.ArrayList;
        public class Test{
            public static void main(String[] args){
                //生活 ArrayList 对象
                ArrayList al = new ArrayList();
                // add(E e)： 将元素添加到列表的尾部
                al.add(1);
                //add(int indext,E e)： 将元素添加到列表指定的位置
                al.add(0,"ss");
                System.out.println(al);    //ss,1
                //set(int indext,E e): 替换指定位置上的元素
                al.set(0, 11);
                System.out.println(al);    // 11,1
                //get(int index): 根据索引获取对应的元素
                Object a = al.get(0);    
                System.out.println(a);// 11
                //remove(int index): 根据索引删除元素
                al.remove(0);
                System.out.println(al);    // 1
                //remover(Object obj) 根据指定元素删除
                    //如果想删除其中的数字，不能直接输入，输入的是下标
                        //应该 new Integer()
                al.remove(new Integer(1));
                System.out.println(al.size());    // 0
            }
        }
    4.3 LinkedList
        4.3.1 概述
        LinkedList 的底层是双向链表
        链表的节点有三个部分，1.添加的元素 2.下一个节点的引用 3.上一个节点的引用
        链表数据结构，在内存中存储也不是连续的，所以没有固定的下标，因此查询效率低。
        因为内存空间不是连续的，只是能找到下一个节点，因为添加和删除就变得简单。
        4.3.2 基本使用
        import java.util.LinkedList;

        public class Test{
            public static void main(String[]args){
                //生成一个 LinkedList 对象
                LinkedList list = new LinkedList();
                // 尾部添加
                list.add(11);
                //头部添加
                list.push(12);
                //尾部添加
                list.addLast(13);
                //头部添加
                list.addFirst(14);
                //尾部添加
                list.offerLast(15);
                //头部添加
                list.offerFirst(16);
                System.out.println(list);    //16,14,12,11,13,15
                //获取最后一个
                System.out.println(list.getLast());    //    15
                //获取第一个
                System.out.println(list.getFirst());// 16
                //根据下标，下标在这里等同于循环次数，得到相应的数据
                System.out.println(list.get(5));    // 15
                // 更改对应下标的数据
                list.set(0, "修改过");
                System.out.println(list);    //"修改过",14,12,11,13,15
                //    根据索引删除
                list.remove(0);
                System.out.println(list);    //14,12,11,13,15
                //删除指定元素
                list.remove(new Integer(14));
                System.out.println(list);    //12,11,13,15
                //获得第一个元素并删除
                list.poll();
                System.out.println(list);    //11,13,15
                //获得第一个元素并删除
                list.pop();
                System.out.println(list);    //13，15
                
            }
        }
        4.3.3 底层实现
            void linkLast(E e){
                final Node<E> I = last;
                final Node<E> newNode = new Node <>(I,e,null);    
                last = newNode;
                if(I == null)
                    first = newNode;
                else
                    I.next = newNode;
                    size++;
                    modCount++;
            }
            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;
        }