Java小农养成记第十四天

Map 是一种键-值对（key-value）集合，Map 集合中的每一个元素都包含一个键对象和一个值对象。其中，键对象不允许重复，而值对象可以重复，并且值对象还可以是 Map 类型的，就像数组中的元素还可以是数组一样。
Map 接口主要有两个实现类：HashMap 类和 TreeMap 类。其中，HashMap 类按哈希算法来存取键对象，而 TreeMap 类可以对键对象进行排序。
java.util. Map集合
Map集合的特点:

Map集合是一个双列集合,一个元素包含两个值(一个key,一个value)Map集合中的元素,key和value的数据类型可以相同,也可以不同Map集合中的元索,key是不允许重复的,value是可以重复的Map集合中的元素,key和vaLue是一一对应

public class Demo01Map {
}

Map接口中定义了很多方法，常用的如下:

public v put(K key，v value):把指定的键与指定的值添加到Map集合中。public v remove(Object key):把指定的键所对应的键值对元素在Map集合中删除，返回被删除元素的值。public v get(0bject key):根据指定的键，在Map集合中获取对应的值。boolean containsKey(Object key):判断集合中是否包含指定的键。public Set keySet():获取Map集合中所有的键，存储到Set集合中。public Set> entrySet():获取到Map集合中所有的键值对对象的集合(Set集合)。

public class Demo01Map {
    public static void main(String[] args) {
        show01();
        show02();
        show03();
        show04();
    }

    
    private static void show01() {
        //创建Map集合对象，多态
        Map map = new HashMap<>();

        String v1 = map.put("李晨", "范冰冰1");
        System.out.println("v1:" + v1);//v1:null

        String v2 = map.put("李晨","范冰冰2");//v2:范冰冰1
        System.out.println("v2:" + v2);

        System.out.println(map);//{李晨=范冰冰2}

        map.put("冷锋", "龙小云");
        map.put("杨过", "小龙女");
        map.put("尹志平", "小龙女");
        System.out.println(map);//{杨过=小龙女, 尹志平=小龙女, 李晨=范冰冰2, 冷锋=龙小云}
    }
    
    private static void show02() {
        Map map = new HashMap<>();
        map.put("赵丽颖" ,168);
        map.put("杨幂" ,169);
        map.put("迪丽热巴" ,165);
        System.out.println(map);//{赵丽颖=168, 迪丽热巴=165, 杨幂=169},无序的

        Integer v1 = map.remove("迪丽热巴");
        System.out.println("v1:" + v1);//v1:165

        //int v2 = map.remove("迪丽热巴");//自动拆箱，NullPointerException(空指针异常)
        Integer v2 = map.remove("迪丽热巴");
        System.out.println("v2:" + v2);//v2:null
    }
    
    private static void show03() {
        Map map = new HashMap<>();
        map.put("赵丽颖" ,168);
        map.put("杨幂" ,169);
        map.put("迪丽热巴" ,165);

        Integer v1 = map.get("杨幂");
        System.out.println("v1:" + v1);//v1:169

        Integer v2 = map.get("郭德纲");
        System.out.println("v2:" + v2);//v2:null
    }
    
    private static void show04() {
        Map map = new HashMap<>();
        map.put("赵丽颖" ,168);
        map.put("杨幂" ,169);
        map.put("迪丽热巴" ,165);
        boolean b1 = map.containsKey("赵丽颖");
        System.out.println("b1:" + b1);//b1:true

        boolean b2 = map.containsKey("郭德纲");
        System.out.println("b2:" + b2);//b2:false
    }
}

键找值方式:即通过元素中的键，获取键所对应的值
分析步骤∶

获取Map中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键。方法提示: keyset()遍历键的Set集合，得到每一个键。根据键，获取键所对应的值。方法提示: get(K key)

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


