List,Set,Map的区别以及接口API解析

List,Set,Map的区别　　

List:

      1、可以允许重复的对象

      2、可以插入多个null元素

      3、是一个有序容器，保持了每个元素的插入顺序，输出的顺序就是插入的顺序

      4、常用的实现类有ArrayList,LinkedList和Vector。ArrayList提供了使用索引的随意访问，底层结构是数组，优查询劣增删，而LinkedList经常用于添加或删除元素的场合，底层结构是链表

Set:

     1、不允许重复的对象

     2、无序容器，你无法保证每个元素的存储顺序，TreeSet通过Conparator或者Comparable维护了一个排序顺序

     3、只允许一个null元素

     4、Set常用的实现类是HashSet,LinkedHashSet以及TreeSet。最流行的是基于HashMap实现的HashSet，TreeSet还实现了SortedSet接口，因此TreeSet是一个根据其conpare()和compareTo()的进行排序的有序容器。

Map:

     1、Map不是collection的子接口或者实现类，Map是一个接口

     2、Map的每个Entry都持有俩个对象，一个键一个值，可能会持有相同的值对象但键对象必须是唯一的。

     3、TreeMap也通过Comparator或者Comparable维护了一个排序顺序

     4、Map里你可以拥有任意个null,但只能有一个null键

     5、常用的实现类HashMap,LinkedHashMap,Hashtable,TreeMap

List接口API解析

public interface List<E> extends Collection<E> {

　　/**    
　　 * 返回该list的element数目。
    * 如果该list包含元素数<tt>Integer.MAX_VALUE</tt> ，那返回 <tt>Integer.MAX_VALUE</tt>
　　 *集合的长度
    */
    int size()；
    
     /**
     * 当list为空集合时，返回true*/
    boolean isEmpty();
    /**
     * 当该list不为空（至少包含一个元素且不为null时，设为e）且包含o（或者o与e 相同）时，则返回true。*/
    boolean contains(Object o);
     /**
     * 返回一个能够以合适顺序返回此队列元素的iterator（迭代器）
*/
    Iterator<E> iterator();
    /**
     * 以一个合适的方式返回一个包含本队列中所有元素的队列。（从第一个元素到最后一个）
     * 这个返回的 <tt>array</tt> 将会是"安全"的,因为它将会是一个全新的引用。也就是说调用者可以随意自由的修改返回的 <tt>array</tt>。
     * 本方法相当于是 <tt>array</tt> 和 <tt>collection</tt> 的桥梁
     * 将集合转化为Object类型数组
*/
    Object[] toArray();
    
     /**
     * 返回数组的运行时类型是指定数组的运行时类型。 如果列表适合指定的数组，则返回其中。 否则，将为新数组分配指定数组的运行时类型和此列表的大小。
     * 如果列表适合指定的数组并且有空余空间（即，数组的元素多于列表），则紧跟在列表末尾之后的数组中的元素将设置为<tt> null </ tt>
     * 该方法不仅限于作为array和collection之间的桥梁。同时它还可以在运行时精确控制类型。并且在某些情况下节省分配成本。
     * 假使 x 是一个一直的只包含string 的list。 这段代码可以将该list载入一个全新的String[] 数组中。
     * 将集合转化为指定类型（T）的数组*/
    <T> T[] toArray(T[] a);
    
    /*-----------------------修改类型的方法--------------------*/
    
    /**
     * 将该元素(类型为E的e)保存到list中，且放在最后。
     * 支持本方法的list实现类往往会对可add 的元素设限制。 有一个list拒绝add null，还有一些可能对add 的元素添加限制。列表类应在其文档中明确指出可以添加哪些元素的任何限制。
*/
    boolean add(E e);
    
    /**
     * 如果该元素存在，删除出现的第一个匹配的元素。不过不包含该元素，不做任何事。
     * 官方一点讲：删除所有匹配的元素中索引值最小的那个。*/
    boolean remove(Object o);
     
    /**
     * 如果包含传入的集合的所有元素，则返回true。*/
    boolean containsAll(Collection<?> c);
    
    
    /**
     * 将传入集合的所有元素“续写”到该集合的末尾，这部分元素保持原来的顺序不变。
     * 如果该集合（不为空）正在进行相关操作时，拼接传入的集合，将会发生未知事情。*/
    boolean addAll(Collection<? extends E> c);
 /**
     * 将所有元素插入到index位置。将当前位置的元素（如果有）和任何后续元素向右移动（增加其索引）。
     * 新元素将按照指定集合的迭代器返回的顺序出现在此列表中。*/
    boolean addAll(int index, Collection<? extends E> c);
    
    /**
     * 删除所有包含的元素。*/
    boolean removeAll(Collection<?> c);

        /**
     * 取交集： 删除所有  该集合中有但是传入没有的元素。*/
    boolean retainAll(Collection<?> c);
    
