day_17 LinkedList和Comparable

        2.LinkedList
            1.基本使用
                底层是一个双向链表，因为不是连续存储，
                只能找到下一个元素的地址，所以进行添加和删除操作效率较高
                但是查询效率较低，只能从第一个挨个找

                LinkedList list = new LinkedList();
                //添加
                list.add(1);
                list.add(12);
                list.add(13);
                //个数
                System.out.println(list.size());
                //是否为空
                System.out.println(list.isEmpty());
                //根据下标删除
                list.remove(new Integer(11));
                //清空
                list.clear();
                //更改
                list(2,111);
                //获取
                list.get(2);
                //遍历
                for(Object object:list){}
            
            2.底层实现
                2.1 节点类
                    链表由节点构成 因为是双向链表，所以节点中由三个属性
                        1.保存的数据 Object
                        2.下一个节点对象 节点类型
                        3.上一个节点对象 节点类型
                        底层逻辑看笔记

                2.2 LinkedList 类
                    size ：已有元素个数
                    first：首节点
                    last：尾节点
                    为了首尾添加效率更高，LinkedList类中保存了首节点和尾节点

                2.3 添加 add
                    public boolean add(E e){
                        linkLast(e);
                        return true;
                    }

                2.4 获取 get
                    public E get(int index){
                        checkElementIndex（index）;     检验下标是否合法
                        return node(index).item;        获取数据
                    }
                    get方法只是模拟下标获取的方式而已，本质上就是遍历操作
                    只不过做了一定的判断，判断找前半截快还是后半截快

                  删除：它的上一个的下一个指向下一个，
                        它的下一个的上一个指向上一个
    
    6.Set 和 排序
        特性：无序且不可重复，无序指的是添加顺序和取出顺序不保证一致

        HashSet：底层是散列表

        TreeSet:底层是红黑树，添加的元素必须按照一定的格式进行排序
            数字：默认从小到大
            字符串：按ACSII码进行排序
            日期：自然日期，昨儿今儿明儿……

        1.TreeSet
            //创建对象
                Set set = new TreeSet();
            //添加
                set.add(1);
            //因为treeset必须保证元素有序，也就意味着元素类型必须统一，不统一没有可比性，无法排序

            //不可重复，如果重复则不添加

            //根据内容删除，不能根据索引删除，因为没有索引
                set.remove(22);
            //遍历
                for(Object object:set){
                    System.out.println(object);
                }

            //排序时对每一个字符串的ASCII码进行比较
                set.add("1");
                set.add("2");
                set.add("10");         // [1,10,2]

        2.Comparable
            使用TreeSet的时候，元素必须实现了Comparable接口，因为在添加的时候会自动调用
            该接口的compareTo方法进行比较，添加字符串，数字，日期的时候会进行自动排序，
            因为Integer,String,Date都实现了该接口和该方法
            如果我们要存储自定义类型的时候，就需要让该类去实现对应的接口和方法才能进行存储

            //比较器类
                public int compare(Object o1,Object o2){
                    //o1是要添加的元素
                    //o2是集合中的元素
                    Integer i1 = (Integer) o1;
                    Integer i2 = (Integer) o2;
                    //该方法返回0说明重复不添加
                    //返回大于0的值说明添加的元素比集合中的打，就往后放
                    //返回小于0的值说明添加的元素比集合中的元素小，往前放
                    return i2-i1；
                }

            //把比较器类的对象传入
                TreeSet set = new TreeSet(new A());
            //匿名内部类写法
                TreeSet set = new TreeSet(new Comparator(){
                    //比较器类
                })
            
        3.List排序
            List list = new ArrayList();
            //该方法会调用对象的Comparable中的compareTo方法或者是Comparator接口中的方法
            //因为Integer中有compareTo方法，而且是升序，所以才可以使用sort方法
            //比如想要降序可以使用sort（list）; 

      
        4.总结
            Comparable :如果treeset中保存我们自己定义的类型的时候，使用Comparable
            Comparator :如果treeSet中保存的不是我们写的类型时，就要用此来指定排序规则
                比如Integer默认时升序排序，加入我们需要降序排序，只能使用Comparator，因此我们不能去更改Integer的源码
                但此时Integer中是有Comparable接口的实现的，等于两个比较都存在，到那时Comparator优先级高
                    所以会按照我们定义的规则进行排序
                    开闭原则：对修改关闭，对扩展开放

    为null：没有这个对象，个数为零
    为0：有这个对象