小东吖之 java Map集合类

最新推荐文章于 2022-08-23 15:01:49 发布

小东啊

最新推荐文章于 2022-08-23 15:01:49 发布

阅读量814

点赞数

分类专栏： map集合类文章标签：框架 map 集合类

本文链接：https://blog.csdn.net/qq_34936541/article/details/78867054

版权

map集合类专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一.初识map

1.java集合框架用于存储数据，也被称为集合类

位于java.util包下

java.util包下常用接口和类

Collection和Map是Java集合框架的根接口

List集合是有序集合，集合中的元素可以重复，有下标,访问集合中的元素可以根据元素的索引来访问

Set集合是无序集合，集合中的元素不可以重复，访问集合中的元素只能根据元素本身来访问（也是不能集合里元素不允许重复的原因）。

Map集合中保存Key-value对形式的元素，访问时只能根据每项元素的key来访问其value。

2.Map接口

Map接口不是Collection接口的继承。Map接口用于维护键/值对(key/value pairs)。该接口描述了从不重复的键到值的映射。

HashMap 是一个最常用的Map,它根据键的HashCode 值存储数据,根据键可以直接获取它的值，具有很快的访问速度。

HashMap最多只允许一条记录的键为Null;允许多条记录的值为Null;HashMap不支持线程的同步，即任一时刻可以有多个线程同时写HashMap;

可能会导致数据的不一致。如果需要同步，可以用Collections的synchronizedMap方法使HashMap具有同步的能力。

TreeMap 不仅可以保持顺序，而且可以用于排序

Map与Collection：
Map与Collection在集合框架中属并列存在
Map存储的是键值对
Map存储元素使用put方法，Collection使用add方法
Map集合没有直接取出元素的方法，而是先转成Set集合，在通过迭代获取元素
Map集合中键要保证唯一性

二.一些方法的使用

3.向集合添加元素

/** 
 *  
 * 向Map集合添加
 * 
 */  
public class Demo01   
{  
    public static void main(String[] args)  
    {  
        Map<String,Integer> map = new HashMap<String,Integer>();  
          // 三对键值对
       map.put("张三", 19);  
       map.put("李四", 17);  
       map.put("王五", 18);  
        // 如果你的key值一样 value的值不一样 就会被覆盖
        // 因为key值 是唯一的
        map.put("张三", 20)
        System.out.println(map);  
    }  
}

在这里要注意的是: 方法的返回值返回的是被覆盖的值

4.一些常用的方法:
clear()
从此映射中移除所有映射关系（可选操作）
containsKey(Object key)
如果此映射包含指定键的映射关系，则返回 true。
containsValue(Object value)
如果此映射将一个或多个键映射到指定值，则返回 true。
isEmpty()
如果此映射未包含键-值映射关系，则返回 true。
remove(Object key)
如果存在一个键的映射关系，则将其从此映射中移除（可选操作）
size()
返回此映射中的键-值映射关系数。
get(Object key)
返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。

       Map<String, Integer> map = new HashMap<>();
        Integer num1 = map.put("小一", 13);
        Integer num2 = map.put("小二", 15);
        Integer num3 = map.put("小三", 18);
        Integer num4 = map.put("小四", 11);
        // 测试clean
        //map.clear();
        // containsKey(Object key)
        // 是否包含key 键值
        boolean containsKey = map.containsKey("小三");
        System.out.println(containsKey);
        // containsValue(Object value) 
        // 是否包含value 键值对应的值
        boolean containsValue = map.containsValue(18);
        System.out.println(containsValue);
        // isEmpty() 
        // 判断map是否为空/
        boolean empty = map.isEmpty();
        System.out.println(empty);
        // remove(Object key) 返回的是 value
        // 删除key 键值 (根据键来删除 键是唯一的)
        Integer remove = map.remove("小三");
        System.out.println(remove);
        // size() 
        // map有几对键值对
        int size = map.size();
        System.out.println(size);
        System.out.println(map);

        // get 是通过键值获取value值
        Integer integer = map.get("小三");
        System.out.println(integer);
    }

三.map集合的两种取出方式：

1 . Set keySet：将map中所有的键存入到Set集合。因为set具备迭代器。所有可以迭代方式取出所有的键，在根据get方法。获取每一个键对应的值。

Set keySet 是把map中的所有键(key) 取出来放入一个Set集合中返回给你

get(Object key) 是通过传入键key 返回的是键key 对应的value值

Map集合的取出原理：将map集合转成set集合。在通过迭代器取出。
2 . Set

四.map遍历的三种方法

1.for循环遍历

Map<String, Integer> map = new HashMap<>();
        Integer num1 = map.put("小一", 13);
        Integer num2 = map.put("小二", 15);
        Integer num3 = map.put("小三", 18);
        Integer num4 = map.put("小四", 11);

        // for循环遍历
        // 先获取key键值 
        for (String string : map.keySet()) {
            // 通过键值找到value的值
            Integer integer = map.get(string);
            System.out.println(string + " " + integer);
        }