     /**
     * 将该列表的每个元素替换为将运算符应用于该元素的结果。
     * 倘若不支持该方法，则在替换第一个元素时抛出<tt>UnsupportedOperationException</tt>*/
    default void replaceAll(UnaryOperator<E> operator) {
        Objects.requireNonNull(operator);
        final ListIterator<E> li = this.listIterator();
        while (li.hasNext()) {
            li.set(operator.apply(li.next()));
        }
    }
    
    /**
     * 按照 Comparator 的要求进行排序
     * 所有的元素通过比较器（comparator）相互比较。
     * 如果比较器时null，那这个list必须要自己实现一个Comparable接口。
     *该集合必须可以被编辑。不一定一定可以调整大小。
     * 默认实现获取包含此列表中所有元素的数组，对数组进行排序，并迭代此列表，从数组中的相应位置重置每个元素。*/
    @SuppressWarnings({"unchecked", "rawtypes"})
    default void sort(Comparator<? super E> c) {
        Object[] a = this.toArray();
        Arrays.sort(a, (Comparator) c);
        ListIterator<E> i = this.listIterator();
        for (Object e : a) {
            i.next();
            i.set((E) e);
        }
    }
    /**
     * 删除所有元素*/
    void clear();
     /**
     * 比较两个集合中的元素值相等并且以确定的顺序排列，此定义确保equals方法在<tt> List </ tt>接口的不同实现中正常工作。*/
    boolean equals(Object o);

     /**
     * equals 方法意味着 hash值相等*/
    int hashCode();
    
    /*------------------------位置操作----------------------------*/
      /**
     * 返回该集合中该位置的元素。*/
    E get(int index);
    /**
     * 将该位置的元素替换为该元素*/
    E set(int index, E element);
 /**
     * 在该位置插入该元素。并且将原从该位置开始的所有元素向右顺移动*/
    void add(int index, E element);

    /**
     * 将该位置的元素删除，并且原该位置及之后的元素向左顺移。返回删除该元素之后的集合*/
    E remove(int index);
    
     /*-------------------------搜索操作-------------------------*/
    /**
     * 返回第一次与该元素索引的位置。如果不存在则返回-1*/
    int indexOf(Object o);
    /* 返回第一次与该元素索引的位置。如果不存在则返回-1 */
    int lastIndexOf(Object o);
    
    /*-----------------------List Iterator---------------------*/
    ListIterator<E> listIterator();

    /**
     * 从列表中的指定位置开始，返回列表中元素的列表迭代器（按正确顺序）。指定的索引表示初始调用{@link ListIterator＃next next}将返回的第一个元素。对{@link ListIterator＃previous previous}的初始调用将返回指定索引减去1的元素*/
    ListIterator<E> listIterator(int index);
    
     /**
     * 返回从 fromIndex 到 toIndex 的视图。如果fromIndex==toIndex，则返回空集。返回的list由原集合提供视图，也就是说任何这两个引用的操作都会直接改变该list在堆中的值。
     *此方法消除了对显式范围操作的需要（对于数组通常存在的排序）。 任何需要列表的操作都可以通过传递subList视图而不是整个列表来用作范围操作。
     * 可以为<tt> indexOf </ tt>和<tt> lastIndexOf </ tt>构造类似的习语，并且<tt> Collections </ tt>类中的所有算法都可以应用于subList。<p>
     * 如果支持列表（即，此列表）以除了通过返回列表之外的任何方式进行<i>结构修改</ i>，则此方法返回的列表的语义将变为未定义。 （结构修改是那些改变了这个列表的大小，或以其他方式扰乱它的方式，正在进行的迭代可能会产生不正确的结果。）
　　　*截取范围内的集合*/
    List<E> subList(int fromIndex, int toIndex);
    
    @Override
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, Spliterator.ORDERED);

}

Set接口API解析

Set:
一种不可以包含重复元素的Collection,且最多包含一个null元素

boolean add(E o)    //如果 set 中尚未存在指定的元素，则添加此元素（可选操作）。
boolean addAll(Collection<? extends E> c)    //如果 set 中没有指定 collection 中的所有元素，则将其添加到此 set 中（可选操作）。
void clear()    //移除 set 中的所有元素（可选操作）。
boolean contains(Object o)    //如果 set 包含指定的元素，则返回 true。
boolean containsAll(Collection<?> c)    //如果此 set 包含指定 collection 的所有元素，则返回 true。
boolean equals(Object o)    //比较指定对象与此 set 的相等性。
int hashCode()   // 返回 set 的哈希代码值。
boolean isEmpty()   // 如果 set 不包含元素，则返回 true。
Iterator iterator()    //返回在此 set 中的元素上进行迭代的迭代器。
boolean remove(Object o)   // 如果 set 中存在指定的元素，则将其移除（可选操作）。
boolean removeAll(Collection<?> c)   // 移除 set 中那些包含在指定 collection 中的元素（可选操作）。
boolean retainAll(Collection<?> c)   // 仅保留 set 中那些包含在指定 collection 中的元素（可选操作）。
int size()   // 返回 set 中的元素数（其容量）。
Object[] toArray()   // 返回一个包含 set 中所有元素的数组。
T[] toArray(T[] a)   // 返回一个包含 set 中所有元素的数组；返回数组的运行时类型是指定数组的类型。

