Day20-C:\Users\Lenovo\Desktop\note\code\JavaSE\Basic\src\com\CollectionandMap-Map+Test-Map类遍历学生ABCD-调用自带有参构造器比较

Map

Map是键值对集合，key=value，称为一个键值对/键值对象，左边的键是不允许重复的，但是值可以重复，键和值是一一对应的。

需要存储一一对应的数据时可以用map

Map<K,V>

接口名<泛型参数>

Map系列集合的特点都是由键决定的，和值没有关系

HashMap(由键决定特点)：无序、不重复、无索引
LinkedHashMap(由键决定特点)：有序、不重复、无索引
TreeMap(由键决定特点)：按键的大小升序排序、不重复、无索引

package com.CollectionandMap.Map;

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.TreeMap;

public class Maptest1 {
    public static void main(String[] args) {
        //Map<String,Integer> map = new HashMap();//这是一行经典代码（多态），无序，不重复，无索引
        Map<String,Integer> map = new LinkedHashMap();//这是一行经典代码（多态），有序，不重复，无索引
        map.put("手表",100);
        map.put("手表",220);//后面重复的键会覆盖前面的数据
        map.put("手机",2);
        map.put("Java",2);
        map.put(null,null);
        System.out.println(map);//{null=null, 手表=220, Java=2, 手机=2}

        Map<Integer,String> map1 = new TreeMap<>();//升序
        map1.put(23,"Java");
        map1.put(23,"MySQL");
        map1.put(19,"李四");
        map1.put(20,"王五");
        System.out.println(map1);
    }
}

Map的常用方法

put，replace

package com.CollectionandMap.Map;

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

public class Maptest2 {
    //1.添加元素：无序，不重复，无索引
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap();
        map.put("手表",100);
        map.put("手表",220);//后面重复的键会覆盖前面的数据
        map.put("手机",2);
        map.put("Java",2);
        map.put(null,null);
        System.out.println(map);

        //获取集合大小
        System.out.println(map.size());

        //清空map集合
//        map.clear();
//        System.out.println(map);

        //判断集合是否为空，为空返回true，反之则为
        System.out.println(map.isEmpty());

        //根据键获取对应值
       int v1 = map.get("手表");
        System.out.println(v1);
        System.out.println(map.get("手机"));
        System.out.println(map.get("张三"));//null

        //根据键删除元素，并返回被删除值
        System.out.println(map.remove("手表"));
        System.out.println(map);

        //判断是否包含某个键，包含则返回true
        System.out.println(map.containsKey("手表"));
        System.out.println(map.containsKey("手机"));
        System.out.println(map.containsKey("JAVA"));

        //判断是否包含某个值，包含则返回true
        System.out.println(map.containsValue(2));
        System.out.println(map.containsValue("2"));

        //获取map键的全部键，会把Map类集合的键放到一个set里面然后返回给我们
        Set<String> keys = map.keySet();
        System.out.println(keys);

        //获取Map集合的全部值，会把Map类集合的值放到一个Collection里面然后返回给我们（可重复）
        Collection<Integer> values = map.values();
        System.out.println(values);

        //把其他Map集合的数据倒入自己的集合中来
        Map<String, Integer> map1 = new HashMap<>();
        map1.put("java1",10);
        map1.put("java2",20);
        Map<String, Integer> map2 = new HashMap<>();
        map2.put("java3",10);
        map2.put("java2",222);
        map1.putAll(map2);//把map2集合中的元素全部倒入map1，相当于拷贝
        System.out.println(map1);//"java2",222把"java2",20覆盖了
        System.out.println(map2);
    }



}

Map集合的遍历方式

键找值
键值对，把键值对看成一个整体对象进行遍历：map.entrySet
```
Set<Map.Entry<String, Double>> entries = map.entrySet();
```
Map.Entry提供的方法：getKey和getValue
Lambda

package com.CollectionandMap.Map;

import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;

public class MapTest03 {
    public static void main(String[] args) {
        Map<String, Double> map = new HashMap<>();
        map.put("蜘蛛精",162.5);
        map.put("蜘蛛精",169.8);
        map.put("紫霞",165.8);
        map.put("至尊宝",169.5);
        map.put("牛魔王",183.6);
        System.out.println(map);

        map.forEach((k,v)->{
            //new BiConsumer是函数方法，最后会返回action.accept(k, v);来自new BiConsumer源码
            //其中k = entry.getKey();v = entry.getValue();来自 forEach源码
            System.out.println(k+":"+v);
        });
//        map.forEach(new BiConsumer<String, Double>() {//Objects.requireNonNull(action);判断输入的action不是null
//            @Override
//            public void accept(String key, Double value) {
//                System.out.println(key+","+value);
//            }
//        });


    }
}

注意Map类的put()方法，如果键相同，会更新键值对

package com.CollectionandMap.Map;

import java.util.*;

