Java集合二

Java集合二
    1.List接口 : 有序的,可以重复,可以根据索引操作
        有序 : 存储的顺序与内部真实存放的顺序 保持一致
        新增方法 : 新增了一些与索引相关的方法
        jdk1.7之前 : 标准 写法 前后的类型都需要<String>
            ArrayList<String> list = new ArrayList<String>();
        jdk1.7 :后面的类型后可以省略传递类型<>
             ArrayList<String> list = new ArrayList<>();
        方法
            void add(int index, E element)
                在此列表中的指定位置插入指定元素（可选操作）。
            boolean add(E e)
                将指定元素附加到此列表的末尾（可选操作）。
            boolean addAll(int index, Collection<? extends E> c)
                将指定集合中的所有元素插入到此列表中的指定位置（可选操作）。
            boolean addAll(Collection<? extends E> c)
                将指定集合中的所有元素附加到此列表的末尾，按照指定集合的迭代器返回的顺序（可选操作）。
            E get(int index)
                返回此列表中指定位置的元素。
            int indexOf(Object o)
                返回此列表中指定元素第一次出现的索引，如果此列表不包含该元素，则返回 -1。
            int lastIndexOf(Object o)
                返回此列表中指定元素最后一次出现的索引，如果此列表不包含该元素，则返回 -1。
            E remove(int index)
                移除此列表中指定位置的元素（可选操作）。
            boolean remove(Object o)
                如果指定元素存在，则从该列表中删除第一次出现的指定元素（可选操作）。
            E set(int index, E element)
                将此列表中指定位置的元素替换为指定元素（可选操作）。
            List<E> subList(int fromIndex, int toIndex)
                返回此列表在指定fromIndex （包括）和toIndex （不包括）之间部分的视图。
        list集合遍历方式 :
             1.for
                
             2.foreach
                
             3.iterator
                
            4.listIterator
                 列表迭代器 ListIterator
                 列表的迭代器，允许程序员在任一方向遍历列表，在迭代期间修改列表，并获取迭代器在列表中的当前位置。
                 1.获取列表迭代器实例
                 2.判断是否存在下一个元素|判断是否存在上一个元素
                 3.获取下一个元素|获取索引|获取 上一个元素以及索引
        List 接口下的实现类 :
              有序的,可重复的,可以根据索引操作的
              ArrayList :
                允许所有元素，包括null 。
                底层结构 : 数组  Object[] elementData;
                特点 : 根据索引查询效率高,做增删效率低
                 应用场景 : 适合应用在大量做查询,少量做增删的场景下
                初始容量 : 默认为10 private static final int DEFAULT_CAPACITY = 10; | 可以通过构造器指定
                扩容机制 : 每次扩容原容量的1.5倍    int newCapacity = oldCapacity + oldCapacity>>1;
                     通过调用Arrays.copyOf方法实现扩容+拷贝数据
                  新增方法 : 没有新增方法
                 遍历方式 : 1)for  2)foreach   3)iterator  4)listIterator
                 请注意，此实现不同步。
                注意 : 当使用ArrayList存储自定义引用数据类型的对象数据的时候,要求根据所有属性值重写toString与equals
            Vector :向量 了解
                共性 : 
                    1)都是List接口下的实现类,相同的特点...
                    2)底层结构都是数组,特点相同
                 不同点 :
                      1)线程安全问题
                         ArrayList : 线程不安全|不同步的
                        Vector : 线程安全|同步的
                        如果不需要线程安全实现，建议使用ArrayList代替Vector 。
                    2)初始容量与扩容机制
                        初始容量 :
                             ArrayList与Vector : 默认底层数组容量的为10  |  可以通过构造器指定
                        扩容机制 :
                            ArrayList : 每次扩容原容量的1.5倍
                             Vector :  如果用户指定每次扩容的容量增量capacityIncrement,就每次原容量+capacityIncrement,如果用户没有指定capacityIncrement,那么每次扩容原容量的2倍
                                 int dCapacity = oldCapacity +  capacityIncrement > 0 ? capacityIncrement : oldCapacity?
             LinkedList : 有序的,可重复的,可以根据索引操作的
                允许所有元素（包括null ）。
                底层结构 : 双向链表
                 特点 : 查询效率低,增删效率高
                 应用场景 : 适合应用在大量做增删,少量做查询的情况
                新增方法 : 新增了一些操作链表头尾的方法
                    LinkedList()
                        构造一个空列表。
                    void addFirst(E e)
                        在此列表的开头插入指定元素。
                    void addLast(E e)
                        将指定元素附加到此列表的末尾。
                    boolean offerFirst(E e)
                        在此列表的前面插入指定的元素。
                    boolean offerLast(E e)
                        在此列表的末尾插入指定的元素。
                    E getFirst()
                        返回此列表中的第一个元素。
                    E getLast()
                        返回此列表中的最后一个元素。
                    E peekFirst()
                        检索但不删除此列表的第一个元素，如果此列表为空，则返回null 。
                    E peekLast()
                        检索但不删除此列表的最后一个元素，如果此列表为空，则返回null 。
                    E pollFirst()
                        检索并删除此列表的第一个元素，如果此列表为空，则返回null 。
                    E pollLast()
                        检索并删除此列表的最后一个元素，如果此列表为空，则返回null 。
                    E removeFirst()
                        从此列表中删除并返回第一个元素。
                    boolean removeFirstOccurrence(Object o)
                        删除此列表中第一次出现的指定元素（从头到尾遍历列表时）。
                    E removeLast()
                        移除并返回此列表中的最后一个元素。
                    boolean removeLastOccurrence(Object o)
                        删除此列表中指定元素的最后一次出现（从头到尾遍历列表时）。
                遍历方式 :
                    for
                     foreach
                     iterator
                     listIterator
                     descendingIterator()  逆序迭代
                请注意，此实现不同步。
    2.Set : 无序的,不可重复,不能跟随索引操作
        无序的(存储的顺序与内部真实存放 的顺序不保证一致),去重的,不可以根据索引使用的
        TreeSet
            无序的,去重的
             底层结构 : 红黑树(平衡二叉树)
            特点 : 自动做升序排序
             应用场景 : 适合应用在想要对数据根据指定规则做升序|降序排序的情况下
            新增方法 : 新增了一些比较大小相关的方法
                E ceiling(E e)
                    返回此集合中大于或等于给定元素的最小元素，如果没有这样的元素，则null 。
                E floor(E e)
                    返回此集合中小于或等于给定元素的最大元素，如果没有这样的元素，则null 。
                E first()
                    返回此集合中当前的第一个（最低）元素。
                E last()
                    返回此集合中当前的最后一个（最高）元素。
                E higher(E e)
                    返回此集合中严格大于给定元素的最小元素，如果没有这样的元素，则null 。
                E lower(E e)
                    返回此集合中严格小于给定元素的最大元素，如果没有这样的元素，则null 。
                E pollFirst()
                    检索并删除第一个（最低）元素，如果此集合为空，则返回null 。
                E pollLast()
                    检索并删除最后一个（最高）元素，如果此集合为空，则返回null 。
            遍历方式 :
                foreach
                iterator()
                 descendingIterator()
                    逆序
                        
             请注意，此实现不同步。
            要求存储的类型实现比较规则(内部|外部),如果没有实现,遇到类型转换异常ClassCastException
                去重与排序 : 都只根据调用的比较规则决定
                如何定义比较规则 :
                    1.内部比较器|自然排序|默认比较规则 :
                        要比较的类型实现Comparable接口,重写compareTo(T o)方法,方法的内部定义比较规则
                    2.外部比较器|定制排序|自定义比较规则 :
                        实现类实现 Comparator<T>接口,重写compare(T o1, T o2) 方法,方法的内部定义比较规则
                内部比较
                    在类内继承Comparable接口，进行比较
                1.构建TreeSet集合
                    TreeSet<Employee> set = new TreeSet<>();
                         默认使用内部比较器(自然排序)
                        在类内继承Comparable接口，进行比较
                    TreeSet(Comparator<? super E> comparator)
                         构造一个新的空树集，根据指定的比较器排序。
                        TreeSet<Employee> set = new TreeSet<>(new Test());
                        匿名内部类简化
                            
                 x.compareTo(y)
                    返回值 : 根据返回值决定比较的两个对象的大小
                         =0    x=y
                         <0    x<y
                        >0    x>y
        HashSet
            无序的,去重的,不能根据索引使用的
            底层是由HashMap维护的
             底层结构 : 
                哈希表(jdk1.7及之前:数组+链表
                jdk1.8及之后:数组+链表+红黑树)
              特点 : 查询增删效率都较高
            应用场景 : 适合应用在大量做查询增删的需求下
              去重 : 
                一般结合业务都想要根据对象的内容做去重
                 在对象类型中根据内容重写hashCode与equals方法
             注意 :
                前提在根据内容重写 hashCode与equals方法之后 :
                 hashCode相等,equals一定相等  :不一定
                 equals相等,hashCode相等 : 一定相等
         Set :
            不包含重复元素的集合。
            无新增方法
            遍历方式 :
                foreach
                     set.forEach(System.out::println);
                 iterator
                    for(String s:set){
            System.out.println(s);
        }
            方法
                static <E> Set<E> of(E... elements)
                    返回包含任意数量元素的不可修改集合。