集合类各容器方法以及细节

1、集合类各容器方法：

**接口Collection方法摘要(没有构造方法)       

    a)添加：                           

        i.  boolean add(E e)                           

        j.  boolean addAll(Collection c)

    b)删除：

        i.  void clear():清空容器

        j.  boolean remove(Objec object):

        k.  boolean removeAll(Collection c):

    c)判断：

        i.  boolean contains(Object object):判断是否包含此元素

        j.  boolean containsAll(Collection c):判断是否包含一堆元素

        k.  boolean equals(Object object):比较此collection与指定对象是否相等

        m.  boolean isEmpty():判断是否集合为空

    d)获取：

        h.  Iterator iterator():取出

        i.  int hashCode():返回此collection的哈希值

        j.  int size():返回此collection中元素的个数

        k.  boolean retainAll(Collection c):取交集

        m.  Object toArray():返回此collection中所有元素的数组

        n.  T[] toArray(T[] a):返回包含此collection中所有元素的数值。

*****List集合子类及其方法

    (1)List接口是Collection接口的一个子接口。

    (2)List接口中的元素有如下特点(对角标的操作都是特有方法，因为有序)：

        A:元素有序(存储顺序和取出顺序一致)

        B:元素可以重复

    (3)List接口中的特有方法

        A:add(int index,Object obj):在指定位置加入元素

        B:remove(int index):移除指定位置的元素

        C:set(int index,Object obj):修改指定位置的元素

        D:get(int index):获取指定位置的元素

        E:indexOf(Object obj):获取指定元素的位置

        F:subList(int start,int end):从一个大的List中截取一个小的List

        G:listIterator():返回一个List接口特有的迭代器

(1)、ArrayList：

    |--->构造方法摘要：(少用，不是重点)

    ArrayList()：构造一个初始容量为 10 的空列表。

    ArrayList(Collection<? extends E> c)： 构造一个包含指定 collection 的元素的列表，                           

    ArrayList(int initialCapacity)： 构造一个具有指定初始容量的空列表。

    |--->方法摘要：

    |--->添加：

    boolean add(E e)： 将指定的元素添加到此列表的尾部。

    void add(int index, E element)： 将指定的元素插入此列表中的指定位置。

    boolean addAll(Collection<? extends E> c):按照指定 collection 的迭代器所返回的元素顺序，

                         将该 collection 中的所有元素添加到此列表的尾部

    boolean addAll(int index, Collection<? extends E> c)： 从指定的位置开始，将指定 collection

                                   中的所有元素插入到此列表中。

    |--->删除：

    void clear(): 移除此列表中的所有元素。

    E remove(int index): 移除此列表中指定位置上的元素。

    boolean remove(Object o): 移除此列表中首次出现的指定元素（如果存在）。

    protected  void removeRange(int fromIndex, int toIndex):

            移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。

    boolean removeAll(Collection<?> c): 从列表中移除指定 collection 中包含的其所有元素

    |--->获取：

    E get(int index): 返回此列表中指定位置上的元素。

    int indexOf(Object o): 返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。

    int lastIndexOf(Object o) 返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。   

    public List<E> subList(int fromIndex,int toIndex): 返回列表中指定的 fromIndex（包括 ）                                           和 toIndex（不包括）之间的部分视图。

    Iterator<E> iterator(): 返回按适当顺序在列表的元素上进行迭代的迭代器。

    ListIterator<E> listIterator(int index):返回列表中元素的列表迭代器(按适当顺序),从列表的指定位置开始。

    |--->修改：(特有方法！！)

        E set(int index, E element): 用指定的元素替代此列表中指定位置上的元素。

(2)LinkedList:

    |--->构造方法摘要：

        LinkedList(): 构造一个空列表。

        LinkedList(Collection<? extends E> c): 构造一个包含指定 collection 中的元素的列表，

                               这些元素按其 collection 的迭代器返回的顺序排列。

    |--->方法摘要:(特有的)

        |--->添加

            void addFirst(E e): 将指定元素插入此列表的开头。

            void addLast(E e): 将指定元素添加到此列表的结尾。

        |--->获取元素，但不删除元素

             E get(int index): 返回此列表中指定位置处的元素。           

             E getFirst(): 返回此列表的第一个元素。         

             E getLast(): 返回此列表的最后一个元素。

        |--->获取元素且删除元素

             E remove()： 获取并移除此列表的头（第一个元素）。         

             E remove(int index)： 移除此列表中指定位置处的元素。         

             boolean remove(Object o)： 从此列表中移除首次出现的指定元素（如果存在）。         

             E removeFirst()： 移除并返回此列表的第一个元素。

             E removeLast(): 移除并返回此列表的最后一个元素。

        |--->修改

             E set(int index, E element) 将此列表中指定位置的元素替换为指定的元素。

