Map

目录：
Map集合
HashMap和Hashtable的区别
Collections(集合工具类)
集合练习
模拟斗地主(洗牌,发牌,看牌)
Map接口和Collection接口的不同
Map是双列的,Collection是单列的
Map的键唯一,Collection的子体系Set是唯一的
Map集合的数据结构针对键有效，跟值无关;Collection集合的数据结构是针对元素有效
1、map
Map集合的功能概述：
a:添加功能
V put(K key,V value):添加元素。这个其实还有另一个功能?替换
如果键是第一次存储，就直接存储元素，返回null
如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值
b:删除功能
void clear():移除所有的键值对元素
V remove(Object key)：根据键删除键值对元素，并把值返回
c:判断功能
boolean containsKey(Object key)：判断集合是否包含指定的键
boolean containsValue(Object value):判断集合是否包含指定的值
boolean isEmpty()：判断集合是否为空
d:获取功能
Set<Map.Entry<K,V>> entrySet(): 返回一个键值对的Set集合
V get(Object key):根据键获取值
Set keySet():获取集合中所有键的集合
Collection values():获取集合中所有值的集合
e:长度功能
int size()：返回集合中的键值对的对数
2、HashMap和Hashtable的区别
// HashMap 基于哈希表的 Map接口的实现。这种实现提供了所有可选的Map操作，并允许 null值和 null关键。 线程不安全效率高
// Hashtable 不允许存 null 键和null值 线程安全 效率低
3、 Collections(集合工具类)
Collections：集合工具类 包含对集合排序 二分查找 打乱集合元素顺序 获取最大值等功能

		public static <T> void sort(List<T> list) :将指定的集合进行排序 
		public static <T> int binarySearch(List<?> list,T key)：在指定的集合中，进行指定元素的二分查找
		public static <T> T max(Collection<?> coll) 获取结合中最大的元素
		public static void reverse(List<?> list) 将集合中的元素反转
		public static void shuffle(List<?> list) 将集合中的元素随机置换
		public static <T> void sort(List<T> list) : 将指定集合的元素进行排序
		public static <T> void sort(List<T> list, Comparator<T> c)根据指定比较器产生的顺序对指定列表进行排序

4、集合练习
集合练习
1、请编写程序，统计一个字符串中每个字符出现的次数
思路：1.遍历字符串，截取每一个字符
2.判断字符是不是第一次出现 map.get(ch)==null的话就是第一次出现
3.如果不是第一次出现就获取它的值，加1在进行保存

		import java.util.Scanner;
		import java.util.Set;
		import java.util.TreeMap;
		
public class MapDemo {
    public static void main(String[] args) {
        TreeMap<Character, Integer> map = new TreeMap<>();
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入一段字符串");
        String str=scanner.next();
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if (map.get(c)==null){
                map.put(c,1);
            }else if (map.get(c)!=null){
                Integer value = map.get(c);
                value++;
                map.put(c,value);
            }
        }
        StringBuffer sb = new StringBuffer();
        Set<Character> keySet = map.keySet();
        for (Character cha:keySet){
            sb.append(cha).append("(").append(map.get(cha)).append(")");
        }
        System.out.println(sb);
    }
}

2、请编写程序，存储自定义对象到HashMap集合中，并采用两种方式遍历

	public class Person {
	    private String name;
	    private int age;
	
	    public Person() {
	    }
	
	    public Person(String name, int age) {
	        this.name = name;
	        this.age = age;
	    }
	
	    @Override
	    public boolean equals(Object o) {
	        if (this == o) return true;
	        if (o == null || getClass() != o.getClass()) return false;
	        Person person = (Person) o;
	        return age == person.age &&
	                Objects.equals(name, person.name);
	    }
	
	    @Override
	    public int hashCode() {
	        return Objects.hash(name, age);
	    }
	
	    @Override
	    public String toString() {
	        return "Person{" +
	                "name='" + name + '\'' +
	                ", age=" + age +
	                '}';
	    }
	}
	public class HashMapDemo {
	    public static void main(String[] args) {
	        HashMap<String, Person> hashMap = new HashMap<>();
	        hashMap.put("s001",new Person("张三",23));
	        hashMap.put("s002",new Person("张三",23));
	        hashMap.put("s003",new Person("李四",25));
	        hashMap.put("s004",new Person("李四",23));
	        hashMap.put("s005",new Person("赵六",26));
	        hashMap.put("s006",new Person("王八",28));
	        Person put = hashMap.put("s001", new Person("张三", 27));
	        System.out.println(put);//返回的是被替换掉的键
	        // System.out.println(hashMap);跟值无关，键一样值就会覆盖
	        //方式1 先获取键的集合
	        Set<String> keySet = hashMap.keySet();
	        for (String s : keySet) {
	            Person value = hashMap.get(s);
	            System.out.println(s+"=="+value);
	        }
	        System.out.println("-----------------");
	        //方式2获取键值对集
	        Set<Map.Entry<String, Person>> entries = hashMap.entrySet();
	        for (Map.Entry<String, Person> entry : entries) {
	            String key = entry.getKey();
	            Person value = entry.getValue();
	            System.out.println(key+"=="+value);
	        }
	    }
	}

