Java——集合

package com.fazai.wechat.util;


import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.*;

public class Tests {

    public static void main(String[] args) {
        //  c.forEach(i->System.out.println(i));
    }

    /**四大类：Set(无序不可重复) List(有序可重复)  Map(键值对) Queue(保持一个队列(先进先出)的顺序)
     *
     *
     * ArrayDeque 用循环数组实现的双端队列
     * HashSet 没有重复元素的无序集合
     * TreeSet TreeSet可以确保集合元素处于排序状态
     * EnumSet  EnumSet是一个专门为枚举类设计的集合类，以枚举值在Enum类内的定义顺序来决定集合元素的顺序
     * LinkedHashSet 使用链表维护元素的次序，这样使得元素看起来是以插入的顺序保存的
     * PriorityQueue 高效删除最小元素的集合
     *
     * HashMap 键值关联的数据结构
     * TreeMap 键值有序排列的映射表
     * EnumMap 键值属于枚举类型的映射表
     * LinkedHashMap 记住键值项添加顺序的映射表
     * WeakHashMap 值无用后可以被垃圾回收机制回收
     * IdentityHashMap 用==而不是equals比较键值的映射表
     *
     */

    /**
     * Map类
     * HashMap(可以接受null键值) Hashtable(线程安全的)
     * LinkedHashMap 加上链表来维护map
     * Properties
     * TreeMap
     * WeakHashMap
     * IdentityHashMap
     * EnumMap
     */
    static void map() throws IOException {

        //------------HashMap
        HashMap hashMap = new HashMap();

        hashMap.put(null, "a");//添加

        hashMap.put("1", null);

        hashMap.put("2", "b");

        hashMap.remove("1");//删除,clear清空

        hashMap.get("2");//根据键获取值

        hashMap.replace("2", "c");//修改，或者放入put相同的键也能达到修改效果

        Set smap = hashMap.entrySet();//将键值对组合成set集合,keySet将键以set形式返回

        hashMap.containsKey("2");//是否包含这个键,containsValue值

        Collection c = hashMap.values();//将值转换为Collection

        //------------Properties
        Properties p = new Properties();
        p.setProperty("name", "tom");//添加
        p.getProperty("name");//获取
        p.loadFromXML(new FileInputStream("aa.xml"));//从文件中获取，当然可以写出到文件
    }

    /**
     * Set类
     * HashSet
     * LinkedHashSet
     * TreeSet
     */
    static void set() {

    }

    /**
     * List类 常用操作
     * ArrayList 动态增长和减少的索引序列，查找速度快
     * LinkedList 在任何位置进行高效插入和删除的有序序列
     * Vector 线程安全
     */
    static void list() {
        ArrayList array = new ArrayList();
        LinkedList linked = new LinkedList();
        Vector vector = new Vector();

        //-----------------arrayList 基于数组的线性表
        //增删改查

        array.add("1");// 添加

        array.add(0, "2");//指定位置添加

        array.set(0, "2");//修改

        array.get(0);//根据索引取值；indexOf 根据值取索引,   lastIndexOf​(Object o)最后一次出现的位置

        array.remove(0);//clear清空集合，remove(obj)移除该对象，removeRange移除某段内容,subList截取某段

        array.contains("1");//是否包含

        array.size();//集合大小

        array.toArray();//转换为数组

        //----------------linkedList 基于链的线性表,类似于双端队列、栈的用法功能强大

        linked.addFirst("a");//从头部添加,addLast从尾部添加

        linked.getLast();//获取最后一个,  getFirst

        linked.offer("b");//加入到队列的尾部(双端队列),push 顶部

        linked.peekFirst();//访问顶部元素

        linked.pop();//弹出顶部元素

        linked.pollLast();//访问并删除最后一个元素

    }