(3)Vector

    |--->构造方法摘要：

        Vector(): 构造一个空向量，使其内部数据数组的大小为 10，其标准容量增量为零。         

        Vector(Collection<? extends E> c):  构造一个包含指定 collection 中的元素的向量，

                            这些元素按其 collection 的迭代器返回元素的顺序排列。

    |--->方法摘要：

        |--->添加：

            boolean add(E e): 将指定元素添加到此向量的末尾。

            void add(int index, E element): 在此向量的指定位置插入指定的元素。         

            boolean addAll(Collection<? extends E> c):

                     将指定 Collection 中的所有元素添加到此向量的末尾，

                     按照指定 collection 的迭代器所返回的顺序添加这些元素。

            boolean addAll(int index, Collection<? extends E> c): 在指定位置将指定 Collection 中的所有元素插入到此向量中。

        |--->获取:

            Enumeration<E> elements(): 返回此向量的组件的枚举。

               Vector特有的取出方式:

               枚举和迭代器很像，其实枚举和迭代器是一样的，只是因为枚举的名称和方法的名称

               名字都过长，所以枚举被迭代器取代了。

            |--->枚举Enumeration的方法摘要：

                 boolean hasMoreElements(): 测试此枚举是否包含更多的元素。

                 E nextElement(): 如果此枚举对象至少还有一个可提供的元素，

                          则返回此枚举的下一个元素。

*****Set集合子类及其方法

(1)HashSet:它不保证set的迭代顺序;特别是它不保证该顺序恒久不变.此类允许使用null元素。

    |--->构造方法：

        HashSet() 构造一个新的空 set，其底层 HashMap 实例的默认初始容量是 16，加载因子是 0.75。

        HashSet(Collection<? extends E> c) 构造一个包含指定 collection 中的元素的新 set。

    |--->方法摘要：

        boolean add(E e) 如果此 set 中尚未包含指定元素，则添加指定元素。   

        void clear() 从此 set 中移除所有元素。     

        Object clone() 返回此 HashSet 实例的浅表副本：并没有复制这些元素本身。       

        boolean contains(Object o) 如果此 set 包含指定元素，则返回 true。       

        boolean isEmpty() 如果此 set 不包含任何元素，则返回 true。       

        Iterator<E> iterator() 返回对此 set 中元素进行迭代的迭代器。       

        boolean remove(Object o) 如果指定元素存在于此 set 中，则将其移除。       

        int size() 返回此 set 中的元素的数量（set 的容量）。 

(2)TreeSet:使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序.

    |--->构造方法：

        TreeSet() 构造一个新的空 set，该set根据其元素的自然顺序进行排序。         

        TreeSet(Collection<? extends E> c)

             构造一个包含指定 collection 元素的新 TreeSet，它按照其元素的自然顺序进行排序。

        TreeSet(Comparator<? super E> comparator)  构造一个新的空 TreeSet，它根据指定比较器进行排序。

    |--->方法摘要：

        添加：

         boolean add(E e)  将指定的元素添加到此 set（如果该元素尚未存在于 set 中）。

         boolean addAll(Collection<? extends E> c) 将指定 collection 中的所有元素添加到此 set 中。

         删除：

          void clear() 移除此 set 中的所有元素。

          boolean remove(Object o)  将指定的元素从 set 中移除（如果该元素存在于此 set 中）。

          E pollFirst() 获取并移除第一个（最低）元素；如果此 set 为空，则返回 null。

          E pollLast() 获取并移除最后一个（最高）元素；如果此 set 为空，则返回 null。

        获取：

          Iterator<E> iterator()  返回在此 set 中的元素上按升序进行迭代的迭代器。

          E first() 返回此 set 中当前第一个（最低）元素。

          E last() 返回此 set 中当前最后一个（最高）元素。

          int size()  返回 set 中的元素数（set 的容量）。

        判断：

         boolean isEmpty()  如果此 set 不包含任何元素，则返回 true。

         boolean contains(Object o) 如果此 set 包含指定的元素，则返回 true。