2.用迭代器遍历

    Map<String, Integer> map = new HashMap<>();
        Integer num1 = map.put("小一", 13);
        Integer num2 = map.put("小二", 15);
        Integer num3 = map.put("小三", 18);
        Integer num4 = map.put("小四", 11);

        // 先获取set的迭代器
        Set<String> keySet = map.keySet();
        Iterator<String> iterator = keySet.iterator();
        while (iterator.hasNext()) {
            String next = iterator.next();
            Integer integer = map.get(next);
            System.out.println(next + " " + integer);
        }

3.使用Entry
entrySet()
返回此映射中包含的映射关系的 Set 视图。
主要使用其中的方法
getKey()
返回与此项对应的键。
getValue()
返回与此项对应的值。

         //该方法是一个集合 集合中储存的是一个一个键值对对象
        // Entry对象 中 保存的是 key 和 value
        // 利用该方法遍历
Map<String, Integer> map = new HashMap<>();
        Integer num1 = map.put("小一", 13);
        Integer num2 = map.put("小二", 15);
        Integer num3 = map.put("小三", 18);
        Integer num4 = map.put("小四", 11);
        // 获取map中所有的 Entry对象的Set集合
        Set<Entry<String, Integer>> entrySet = map.entrySet();
        // for循环遍历
        for (Entry<String, Integer> entry : entrySet) {
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key + " " + value);
        }

五.TreeMap集合 TreeMap 不仅可以保持顺序，而且可以用于排序

创建学生类 TreeMap集合
先储存3个学生户籍


public class Student implements Comparable<Student>{
    private String name;
    private int age;
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Student(String name, int age) {
        super();
        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 + "]";
    }

  // 重写 HashCode 和 equals 方法
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Student other = (Student) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
// 按年龄排序就要进行重写compareTo方法
    @Override
    public int compareTo(Student o) {
        int num = this.age- o.age;
        return num == 0? 1 : num;
    }
}


 public static void main(String[] args)  
    {  
        // TreeMap 可以对map中的键进行排序 
        // 向TreeMap中添加3个学生 key是学生 value户籍
        // 按年龄排序
        TreeMap<Student, String> treeMap = new TreeMap<>(new MyComparator());
        treeMap.put(new Student("张三", 13), "安徽");
        treeMap.put(new Student("李四", 12), "上海");
        treeMap.put(new Student("王五", 15), "北京");

        System.out.println(treeMap);
    }

HashMap 的用法和 HashSet的用法完全一样因为 HashSet的底部实现就是HashMap集合
所以要进行去重方法重写 HashCode 和 equals 方法
排序也要重写compareTo方法通过类实现Comparable接口即可
六.Map嵌套


         * java 学科
         * java 1班 -- 学生 和 户籍 
         * java 2班 -- 学生 和 户籍
         * 
         * java学科 是一个map 
         * 保存了两个键值对
         * 
         * 1班 也是一个 map
         * 保存 --- 学生 户籍

        // java 学科
        HashMap<HashMap<Student, String>, String> bigMap = new HashMap<>();
        // 1班
        HashMap<Student, String> class1 = new HashMap<>();
        class1.put(new Student("1", 13), "安徽");
        class1.put(new Student("2", 14), "北京");
        // 2班
        HashMap<Student, String> class2 = new HashMap<>();
        class2.put(new Student("3", 15), "广州");
        class2.put(new Student("4", 16), "深圳");

        bigMap.put(class1, "1班");
        bigMap.put(class2, "2班");

        // 遍历  我遍历的是哪个容器 容器里存在的什么?
        // 遍历 biaMap
        for (HashMap<Student, String> ban : bigMap.keySet()) {
            // 在bigMap 中 对应value 班
            String string = bigMap.get(ban);
            System.out.println(string);
            // 继续遍历 通过学生找 户籍
            for (Student student : ban.keySet()) {
                // 找户籍 
                String hj = ban.get(student);
                System.out.println(student + " " + hj);
            }
        }

七.练习

键盘输入一个字符串来计算每个字符出现的次数

     // 键盘输入一个字符串 来计算每个字符出现的次数
        System.out.println("请输入");
        Scanner scanner = new Scanner(System.in);
        String string = scanner.nextLine();
        // 把字符串转为数组
        char[] charArray = string.toCharArray();
        // 创建map集合
        HashMap<Character, Integer> map = new HashMap<>();
        for (int i = 0; i < charArray.length; i++) {
            // 遍历输入的字符串
            char c1 = charArray[i];
            // 如果集合没有包含这个字符
            if (!map.containsKey(c1)) {
                // 就添加到集合中去
                map.put(c1, 1);
            }else {
                // 通过键值获取value的值
                Integer num = map.get(c1);
                // 有的话 就会被覆盖 value值加1
                map.put(c1, num+1);
            }
        }
        System.out.println(map);