Java：Map双列集合、计算字符串字符次数

1、Map-概述

特点：

1）、Map内部采用”键值对”的形式进行存储；

2）、在一个Map内，“键”是唯一的；

3）、键和值可以是任意对象；

4）、可以通过“键“获取对应的”值“；

2、Map集合-常用子类

Map(接口)：双列集合：

–HashMap(子类)：键是哈希表结构

–LinkedHashMap(子类)：键是 链表、哈希表结构

面试常问：HashTable不可以使用null做对象和值，但HashMap可以

3、Map集合-Map接口中定义的常用方法

按照键的哈希值进行顺序存储

1）、添加、修改：

public V put(K key, V value);//将指定的键与指定的值添加到Map集合中

当存储一个已存在的键时，用新值替换旧值，并将旧值返回

2）、删除：

public V remove(Object key);//把指定的键所对应的键值对元素在Map集合中删除，返回被删除元素的值

3）、查询：

public V get(Object key);//通过键，获取值
public int size();//获取键值对的数量

4）、遍历

Map本身没有遍历的的方法，都是间接遍历

1）、键找值：keySet()

2）、获取“键值对”的方式：entrySet()

4、Map集合-遍历-键找值

键找值：先获取Map中多有键的集合，然后在逐个根据每个键获取对应的值

public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<>();
        map.put(1,"张璇");
        map.put(3,"丽丽");
        map.put(5,"奥特曼");
        map.put(2,"ez");

        System.out.println(map);
        //键找值：先获取所有键的集合
        Set<Integer> set = map.keySet();
        //遍历set集合，在使用get方法获取键对应的值
        for (int a:
             set) {
            System.out.println(a+"="+map.get(a));
        }
    }

5、Map集合-键值对对象-Entry对象说明

向Map中存储键值对时，在Map中会将键值对封装到一个Entry对象中

6、Map集合-键值对对象

键值对对象：将所有的Entry对象封装到一个Set中，并返回；

public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<>();
        map.put("美女", "马蓉");
        map.put("绿巨人", "王宝强");
        map.put("老王", "宋喆");
        map.put("影帝", "黄渤");
        System.out.println(map);
        //键值对：将键值对放在set集合中
        Set<Map.Entry<Integer,String>> set = map.entrySet();
        //遍历set集合，获取每个Entry对象
        for (Map.Entry<Integer,String> entry:
             set) {
            int key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+","+value);
        }
    }

俩种方式的对比：

7、Map集合-Map子类-HashMap的基本使用和使用自定义对象做键

键是唯一的，所以在使用自定义对象做键时，要在自定义对象的类中重写hashCode()和equals()方法

注意：自定义对象做键，必须重写hashCode()和equals()方法

public class Student {
    .....
    @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);
    }
}

测试类：

public static void main(String[] args) {
    Map<Student,String> map = new HashMap<>();

    map.put(new Student("张三", 18), "帅哥");
    map.put(new Student("杨幂", 17), "美女");
    map.put(new Student("杨幂", 17), "女神");//“女神”覆盖了“美女”

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

8、Map集合-Map子类-LinkedHashMap的基本使用

LinkedHashMap：他是Map的特例，是有序的哈希表

public static void main(String[] args) {
        Map<String,String> map = new LinkedHashMap<>();

        map.put("s","lili");
        map.put("a","kangkang");
        map.put("d","xman");
        map.put("t","fuckman");

        //键找值的方式
        Set<String> key = map.keySet();
        for (String s:
             key) {
            System.out.println(s+","+map.get(s));
        }
        System.out.println("----------------");
        //通过键值对遍历
        Set<Map.Entry<String ,String>> entrySet = map.entrySet();
        for (Map.Entry<String ,String> entry:
             entrySet) {
            System.out.println(entry);
        }
    }

遍历之后是按照put的顺序

9、JDK9对集合添加的优化

1）、向集合添加元素：.add();

2）、JDK9的三个集合接口：List、Set、Map中都提供了一种静态方法：of()

List<String> strList = List.of("张三","李四","王五","周六");
Set<String> strSet = Set.of("黄渤","黄老邪","黄磊","黄瓜");
Map<Character,Integer> map = Map.of('a',10,'b',20,'c',25);

3）、重点：of()添加后，是内容不可变的元素（不可删除、添加、修改）

public static void main(String[] args) {
    List<String> list = List.of("张三", "李四", "王五");

    System.out.println(list);

//   list.add("周六");//运行时异常
//   list.remove(0);//运行时异常
//   list.set(0, "张三丰");//运行时异常

    System.out.println(list);
}

10、Debug追踪调试

F8：单步执行，遇到方法时不会进去方法体中

F7：单步执行，遇到方法调用，进入方法体中执行

F9：结束单步执行；继续执行后面的代码，如果后面代码没有断点，直接将后续所有代码执

11、练习：计算字符串中每个字符出现的次数

创建Map集合，键存储字符，值存储字符出现次数

public static void main(String[] args) {
        String s = "115572375,SDFDFGSF";
        //创建Map集合，键存储字符，值存储字符出现次数
        Map<Character,Integer> map = new HashMap<>();

        //将字符串转为数组，遍历
        char[] chars = s.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            //键存储字符，值为出现次数
            Integer value = map.get(chars[i]);
            if (value == null){//当该字符出现次数为0，Integer对象为空，给值赋值为1
                value = 1;
            }else {//当出现该字符，便给value+1
                value++;
            }
            map.put(chars[i],value);
        }
        //验证结果
        Set<Character> key = map.keySet();
        for (char c:
             key) {
            System.out.println(c+"="+map.get(c));
        }
    }

复习

• [ ] 能够说出Map集合特点

  Map双列集合，以键值对的形式进行存储，键不可重复

• [ ] 使用Map集合添加方法保存数据

  Map对象名.put()，添加数据，当添加数据的键相同时，会使用新的值覆盖久的值，put方法在覆盖时会返回被覆盖的值

• [ ] 使用”键找值”的方式遍历Map集合

  Set<键的类型例如String> set = map.keySet();
  for(String s:set){
    System.out.println(s+"="+map.get(s));
  }

• [ ] 使用”键值对”的方式遍历Map集合

  Set<map.Entry<String,String>> set = map.EntrySet();
  for(map.Entry<String,String> entry:set){
    String key = entry.getKey();
    String value = entry.getValue();
    System.out.println(key+","+value);
  }

• [ ] 能够使用HashMap存储自定义键值对的数据

  当时用HashMap一自定义类型为键时，要在自定义类中重写hashCode()和equals()方法

• [ ] 能够使用HashMap编写斗地主洗牌发牌案例