Java 集合框架

1. 集合

   一方面， 面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象的操作，就要对对象进行存储。另一方面，使用 Array 存储对象方面具有一些弊端，而 Java 集合就像一种容器，可以动态地把多个对象的引用放入容器中。

   Java 集合类可以用于存储数量不等的多个对象，还可用于保存具有映射关系的关联数组。

2. 集合框架图
   
   1. 所有集合类都位于 java.util 包下。Java 的集合类主要由两个接口派生而出：Collection 和 Map，Collection 和 Map 是 Java 集合框架的根接口，这两个接口又包含了一些子接口或实现类。
   2. 集合接口：6 个接口（短虚线表示），表示不同集合类型，是集合框架的基础。
   3. 抽象类：5 个抽象类（长虚线表示），对集合接口的部分实现。可扩展为自定义集合类。
   4. 实现类：8 个实现类（实线表示），对接口的具体实现。
   5. Collection 接口是一组允许重复的对象。
   6. Set 接口继承 Collection，集合元素不重复。
   7. List 接口继承 Collection，允许重复，维护元素插入顺序。
   8. Map 接口是键－值对象，与 Collection 接口没有什么关系。
   9. Set、List 和 Map 可以看做集合的三大类：List 集合是有序集合，集合中的元素可以重复，访问集合中的元素可以根据元素的索引来访问。Set 集合是无序集合，集合中的元素不可以重复，访问集合中的元素只能根据元素本身来访问（也是集合里元素不允许重复的原因）。Map 集合中保存 Key-value 对形式的元素，访问时只能根据每项元素的 key 来访问其 value。

3. Collection 接口

   Collection 接口是处理对象集合的根接口，其中定义了很多对元素进行操作的方法。Collection 接口有两个主要的子接口 List 和 Set，注意 Map 不是 Collection 的子接口，这个要牢记。

4. Iterator

   GOF 给迭代器模式的定义为：提供一种方法访问一个容器 (container) 对象中各个元素，而又不需暴露该对象的内部细节。迭代器模式，就是为容器而生。

   Iterator 是一个接口，它是集合的迭代器。集合可以通过 Iterator 去遍历集合中的元素，Iterator 本身并不提供承装对象的能力。如果需要创建 Iterator 对象，则必须有一个被迭代的集合。

   Collection 接口继承了 java.lang.Iterable 接口，该接口有一个 iterator() 方法，那么所有实现了Collection 接口的集合类都有一个 iterator() 方法，用以返回一个实现了 Iterator 接口的对象。

   集合对象每次调用 iterator() 方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。

5. ListIterator

   ListIterator 是一个功能更加强大的迭代器, 它继承于 Iterator 接口,只能用于各种 List 类型的访问。可以通过调用listIterator() 方法产生一个指向 List 开始处的 ListIterator, 还可以调用 listIterator(n) 方法创建一个一开始就指向列表索引为n的元素处的 ListIterator。

6. List 接口

   鉴于 Java 中数组用来存储数据的局限性，我们通常使用 List 替代数组。

   List 集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。

   List 容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。

   JDK API 中 List 接口的实现类常用的有：ArrayList、LinkedList 和 Vector。

7. LinkedList

   链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。

   以下情况使用 LinkedList ：你需要通过循环迭代来访问列表中的某些元素。需要频繁的在列表开头、中间、末尾等位置进行添加和删除元素操作。

8. ArrayList

   ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。

   以下情况使用 ArrayList ：频繁访问列表中的某一个元素。只需要在列表末尾进行添加和删除元素操作。

9. ArrayList 和 LinkedList 的区别

   ArrayList 是 List 接口的一种实现，它是使用数组来实现的。

   LinkedList 是 List 接口的一种实现，它是使用链表来实现的。

   ArrayList 遍历和查找元素比较快。LinkedList 遍历和查找元素比较慢。

   ArrayList 添加、删除元素比较慢。LinkedList 添加、删除元素比较快。

