集合

集合    List Set Map Queue 

List: 有序 重复

Set: 无序 不重复

Map集合：
       以键—值对的形式保存数据
       通过键操作数据
       键不可以重复
      值可以重复
Deque(Queue)集合：
      就是一种双端队列的实现，允许在队列的两端操作元素
     有序的，允许重复的先进先出（FIFO）,不能随机访问队列中的数据 尾部添加头部删除

List

package Content;

import java.util.*;

public class ListDemo {

    public static void main(String[] args) {
        /*List集合: 有序 重复
         *      代表一个元素有序、可重复的集合；
         *       List集合每个元素都有对应的索引
         *       List集合可以双向遍历ListIterator
         *分类：
         * ArrayList:   动态数组  查询快 增删慢
         * LinkedList:  链表列表,既是一个链表，又是一个双端队列 查询慢 增删快
        */
        ArrayList<String> arrayList = new ArrayList<String>();
        
        arrayList.add("Anna");
        arrayList.add("Sam");
        arrayList.add("John");
        arrayList.add("Mike");
        arrayList.add("Peter");
        arrayList.add("Sam");
        
        System.out.println(arrayList);
        //常用方法
        System.out.println(arrayList.size());
        System.out.println(arrayList.contains("John"));
        System.out.println(arrayList.isEmpty());
        
        arrayList.remove("Anna");
        System.out.println(arrayList);
        
        arrayList.add(0, "Jerry");
        System.out.println(arrayList);
        
        arrayList.remove(1);
        System.out.println(arrayList);
        
        System.out.println(arrayList.get(3));
        
        /*遍历:
         *   1、通过迭代器Iterator循环遍历
         *   2、通过foreach循环遍历*/
        
        Iterator<String> iterator = arrayList.iterator();
        while (iterator.hasNext()) {
            System.out.print(iterator.next()+" ");
        }
        
        System.out.println();
        
        for (String string : arrayList) {
            System.out.print(string + " ");
        }
        System.out.println();
        
        //双向遍历迭代器ListIterator
        ListIterator<String> listIterator = arrayList.listIterator();
        //向后遍历
        while (listIterator.hasNext()) {
            System.out.print(listIterator.next() + " ");
        }
        System.out.println();
        //向前遍历
        while (listIterator.hasPrevious()) {
            System.out.print(listIterator.previous() + " ");
        }
        System.out.println();
        
        ListIterator<String> listIterator2 = arrayList.listIterator(arrayList.size());
        while (listIterator.hasPrevious()) {
            System.out.print(listIterator.previous() + " ");
        }
        System.out.println();
        
        arrayList.clear();
        System.out.println(arrayList.isEmpty());
        
        LinkedList<Integer> linkedList = new LinkedList<>();
        linkedList.add(500);
        linkedList.add(200);
        linkedList.add(800);
        linkedList.add(300);
        linkedList.add(200);
        
        System.out.println(linkedList);
        System.out.println(linkedList.size());
        System.out.println(linkedList.isEmpty());
        System.out.println(linkedList.contains(500));
        
        linkedList.add(0, 1000);
        System.out.println(linkedList);
        linkedList.remove(1);
        System.out.println(linkedList);
        linkedList.remove(new Integer(200));
        System.out.println(linkedList);
        
        //LinkedList实现了双端队列的功能
        linkedList.addFirst(800);
        linkedList.addLast(700);
        System.out.println(linkedList.removeFirst());
        System.out.println(linkedList.removeLast());
        
        linkedList.push(10000);
        System.out.println(linkedList.pop());
    }

}

Set

package Content;

import java.util.*;


public class SetDemo {

