Java 栈、队列、映射、集合

本篇文章只是本人为方便查找相关方法而记录，下面具体代码并没有真正运行。

		***(一) 栈： 先进后出数据结构，只能在一端进行插入与删除***
        //   继承自Vector，底层通过数组实现, List接口有的方法都有，即许多方法与前面ArrayList相同，这里不再列出
        // (1) 创建栈  只有一个无参构造方法
        Stack<String> st=new Stack<String>();
        Stack<String> st2=new Stack<String>();
        st.push("1");             		// 栈尾添加
        st.push("2");
        st.pop();                       // 返回并删除栈顶元素
        st.peek();                      //  取栈顶元素
        st.size();                      //  元素个数
        st.empty();                     //  是否为空
        st.search("2");              	//  栈顶到该元素首次出现的位置
 
 		***(二) 队列：普通队列，双端队列，优先队列***
   		// (A) 普通队列  Queue 实现类 LinkedList
        // 先进先出数据结构，只能在一端进行操作，使用LinkedList(双向链表)实现
        Queue<String> que=new LinkedList<>();   // 创建队列 后面实现类是LinkedList
        //  错误抛出异常
        que.add("1");                           // 增加元素，错误抛出异常
        que.element();                          // 取队首元素，错误抛出异常
        que.remove();                           // 取并移除队首元素，错误抛出异常
        //  错误返回特殊值
        que.offer("2");                     	// 增加元素，错误返回特殊值
        que.peek();                             // 取队首元素，错误返回特殊值
        que.poll();                             // 取并移除队首元素，错误返回特殊值

        que.size();                             // 队列大小
        que.isEmpty();                          // 是否为空
        que.contains("1");                      // 是否包含指定元素

        // (B) 双端队列 Dequeue  实现类 LinkedList
        // 队列两端既能入队，又能出队，不过需要保持先进先出。 如果限制双端队列只能从一端入队和出队 则即为栈。
        Deque<String> deque=new LinkedList<>(); // 新建双端队列，实现类为LinkedList
        // 错误时抛出异常
        deque.add("2");               	 		// 增加
        deque.addFirst("1");
        deque.addLast("3");
        deque.element();                  		// 获取
        deque.getFirst();
        deque.getLast();
        deque.remove();                			// 获取并删除
        deque.removeFirst();
        deque.removeLast();
        //  错误时返回特殊值
        deque.offer("2");                		// 增加
        deque.offerFirst("1");
        deque.offerLast("3");
        deque.peek();                  			// 获取
        deque.peekFirst();
        deque.peekLast();
        deque.poll();                			// 获取并删除
        deque.pollFirst();
        deque.pollLast();

        deque.push("123");
        deque.pop();
        for (String s : deque)       			// 增强for循环遍历
            System.out.printf("  " + s);
        deque.toArray();            			// 可以转换为数组

        // (C) 优先队列 PriorityQueue  最小堆/最大堆  实现类即为PriorityQueue
        // 可用于String及Integer,Long等包装类，也可用于自定义数据类型(需要编写Comparator比较器)
        Comparator<ListNode> cmp=new Comparator<ListNode>() {
            @Override
            public int compare(ListNode o1, ListNode o2) {
                return o1.val-o2.val;  			// 升序
                // return o2.val-o1.val;  		// 降序
            }
        };
        PriorityQueue<ListNode> pq=new PriorityQueue<ListNode>(cmp); // 可自定义比较规则
        pq.offer(new ListNode(3));       		// 添加元素
        pq.offer(new ListNode(2));
        pq.offer(new ListNode(1));
        pq.peek();                          	// 返回首元素
        pq.poll();                          	// 返回并移除首元素
        pq.size();                          	// 大小
        pq.isEmpty();                       	// 是否为空

		***(三) 映射：键值对***
   		// HashMap  key-value键值散列映射  数组+链表/红黑树实现
        HashMap<Integer,String> hm=new HashMap<Integer, String>(),hm2;  //  创建
        hm.put(1,"one");        				// 增加键值对
        hm.put(2,"three");
        hm.put(2,"two");        				// 保持最新的value
        hm.containsKey(1);      				// 是否存在特定key
        hm.get(1);              				// 获得某特定key对应的value值
        hm.remove(1);      						// 删除指定key-value对
        hm.isEmpty();           				// 是否为空
        hm.size();              				// 大小
        hm2= (HashMap<Integer, String>) hm.clone(); // 克隆
        hm.clear();             				// 清空
        for (Integer integer : hm.keySet())     // 遍历key集合
            System.out.println("integer = " + integer);
        for (String value : hm.values())        // 遍历value集合
            System.out.println("value = " + value);
        for (Map.Entry<Integer, String> x : hm.entrySet())  // 遍历键值对
            System.out.println("Key = " + x.getKey()+"  Value = " + x.getValue());

		***(四) 集合：唯一***
      	// HashSet 内部用了HashMap
        // (1) 创建： 默认空集合/使用已有集合创建
        HashSet<String> hs=new HashSet<>();
        HashSet<String> hs1=new HashSet<>(hs);
        hs.add("123");          				// 添加  唯一元素
        hs.contains("123");     				// 是否包含
        hs.remove("123");    					// 移除指定元素
        hs.clear();             				// 元素清空
        hs.size();              				// 大小
        hs.isEmpty();           				// 是否为空
        for (String h : hs) {   				// 迭代
            System.out.println("h = " + h);
        }
//String5 String4 String3 String2 String1       HashSet元素乱序
//String1 String5 String3 String4 String2       LinkedHashSet保证元素添加顺序
//String1 String2 String3 String4 String5       TreeSet元素按自然顺序排序