3、请编写程序，存储自定义对象到TreeMap集合中，并采用两种方式遍历

		public class Student implements Comparable<Student>{
		    private String name;
		    private int age;
		
	    public Student() {
	    }
	
	    public Student(String name, int age) {
	        this.name = name;
	        this.age = age;
	    }
	
	    public String getName() {
	        return name;
	    }
	
	    public void setName(String name) {
	        this.name = name;
	    }
	
	    public int getAge() {
	        return age;
	    }
	
	    public void setAge(int age) {
	        this.age = age;
	    }
	
	    @Override
	    public int compareTo(Student o) {
	        int i = this.name.compareTo(o.name);
	        int num=i==0?this.age-o.age:i;
	        return num;
	    }
	
	    @Override
	    public String toString() {
	        return "Student{" +
	                "name='" + name + '\'' +
	                ", age=" + age +
	                '}';
	
	    }
	}
	import java.util.Comparator;
	import java.util.Map;
	import java.util.Set;
	import java.util.TreeMap;
	
	public class TreemapDemo {
	    public static void main(String[] args) {
	        TreeMap<Student, Integer> treeMap = new TreeMap<Student, Integer>(new Comparator<Student>() {
	            @Override
	            public int compare(Student o1, Student o2) {
	                int i = o1.getAge() - o2.getAge();
	                int num=i==0?o1.getName().compareTo(o2.getName()):i;
	                return num;
	            }
	        });
	        treeMap.put(new Student("王五",18),23);
	        treeMap.put(new Student("王五",18),23);
	        treeMap.put(new Student("王五",19),24);
	        treeMap.put(new Student("赵六",18),25);
	        treeMap.put(new Student("钱期",20),26);
	        treeMap.put(new Student("王八",23),27);
	        treeMap.put(new Student("周九",22),23);
	        Set<Student> keySet = treeMap.keySet();
	        for (Student stu : keySet) {
	            Integer value = treeMap.get(stu);
	            System.out.println(stu+"=="+value);
	        }
	        System.out.println("-------------------------------------");
	        TreeMap<Student, Integer> map = new TreeMap<>();
	        map.put(new Student("王五",18),23);
	        map.put(new Student("王五",18),23);
	        map.put(new Student("王五",19),24);
	        map.put(new Student("赵六",18),25);
	        map.put(new Student("钱期",20),26);
	        map.put(new Student("王八",23),27);
	        map.put(new Student("周九",22),23);
	        Set<Map.Entry<Student, Integer>> entries = map.entrySet();
	        for (Map.Entry<Student, Integer> entry : entries) {
	            Student key = entry.getKey();
	           Integer value = entry.getValue();
	            System.out.println(key+"=="+value);
	        }
	    }
	}

3、请编写程序，完成集合嵌套,并遍历
传智播客
jc 基础班
张三 20
李四 22
jy 就业班
王五 21
赵六 23
HashMap嵌套HashMap
package QtDemo;

import java.util.HashMap;
import java.util.Set;

