15-HashMap遍历及案例2

map的遍历

通过获取所有键进行遍历

package com.company.day15;

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

public class Test {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("name", "小鲁班");
        map.put("skill1", "无敌沙嘴炮");
        map.put("skill2", "全图导弹");
        map.put("grade", "12");
        map.put("speed", "450");
        System.out.println(map);
        Set<String> keySet = map.keySet();
        for (String key :keySet){
            String value = map.get(key);
            System.out.println(key + "===="+ value);
        }
    }
}

键值对方式去遍历

package com.company.day15;

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

public class Test1 {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("name", "小鲁班");
        map.put("skill1", "无敌沙嘴炮");
        map.put("skill2", "全图导弹");
        map.put("grade", "12");
        map.put("speed", "450");
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> entry :entries) {
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println("key = " + key + "   value = " + value);

        }
    }
}

HashMap存储自定义类型

package com.company.day15;

import java.util.Objects;

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}
package com.company.day15;

import java.util.HashMap;

public class Test2 {
    public static void main(String[] args) {
        HashMap<Student, String> map = new HashMap<>();
        Student stu1 = new Student("张三", 18);
        Student stu2 = new Student("李思", 18);
        Student stu3 = new Student("王五", 18);
        Student stu4 = new Student("赵六", 18);
        map.put(stu1, "北京");
        map.put(stu2, "上海");
        map.put(stu3, "广州");
        map.put(stu4, "深圳");
        System.out.println(map);
        System.out.println(map.size());
    }
}

• 当给HashMap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须复写对象的hashCode和equals方法(如果忘记)。
• 如果要保证map中存放的key和取出的顺序一致，可以使用java.util.LinkedHashMap集合来存放

hashmap的修改

public class Test0 {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("name", "小鲁班");
        map.put("skill1", "无敌沙嘴炮");
        map.put("skill2", "全图导弹");
        map.put("grade", "12");
        map.put("speed", "450");
        System.out.println(map);
        // 修改
        map.put("grade", "15");
        System.out.println(map);

    }
}

词频统计案例

package com.company.day15;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Test3 {
    // 统计单词出现的频率
    public static void main(String[] args) throws FileNotFoundException {
        HashMap<String, Integer> map = new HashMap<>();
//        File file = new File("/Users/ericli/IdeaProjects/houjiheng/song.txt");
        File file = new File("./song.txt");
        BufferedReader bra = new BufferedReader(new FileReader(file));
        Scanner scanner = new Scanner(bra);
        while (scanner.hasNextLine()){
            String line = scanner.nextLine();
            String[] words = line.split(" ");
            for(String word: words){
                System.out.println(word);
                if (map.containsKey(word))
                    map.put(word, map.get(word) +1);
                else
                    map.put(word, 1);
            }
        }
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println("单词: " +  key + "  出现次数: " + value) ;
        }

    }
}

• LinkedHashMap
  我们知道HashMap保证成对元素唯一，并且查询速度很快，可是成对元素存放进去是没有顺序的，那么我们要保证有序，还要速度快怎么办呢？
• 通过链表结构可以保证元素的存取顺序一致；
• 通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

import java.util.LinkedHashMap;

public class Test4 {
    public static void main(String[] args) {
        LinkedHashMap<Integer, String> map = new LinkedHashMap<>();
        map.put(300, "深圳");
        map.put(100, "北京");
        map.put(200, "广州");
        map.put(500, "上海");
        map.put(400, "武汉");
        map.put(400, "深圳");
        System.out.println(map);
    }
}

• TreeMap集合
  TreeMap集合和Map相比没有特有的功能，底层的数据结构是红黑树；可以对元素的**键进行排序，排序方式有两种:自然排序和比较器排序；到时使用的是哪种排序，取决于我们在创建对象的时候所使用的构造方法

public TreeMap()									使用自然排序
public TreeMap(Comparator<? super K> comparator) 	   通过比较器指定规则排序

package com.company.day15;

import java.util.Comparator;
import java.util.TreeMap;

public class Test5 {
    public static void main(String[] args) {
        /// 按照键的默认规则排序: ---->升序
        //  创建TreeMap集合,限制键的类型为Integer,值的类型为String
        TreeMap<Integer, String> map = new TreeMap<>();
        map.put(300, "深圳");
        map.put(100, "北京");
        map.put(200, "广州");
        map.put(500, "上海");
        map.put(400, "武汉");
        map.put(400, "深圳");
        System.out.println(map);
        System.out.println("========================");
        // 按照指定规则排序: ---->降序
        // 创建TreeMap集合,限制键的类型为Integer,值的类型为String
        TreeMap<Integer, String> map2 = new TreeMap<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                // 前减后 升序
                // 后减前 降序
                return o2 - o1;
            }
        });

        map2.put(300, "深圳");
        map2.put(100, "北京");
        map2.put(200, "广州");
        map2.put(500, "上海");
        map2.put(400, "武汉");
        map2.put(400, "深圳");
        System.out.println(map2);
    }
}