public class MapTest04 {
    public static void main(String[] args) {
        //1.把80个学生选择的景点数据拿到程序中
        List<String> data = new ArrayList<>();
        String[] selects = {"A","B","C","D"};
        Random r = new Random();
        for(int i=1;i<=80;i++){
            //模拟学生选择一个景点存入集合中
            int index = r.nextInt(4);//0,1,2,3
            data.add(selects[index]);
        }
        System.out.println(data);

        //2.开始统计每个景点的投票人数
       Map<String, Integer> result = new HashMap<>();

       //3.开始遍历八十个景点数据
        for (String s : data) {
            //问问该map集合中是否存在
            if(result.containsKey(s)){
                //说明这个景点之前统计过，其值加一，put存入到Map集合中
                result.put(s,result.get(s)+1);//两个实参，指的是键值对中的键和值，键覆盖
            }else{
                result.put(s,1);
            }
        }
        System.out.println(result);
    }
}

HashMap

HashMap和HashSet：HashSet底层基于HashMap实现，只接收了键数据

public HashSet() {
    map = new HashMap<>();
}

如果键存储的是自定义类型的对象，可以通过重写hashCode和equals方法：alt+insert+“equals和hashCode方法”，这样可以保证多个对象内容一样时，HashMap集合就能认为是重复的。

package com.CollectionandMap.Map;

import com.CollectionandMap.Student;

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

public class Test1HashMap {
    public static void main(String[] args) {
        Map<Student,String> map = new HashMap<>();
        map.put(new Student("蜘蛛精",25,168.5),"盘丝洞");
        map.put(new Student("蜘蛛精",25,168.5),"水帘洞");
        map.put(new Student("至尊宝",23,163.5),"水帘洞");
        map.put(new Student("牛魔王",28,183.5),"牛头山");
        System.out.println(map);
        //重写hashCode和equals方法
        //判断键是否一样，判断Student类是否一样，equals是否一样
    }
}

linkedHashMap

原来学习的linkedHashSet底层原理就是linkedHashMap的

public LinkedHashSet(Collection<? extends E> c) {
    super(Math.max(2*c.size(), 11), .75f, true);
    addAll(c);
}

HashSet(int initialCapacity, float loadFactor, boolean dummy) {
    map = new LinkedHashMap<>(initialCapacity, loadFactor);
}

当把map.put("键","值")

"键","值"会被封装为一个整体，Entry对象，分配一个长度为16的数组，并根据键的哈希值对底层数组长度求余。

TreeMap

原来学习的TreeSet底层原理就是TreeMap的，基于红黑树实现的排序。

public TreeSet() {
    this(new TreeMap<E,Object>());
}

TreeMap集合同样也支持两种方式来指定排序规则

让类实现Comparable接口，重写比较规则。
TreeMap集合有一个有参构造器，支持创建Comparator比较器对象，以便用来指定比较规则

package com.CollectionandMap.Map;

import com.CollectionandMap.Student;

import java.util.Comparator;
import java.util.Map;
import java.util.TreeMap;
import java.util.TreeSet;

public class Test3TreeMap {
    public static void main(String[] args) {
        //调用Map自带的有参构造器比较
        Map<Student, String> map = new TreeMap<>(new  Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return Double.compare(o1.getHeight(), o2.getHeight());
            }
        });
        map.put(new Student("蜘蛛精",25,168.5),"盘丝洞");
        map.put(new Student("蜘蛛精",25,168.5),"水帘洞");
        map.put(new Student("至尊宝",23,163.5),"水帘洞");
        map.put(new Student("牛魔王",28,183.5),"牛头山");
        System.out.println(map);
        //Lambda表达式
        Map<Student, String> map1 = new TreeMap<>((x,y) ->Double.compare(x.getHeight(), y.getHeight()));
        map1.put(new Student("蜘蛛精",25,168.5),"盘丝洞");
        map1.put(new Student("蜘蛛精",25,168.5),"水帘洞");
        map1.put(new Student("至尊宝",23,163.5),"水帘洞");
        map1.put(new Student("牛魔王",28,183.5),"牛头山");
        System.out.println(map1);
    }
}

集合嵌套

package com.CollectionandMap;

import java.util.*;

/**
 * 目标：理解集合嵌套
 * 江苏省="南京市","扬州市","苏州市","无锡市","常州市"
 * 湖北省="武汉市","孝感市","十堰市","宜昌市","鄂州市"
 * 河北省="石家庄市","唐山市","邢台市","保定市","张家口市"
 */
public class Test {
    public static void main(String[] args) {
        Map<String, List<String>> map = new HashMap<>();
        List<String> cities1 = new ArrayList<>();
        Collections.addAll(cities1,"南京市","扬州市","苏州市","无锡市","常州市");//存入，不能直接cities.addAll
        map.put("江苏省",cities1);

        List<String> cities2 = new ArrayList<>();
        Collections.addAll(cities2,"武汉市","孝感市","十堰市","宜昌市","鄂州市");//存入，不能直接cities.addAll
        map.put("湖北省",cities2);

        List<String> cities3 = new ArrayList<>();
        Collections.addAll(cities3,"石家庄市","唐山市","邢台市","保定市","张家口市");//存入，不能直接cities.addAll
        map.put("河北省",cities3);

        System.out.println(map);
        List<String> cities = map.get("湖北省");
        for (String city : cities) {
            System.out.println(city);
        }
        map.forEach((k,v)->{
            System.out.println(k+"------>"+v);
        });
    }
}

posted @ 2025-10-21 18:26 David大胃阅读(4) 评论(0) 收藏举报

刷新页面返回顶部

David0919