public class demo {
    public static void main(String[] args) {
//        传智播客
//          jc 基础班
            //        张三      20
            //        李四      22
    //        jy   就业班
            //        王五      21
            //        赵六      23
        HashMap<String, Integer> jc = new HashMap<>();
        jc.put("张三",20);
        jc.put("李四",22);
        HashMap<String, Integer> jy = new HashMap<>();
        jy.put("王五",21);
        jy.put("赵六",23);
        HashMap<String, HashMap<String, Integer>> map = new HashMap<>();
        map.put("基础班",jc);
        map.put("就业班",jy);
        HashMap<String, HashMap<String, HashMap<String, Integer>>> cz = new HashMap<>();
        cz.put("传智播客",map);
        Set<String> keySet = cz.keySet();
        for (String s : keySet) {
            System.out.println(s);
            HashMap<String, HashMap<String, Integer>> map1 = cz.get(s);
            Set<String> keySet1 = map1.keySet();
        
        for (String s1 : keySet1) {
            System.out.println("    "+s1);
            HashMap<String, Integer> map2 = map1.get(s1);
            Set<String> keySet2 = map2.keySet();
            
            for (String s2 : keySet2) {
                Integer value = map2.get(s2);
                System.out.println("          "+s2+"   " +value);

            }
            System.out.println();
        }
    }
}

}
运行结果：
传智播客
就业班
王五 21
赵六 23
基础班
李四 22
张三 20

HashMap嵌套ArrayList
public class MapDemo2 {
public static void main(String[] args) {
//基础班
// 张三 20
// 李四 22

    //就业班
    //    王五    21
    //    赵六    23
    //上面这组数据我想存起来
    //HashMap  嵌套HashMap
    HashMap<String, Integer> jc = new HashMap<>();
    jc.put("张三", 20);
    jc.put("李四", 22);
    HashMap<String, Integer> jy = new HashMap<>();
    jy.put("王五", 21);
    jy.put("赵六", 23);
    //再创建一个map集合
    HashMap<String, HashMap<String, Integer>> bigMap = new HashMap<>();
    bigMap.put("基础班", jc);
    bigMap.put("就业班", jy);
    //遍历 键找值
    Set<String> keys = bigMap.keySet();
    for (String k : keys) {
        System.out.println(k);
        HashMap<String, Integer> value = bigMap.get(k);
        Set<String> strings = value.keySet();
        for (String s : strings) {
            System.out.println("\t" + s + "==" + value.get(s));
        }
        System.out.println();
    }

}
}
**5、斗地主**
    //实现斗地主的发牌，洗牌，看牌，
    //思路：1.生成一副牌，放在集合（牌盒）
    //2.洗牌
    //3.三个人斗地主，留三张底牌 发牌
    //4.看牌 ，看谁拿了一副好牌
    //排序版：创建索引结合，在创建一个map集合，map集合中存贮的是索引和牌盒子；发的是索引，根据索引在map中找相对应的值；
    import java.util.*;

public class 斗地主排序版 {
    public static void main(String[] args) {
    //创建牌盒子
        HashMap<Integer, String> map = new HashMap<>();
        //创建索引集合
        ArrayList<Integer> list = new ArrayList<>();
        int index=0;
        String[] colors = {"♥", "♠", "♣", "♦"};
        String[] nums = {"A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"};
        for (String num : nums) {
            for (String color : colors) {
                map.put(index,color.concat(num));
                list.add(index);
                index++;
            }
        }
        //手动添加大小王
        map.put(index, "");
        list.add(index);
        index++;
        map.put(index, "☀");
        list.add(index);
        //洗牌，洗的是索引
        Collections.shuffle(list);
        Collections.shuffle(list);
        Collections.shuffle(list);
        //创建人物集合，因为要排序所以用的是treeset集合
        TreeSet<Integer> 周星驰 = new TreeSet<>();
        TreeSet<Integer> 刘德华 = new TreeSet<Integer>();
        TreeSet<Integer> 周润发 = new TreeSet<Integer>();
        TreeSet<Integer> 底牌 = new TreeSet<Integer>();
	//发牌
    for (int i = 0; i < list.size(); i++) {
        if (i >= list.size() - 3) {
            底牌.add(list.get(i));
        } else if (i % 3 == 0) {
            周星驰.add(list.get(i));

        } else if (i % 3 == 1) {
            刘德华.add(list.get(i));

        } else if (i % 3 == 2) {
            周润发.add(list.get(i));

        }
    }
	//看牌
    lookPoker("周星驰", 周星驰, map);
    lookPoker("刘德华", 刘德华, map);
    lookPoker("周润发", 周润发, map);
    lookPoker("底牌", 底牌, map);
}

private static void lookPoker(String name, TreeSet<Integer> treeSet, HashMap<Integer, String> map) {
    System.out.println(name);
    for (Integer integer : treeSet) {
        System.out.print(map.get(integer)+" ");
        //根据发到的索引， 也就是map集合中键在map集合中找每个人相对应的值
    }
    System.out.println();
}
}