public class Demo02KeySet {
    public static void main(String[] args) {
        Map map = new HashMap<>();
        map.put("赵丽颖" ,168);
        map.put("杨幂" ,169);
        map.put("迪丽热巴" ,165);

        //1.使用Map集合中的方法keySet(),把Map集合所有的key取出来,存储到一个Set集合中
        Set set = map.keySet();

        //2.遍历set集合,获取Map集合中的每一个key
        //使用迭代器遍历Set集合
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            String key = iterator.next();
            //3.通过Map集含中的方法get(key),通过key找到value
            Integer value = map.get(key);
            System.out.println(key + " = " + value);
        }
        System.out.println("======================");
        for (String key : set){
            Integer value = map.get(key);
            System.out.println(key + " = " + value);
        }
    }
}

我们已经知道，Map中存放的是两种对象，一种称为key(键)，一种称为value(值)，它们在Map中是一一对应关系，这一对对象又称做Map中的一个Entry(项)。Entry将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历Map集合时，就可以从每一个键值对(Entry )对象中获取对应的键与对应的值。
既然Entry表示了一对键和值，那么也同样提供了获取对应键和对应值得方法︰

public K getKey():获取Entry对象中的键。public v getValue():获取Entry对象中的值。在Map集合中也提供了获取所有Entry对象的方法∶public Set> entrySet():获取到Map集合中所有的键值对对象的集合(Set集合)。

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


public class Demo03EntrySet {
    public static void main(String[] args) {
        Map map = new HashMap<>();
        map.put("赵丽颖" ,168);
        map.put("杨幂" ,169);
        map.put("迪丽热巴" ,165);

        //1.使用Map集合中的方法entrySet(),把Map集合中多个Entry对象取出来,存储到一个Set集合中
        Set> set = map.entrySet();

        //2.遍历set集合,获取每一个Entry对象
        //使用迭代器遍历Set集合
        Iterator> it = set.iterator();
        while(it.hasNext()){
            Map.Entry entry = it.next();
            //3.使用Entry对象中的方法getKey( )和getValue()获取键与值
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key + " = " + value);
        }
        System.out.println("====================");
        for (Map.Entry entry : set){
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key + " = " + value);
        }

    }
}

