Java 常用容器总结（List，String，HashMap，Stack，Queue，HashSet）

package containers;

import java.util.*;

class TreeNode{
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(){};
    TreeNode(int val){
        this.val = val;
    }
    TreeNode(int val, TreeNode left, TreeNode right){
        this.val = val;
        this.left = left;
        this.right = right;
    }
}

public class Containers {
    public static void main(String[] args) {
        // 每个容器以 增 改 查 删 其他 顺序展示其常用方法
        /* 总结：按 List, String, HashMap, Stack, Queue, HashSet 的顺序
        *  增：add, append, put, push, offer, add
        *  改：set, setCharAt, replace, --, --, --
        *  查：get, charAt, get/ContainsKey/ContainsValue, peek, peek, contains
        *  删：remove, sb.deleteCharAt, remove, pop, poll, remove
        *  其他：获取长度, 除了String用length,其他的都用size,且都有clear;判空都用isEmpty
        * */
        
        //1.ArrayList && LinkedList ===================================================================================
        ArrayList<Integer> arrayList = new ArrayList<>();

        arrayList.add(2);
        arrayList.add(1,3);

        arrayList.set(0,3);

        arrayList.get(0);
        arrayList.lastIndexOf(2);//找到最后一个出现的下标索引

        arrayList.remove(0);

        arrayList.size();
        arrayList.isEmpty();
        arrayList.toArray(); //转数组，返回int[]
        arrayList.clear();

        //给容器排序
        Collections.sort(arrayList,new Comparator<Integer>(){
            public int compare(Integer o1, Integer o2){
                return o1 - o2;
            }
        });
        
        // ------------------------------------------------------------------------------------------------------------
        LinkedList<Integer> linkedList = new LinkedList<>();

        linkedList.add(2);
        linkedList.addFirst(1);
        linkedList.addLast(3);

        linkedList.set(0,1);

        linkedList.get(1);
        linkedList.getFirst();
        linkedList.getLast();

        linkedList.remove(0);
        linkedList.removeFirst();
        linkedList.removeLast();

        linkedList.size();
        linkedList.clear();
        linkedList.toArray();
        linkedList.isEmpty();

        //2.String && StringBuilder ===================================================================================
        String s = "hello world";

        s.concat("lewis");
        
        s.replace('a','b');

        s.charAt(2);
        s.indexOf("ll");
        s.lastIndexOf(" ");
        
        s.equals("hello");
        s.substring(0,3);
        s.length();
        s.trim();
        s.toLowerCase();
        s.toCharArray();
        s.split(" ");
        s.isEmpty();
        
        //-------------------------------------------------------------------------------------------------------------
        
        StringBuilder sb = new StringBuilder("hello world");

        sb.append('a');
        sb.append(2);

        sb.setCharAt(0,'b');

        sb.charAt(1);
        sb.indexOf("ll");
        sb.lastIndexOf("ll");

        sb.deleteCharAt(0);
        
        sb.substring(1,4);
        sb.length();
        sb.toString();
        sb.reverse();


        //3.HashMap ===================================================================================================
        HashMap<Integer,Integer> mp = new HashMap<>();

        mp.put(1,10);

        mp.replace(1,11);

        mp.get(1);
        mp.containsKey(1);
        mp.containsValue(11);

        mp.remove(1);

        mp.isEmpty();
        mp.size();
        mp.clear();
        mp.keySet();  //获取mp的所有key，可以用来遍历mp

        //4.Stack =====================================================================================================
        Stack<TreeNode> st = new Stack<TreeNode>();
        TreeNode node = new TreeNode(2);
        st.push(node);

        st.peek();

        st.pop();

        st.isEmpty();
        st.size();
        st.clear();

        //5.Queue && PriorityQueue ====================================================================================
        Queue<Integer> q = new LinkedList<>();
        q.offer(1);       //队满，add 抛出异常，offer 返回 false
        q.add(2);

        q.peek();    //队空，element 抛出异常，peek 返回 null
        q.element();

        q.poll();     //队空，remove 抛出异常，poll 返回 null
        q.remove();
                        //所以使用队列的时候，推荐使用 offer, peek, poll 这一套操作
        q.isEmpty();
        q.clear();
        q.size();

        //----------------------------------------------------------------------------------------------------------
        
        PriorityQueue<Integer> pq = new PriorityQueue<>((a,b)->(b-a)); //默认是小顶堆，加了 (a,b)->(b-a) 之后变成大顶堆
        pq.offer(1);
        pq.add(2);
        
        pq.peek();
        
        pq.poll();
        pq.remove();
        
        pq.isEmpty();
        pq.size();
        pq.clear();
        
        //7.HashSet & TreeSet ==========================================================================================
        HashSet<Integer> hashSet = new HashSet<>();
        
        hashSet.add(1);
        
        hashSet.contains(1);
        
        hashSet.remove(1);
        
        hashSet.size();
        hashSet.clear();
        hashSet.isEmpty();
        hashSet.toArray();
        // hashSet 可以直接遍历 for(Integer key : hashSet)
//  ----------------------------------------------------------------------

    }
}