JAVA基础整理（5）-集合 泛型 枚举

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.SortedSet;
import java.util.TreeSet;

/**
 * 集合 Java 提供了集合类。集合类主要负责保存、盛装其他数据，因此集合类也被称为容器类。 Java 所有的集合类都位于 java.util 包下，
 * 提供了一个表示和操作对象集合的统一构架，包含大量集合接口，以及这些接口的实现类和操作它们的算法。
 *
 * Java 集合类型分为 Collection 和 Map，它们是 Java 集合的根接口 terator 接口
 * 集合的输出接口，主要用于遍历输出（即迭代访问）Collection 集合中的元素，Iterator
 * 对象被称之为迭代器。迭代器接口是集合接口的父接口，实现类实现 Collection 时就必须实现 Iterator 接口。 
 * Collection 接口 是 List、Set 和 Queue 的父接口，是存放一组单值的最大接口。
 * 所谓的单值是指集合中的每个元素都是一个对象。一般很少直接使用此接口直接操作。
 * Queue 接口 Queue 是 Java 提供的队列实现，有点类似于 List。 
 * Dueue 接口 是 Queue 的一个子接口，为双向队列。 
 * List 接口 是最常用的接口。是有序集合，允许有相同的元素。
 * 使用List能够精确地控制每个元素插入的位置，用户能够使用索引（元素在 List 中的位置，类似于数组下标）来访问 List 中的元素，与数组类似。 
 * Set 接口不能包含重复的元素。 
 * Map 接口是存放一对值的最大接口，即接口中的每个元素都是一对，以 key➡value 的形式保存。
 *
 * 对于 Set、List、Queue 和 Map 这 4 种集合，Java 最常用的实现类分别是
 * HashSet、TreeSet、ArrayList、ArrayDueue、LinkedList 和 HashMap、TreeMap 等 HashSet
 * 为优化査询速度而设计的 Set。它是基于 HashMap 实现的，HashSet 底层使用 HashMap 来保存所有元素，实现比较简单 TreeSet
 * 实现了 Set 接口，是一个有序的 Set，这样就能从 Set 里面提取一个有序序列 ArrayList 一个用数组实现的
 * List，能进行快速的随机访问，效率高而且实现了可变大小的数组 ArrayDueue 是一个基于数组实现的双端队列，按“先进先出”的方式操作集合元素
 * LinkedList 对顺序访问进行了优化，但随机访问的速度相对较慢。
 * 此外它还有addFirst()、addLast()、getFirst()、getLast()、removeFirst() 和 removeLast()
 * 等方法，能把它当成栈（Stack）或队列（Queue）来用 HsahMap 按哈希算法来存取键对象 TreeMap 可以对键对象进行排序
 *
 * Collection接口 
 * boolean add(E e) 向集合中添加一个元素，如果集合对象被添加操作改变了，则返回 true。E 是元素的数据类型
 * boolean addAll(Collection c) 向集合中添加集合 c 中的所有元素，如果集合对象被添加操作改变了，则返回 true。 
 * void clear() 清除集合中的所有元素，将集合长度变为 0。 
 * boolean contains(Object o) 判断集合中是否存在指定元素
 * boolean containsAll(Collection c) 判断集合中是否包含集合 c 中的所有元素 
 * boolean isEmpty() 判断集合是否为空 
 * Iterator<E>iterator() 返回一个 Iterator 对象，用于遍历集合中的元素 
 * boolean remove(Object o) 从集合中删除一个指定元素，当集合中包含了一个或多个元素 o 时，该方法只删除第一个符合条件的元素，该方法将返回true。 
 * boolean removeAll(Collection c) 从集合中删除所有在集合 c 中出现的元素（相当于把调用该方法的集合减去集合c）。如果该操作改变了调用该方法的集合，则该方法返回 true。 
 * boolean retainAll(Collection c) 从集合中删除集合 c里不包含的元素（相当于把调用该方法的集合变成该集合和集合 c 的交集），如果该操作改变了调用该方法的集合，则该方法返回 true。 
 * int size() 返回集合中元素的个数 Object[] toArray() 把集合转换为一个数组，所有的集合元素变成对应的数组元素。
 * 
 * 泛型集合
 * Java 集合有个缺点，就是把一个对象“丢进”集合里之后，集合就会“忘记”这个对象的数据类型，
 * 当再次取出该对象时，该对象的编译类型就变成了 Object 类型（其运行时类型没变）。
 * 泛型本质上是提供类型的“类型参数”，也就是参数化类型。
 * new ArrayList<String>()
 * 
 * 枚举
 * Java声明枚举类型、枚举（enum）类、EnumMap 与 EnumSet
 * 枚举是一个被命名的整型常数的集合，用于声明一组带标识符的常数。
 * 任意两个枚举成员不能具有相同的名称，且它的常数值必须在该枚举的基础类型的范围之内，多个枚举成员之间使用逗号分隔。
 * EnumMap 类 EnumSet 类
 */

