Java中集合的使用

    @Test
    void test() {
        /*单列集合的根接口*/
        Collection c = null;
        /*List集合*/
        /*ArrayList，
        内部使用数组来存储数据，有序，允许存在重复值和null
        在构建时尽可能的传递参数作为数组的初始长度
        和指定泛型来统一元素类型
         * */
        ArrayList<String> list = new ArrayList(20);
        /*add方法：向集合追加一个元素1*/
        list.add("1");
        /*在索引为0的位置插入一个元素2*/
        list.add(0,"2");
        /*addAll方法：追加一个集合*/
        list.addAll(Arrays.asList("11","22","33","33"));
        /*在指定索引位置插入一个集合*/
        list.addAll(2,Arrays.asList("44","55","66"));
        /*remove方法：移除集合中索引最小的元素1*/
        list.remove("1");
        /*移除指定索引位置的元素*/
        list.remove(0);
        /*移除多个元素，只要集合中的元素存在于指定的集合中就将其移除*/
        list.removeAll(Arrays.asList("33","111"));
        /*与removeAll相反，该方法移除不包含在指定集合中的元素*/
        list.retainAll(Arrays.asList("44","55","66"));
        /*此方法参数是一个函数式接口，需要把元素保留或移除的逻辑写在其实现方法中，返回值为true则移除该元素
        * 如下，移除值为11的元素*/
        list.removeIf(s -> "11".equals(s));
        /*该方法的参数也是一个函数式接口，可以将元素的更改逻辑写在实现方法中
        * 如下，在每个元素的末尾加上一个0*/
        list.replaceAll(s -> s+="0");
        /*获取指定索引位置上的元素*/
        list.get(0);
        /*设置指定索引位置上的元素*/
        list.set(2,list.get(2).concat("0"));
        /*获取当前集合中元素数量*/
        list.size();
        /*获取指定元素在集合中首次出现位置的索引,若此元素不存在则返回-1*/
        list.indexOf("440");
        /*获取指定元素在集合中最后一次出现位置的索引*/
        list.lastIndexOf(" ");
        /*判断此集合是否存在指定元素*/
        list.contains("550");
        /*判断此集合中是否包含指定子集,子集元素顺序可以任意排列*/
        list.containsAll(Arrays.asList("440","550"));
        /*截取集合中从指定开始索引到指定结束索引的元素
        * 该方法不会直接对原集合产生影响，他会返回一个新的子集*/
        List list1 = list.subList(0,list.size()/2);
        /*返回一个包含集合所有元素的数组*/
        Object[] os = list.toArray();
        /*将集合所有元素复制到指定数组中，若该类型数组类型与集合元素类型不匹配会抛出异常
        * 若该数组长度低于集合元素数量则后面的元素会丢失*/
        String[] ss = new String[list.size()];
        list.toArray(ss);
        /*排序，传递的参数是Comparable类型，这个接口同样是函数式接口
        * 将比较逻辑写在实现方法中，通过返回值得正负进行排序
        * 如下，直接将String类中compareTo方法充当实现方法让其自然排序就好
        * 此方法执行后只对当前的元素有效，不会影响后来新增的元素顺序*/
        list.sort(String::compareTo);
        /*获取集合迭代器,通常用于无序集合的遍历（在forEach结构出现之前）*/
        Iterator<String> it = list.iterator();
        /*hasNext：判断下一个元素是否存在*/
        while(it.hasNext()){
            /*获取下一个元素*/
            String s = it.next();
        }
        /*以Lambda方法引用的方式遍历数组*/
        list.forEach(s -> System.out.println(s));
        list.forEach(System.out::println);
        list.forEach(s -> {
            s = s.concat(s);
            System.out.println(s);
        });
        /*清空所有元素*/
        list.clear();


        /*LinkedList
        * 内部使用链表结构，此结构是非连续的，而且不用向数组那样在使用前
        * 就定义固定的长度，链表中的每个节点都存储着前一个和后一个节点的信息
        * 在有新元素被加进来时只需将其与前一个节点关联信息即可，但每次查找元素时都必须从首节点开始遍历
        * 因为他是不连续的,这样随机访问的效率就远不如数组
        * 所以LinkedList适用于元素需要频繁变更的场景*/

        /*直接构造，无需初始长度，扩容非常便捷*/
        LinkedList<Integer> ll = new LinkedList();

        /*传递一个其他集合构造LinkedList
        * 该构造器内部是调用了addAll方法*/
        ll = new LinkedList(Arrays.asList(1,22,333,4444));

        /*LinkedList中的特有的方法*/

        /*在首节点位置添加一个元素 55*/
        ll.addFirst(55);
        /*在尾节点后添加一个元素66，此方法等同于add()*/
        ll.addLast(66);
        /*获得首节点位置的元素，若不存在该元素则抛出异常*/
        Integer i = ll.element();
        /*等同于element()*/
        ll.getFirst();
        /*获取尾节点位置的元素，若不存在该元素会抛出异常*/
        ll.getLast();
        /*将元素77添加到尾部节点后，等同于addLast()*/
        ll.offer(77);
        /*等同于addFirst()*/
        ll.offerFirst(0);
        /*等同于offer()*/
        ll.offerLast(888);


        /*Set集合*/

        /*HashSet，此集合内部数据结构为哈希表
        * 有自己独特的排序方式（根据HashCode），添加到此结合的引用数据类型尽量重写hashCode()与equals()
        * 因为此集合中不允许出现重复元素,但可以添加null
        * */
        /*将上方的LinkedList添加到此HashSet中*/
        HashSet<String> set = new HashSet(ll);
        set.add(null);
        /*由于此集合有自己的排序方式，所以他无法使用get()方法通过索引查找元素*/

        /*LinkedHashSet
        * 此结构内部除了哈希表之外还维护了一张链表
        * 他的元素排序就是元素添加顺序的先后
        * 但他仍无法使用get方法*/
        LinkedHashSet<String> lhs = new LinkedHashSet(ll);

        System.out.println(set);

        /*TreeSet
        * 与HashSet不同的是他允许自定义排序方式，它会根据元素实现Comparable接口的CompareTo方法来进行排序
        * 若元素中未实现此方法则使用默认排序*/
        TreeSet<String> ts = new TreeSet(ll);



        /*双列集合的根接口，
        双列集合的每个元素以key-value的键值对形式出现
        key具备HashSet的所有特点（因为HashSet就取自HashMap的key）
        */
        Map map = null;

        /*HashMap
        * 构建一个指定长度的HashMap*/
        HashMap<String,Object> hashMap = new HashMap(20);

        /*一些操作Map的方法*/

        /*put：添加一个元素,若其中已经存在相同的key则将该元素替换*/
        hashMap.put("key0","value0");
        /*将其他的Map添加到此HashMap中*/
        hashMap.putAll(new HashMap<String,Object>());
        /*移除一个指定key的元素*/
        hashMap.remove("k");
        /*移除指定元素*/
        hashMap.remove("k","v");
        /*替换指定key的元素的value*/
        hashMap.replace("key0","v0");
        /*判断此HashMap中是否有元素的key为key0*/
        hashMap.containsKey("key0");
        /*判断此HashMap中是否有元素的value为v0*/
        hashMap.containsValue("v0");
        /*替换指定元素的value
        参数1：key，参数2：oldValue，参数3：newValue
        */
        hashMap.replace("key0","v0","vv0");
        /*参数是一个函数式接口，将元素更新的逻辑写在其实现方法中,返回值为新的value
        * 如下：将key为key0的的元素的值大写*/
        hashMap.replaceAll((k,v) -> "key0".equals(k)?v.toString().toUpperCase():v);
        /*获取所有元素的value组成的集合*/
        List list2 = new ArrayList(hashMap.size());
        list2.addAll(hashMap.values());
        /*获取所有元素的key组成的集合*/
        Set<String> set1 = new HashSet();
        set1.addAll(hashMap.keySet());
        /*返回一个泛型为Entry的Set集合
        * Entry是Map的内部接口，他用于存储元素的key-value信息
        * 常用与遍历集合元素使用*/
        Set<Map.Entry<String,Object>> entrySet = hashMap.entrySet();
        for (Map.Entry entry : entrySet){
            /*获取key*/
            entry.getKey();
            /*获取value*/
            entry.getValue();
        }
        /*遍历集合*/
        hashMap.forEach((k,v) -> System.out.println(k+":"+v));


        /*LinkedHashMap
        * key等同于LinkedHashSet*/
        LinkedHashMap lhm = new LinkedHashMap(20);
        
        /*TreeMap
        key等同于TreeSet*/
        TreeMap tm = new TreeMap(hashMap);

    }