**Map:将键映射到值的对象。Map集合没有迭代器！Map集合特点：该集合存储键值对。而且键是唯一的。

    |--->方法摘要：

       |--->添加：

          V put(K key, V value) 将指定的值与此映射中的指定键关联（可选操作）。           

          void putAll(Map<? extends K,? extends V> m) 从指定映射中将所有映射关系复制到此映射中

       |--->删除：

              void clear()  从此映射中移除所有映射关系（可选操作）。

          V remove(Object key) 如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。

       |--->判断

          boolean containsKey(Object key) 如果此映射包含指定键的映射关系，则返回 true。

              boolean containsValue(Object value) 如果此映射将一个或多个键映射到指定值，则返回 true。

              boolean isEmpty() 如果此映射未包含键-值映射关系，则返回 true。

           |--->获取

          int size() 返回此映射中的键-值映射关系数。

              Collection<V> values()  返回此映射中包含的值的 Collection 视图。

      重点：Map集合没有迭代器，以下是Map的两种取出方式：

      第一种：Set<K> keySet()

        返回此映射中包含的键的Set视图，将Map集合中所有的键存入Set集合，然后再通过Set集合的

        迭代器取出所有的键，再根据get方法获取每个键的值；

      第二种：Set<Map.Entry<K,V>> entrySet()

        返回此映射中包含的映射关系的Set视图，将Map集合中的映射关系存入到Set集合中，

        这个映射关系的数据类型是Map.entry,再通过Map.Entry类的方法再要取出关系里面的键和值

        Map.Entry的方法摘要：

            boolean equals(Object o)  比较指定对象与此项的相等性。             

            K getKey()  返回与此项对应的键。             

            V getValue() 返回与此项对应的值。               

            int hashCode() 返回此映射项的哈希码值。

            V setValue(V value) 用指定的值替换与此项对应的值(特有！！！)。

2、Map集合和Collection集合的区别？

    1，

    Map中一次存储是键值对。

    Collection中一次存储是单个元素。

    2，

    Map的存储使用的put方法。

    Collection存储使用的是add方法。

    3，

    Map集合没有迭代器，Map的取出，是将Map转成Set，在使用迭代器取出。

    Collection取出，使用就是迭代器。

    4，

    如果对象很多，必须使用集合存储。

    如果元素存在着映射关系，可以优先考虑使用Map存储或者用数组，

    如果没有映射关系，可以使用Collection存储。

3、迭代器：Iterator(Map集合没有迭代器)

    (1)迭代器就是取出集合元素的方式

    (2)迭代器的作用

        因为每个集合中元素的取出方式都不一样，于是就把元素的取出方式进行抽取，并定义在集合内部，

        这样取出方式就可以直接访问集合内部的元素；

        而每个容器的数据结构不同，所以取出动作的细节也不一样，但是有共性内容：判断和取出。

        那么就将共性内容进行抽取，从而形成了接口Iterater

    (3)获取迭代器的方法：

        Iterator<E> iterator() 返回在此 collection 的元素上进行迭代的迭代器。

        Iterator<E> iterator() 返回在此 set 中的元素上进行迭代的迭代器。     

    (3)迭代器方法：

        boolean hasNext() 如果仍有元素可以迭代,则返回 true。

        E next() 返回迭代的下一个元素。       

        void remove() 从迭代器指向的collection中移除迭代器返回的最后一个元素（可选操作）。

4、列表迭代器：ListIterator

    (1)List集合特有的迭代器ListIterator是Iterator的子接口，在迭代时，不可以通过集合对象的

       方法操作集合中的元素，因为会发生ConcurrentModificationException(当方法检测到对象的并发修改，

       但不允许这种修改时，抛出此异常)

    (2)Iterator方法有限，只能对元素进行判断、取出和删除的操作

       ListIterator可以对元素进行添加和修改动作等。

    (3)获取列表迭代器方法：

        ListIterator<E> listIterator() 返回此列表元素的列表迭代器（按适当顺序）。

        ListIterator<E> listIterator(int index)

            返回此列表中的元素的列表迭代器（按适当顺序），从列表中指定位置开始。

    (4)列表迭代器方法：

        void add(E e) 将指定的元素插入列表（可选操作）。

        boolean hasPrevious()  如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。

        int nextIndex() 返回对 next 的后续调用所返回元素的索引。         

        E previous() 返回列表中的前一个元素。       

        int previousIndex() 返回对 previous 的后续调用所返回元素的索引。       

        void set(E e) 用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。