//枚举
enum Sex {
    // 定义一个枚举类型
    GREEN,YELLOW,RED
}

public class HelloWord {

    public static void main(String[] args) {
        System.out.println("今年 java");
        System.out.println(Sex.GREEN);

        arrayLists();
        linkedLists();

        hashSets();
        treeSets();

        hashMaps();
        collectionss();
    }

    // LinkedList 写 ArrayList 查
    // List 是一个有序、可重复的集合，集合中每个元素都有其对应的顺序索引。
    // List 集合允许使用重复元素，可以通过索引来访问指定位置的集合元素。
    // List 集合默认按元素的添加顺序设置元素的索引，第一个添加到 List 集合中的元素的索引为 0，第二个为 1，依此类推。
    // List 实现了 Collection 接口，它主要有两个常用的实现类：ArrayList 类和 LinkedList 类。

    // ArrayList 类实现了可变数组的大小，存储在内的数据称为元素。它还提供了快速基于索引访问元素的方式，
    // 对尾部成员的增加和删除支持较好。
    // 使用 ArrayList 创建的集合，允许对集合中的元素进行快速的随机访问，
    // 不过，向 ArrayList 中插入与删除元素的速度相对较慢。
    //
    // 方法名称 说明
    // E get(int index) 获取此集合中指定索引位置的元素，E 为集合中元素的数据类型
    // int indexOf(Object o) 返回此集合中第一次出现指定元素的索引，如果此集合不包含该元
    // 素，则返回 -1
    // int lastIndexOf(Object o) 返回此集合中最后一次出现指定元素的索引，如果此集合不包含该
    // 元素，则返回 -1
    // E set(int index, Eelement) 将此集合中指定索引位置的元素修改为 element 参数指定的对象。
    // 此方法返回此集合中指定索引位置的原元素
    // List<E> subList(int fromlndex, int tolndex) 返回一个新的集合，新集合中包含 fromlndex 和
    // tolndex 索引之间
    // 的所有元素。包含 fromlndex 处的元素，不包含 tolndex 索引处的
    @SuppressWarnings("rawtypes")
    public static void arrayLists() {
        List<Comparable> list1 = new ArrayList<Comparable>();
        String s1 = "s1";
        int i1 = 10;
        list1.add(s1);
        list1.add(i1);
        list1.add(s1);
        list1.add(i1);
        for (int i = 0; i < list1.size(); i++) {
            System.out.println(list1.get(i));
        }

        Iterator it = list1.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }

        int i20 = list1.indexOf("s1"); // 0
        int i21 = list1.lastIndexOf(10); // 3

        List list20 = list1.subList(1, 3);