Map接口API解析

(1)映射（map）是一个存储键、键值对的对象，给定一个键，可以查询得到它的值，键和值都可以是对象
(2)键必须是唯一的，值可以重复（Map接口映射唯一的键到值）
(3)有些映射可以接收null键和null值，而有的不行
(4)下面的接口支持映射：
Map接口 映射唯一关键字给值
Map.Entry接口 描述映射中的元素（关键字/值对），这是Map的一个内部类
SortedMap接口 扩展Map以便关键字按升序保持

(5)键(Key)是以后用于检索值的对象，给定一个键和一个值，可以存储这个值到一个Map对象中，以后可以
使用对应的键来检索它

public interface Map<K,V> {

    int size();//存储的键值对的个数
    boolean isEmpty();//判断容器中是不是空的
    boolean containsKey(Object key);//判断容器中是否包含对应的键
    boolean containsValue(Object value);//判断容器中是否包含指定的值
    V get(Object key);//根据键来获取对应的值
    V put(K key,V value) //把键值对数据添加到Map容器中
    V remove(Object key) //删除Map容器中对应的key
    void putAll(Map<? extends K, ? extends V> m);//将其他map中的所有key，value都放在当前map中(注意：使用putAll方法之后，由于map的特性，key相同时后面的会覆盖前面的值)
    void clear();//将整个map清空
    Set<K> keySet();//该方法返回map中所有key值的列表
    Collection<V> values();// 获取Map容器中所有的值
    Set<Map.Entry<K, V>> entrySet();//返回包含的映射关系的Set视图(调用entrySet后返回一个Map.Entry的Set集合)
    
    //通过这个集合的迭代器，您可以获得每一个条目(唯一获取方式)的键或值并对值进行更改。当条目通过迭代器返回后，除非是迭代器自身的remove()方法或者迭代器返回的条目的setValue()方法，其余对源Map外部的修改都会导致此条目集变得无效，同时产生条目行为未定义
    interface Entry<K,V> {
        K getKey();//获取当前操作集合中的具体的key值
        V getValue();//获取当前操作集合中的具体的value值
        V setValue(V value);//将当前操作的值改为value，并且返回旧值
        boolean equals(Object o);//比较指定对象与当前项的相等性
        int hashCode();//获取code码
        
    }

    boolean equals(Object o);//判断Map集合是否与指定的对象相同
    int hashCode();//获取code码
    default V getOrDefault(Object key, V defaultValue) {//当Map集合中有这个key时，就使用这个key值，如果没有就使用默认值defaultValue
                V v;
               return (((v = get(key)) != null) || containsKey(key))
                    ? v
                    : defaultValue;
        }
    
    //用于两个参数之间进行操作的函数式接口是 BiConsumer。这个函数式接口正好用来操作 Map 的 key 和 value。JDK8强化了针对 Map 类的迭代方式，新增了一个默认方法 forEach，它接收一个 BiConsumer 函数。JDK给出的描述如下：
    //Performs the given action for each entry in this map until all entries have been processed or the action throws an exception.（对该映射中的每个条目执行给定的操作，直到所有条目已被处理或动作抛出异常为止。）
    default void forEach(BiConsumer<? super K, ? super V> action) {
                Objects.requireNonNull(action);
                for (Map.Entry<K, V> entry : entrySet()) {
                        K k;
                        V v;
                        try {
                            k = entry.getKey();
                            v = entry.getValue();
                        } catch(IllegalStateException ise) {
                            throw new ConcurrentModificationException(ise);
                        }
                            action.accept(k, v);
                }
        }
    
    //BiFunction是函数接口，这个参数一般就是写个lambda表达式。由这个lambda表达式得到过滤条件和返回值[键值对<K,V>中的V值]，并以该新的V值替换旧的V值。
    default void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
                Objects.requireNonNull(function);
                for (Map.Entry<K, V> entry : entrySet()) {
                        K k;
                       V v;
                        try {
                            k = entry.getKey();
                            v = entry.getValue();
                        } catch(IllegalStateException ise) {
                            throw new ConcurrentModificationException(ise);
                        }
                            v = function.apply(k, v);
                       try {
                            entry.setValue(v);
                        } catch(IllegalStateException ise) {
                            throw new ConcurrentModificationException(ise);
                        }
                }
        }

    //这个方法在key不存在的时候加入一个值,如果key存在就不放入
    default V putIfAbsent(K key, V value) {
                V v = get(key);
                if (v == null) {
                        v = put(key, value);
                }
                return v;
        }

    
}