Map集合练习

需求

• 输入一个字符串统计该字符串中每个字符出现次数。

分析

• 获取一个字符串对象
• 创建一个Map集合，键代表字符，值代表次数。
• 遍历字符串得到每个字符。
• 判断Map中是否有该键。
• 如果没有，第一次出现，存储次数为1；如果有，则说明已经出现过，获取到对应的值进行++，再次存储。
• 打印最终结果

package com.company.day15;

import java.util.HashMap;
import java.util.Scanner;

public class Test6 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String str = sc.next();
        HashMap<Character, Integer> map = new HashMap<>();
        for (char c : str.toCharArray())
            if (map.containsKey(c)){
                Integer value = map.get(c);
                value++;
                map.put(c,value);
            }
            else map.put(c,1);
        for (Character word : map.keySet()){
            Integer value = map.get(word);
            System.out.println(word + " = " + value);
        }

    }
}

集合的嵌套

任何集合内部都可以存储其它任何集合

• List嵌套Map

package com.company.day15;

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

public class Test7 {
    public static void main(String[] args) {
        Map<String, String> map1 = new HashMap<>();
        ArrayList<Map<String, String>> list = new ArrayList<>();
        map1.put("name", "小鲁班");
        map1.put("skill1", "无敌沙嘴炮");
        map1.put("skill2", "全图导弹");
        map1.put("grade", "12");
        map1.put("speed", "450");
        Map<String, String> map2 = new HashMap<>();
        map2.put("name", "程咬金");
        map2.put("skill1", "转转转");
        map2.put("skill2", "加血");
        map2.put("grade", "12");
        map2.put("speed", "450");
        Map<String, String> map3= new HashMap<>();
        map3.put("name", "李白");
        map3.put("skill1", "刮痧");
        map3.put("skill2", "将进酒");
        map3.put("grade", "12");
        map3.put("speed", "450");
        list.add(map1);
        list.add(map2);
        list.add(map3);

        for (Map<String, String> map: list){
            for (String s : map.keySet()) {
                System.out.println("key = " + s + "   value = " + map.get(s));
            }

        }
    }
}

按照斗地主的规则，完成洗牌发牌的动作。

具体规则：

1. 组装54张扑克牌
2. 54张牌顺序打乱
3. 三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。
4. 查看三人各自手中的牌（按照牌的大小排序）、底牌
   

package com.company.day15;

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

public class Test8 {
    public static void main(String[] args) {
        HashMap<Integer, String> pokerBox = new HashMap<>();
        ArrayList<String> numbers = new ArrayList<>();
        ArrayList<String> colors = new ArrayList<>();
        Collections.addAll(colors, "♥", "♦", "♠", "♣");
        Collections.addAll(numbers, "2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3");
        int id = 0;
        pokerBox.put(id++, "大王");
        pokerBox.put(id++, "小王");
        for (String num : numbers){
            for (String color: colors){
                pokerBox.put(id++, color+num);
            }
        }

        System.out.println(pokerBox.size());
        System.out.println(pokerBox);
        // 洗牌

        Set<Integer> keySet = pokerBox.keySet();

        // 有序
        ArrayList<Integer> list = new ArrayList<>();
        list.addAll(keySet);

        Collections.shuffle(list);
        System.out.println("打乱编号" + list);
        ArrayList<Integer> play1Id = new ArrayList<>();
        ArrayList<Integer> play2Id = new ArrayList<>();
        ArrayList<Integer> play3Id = new ArrayList<>();
        ArrayList<Integer> diPaiId = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            Integer paiId = list.get(i);

            if (i >= 51)
                diPaiId.add(paiId);
            else if (i%3==0)
                play1Id.add(paiId);
            else if (i%3==1)
                play2Id.add(paiId);
            else if (i%3==2)
                play3Id.add(paiId);
        }
        Collections.sort(play1Id);
        Collections.sort(play2Id);
        Collections.sort(play3Id);
        System.out.println("鲁班的牌");
        for (Integer paiId :play1Id){
            String s = pokerBox.get(paiId);
            System.out.print(s +" ");
        }
        System.out.println();
        System.out.println("凯爹的牌");
        for (Integer paiId :play2Id){
            String s = pokerBox.get(paiId);
            System.out.print(s +" ");
        }
        System.out.println();

        System.out.println("诸葛亮的牌");
        for (Integer paiId :play3Id){
            String s = pokerBox.get(paiId);
            System.out.print(s +" ");
        }
        System.out.println();
        System.out.println("底牌");
        for (Integer paiId :diPaiId){
            String s = pokerBox.get(paiId);
            System.out.print(s +" ");
        }
        System.out.println();
    }
}