    public static void main(String[] args) {
        /* HashSet:        无序 不重复
         * LinkedHashSet:  有序(进出顺序) 不重复
         * TreeSet:        排序 不重复
         * */ 
         System.out.println("HashSet集合：无序 不重复");
         HashSet<String> hashSet = new HashSet<>();
         hashSet.add("Tom");
         hashSet.add("Anna");
         hashSet.add("John");
         hashSet.add("MiKe");
         hashSet.add("Prter");
         hashSet.add("Tom");
         System.out.println(hashSet);
         
         
         HashSet<Integer> hashSet11 = new HashSet<>();
         hashSet11.add(1);
         hashSet11.add(9);
         hashSet11.add(8);
         hashSet11.add(7);
         hashSet11.add(3);
         hashSet11.add(2);
         System.out.println(hashSet11);
         
         System.out.println("LinkedHashSet集合：");
         LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();
         linkedHashSet.add("Tom");
         linkedHashSet.add("Anna");
         linkedHashSet.add("John");
         linkedHashSet.add("MiKe");
         linkedHashSet.add("Prter");
         linkedHashSet.add("Tom");
         
         System.out.println(linkedHashSet);
         
         System.out.println("TreeSet集合：");
         TreeSet<String> treeSet = new TreeSet<>();
         treeSet.add("Tom");
         treeSet.add("Anna");
         treeSet.add("John");
         treeSet.add("MiKe");
         treeSet.add("Prter");
         treeSet.add("Tom");
         
         System.out.println(treeSet);
         
         //遍历
        Iterator<String> iterator = hashSet.iterator();
         while (iterator.hasNext()) {
             System.out.print(iterator.next()+" ");
         }
         
         System.out.println();
         
         for (String string : hashSet) {
             System.out.print(string + " ");
         }
         System.out.println();
    }

}

Map

package Content;

import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class MapDemo {
    /*Map集合：
     *      以键—值对的形式保存数据
     *      通过键操作数据
     *      键不可以重复
     *      值可以重复
     * HashMap: 无序
     * LinkedHashMap:
     * TreeMap: 有序
     * */
    public static void main(String[] args) {
        HashMap<String, String> hashMap = new HashMap<>();
        hashMap.put("CN", "China");
        hashMap.put("US","USA");
        hashMap.put("GB","Great Britain");
        hashMap.put("JP", "Japan");
        hashMap.put("XRB", "Japan");
        
        System.out.println(hashMap);
        //使用put()方法来修改Map中已存在的映射
        System.out.println(hashMap.put("CN", "People's Republic of China"));
        System.out.println(hashMap);
        System.out.println(hashMap.get("US"));
        System.out.println(hashMap.size());
        System.out.println(hashMap.isEmpty());
        
        System.out.println(hashMap.remove("JP"));
        
        System.out.println(hashMap.containsKey("US"));
        System.out.println(hashMap.containsValue("Japan"));
        
        //遍历
        
        //通过keySet方法，返回Map中所有“键”的Set集合
        Set<String> set = hashMap.keySet();
        Iterator<String> iterator = set.iterator();
        while(iterator.hasNext()) {
            String key = iterator.next();
            String value = hashMap.get(key);
            System.out.println(key + "——" + value);
        }
        
        System.out.println();
        
        for (String string : hashMap.keySet()) {
            System.out.println(string + "——" +hashMap.get(string));
        }
        
        System.out.println();
        /*
         * entrySet()方法返回映射所包含的映射关系的Set集合（一个关系就是一个键-值对），
         * 把(key-value)作为一个整体一对一对地存放到Set集合当中。
         * 迭代后可以e.getKey()，e.getValue()取key和value。
         */
        Set<Map.Entry<String,String>> entrySet = hashMap.entrySet();
        for(Map.Entry<String,String> entry:entrySet){
            System.out.println(entry.getKey() + "--" + entry.getValue());
        }
        
        HashMap<String, Integer> hashMap1 = new HashMap<String,Integer>();
        hashMap1.put("ABC", 0);
        hashMap1.put("BCD",2);
        System.out.println(hashMap1.get("ABC"));
        hashMap1.put("ABC",hashMap1.get("ABC")+1);
        System.out.println(hashMap1.get("ABC"));
        for(String e:hashMap1.keySet()) {
            if(hashMap1.get(e)==2)
                System.out.println(e);
        }
      
        
        System.out.println("---------------------HashMap-----------------------");
        HashMap<String, String> hashMap111 = new HashMap<>();
        hashMap111.put("CN", "China");
        hashMap111.put("US","USA");
        hashMap111.put("GB","Great Britain");
        hashMap111.put("JP", "Japan");
        hashMap111.put("XRB", "Japan");
        
        System.out.println(hashMap111);
        
        System.out.println("---------------------LinkedHashMap-----------------------");
        LinkedHashMap<String, String> LinkedHashMap111 = new LinkedHashMap<>();
        LinkedHashMap111.put("CN", "China");
        LinkedHashMap111.put("US","USA");
        LinkedHashMap111.put("GB","Great Britain");
        LinkedHashMap111.put("JP", "Japan");
        LinkedHashMap111.put("XRB", "Japan");
        
        System.out.println(LinkedHashMap111);
        
        /* HashMap:         无序
         * LinkedHashMap:   有序
         * TreeMap:         排序
         *  */
        System.out.println("---------------------TreeMap-----------------------");
        TreeMap<String, String> TreeMap111 = new TreeMap<>();
        TreeMap111.put("CN", "China");
        TreeMap111.put("US","USA");
        TreeMap111.put("GB","Great Britain");
        TreeMap111.put("JP", "Japan");
        TreeMap111.put("XRB", "Japan");
        
        System.out.println(TreeMap111);
    }
}

