一周学完Java基础，第六天，常见容器

(1) 列表List 

        接口:
        java.util.List<>
        实现方式:
        java.util.ArrayList<> : 变长数组
        java.util.LinkedList<> : 双链表
        函数:
        add() : 在末尾添加一个元素
        clear():清空
        size():返回长度
        isEmpty():是否为空
        get(i) : 获取第i个元素
        set(i,val) : 将第i个元素设置为val

    //  List<Integer> list = new ArrayLsit<>();
        List<Integer> list = new LinkedList<>();
        
        list.add(1); //[1]
        list.add(2); //[1, 2]
        list.clear(); //[]
        list.add(1); 
        list.add(2); 
        list.size(); // 2
        list.isEmpty(); //false
        list.get(1); // 2
        list.set(1,4); 
        //list.set(3,4); 报错 必须先add再set

 

 (2) 栈 Stack

        类:
        java.util.Stack<>
        函数:
        push() : 压入元素
        pop() : 弹出栈顶元素，并返回栈顶元素
        peek() : 返回栈顶元素
        size() : 返回长度
        empty() : 栈是否为空
        clear() : 清空

            Stack<Integer> stk = new Stack<>();
            stk.push(1);
            stk.push(2);
            stk.pop(); // 2
            stk.peek();// 1
            stk.size();// 1
            stk.empty(); // false
            stk.clear();
            System.out.println(stk.size());

(3) 队列  Queue

        类:
        java.util.LinkedList<> 双链表
        java.util.PriorityQueue<> 优先队列,小根堆
        java.util.PriorityQueue<>(Collection.reverseOrder) 大根堆
        函数:
        add() : 队尾添加元素
        remove() : 删除并返回队头
        isEmpty() : 是否为空
        size() : 返回长度
        peek() : 返回队头
        clear() : 清空

       Queue<Integer> q= new PriorityQueue();//小根堆
       q.add(2);
       q.add(1);
       q.add(10);
       System.out.println(q.peek()); //1  由于是小根堆，所以顶部是最小值
       q.remove();
       System.out.println(q.peek()); //2  
       
       Queue<Integer> Bq = new PriorityQueue(Collections.reverseOrder());//大根堆
       Bq.add(2);
       Bq.add(1);
       Bq.add(10);
       System.out.println(Bq.peek()); //10

(4) 集合  Set

        接口:
        java.util.Set<K>
        实现:
        java.util.HashSet<K> : 哈希表
        java.util.TreeSet<K> : 平衡树
        函数:
        add() : 添加元素
        contains() : 是否包含某个元素
        remove() : 删除元素
        size() : 返回元素数
        isEmpty() : 是否为空
        clear() : 清空
        
        java.util.TreeSet的函数:
        ceiling(key):返回大于等于key的最小元素,不存在则返回null
        floor(key):返回小于等于key的最大元素,不存在则返回null

    Set<Integer> set = new HashSet<>(); //哈希表,顺序是随机的
       set.add(1);
       set.add(2);
       set.add(10);
       set.contains(2); //true
       set.remove(2);
       set.contains(2); //false
       for(int x : set)  System.out.println(x); //遍历Set
    TreeSet<Integer> setTree = new TreeSet<>(); //平衡树,顺序是有序的
       setTree.add(1);
       setTree.add(2);
       setTree.add(10);
       System.out.println(setTree.ceiling(5)); // 10
       System.out.println(setTree.floor(5)); // 2   

(5) 图  Map

        接口:
        java.util.Map<K,V>
        实现:
        java.util.HashMap<K,V> : 哈希表
        java.util.TreeMap<K,V> : 平衡树
        函数:
        put(key,value) : 添加关键字与其对应值
        get(key) : 返回关键字对应的值
        containsKey(key) : 是否包含关键字
        remove(key) : 删除关键字
        size() : 返回元素数
        isEmpty() : 是否为空
        clear() : 清空
        entrySet() : 获取Map中所有对象的集合
        
        Map.Entry<K,V> : Map中的对象类型
            getKey() : 获取关键字
            getValue() : 获取值
    
        java.util.TreeMap<K,V>的函数:
        ceilingEntry(key):返回大于等于key的最小元素,不存在则返回null
        floorEntry(key):返回小于等于key的最大元素,不存在则返回null

    Map<String,Integer> map = new HashMap<>(); //哈希表 无序
        map.put("123",2);
        map.put("321",3);
        map.put("21",10);
        map.get(123); //null
        map.get("123"); //2
        map.containsKey("123"); //true
        map.remove("123");
        map.containsKey("123"); //false
        
        for(Map.Entry<String,Integer> entry:map.entrySet())
            System.out.printf("%s %d\n",entry.getKey(),entry.getValue());
        //321 3
        //21 10
        
     TreeMap<String,Integer> map = new TreeMap<>(); //平衡树 有序
        map.put("123",2);
        map.put("321",3);
        map.put("21",10);
    
        
        for(Map.Entry<String,Integer> entry:map.entrySet())
            System.out.printf("%s %d\n",entry.getKey(),entry.getValue());
        //    123 2
        //    21 10
        //    321 3
        由于TreeMap的key为String类，其比较大小是通过字典序。所以是123>21>321
        
        TreeMap<Integer,Integer> Newmap = new TreeMap<>(); 
        Newmap.put(123,2);
        Newmap.put(321,3);
        Newmap.put(21,10);
        
        Map.Entry<Integer,Integer> up = Newmap.ceilingEntry(124);
        System.out.println(up);               //321=3
        System.out.println(up.getKey());      //321
        System.out.println(up.getValue());    //3