    /**
     * Queue 队列，栈
     */
    static void queue() {
        //PriorityQueue----------------
        PriorityQueue pq = new PriorityQueue();
        pq.offer(6);  //入队
        pq.offer(-3);

        //输出pq队列，并不是按元素的加入顺序排列，而是按元素的大小顺序排列，输出[-3, 6]

        //访问队列第一个元素，其实就是队列中最小的元素：-3
        pq.poll();

        //ArrayDeque 既可以作为队列使用、也可以作为栈使用-------------------
        ArrayDeque ad = new ArrayDeque();

        ad.push("A"); //入队

        ad.peek(); //访问第一个元素，但并不将其pop

        ad.pop();//出队.pop出第一个元素

        //stack--栈,先进后出java中栈用来存储对象的引用和基本数据类型
        Stack v = new Stack();
        //依次将三个元素push入"栈"
        v.push("第一个元素");
        v.push("第二个元素");
        v.push("第三个元素");

        //输出
        System.out.println(v);

        //访问第一个元素，但并不将其pop出"栈"
        System.out.println(v.peek());

        //pop出第一个元素
        System.out.println(v.pop());

        //输出
        System.out.println(v);

    }

    /**
     * 堆---可以被看做一棵树的数组对象，堆的实现通过构造二叉堆（binary heap），实为二叉树的一种。将根节点最大的堆叫做最大堆或大根堆
     * 逻辑定义：n个元素序列{k1,k2...ki...kn},当且仅当满足下列关系时称之为堆：(ki <= k2i,ki <= k2i+1)或者(ki >= k2i,ki >= k2i+1), (i = 1,2,3,4...n/2)
     * 特点：
     * 任意节点小于（或大于）它的所有后裔，最小元（或最大元）在堆的根上（堆序性）。
     * 堆总是一棵完全树。即除了最底层，其他层的节点都被元素填满，且最底层尽可能地从左到右填入
     * java中用来存储对象数组等
     */
    static void heap() {


    }

    /**
     * 集合遍历
     */
    static void iter() {
        //--------------List类
        List l = new ArrayList();
        l.add(1);
        l.add(2);

        //方法一：迭代器遍历
        Iterator it = l.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }

        //方法二：for循环
        for (int i = 0; i < l.size(); i++) {
            System.out.println(l.get(i));
        }

        //方法三：foreach
        for (Object i : l) {
            System.out.println(i);
        }

        //方法四：函数式
        l.forEach(i -> System.out.println(i));

        //方法五：list特有的listIterator
        ListIterator li = l.listIterator();
        while (li.hasNext()) {
            System.out.println(li.next());
        }


    }
/**
     * 集合工具类 Collections 和Arrays
     */
    static void tool() {
        List<Integer> list = new ArrayList<>();
        int[] in = {1, 4, 6, 8, 9};

        //-----Collections--------

        //向指定的集合添加元素
        Collections.addAll(list, 2, 1, 3);

        //反转
        Collections.reverse(list);

        //排序，默认升序;若要降序反转即可
        Collections.sort(list);

        //二分查找,返回索引,前提是要升序排列；找不到会返回负数
        int i = Collections.binarySearch(list, 2);

        //打乱
        Collections.shuffle(list);

        //不可修改,封装后cl不可更改,否则运行会报异常
        Collection cl = Collections.unmodifiableCollection(list);

        //线程安全
        Collection sl = Collections.synchronizedCollection(list);

        //-------Arrays------------

        //打印数组
        Arrays.toString(in);

        //将数组与list的转换
        List l3 = Arrays.asList(in);

        //复制数组
        int[] in2 = Arrays.copyOfRange(in, 0, in.length);

        //数组排序
        Arrays.sort(in);

        //二分查找
        Arrays.binarySearch(in, 2);

        //构造Stream
        IntStream s = Arrays.stream(in);
    }


    /**
     * 集合之间的运算
     */
    static void operate() {
        List<Integer> list1 = new ArrayList<>();
        List<Integer> list2 = new ArrayList<>();
        Collections.addAll(list1, 2, 1, 3);
        Collections.addAll(list2, 2, 1, 5);

        //交 list1交上list2，谁调用的方法，改变的就是谁（此处list1改变，list2不变）
        //list1.retainAll(list2);
        // System.out.println(list1);//[2, 1]

        //并 定义临时list3,先求出两者的交集-->list2中移除交集-->都加入到list3
        List<Integer> list3 = new ArrayList<>();
        list3.addAll(list1);
        list1.retainAll(list2);
        list2.removeAll(list1);
        list3.addAll(list2);
        System.out.println(list1);

        //补
        list1.removeAll(list2);

    }

}