        for (int i = 0; i < list20.size(); i++) {
            System.out.println(list20.get(i));
        }

    }

    // LinkedList 写 ArrayList 查
    // LinkedList 类采用链表结构保存对象，这种结构的优点是便于向集合中插入或者删除元素。
    // 需要频繁向集合中插入和删除元素时，使用 LinkedList 类比 ArrayList 类效果高，
    // 但是 LinkedList 类随机访问元素的速度则相对较慢。
    // ArrayList 是基于动态数组数据结构的实现，访问元素速度优于 LinkedList。
    // LinkedList 是基于链表数据结构的实现，占用的内存空间比较大，但在批量插入或删除数据时优于 ArrayList。
    //
    // 方法名称 说明
    // void addFirst(E e) 将指定元素添加到此集合的开头
    // void addLast(E e) 将指定元素添加到此集合的末尾
    // E getFirst() 返回此集合的第一个元素
    // E getLast() 返回此集合的最后一个元素
    // E removeFirst() 删除此集合中的第一个元素
    // E removeLast() 删除此集合中的最后一个元素
    public static void linkedLists() {
        LinkedList<String> l1 = new LinkedList<String>();
        String s1 = "1s1";
        String s2 = "1s2";

        l1.add(s1);
        l1.addLast(s1);
        l1.addFirst(s2);

        String s10 = l1.getFirst();
        String s11 = l1.getLast();

        String s13 = l1.removeFirst();
        String s14 = l1.removeLast();
    }

    /**
     * HashSet Set 集合类似于一个罐子，程序可以依次把多个对象“丢进”Set 集合，而 Set 集合通常不能记住元素的添加顺序。也就是说 Set
     * 集合中的对象不按特定的方式排序，只是简单地把对象加入集合。Set 集合中不能包含重复的对象，并且最多只允许包含一个 null 元素。 Set 实现了
     * Collection 接口，它主要有两个常用的实现类：HashSet 类和 TreeSet类。
     * 
     * HashSet 是 Set 接口的典型实现，大多数时候使用 Set 集合时就是使用这个实现类。 HashSet 是按照 Hash
     * 算法来存储集合中的元素。因此具有很好的存取和查找性能。
     * 
     * 不能保证元素的排列顺序，顺序可能与添加顺序不同，顺序也有可能发生变化。 HashSet 不是同步的，如果多个线程同时访问或修改一个
     * HashSet，则必须通过代码来保证其同步。 集合元素值可以是 null。
     * 
     */
    public static void hashSets() {
        HashSet<String> h1 = new HashSet<String>();
        String s1 = "hs1";
        String s2 = "hs2";
        String s3 = null;

        h1.add(s1);
        h1.add(s2);
        h1.add(s3);
        Iterator<String> it = h1.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }

    /**
     * TreeSet TreeSet 类同时实现了 Set 接口和 SortedSet 接口。 SortedSet 接口是 Set
     * 接口的子接口，可以实现对集合进行自然排序， 因此使用 TreeSet 类实现的 Set 接口默认情况下是自然排序的，这里的自然排序指的是升序排序。
     * 
     * TreeSet 只能对实现了 Comparable 接口的类对象进行排序, 因为 Comparable 接口中有一个 compareTo(Object o) 方法用于比较两个对象的大小
     * E first() 返回此集合中的第一个元素。其中，E 表示集合中元素的数据类型 
     * E last() 返回此集合中的最后一个元素 E poolFirst()获取并移除此集合中的第一个元素 
     * E poolLast() 获取并移除此集合中的最后一个元素 
     * SortedSet<E> subSet(E fromElement,E toElement) 返回一个新的集合，新集合包含原集合中 fromElement 对象与 toElement对象之间的所有对象。包含 fromElement 对象，不包含 toElement 对象 
     * SortedSet<E> headSet<E toElement〉 返回一个新的集合，新集合包含原集合中 toElement 对象之前的所有对象。 不包含 toElement 对象
     * SortedSet<E> tailSet(E fromElement) 返回一个新的集合，新集合包含原集合中 fromElement 对象之后的所有对象。包含 fromElement 对象
     * 
     */
    public static void treeSets() {
        TreeSet<String> h1 = new TreeSet<String>();
        String s1 = "hss1";
        String s2 = "hss2";
        String s3 = "hss3";

        h1.add(s1);
        h1.add(s2);
        h1.add(s3);
        Iterator<String> it = h1.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }

        // 不含s2
        SortedSet<String> h10 = h1.headSet(s2);

        Iterator<String> it10 = h10.iterator();
        while (it10.hasNext()) {
            System.out.println(it10.next());
        }

        // 含s2
        SortedSet<String> h20 = h1.tailSet(s2);

        Iterator<String> it20 = h20.iterator();
        while (it20.hasNext()) {
            System.out.println(it20.next());
        }

        h1.pollFirst();
        h1.pollLast();
        h1.first();
        h1.last();
        it = h1.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }

    }

    /**
     * Map集合 Map 是一种键-值对（key-value）集合，Map 集合中的每一个元素都包含一个键（key）对象和一个值（value）对象。
     * 用于保存具有映射关系的数据。 Map 以及实现 Map 的接口类（如 HashMap、TreeMap、LinkedHashMap、Hashtable 等）
     * 
     * Map 接口主要有两个实现类：HashMap 类和 TreeMap 类。其中，HashMap 类按哈希算法来存取键对象，而 TreeMap
     * 类可以对键对象进行排序。 void clear() 删除该 Map 对象中的所有 key-value 对。 
     * 
     * boolean containsKey(Object key) 查询 Map 中是否包含指定的 key，如果包含则返回 true。 
     * boolean containsValue(Object value) 查询 Map 中是否包含一个或多个 value，如果包含则返回 true。 
     * V get(Object key) 返回 Map 集合中指定键对象所对应的值。V 表示值的数据类型 
     * V put(K key, V value) 向 Map 集合中添加键-值对，如果当前 Map 中已有一个与该 key 相等的 key-value 对，则新的 key-value 对会覆盖原来的
     * key-value 对。 
     * void putAll(Map m) 将指定 Map 中的 key-value 对复制到本 Map 中。 
     * V remove(Object key) 从 Map 集合中删除 key 对应的键-值对，返回 key 对应的 value，如果该 key 不存在，则返回null 
     * boolean remove(Object key, Object value) 这是 Java 8 新增的方法，删除指定 key、value 所对应的 key-value 对。如果从该 Map 中成功地删除该 key-value 对，该方法返回 true，否则返回 false。 
     * Set entrySet() 返回 Map 集合中所有键-值对的 Set 集合，此 Set 集合中元素的数据类型为 Map.Entry 
     * Set keySet() 返回 Map 集合中所有键对象的 Set 集合 boolean isEmpty() 查询该 Map 是否为空（即不包含任何 key-value对），如果为空则返回 true。 
     * int size() 返回该 Map 里 key-value 对的个数 Collection values() 返回该Map 里所有 value 组成的 Collection
     */
    public static void hashMaps() {
        HashMap<String, Object> h1 = new HashMap<String, Object>();

        String s1 = "hm1";
        String s2 = "hm2";
        int i1 = 10;
        int i2 = 20;

        h1.put("s1", s1);
        h1.put("s2", s2);
        h1.put("i1", i1);
        h1.put("i2", i2);
        // 遍历Iterator
        Iterator<String> it = h1.keySet().iterator();
        while (it.hasNext()) {
            Object key = it.next();
            Object val = h1.get(key);
            System.out.println("k:" + key + ",v:" + val);
        }

        boolean b1 = h1.containsKey("s1");
        boolean b2 = h1.containsValue(10);

        h1.remove("s1");
        boolean b3 = h1.containsKey("s1");

        int i20 = h1.size();

        Collection<Object> l1 = h1.values();
        Iterator<Object> it2 = l1.iterator();
        while (it2.hasNext()) {
            System.out.println(it2.next());
        }

        // 遍历entrySet
        for (Entry<String, Object> entry : h1.entrySet()) {
            String mapKey = entry.getKey();
            Object mapValue = entry.getValue();
            System.out.println(mapKey + "：" + mapValue);
        }

        // 遍历keySet 打印键集合
        for (String key : h1.keySet()) {
            System.out.println(key);
        }
        // 遍历values 打印值集合
        for (Object value : h1.values()) {
            System.out.println(value);
        }

        // 遍历Iterator
        Iterator<Entry<String, Object>> it3 = h1.entrySet().iterator();
        while (it3.hasNext()) {
            Entry<String, Object> entry = it3.next();
            String key = entry.getKey();
            Object value = entry.getValue();
            System.out.println(key + ":" + value);
        }

        h1.clear();
    }

    /**
     * Collections类 Collections 类是 Java 提供的一个操作 Set、List 和 Map 等集合的工具类。
     * 
     * void reverse(List list)：对指定 List 集合元素进行逆向排序。 
     * void shuffle(List list)：对 List集合元素进行随机排序（shuffle 方法模拟了“洗牌”动作）。 
     * void sort(List list)：根据元素的自然顺序对指定 List集合的元素按升序进行排序。 
     * void sort(List list, Comparator c)：根据指定 Comparator 产生的顺序对 List集合元素进行排序。 
     * void swap(List list, int i, int j)：将指定 List 集合中的 i 处元素和 j 处元素进行交换。
     * void rotate(List list, int distance)：当 distance 为正数时，将 list 集合的后 distance个元素“整体”移到前面；
     * 当 distance 为负数时，将 list 集合的前 distance 个元素“整体”移到后面。该方法不会改变集合的长度。
     * 
     * Collections 还提供了如下常用的用于查找、替换集合元素的方法。
     * int binarySearch(List list, Object key)：使用二分搜索法搜索指定的 List 集合，以获得指定对象在 List 集合中的索引。如果要使该方法可以正常工作，则必须保证 List 中的元素已经处于有序状态。
     * Object max(Collection coll)：根据元素的自然顺序，返回给定集合中的最大元素。
     * Object max(Collection coll, Comparator comp)：根据 Comparator 指定的顺序，返回给定集合中的最大元素。
     * Object min(Collection coll)：根据元素的自然顺序，返回给定集合中的最小元素。
     * Object min(Collection coll, Comparator comp)：根据 Comparator 指定的顺序，返回给定集合中的最小元素。
     * void fill(List list, Object obj)：使用指定元素 obj 替换指定 List 集合中的所有元素。
     * int frequency(Collection c, Object o)：返回指定集合中指定元素的出现次数。
     * int indexOfSubList(List source, List target)：返回子 List 对象在父 List 对象中第一次出现的位置索引；如果父 List 中没有出现这样的子 List，则返回 -1。
     * int lastIndexOfSubList(List source, List target)：返回子 List 对象在父 List 对象中最后一次出现的位置索引；如果父 List 中没有岀现这样的子 List，则返回 -1。
     * boolean replaceAll(List list, Object oldVal, Object newVal)：使用一个新值 newVal 替换 List 对象的所有旧值 oldVal。
     * 
     * Collections 类的 copy() 静态方法用于将指定集合中的所有元素复制到另一个集合中。
     * 执行 copy() 方法后，目标集合中每个已复制元素的索引将等同于源集合中该元素的索引。
     */
    public static void collectionss() {
        ArrayList<Integer> h1 = new ArrayList<Integer>();
        ArrayList<Integer> h2 = new ArrayList<Integer>();
        for (int i = 0; i < 5; i++) {
            h1.add(i);
        }
        for (int i = 0; i < 5; i++) {
            h2.add(i);
        }
        
        Collections.sort(h1);//01234
        Collections.reverse(h1);//43210
        Collections.swap(h1, 1, 2);//42310
        Collections.shuffle(h1);
        Collections.sort(h1);
        Collections.rotate(h1, 2); //34012
        Collections.rotate(h1, -2); //01234
        Collections.sort(h1);
        
        int i1 = Collections.binarySearch(h1, 2); //2
        i1 = Collections.max(h1);
        i1 = Collections.min(h1);
        Collections.fill(h1, 1); //11111
        i1 = Collections.frequency(h1, 1); //5
        Collections.replaceAll(h1, 1, 2); //22222
        
        Collections.copy(h2, h1);

        for (int i = 0; i < h2.size(); i++) {
            System.out.print(h2.get(i));
        }
        
        

    }

}