LinkedList 学习

​
package cn.onloc.utils.conllection;

import cn.onloc.utils.User;

import java.util.*;

public class LinkedList_1 {

    /**  链表集合
     *  1、为什么在有了数组的情况下还需要链表？
     *      数组是定长的，即使在初始化ArrayList()的时候我们自己没有去设置长度，默认的default_capacity = 10；但是如果对一个ArrayList频繁的添加元素，造成ArrayList频繁的去扩容
     *      是一件很消耗内存和耗时的事情，所以就提出了链表的概念。
     *  2、链表不用设置他的长度，只需要在每个对象的头和尾部添加一个属性，分别记录其对应的上一个和下一个元素的内存地址即可，就不用频繁的去扩容。
     *  数组集合：查询块，增删慢
     *  链表集合：增删快，查询慢
     *
     *  继承体系：
     *  LinkedList  extends AbstractSequentialList ：
     *  AbstractSequentialList extends AbstractList:
     *  AbstractList extends AbstractCollection implements List
     *  AbstractCollection implements Collection
     *
     *  常用api:
     *  1、新增
     *      public boolean add(E e) ,像一个链表插入元素，插入的时候调用的是LinkedList的addLast(); 默认是链表最后一个元素的后面添加元素
     *      public boolean add(int index, E e) ,在链表的指定位置添加元素。
     *      链表特有：
     *      public void addFirst(E e) , 向链表头部添加元素
     *      public void addLast(E e) , 在链表的最后添加元素，链表的add方法调用。
     *
     *  2、删除
     *      因为都是实现的Collection，所以即使很多方法的实现不同，但是输入输出肯定是一致的。
     *      public E remove(E e), 根据集合中的内容去删除一个数据，所有的集合都有实现该方法。
     *      注意：collection是整个大集合类的父接口，他定义的肯定是一些所有集合都能用的东西，在删除元素的定义上，他定义的接口是根据集合元素去删除，根据集合下标去删除这个接口是在list里定义的。
     *      public E remove(int index), 根据下标删除元素；虽然链表数据在内存中的位置不在一块，但是通过首位的下标指引，还是可以通过下标去取值的。
     *      链表特有：
     *      public E removefirst(),
     *      public E removeLast(),
     *  3、修改
     *      public E set(int index, E e), 对下标为多少的元素进行修改并返回修改以前的元素
     *  4、查询
     *      public E get(int index) ; //根据下标获取值，需要重第一个元素开始一个一个的查询过去，因为并不知道第index个元素在内存中的位置，只能一个一个的问过去。所以他的查询是很耗时的
     *      链表特有：
     *      public E getFirst();
     *      public E getLast();
     *  5、循环遍历
     *      和ArrayList一样，也是三种遍历，注意的是forEach是不能对null遍历的会报错。
     *  6、比较
     *      其比较方式和ArrayList一样，主要是利用list定义的sort接口方法
     *  7、查询是否包含
     *  8、复制
     *  9、和数组的相互转换
     *      collection有一个toArray的接口方法，可以实现吧一个集合转换为数组，这是可以做到的。
     *      但是如果把一个数组的Arrays.asList(); 是只能把一个数组转换为ArrayList的，这是一种适配器模式的开发方式，只是把上层数组的接口变化了，底层的数据还是存储为的数组状况。
     *      而且因为数组是不能自动扩容的，造成转换后的ArrayList是不能实现对数组的增删清空的，只能遍历查询和修改，只要不涉及改变length都可以。
     *
     * @param args
     */
    public static void main(String[] args) {

        {
            //新增
            List linkedList = new LinkedList();
            boolean result = linkedList.add("a");
            linkedList.add("b");
            linkedList.add(1, 2);
            ((LinkedList) linkedList).addFirst("c");
            ((LinkedList) linkedList).addLast("d");
            System.out.println("public boolean add(E e):" + linkedList);// public boolean add(E e):[c, a, 2, b, d]
        }

        {
            //删除
            List linkedList = new LinkedList();
            boolean result = linkedList.add("a");
            linkedList.add("b");
            linkedList.add("c");
            linkedList.add("d");
            linkedList.add("a");
            System.out.println("原始linkedList:" + linkedList); // 原始linkedList:[a, b, c, d, a]
            linkedList.remove(1);
            System.out.println("linkedList  remove(int i):" + linkedList); // linkedList  remove(int i):[a, c, d, a]
            Object a = linkedList.remove("a");
            System.out.println("linkedList -- remove(E e):" + linkedList); // linkedList -- remove(E e):[c, d, a]
            Object o = ((LinkedList) linkedList).removeFirst();
            System.out.println("remove():" + o); //remove():c
            System.out.println("linkedList:" + linkedList); //linkedList:[d, a]
        }

        {
            //修改
            List linkedList = new LinkedList();
            boolean result = linkedList.add("a");
            linkedList.add("b");
            linkedList.add("c");
            linkedList.add("d");
            linkedList.add("a");
            System.out.println("原始linkedList:" + linkedList); // 原始linkedList:[a, b, c, d, a]

            Object o = linkedList.set(1, 2);
            System.out.println("linkedList--set(): " + linkedList + "--old:" + o); // linkedList--set(): [a, 2, c, d, a]--old:b
        }

        {
            //排序
            User zs = new User("张三", 23);
            User ls = new User("李四", 24);
            User ww = new User("王五", 25);
            List<User> list = new LinkedList<User>();
            list.add(zs);
            list.add(ww);
            list.add(ls);
            System.out.println("原始linkedList:" + list);
            //原始linkedList:[User{age=23, name='张三', sex=null}, User{age=25, name='王五', sex=null}, User{age=24, name='李四', sex=null}]
          /*  list.sort(new Comparator<User>() {
                @Override
                public int compare(User o1, User o2) {
                    return o1.getAge() - o2.getAge();
                }
            });
            System.out.println("sort以后:" + list);*/
            //sort以后:[User{age=23, name='张三', sex=null}, User{age=24, name='李四', sex=null}, User{age=25, name='王五', sex=null}]

            Comparator<User> comparator = new Comparator<User>() {
                @Override
                public int compare(User o1, User o2) {
                    return o1.getAge() - o2.getAge();
                }
            };
            Collections.sort(list, comparator);
            System.out.println("Collections 的 sort以后:" + list);
            //Collections 的 sort以后:[User{age=23, name='张三', sex=null}, User{age=24, name='李四', sex=null}, User{age=25, name='王五', sex=null}]
        }

        {
            //查询
            List linkedList = new LinkedList();
            linkedList.add("a");
            linkedList.add("b");
            linkedList.add("c");
            linkedList.add("d");
            linkedList.add("a");
            System.out.println("原始linkedList:" + linkedList); // 原始linkedList:[a, b, c, d, a]
            System.out.println(" linkedList 的get方法：" + linkedList.get(2)); //  linkedList 的get方法：c
        }

        {
            //循环
            List linkedList = new LinkedList();
            linkedList.add("a");
            linkedList.add("b");
            linkedList.add("c");
            linkedList.add("d");
            linkedList.add("a");
            System.out.println("原始linkedList:" + linkedList); // 原始linkedList:[a, b, c, d, a]
            //1、 for
            for(int i = 0; i < linkedList.size(); i++) {
                System.out.println("i :" + linkedList.get(i));
            }
            //i :a
            //i :b
            //i :c
            //i :d
            //i :a

            //2、forEach 注意forEach不能遍历null，会报错
            for(Object o : linkedList) {
                System.out.println("forEach :" + o);
            }
            //forEach :a
            //forEach :b
            //forEach :c
            //forEach :d
            //forEach :a

            //3、iterator
            Iterator iterator = linkedList.iterator();
            while(iterator.hasNext()) {
                System.out.println("iterator : " + iterator.next());
            }
            //iterator : a
            //iterator : b
            //iterator : c
            //iterator : d
            //iterator : a
        }

        {
            //和数组的相互转换
            List linkedList = new LinkedList();
            linkedList.add("a");
            linkedList.add("b");
            linkedList.add("c");
            linkedList.add("d");
            linkedList.add("a");
            System.out.println("原始linkedList:" + linkedList); // 原始linkedList:[a, b, c, d, a]

            Object[] arr = linkedList.toArray();
            System.out.println("asArray : " + arr); // asArray : [Ljava.lang.Object;@404b9385
            for(Object o : arr) {
                System.out.println("arr : " + o);
            }
            //arr : a
            //arr : b
            //arr : c
            //arr : d
            //arr : a
        }

    }

}

​