JAVA Map集合

JAVA中Map集合与集合回顾

1.Map集合

• Map接口概述

  • 可以将键映射到值的对象
  • 一个映射不能包含重复的键
  • 每个键最多只能映射到一个值

• Map接口和Collection接口的不同

  • Map是双列的,Collection是单列的
  • Map的键唯一,Collection的子体系Set是唯一的
  • Map集合的数据结构针对键有效，跟值无关;
  • Collection集合的数据结构是针对元素有效

• Map集合的功能概述

  • 添加功能
    • V put(K key,V value):添加元素。这个其实还有另一个功能?替换
    • 如果键是第一次存储，就直接存储元素，返回null
    • 如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值
  • 删除功能
    • void clear(): 移除所有的键值对元素
    • V remove(Object key)：根据键删除键值对元素，并把值返回
  • 判断功能
    • boolean containsKey(Object key)：判断集合是否包含指定的键
    • boolean containsValue(Object value):判断集合是否包含指定的值
    • boolean isEmpty()：判断集合是否为空
  • 获取功能
    • Set<Map.Entry<K,V>> entrySet(): 返回一个键值对的Set集合
    • V get(Object key):根据键获取值
    • Set keySet():获取集合中所有键的集合
    • Collection values():获取集合中所有值的集合
  • 长度功能
    • int size()：返回集合中的键值对的对数

• 案例演示

A:案例演示
	Map集合的基本功能
	
	V put(K key,V value)//键相同 值覆盖  
	V remove(Object key)
	void clear()
	boolean containsKey(Object key)
	boolean containsValue(Object value)
	boolean isEmpty()
	int size()