5、堆栈和队列

    堆栈：先进后出，比如杯子里的水

    队列：先进先出，比如水管的水

6、集合类各种容器的使用注意细节：

     (1)迭代器：

        **迭代器的next方法是自动向下取元素，要避免出现NoSuchElementException。

          也就是在迭代循环中调用一次next方法一次就要hasNext判断一次，比如语句

          sop(it.next()+"..."+it.next())会发生上述异常。

        **迭代器的next方法返回值类型是Object，所以要记得类型转换,应用泛型后就不用强转

    (2)List集合：

        **List集合里面的元素因为是带角标，所以List集合里面的元素都是有序的，

          另外List集合可以包含重复元素，也可以包含null。 

        **List集合有迭代器Iterator，还有一个特有迭代器列表ListIterator

        **List集合中判断元素是否相同都是用equals方法，无论contains、remove都依赖equals方法

          比如往ArrayList集合里面存放学生，同名同年龄视为同一个人，此时就需要在学生类复写Object类

          里面的equals方法(非常重要！！！要注意！！)

    (3)Set集合：

        **Set接口里面存放的是元素是无序的，不可以有重复元素，可以包含null

        **Set集合只有一种取出方式，就是迭代器Iterator

        **Set集合功能和Collection是一致的，没有特殊方法

        |--->HashSet:

        **集合里面存放的元素是无序的，唯一的

        **底层数据结构是哈希表，哈希表结构的数据都是无序的，哈希表结构的操作效率都高效

        **线程不同步

        **保证元素唯一性的原理是：通过复写hashCode和equals方法

            ****如果两元素的hashCode值相同，则继续判断两元素equals是否为真

            ****如果两元素的hashCode值不同，则不会调用equals方法。

        **当我们往HashSet集合存放自定义的元素时(比如学生对象)，通常都要复写hashCode和equals方法，

          而且hashCode和equals方法不通过我们调用，HashSet集合底层内部自己调用，自己拿元素去比较

        |--->TreeSet

        **TreeSet集合可以对存放的元素进行排序，弥补了Set集合元素无序的缺点，且元素是唯一的

        **底层数据结构是二叉树，二叉树结构都是有序的

        **线程不同步

        **TreeSet集合要求往集合里存放的元素自身具备比较性，否则会报错

        **TreeSet集合保证元素唯一性的依据是：通过compareTo或者compare方法中的来保证元素的唯一性。

            TreeSet排序的第一种方式:让元素自身具备比较性，

                        定义元素类实现Compareble接口，覆盖compare方法，

                        此方式是元素的自然顺序。

            TreeSet排序的第二种方式:让集合具备比较性

                        当元素自身不具备比较性或者具备的比较性不是

                        我们所需要的比较性时，此时就需要让集合具备自定义的比较性。

                        那如何让集合自身具备比较性呢？

                        可在集合初始化时，就让集合具备比较方式。

                        即定义一个类，实现Comparator接口，覆盖compare方法。

            注：

            **判断元素唯一时，当主要条件一样时，判断次要条件

            **两种排序方式都在时，以比较器为主！！！

    (4)Map集合：

        |--Hashtable

            底层是哈希表结构

            线程安全的，并且键和值不能为null。

        |--HashMap

            底层是哈希表结构

            线程不安全的，键和值可以为null。

            |--LinkedHashMap

                底层是链表和哈希表

                线程不安全

        |--TreeMap

            底层是二叉树

            线程不安全的

    **Iterator：对collection进行迭代的迭代器.迭代器取代了Enumeration。

        迭代器和枚举的区别：

        1、迭代器允许调用者利用定义良好的语义在迭代期间从迭代器所指向的collection移除元素

        2、方法名称得到了改进，简化书写

    **LisIterator：系列表迭代器，允许程序员按任一方向遍历列表、迭代期间修改列表       

    **Comparable：此接口强行对实现它的每个类的对象进行整体自然排序。使元素具备比较性

    **Comparator：强行对某个对象collection进行整体排序的比较函数，使集合具备比较性

    **Collections：此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。

    **Arrays：此类包含用来操作数组(比如排序和搜索)的各种静态方法