1. HashMap<String, Integer> mp = new HashMap<>();    //定义一个HashMap
    2. mp.put(key, value);                                //插入键值对
    3. mp.size()                                       //获取容器中键值对数量
    4. mp.get(str);                                    //获取key值对应的value
    1. class PII implements Comparable<PII> {
    2.     public int ts;
    3.     public int id;
    4.     public PII(int ts, int id) {
    5.         this.ts = ts;
    6.         this.id = id;
    7.     }
    8.     //自定义排序
    9.     @Override
    10.     public int compareTo(PII o) {
    11.         return Integer.compare(ts, o.ts);
    12.     }
    13. }
    1. ArrayList res = new ArrayList();        //定义一个动态数组
    2. res.add(obj);                            //向动态数组中加入一个元素
    3. for (int i = 0; i < res.size(); i++) {    //遍历该动态数组
    4.     System.out.print(res.get(i) + " ");
    5. }
    1. Stack<Integer> stk = new Stack<Integer>();        //定义一个栈
    2. stk.push(value);        //入栈
    3. stk.empty();            //判断栈顶是否为空
    4. stk.pop();                //移除堆栈对象并将其返回（与C++中的不同）
    5. stk.peek();                //返回栈顶对象
    6. stk.search();            //返回对象在堆栈中的位置，以 1 为基数，其实位置为栈顶
    1. Queue<node> q = new LinkedList<node>(); //定义一个队列
    2. q.offer(new node(sx, sy, 0));            //向队列中加入一个元素【add()和remove()方法在失败的时候会抛出异常(不推荐)】
    3. q.poll();                                //返回第一个元素，并在队列中删除
    4. queue.element() 或 queue.peek();           //返回第一个元素
    1. import java.util.PriorityQueue;
    3. PriorityQueue<int[]> q = new PriorityQueue;    //定义一个优先队列
    5. static Comparator<int[]> cmp = new Comparator<int[]>() {    //重写比较器自定义排序
    6.     @Override
    7.     public int compare(int[] o1, int[] o2) {
    8.         return o1[0] - o2[0];    //这里表示按优先队列中第一个元素从小到大排序
    9.    }
    10. };
    12. q = new PriorityQueue<>(cmp);    //用重写的比较器初始化优先队列
    14. q.add({...});    //向队尾加入新的元素
    15. q.size();    //返回优先队列的长度
    16. q.peek()[0]    //返回优先队列队头的第一个元素值
    17. q.poll()[0]    //返回优先队列队头的第一个元素值并将队头删除