import java.util.Objects;

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(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 String toString() {
        return "Person{" +
                "name='" + name + ''' +
                ", 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);
    }
}

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;


public class Demo01HashMapSavePerson {
    public static void main(String[] args) {
        show01();
        show02();
    }
    
    private static void show01() {

        HashMap map = new HashMap<>();

        map.put("北京", new Person("张三", 18));
        map.put("上海", new Person("李四", 19));
        map.put("广州", new Person("王五", 20));
        map.put("北京", new Person("赵六", 18));

        Set set = map.keySet();
        for (String key : set){
            Person value = map.get(key);
            System.out.println(value);
        }
    }
    
    private static void show02() {
        HashMap map = new HashMap<>();
        map.put(new Person("女王", 18), "英国");
        map.put(new Person("秦始皇", 18), "秦国");
        map.put(new Person("普京", 18), "俄罗斯");
        map.put(new Person("女王", 18), "毛里求斯");

        Set> set = map.entrySet();
        for(Map.Entry entry : set){
            Person key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "--->" + value);
        }
    }

}

我们知道HashMap保证成对元素唯一，并且查询速度很快，可是成对元素存放进去是没有顺序的，那么我们要保证有序，还要速度快怎么办呢?
在HashMap下面有一个子类linkedHashMap，它是链表和哈希表组合的一个数据存储结构。

import java.util.HashMap;
import java.util.linkedHashMap;


public class Demo01linkedHashMap {
    public static void main(String[] args) {
        HashMap map = new HashMap<>();
        map.put("a", "a");
        map.put("c", "c");
        map.put("b", "b");
        map.put("a", "d");
        System.out.println(map);//key不允许重复，无序 {a=d, b=b, c=c}

        linkedHashMap linked = new linkedHashMap<>();
        linked.put("a", "a");
        linked.put("c", "c");
        linked.put("b", "b");
        linked.put("a", "d");
        System.out.println(linked);//key不允许重复，有序 {a=d, c=c, b=b}
    }
}

import java.util.HashMap;
import java.util.Hashtable;


public class Demo02Hashtable {
    public static void main(String[] args) {
        HashMap map = new HashMap<>();
        map.put(null, "a");
        map.put("b", null);
        map.put(null, null);
        System.out.println(map);//{null=null, b=null}

        Hashtable table = new Hashtable<>();
        //table.put(null, "b");//NullPointerException
        //table.put("b", null);//NullPointerException
        //table.put(null, null);//NullPointerException
    }
}

问题：
计算一个字符串中每个字符出现次数。
分析：

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;


public class Demo03Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：" );
        String str = sc.next();

        Map map = new HashMap<>();

        char[] ch = str.toCharArray();
        for (int i = 0; i < ch.length; i++) {
            if(map.containsKey(ch[i])){
                map.put(ch[i], map.get(ch[i]) + 1);
            }else{
                map.put(ch[i], 1);
            }
        }

        Set> set = map.entrySet();
        for (Map.Entry entry : set){
            Character c = entry.getKey();
            Integer i = entry.getValue();
            System.out.println(c + "出现" + i + "次");
        }
    }
}

import java.util.List;
import java.util.Map;
import java.util.Set;

public class Dmeo01JDK9 {
    public static void main(String[] args){
        List list = List.of("a", "b", "c", "d");
        System.out.println(list);//[a, b, c, d]
        //list.add("w");//UnsupportedOperationException不支持操作异常

        //Set set = Set.of("a", "b", "c", "d", "a");//IllegalArgumentException非法参数异常
        Set set = Set.of("a", "b", "c", "d");
        System.out.println(set);//[a, b, c, d]
        //set.add("f");//UnsupportedOperationException不支持操作异常

        //Map map = Map.of("张三", 18, "李四", 19, "王五", 20,"张三", 20);//IllegalArgumentException非法参数异常
        Map map = Map.of("张三", 18, "李四", 19, "王五", 20);
        System.out.println(map);//{张三=18, 王五=20, 李四=19}
        //map.add("张三", 18);//UnsupportedOperationException不支持操作异常
    }
}

public class Demo01Debug {
    public static void main(String[] args){
//        int a = 10;
//        int b = 20;
//        int sum = a + b;
//        System.out.println(sum);
        for (int i = 0; i < 3; i++){
            System.out.println(i);
        }
    }
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;

public class DouDiZhu {
    public static void main(String[] args) {
        HashMap poker = new HashMap<>();
        List list = new ArrayList<>();

        String[] color = {"♠", "♥", "♣", "♦"};
        String[] number = {"2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3"};

        int index = 0;
        list.add(index);
        poker.put(index++, "大王");
        list.add(index);
        poker.put(index++, "小王");

        for (int i = 0; i < color.length; i++) {
            for (int j = 0; j < number.length; j++) {
                list.add(index);
                poker.put(index++, color[i] + number[j]);
            }
        }

        //System.out.println(poker);
        Collections.shuffle(list);
        //System.out.println(list);

        ArrayList player01 = new ArrayList<>();
        ArrayList player02 = new ArrayList<>();
        ArrayList player03 = new ArrayList<>();
        ArrayList dipai = new ArrayList<>();
        for (int i = 0; i < list.size(); i++){
            Integer in = list.get(i);
            if (i >= 51){
                dipai.add(in);
            }else if (i % 3 == 0){
                player01.add(in);
            }else if (i % 3 == 1){
                player02.add(in);
            }else if (i % 3 == 2){
                player03.add(in);
            }
        }

        Collections.sort(player01);
        Collections.sort(player02);
        Collections.sort(player03);
        Collections.sort(dipai);

        lookPoker("刘德华",poker,player01);
        lookPoker("周润发",poker,player02);
        lookPoker("周星驰",poker,player03);
        lookPoker("底牌",poker,dipai);
    }
    
    public static void lookPoker(String name, HashMap poker, ArrayList list){
        System.out.println(name + ": ");

        for (Integer key : list){
            String value = poker.get(key);
            System.out.print(value + " ");
        }
        System.out.println();
    }
}