Queue

package Content;

import java.util.Comparator;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;

public class QueueDemo {
    /* Deque(Queue)集合：
     *         就是一种双端队列的实现，允许在队列的两端操作元素
     *           有序的，允许重复的先进先出（FIFO）,不能随机访问队列中的数据  尾部添加头部删除
     * 
　　 * PriorityQueue。
          每次从队列中取出的是具有最高优先权的元素。
　　　　   如果想实现按照自己的意愿进行优先级排列的队列的话，需要实现Comparator接口。
            优先队列中元素默认按自然顺序排列，也就是数字默认是小的在队列头，字符串则按字典序排列。
     */
    
    /*Queue队列:
     *      就是一种双端队列的实现，允许在队列的两端操作元素
     *       有序的，允许重复的
     *    
     *添加：
     *  add        增加一个元索                     如果队列已满，则抛出一个IIIegaISlabEepeplian异常
     *  offer       添加一个元素并返回true       如果队列已满，则返回false
     *  put         添加一个元素                      如果队列满，则阻塞
     *刪除： 
   *  remove   移除并返回队列头部的元素    如果队列为空，则抛出一个NoSuchElementException异常
   *  poll         移除并返问队列头部的元素    如果队列为空，则返回null
     *  take        移除并返回队列头部的元素     如果队列为空，则阻塞
     *查找：
   *  peek       返回队列头部的元素             如果队列为空，则返回null
   *  element  返回队列头部的元素             如果队列为空，则抛出一个NoSuchElementException异常
   *  
     * */
    static class node{
        int num1;
        int num2;
        String string;
        public node(int num1,int num2,String string) {
            this.num1 = num1;
            this.num2 = num2;
            this.string = string;
        }
    }
    public static void main(String[] args) {
        
        //LinkedList实现了Deque接 口
        Queue<Integer> queue1 = new LinkedList<Integer>();
        queue1.offer(1);
        queue1.offer(3);
        queue1.offer(2);
        queue1.offer(5);
        System.out.println(queue1);
        
        System.out.println(queue1.size());
        
        System.out.println(queue1.peek());
        System.out.println(queue1);
        
        System.out.println(queue1.poll());
        System.out.println(queue1);
        
        Queue<node> queue = new LinkedList<node>();
        queue.add(new node(33, 55, "Amy"));
        queue.add(new node(44, 55, "Bob"));
        queue.add(new node(44, 66, "Cindy"));
        queue.add(new node(44, 66, "Dam"));
        
        System.out.println(queue);
        
        //默认由小到大
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<Integer>(); 
        priorityQueue.add(4);
        priorityQueue.add(1);
        priorityQueue.add(3);
        priorityQueue.add(5);
        priorityQueue.add(2);
        System.out.println(priorityQueue);
    
        //由大到小
        PriorityQueue<Integer> priorityQueue1 = new PriorityQueue<Integer>(11,new Comparator<Integer>(){
            public int compare(Integer i1,Integer i2){
                return i2-i1;
            }
        });
        priorityQueue1.add(4);
        priorityQueue1.add(1);
        priorityQueue1.add(3);
        priorityQueue1.add(2);
        System.out.println(priorityQueue1);
        
    }

}