• Map集合的获取功能

  • V get(Object key
  • Set keySet()
  • Collection values()

• Map集合的遍历

  • 获取所有键的集合

  • 遍历键的集合，获取到每一个键

  • 根据键找值

• Map集合的遍历之键值对对象找键和值

  • 获取所有键值对对象的集合

  • 遍历键值对对象的集合，获取到每一个键值对对象

  • 根据键值对对象找键和值

• HashMap 集合键是Student值是String

  • 键唯一 注意重写hashCode方法 和 equals 方法

2. LinkedHashMap

• LinkedHashMap
  • Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序
• LinkedHashMap的特点
  • 底层的数据结构是链表和哈希表 元素有序 并且唯一
  • 元素的有序性由链表数据结构保证 唯一性由 哈希表数据结构保证
  • Map集合的数据结构只和键有关

3.TreeMap集合

• TreeMap 键不允许插入null

• TreeMap:

  • 键的数据结构是红黑树,可保证键的排序和唯一性
  • 排序分为自然排序和比较器排序
  • 要实现Comparable 接口
  • 线程是不安全的效率比较高

• 统计字符串中每个字符出现的次数

public class MyTest {
    public static void main(String[] args) {
        /*A:
        案例演示:
        需求：统计字符串中每个字符出现的次数
        "aababcabcdabcde", 获取字符串中每一个字母出现的次数要求结果:a(5) b(4) c(3) d(2) e(1)*/

        //"aababcabcdabcde"
        // a(5) b(4) c(3) d(2) e(1)

      */

        LinkedHashMap<Character, Integer> hm = new LinkedHashMap<>();
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一段字符串");
        String s = scanner.nextLine();
        // char[] chars = s.toCharArray();
        for (int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            //如果不存在这个键，就把他存进去
            if (!hm.containsKey(ch)) {
                hm.put(ch, 1);
            } else {
                //取出上一次的值
                Integer value = hm.get(ch);
                //累加一下
                value++;
                //再存进去，键相同，值覆盖。
                hm.put(ch, value);
            }
        }
        //遍历集合拼串  a(5) b(4) c(3) d(2) e(1)
        StringBuilder sb = new StringBuilder();
        hm.forEach(new BiConsumer<Character, Integer>() {
            @Override
            public void accept(Character key, Integer value) {
                sb.append(key).append("(").append(value).append(")");
            }
        });
        String s1 = sb.toString();
        System.out.println(s1);
    }
}

4.集合嵌套

• HashMap 嵌套 HashMap
• 案例演示

public class MyTest2 {
    public static void main(String[] args) {

        HashMap<String, Integer> jcMap = new HashMap<>();
        jcMap.put("张三", 20);
        jcMap.put("李四", 22);


        HashMap<String, Integer> jyMap = new HashMap<>();
        jyMap.put("王五", 21);
        jyMap.put("赵六", 23);

        HashMap<String, HashMap<String, Integer>> maxMap = new HashMap<>();
        maxMap.put("基础班", jcMap);
        maxMap.put("就业班", jyMap);
 
  maxMap.forEach(new BiConsumer<String, HashMap<String, Integer>>() {
            @Override
            public void accept(String s, HashMap<String, Integer> minMap) {
                System.out.println(s);
                minMap.forEach(new BiConsumer<String, Integer>() {
                    @Override
                    public void accept(String key, Integer value) {
                        System.out.println("\t" + key + "\t" + value);
                    }
                });
            }
        });
    }
}

• HashMap嵌套ArrayList

public class MyTest {
    public static void main(String[] args) {
        ArrayList<String> sgList = new ArrayList<>();
        sgList.add("吕布");
        sgList.add("周瑜");

        ArrayList<String> xaList = new ArrayList<>();
        xaList.add("令狐冲");
        xaList.add("林平之");


        ArrayList<String> sdList = new ArrayList<>();
        sdList.add("郭靖");
        sdList.add("杨过");

        LinkedHashMap<String, ArrayList<String>> maxMap = new LinkedHashMap<>();
        maxMap.put("三国演义", sgList);
        maxMap.put("笑傲江湖", xaList);
        maxMap.put("神雕侠侣", sdList);
        maxMap.forEach(new BiConsumer<String, ArrayList<String>>() {
            @Override
            public void accept(String s, ArrayList<String> list) {
                System.out.println(s);
                list.forEach(new Consumer<String>() {
                    @Override
                    public void accept(String s) {
                        System.out.println("\t" + s);
                    }
                });
            }
        });


    }
}

• ArrayList嵌套HashMap

public class MyTest2 {
    public static void main(String[] args) {

        HashMap<String, String> sgMap = new HashMap<>();
        sgMap.put("周瑜", "小乔");
        sgMap.put("吕布", "貂蝉");

        HashMap<String, String> sdMap = new HashMap<>();
        sdMap.put("郭靖", "黄蓉");
        sdMap.put("杨过", "小龙女");


        HashMap<String, String> xaMap = new HashMap<>();
        xaMap.put("令狐冲", "任盈盈");
        xaMap.put("林平之", "岳灵珊");

        ArrayList<HashMap<String, String>> maxList = new ArrayList<>();
        maxList.add(sgMap);
        maxList.add(xaMap);
        maxList.add(sdMap);

        for (HashMap<String, String> minMap : maxList) {
            minMap.forEach(new BiConsumer<String, String>() {
                @Override
                public void accept(String key, String value) {
                    System.out.println(key + "--------" + value);

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


    }
}

5.HashMap和Hashtable的区别

• HashMap和Hashtable的区别
  • HashMap: 线程不安全,效率高.允许null值和null键
  • Hashtable: 线程安全 , 效率低.不允许null值和null键

6.Collections工具类

• Collections类概述: 针对集合操作 的工具类

• Collections成员方法
  public static void sort(List list): 排序,默认按照自然顺序
  public static int binarySearch(List<?> list,T key): 二分查找
  public static T max(Collection<?> coll): 获取最大值
  public static void reverse(List<?> list): 反转
  public static void shuffle(List<?> list): 随机置换

• 案例演示

•         while (true) {
              System.out.println("请输入一个数字 1----100");
              int guessNumber = sc.nextInt();
              if(guessNumber>=0&&guessNumber<=100){
                  if (guessNumber > num) {
                      System.out.println("猜大了");
                  } else if (guessNumber < num) {
                      System.out.println("猜小了");
                  } else if (guessNumber == num) {
                      System.out.println("恭喜你猜对了");
                      break;
                  }
              }else{
                  System.out.println("输入错误，请重新输入");
                  playGame();
              }
        
          }
        
      }
  }
  

7.模拟斗地主洗牌和发牌

public class Test {
    public static void main(String[] args) {
        //创建集合,生成牌合
        TreeMap<Integer, String> Porkerbox = new TreeMap<>();
        //定义54牌(除过大小王)
        String[] colors = {"♣", "♠", "♦", "♥"};
        String[] numbers = {"A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"};
        //创建一个Arraylist集合来存储对牌的索引
        ArrayList<Integer> index = new ArrayList<>();
        //定义初始索引为1
        int i=0;
        //对花色和数字进行遍历
        for (String color : colors) {
            for (String number : numbers) {
                Porkerbox.put(i,color+number);
                //将定义的索引加入集合中
                index.add(i);
                //每添加一张牌索引+1
                i++;
            }
            //存放大小王
            Porkerbox.put(i,"大王");
            index.add(i);
            i++;
            Porkerbox.put(i,"小王");
            index.add(i);
            i++;
        }
        //洗牌
        Collections.shuffle(index);
        //根据索引去发牌
        TreeSet<Integer> 高进 = new TreeSet<>();
        TreeSet<Integer> 刀仔 = new TreeSet<>();
        TreeSet<Integer> 星仔 = new TreeSet<>();
        TreeSet<Integer> 底牌 = new TreeSet<>();

        for (int j = 0; j < Porkerbox.size(); j++) {
            if (j >= Porkerbox.size() - 3) {
                底牌.add(index.get(j));
            } else if (j % 3 == 0) {
                高进.add(index.get(j));
            } else if (j % 3 == 1) {
                刀仔.add(index.get(j));
            } else {
                星仔.add(index.get(j));
            }
        }
        //看牌
        lookPoker("高进", 高进,Porkerbox);
        lookPoker("刀仔", 刀仔,Porkerbox);
        lookPoker("星仔", 星仔,Porkerbox);
        lookPoker("底牌", 底牌,Porkerbox);
    }

    private static void lookPoker(String name, TreeSet<Integer> index, TreeMap<Integer, String> porkerbox) {
        System.out.println(name+"的底牌是:");
        for (Integer i : index) {
            System.out.print(porkerbox.get(i+""));
        }
        System.out.println();
    }
}