10. Set 接口

    Set 接口是 Collection 的子接口，Set 接口没有提供额外的方法。

    Set 集合不允许包含相同的元素，如果试把两个相同的元素加入同一个 Set 集合中，则添加操作失败。

    Set 判断两个对象是否相同不是使用 == 运算符，而是根据 equals() 方法。

    JDK API 中 Set 接口的实现类常用的有：HashSet、LinkedHashSet 和 TreeSet。

11. HashSet

    HashSet 基于 HashMap 来实现的，是一个不允许有重复元素的集合。

    HashSet 允许有 null 值。

    HashSet 是无序的，即不会记录插入的顺序。

    HashSet 不是线程安全的， 如果多个线程尝试同时修改 HashSet，则最终结果是不确定的。 您必须在多线程访问时显式同步对 HashSet 的并发访问。

12. Set 和 List 的区别

    Set 接口实例存储的是无序的，不重复的数据。List 接口实例存储的是有序的，可以重复的元素。

    Set 检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变 <实现类有HashSet,TreeSet>。

    List 和数组类似，可以动态增长，根据实际存储的数据的长度自动增长 List 的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector> 。

13. Map 接口

    Map 与 Collection 并列存在。用于保存具有映射关系的数据: key-value。

    Map 中的 key 和 value 都可以是任何引用类型的数据。

    Map 中的 key 用 Set 来存放，不允许重复，即同一个 Map 对象所对应的类，须重写 hashCode() 和 equals() 方法。

    常用 String 类作为 Map 的“键”。

    key 和 value 之间存在单向一对一关系，即通过指定的 key 总能找到唯一的、确定的 value。

    Map 接口的常用实现类：HashMap、TreeMap、LinkedHashMap 和 Properties。其中，HashMap 是 Map 接口使用频率最高的实现类。

14. HashMap

    HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。

    HashMap 实现了 Map 接口，根据键的 HashCode 值存储数据，具有很快的访问速度，最多允许一条记录的键为 null，不支持线程同步。

    HashMap 是无序的，即不会记录插入的顺序。

    HashMap 继承于AbstractMap，实现了 Map、Cloneable、java.io.Serializable 接口。

15. Collections 工具类
    reverse(List)：反转 List 中元素的顺序
    shuffle(List)：对 List 集合元素进行随机排序
    sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
    sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
    swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
    Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
    Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
    Object min(Collection)
    Object min(Collection，Comparator)
    int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
    void copy(List dest,List src)：将src中的内容复制到dest中
    boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值

16. 例子

    遍历 ArrayList

    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    public class Test {
        public static void main(String[] args) {
            List<String> list = new ArrayList<String>();
            list.add("Java");
            list.add("SQL");
            list.add("Spring");
            //第一种遍历方法使用 For-Each 遍历 List
            for (String str : list) {
                System.out.println(str);
            }
            //第二种遍历，把链表变为数组相关的内容进行遍历
            String[] strArray = new String[list.size()];
            list.toArray(strArray);
            for (int i = 0; i < strArray.length; i++) {
                System.out.println(strArray[i]);
            }
            //第三种遍历 使用迭代器进行相关遍历
            Iterator<String> ite = list.iterator();
            while (ite.hasNext()){
                System.out.println(ite.next());
            }
        }
    }
    

    遍历 Map

    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    
    public class Test {
        public static void main(String[] args) {
            Map<String, String> map = new HashMap<>();
            map.put("1", "Java");
            map.put("2", "SQL");
            map.put("3", "Spring");
            //第一种：普遍使用，二次取值，通过Map.keySet遍历key和value
            for (String key : map.keySet()) {
                System.out.println("key= "+ key + " and value= " + map.get(key));
            }
            //第二种：通过Map.entrySet使用iterator遍历key和value
            Iterator<Map.Entry<String, String>> ite = map.entrySet().iterator();
            while (ite.hasNext()){
                Map.Entry<String, String> entry = ite.next();
                System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
            }
            //第三种：推荐，尤其是容量大时，通过Map.entrySet遍历key和value
            for (Map.Entry<String, String> entry : map.entrySet()) {
                System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
            }
            //第四种：通过Map.values()遍历所有的value，但不能遍历key
            for (String v : map.values()) {
                System.out.println("value= " + v);
            }
        }
    }