Java学习日记:Map集合

最新推荐文章于 2024-07-29 14:22:26 发布

kxbb99

最新推荐文章于 2024-07-29 14:22:26 发布

阅读量573

点赞数

文章标签： java 学习开发语言

本文链接：https://blog.csdn.net/kxbb99/article/details/127474420

版权

Map接口介绍

现实生活中，我们经常需要成对存储某些信息。比如，我们使用的微信，一个手机号只能对应一个微信账户。这就是一种成对存储的关系。

Map接口位于java.util包中，常用的实现类有HashMap、TreeMap、HashTable等。

Map集合的特点：

1、Map集合一次存储两个对象，一个键对象，一个值对象

2、键对象在集合中是唯一的，可以通过键来查找值

3、HashMap特点：

1、使用哈希算法对键去重复，效率高，但无序

2、HashMap是Map接口的主要实现类

map的创建与常用方法案例

public class Demo1 {
    public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<>();
        map.put(1,"kxbb");
        map.put(2,"kxbd");
        map.put(3,"kxdb");
        map.put(4,"kxdd");
        //可以为空
        map.put(null,"");

        //先化成set集合再使用迭代器
        Set<Integer> integers = map.keySet();

        Iterator<Integer> iterator = integers.iterator();
        while (iterator.hasNext()){
            //利用迭代器得到key，key.get到value
            Integer key = iterator.next();
            String value = map.get(key);
            System.out.println("key:"+key+",value:"+value);
        }
        //长度size
        System.out.println(map.size());

        //判断是否为空
        System.out.println(map.isEmpty());

        //根据key得到value
        System.out.println(map.get(2));

        //判断是否有这个key
        System.out.println(map.containsKey(3));

        //判断这个集合是否有这个value
        System.out.println(map.containsValue("kxbb"));

        //输出map的所有值
        System.out.println(map.values());

        //删除对应的key
        map.remove(2);
        System.out.println(map);

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

注意map没有迭代器所以需要转换成set再使用迭代器

两种办法（会一个即可）

1：keyset《我常用》推荐

案例如下

public class Demo2 {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<>();
        map.put("a",1);
        map.put("b",2);
        map.put("c",3);
        map.put("d",4);
        map.put("a",555);
        Iterator<String> iterator = map.keySet().iterator();
        while (iterator.hasNext()){
            String key = iterator.next();
            System.out.println("key:"+key+"   value:"+map.get(key));
        }
    }
}

2.entrySet

// entrySet方法
11 Set<Map.Entry<Integer, String>> entrySet = map.entrySet();
12 // 获取迭代器
13 Iterator<Map.Entry<Integer, String>> iterator = entrySet.iterator();
14 while(iterator.hasNext()) {
15 // 获取Entry对象
16 Map.Entry<Integer, String> next = iterator.next();
17 // 输出map的key和value
18 System.out.println("key: " + next.getKey() + " value: " + next.getValue());
19 }

Hashmap：

HashMap 集合中的 key 不能重复(key可以为null)，HashMap 中key为 JavaAPI 中提供的类型元素时，不需要重写元素的 hashCode 和 equals 方法，因为这两个方法，在 JavaAPI 的每个类中已经重写完毕，如 String 类、Integer 类等。

（当我们自建对象当作key时需要重写hashCode 和 equals 方法）

注意：当在HashMap 中put的key在之前已经存过，则不会重复存储，会覆盖之前key对应的value。

Treemap（排序的时候用且key不为空）

对map的排序（上节课讲过的）案例如下

方法一

public class Demo5 {
    public static void main(String[] args) {
        TreeMap<Teacher,String> map = new TreeMap<>();
        map.put(new Teacher(1,"kxbb"),"99");
        map.put(new Teacher(2,"kxbb"),"99");
        map.put(new Teacher(1,"dddd"),"99");//会覆盖
        map.put(new Teacher(3,"kxbb"),"99");

        Iterator<Teacher> iterator = map.keySet().iterator();
        while (iterator.hasNext()){
            Teacher next = iterator.next();
            System.out.println(next+map.get(next));
        }
    }
}
class Teacher implements Comparable<Teacher>{//比较要实现comparable方法
    private int age;
    private String name;

    public Teacher(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    @Override
    public int compareTo(Teacher o) {//要是Teacher o
        if (this.age>o.age){
            return 1;
        }else if (this.age<o.age){
            return -1;
        }else {
            return 0;
        }
    }
}

方法二

public class Demo6 {
    public static void main(String[] args) {
        TreeMap<man,String> map = new TreeMap<>(new Comparator<man>() {
            @Override
            public int compare(man o1, man o2) {
                if (o1.getAge()>o2.getAge()){
                    return 1;
                }else if (o1.getAge()<o2.getAge()){
                    return -1;
                }else
                return 0;


                /*if (o1 instanceof man && o2 instanceof man){
                    man t1 = (man)o1;
                    man t2 = (man)o2;
                    return Integer.compare(t1.getAge(), t2.getAge());
                }
                return 0;*/

                
            }
        });
        map.put(new man(1,"kxbb"),"99");
        map.put(new man(2,"kxbb"),"99");
        map.put(new man(1,"dddd"),"99");//会覆盖
        map.put(new man(3,"kxbb"),"99");

        Iterator<man> iterator = map.keySet().iterator();
        while (iterator.hasNext()){
            man next = iterator.next();
            System.out.println(next+map.get(next));
        }
    }
}


class man {
    private int age;
    private String name;

    public man(int age, String name) {
        this.age = age;
        this.name = name;
    }

    @Override
    public String toString() {
        return "man{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

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

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

小知识点：

HashMap：线程不安全，效率高，允许key或value为null。

Hashtable：线程安全，效率低，不允许key或value为null。

工具类：Collections

常用方法：

1:排序（Sort）自然排序

2:混排（Shuffling）打乱

3:反转（Reverse）反着自然排序

4:替换所有的元素（Fill）指定集合替换所有元素

斗地主案列

1.Map

public class Demo7 {
    public static void main(String[] args) {
        //1.创建一个牌盒
        HashMap<Integer,String> map = new HashMap<>();

        //2,创建两个集合放颜色和数字
        ArrayList<String> colors = new ArrayList<>();
        ArrayList<String> numbers = new ArrayList<>();

        //3,给花色，数字赋值   ♥♠♣♦  用工具类COLLECTIONS 方法
        Collections.addAll(colors,"♥","♠","♣","♦");
        Collections.addAll(numbers,"3","4","5","6","7","8","9","10","J","Q","K","A","2");

        //4，装大小王
        int index = 0;
        map.put(index,"大王");
        index++;
        map.put(index,"小王");
        index++;

        //5.嵌套遍历两个集合,生产出所有的牌,并存入map集合
        //外层遍历数字,内层遍历花色
        for (String number : numbers) {
            for (String color : colors) {
                String s = color + number;
                //存入map
                map.put(index,s);
                //计数
                index++;
            }
        }

        //6,洗牌
        //6.1得到所有牌的序号
        Set<Integer> integers = map.keySet();
        ArrayList<Integer> list = new ArrayList<>(integers);

        //6,2洗牌
        Collections.shuffle(list);

        //7,发牌
        ArrayList<Integer> kxbb = new ArrayList<>();//1
        ArrayList<Integer> kxbd = new ArrayList<>();//2
        ArrayList<Integer> kxdb = new ArrayList<>();//3
        ArrayList<Integer> kxdd = new ArrayList<>();//底牌

        for (int i = 0; i < list.size(); i++) {
            if (i<=2){
                kxdd.add(list.get(i));
            }else if (i%3==0){
                kxbb.add(list.get(i));
            }else if (i%3==1){
                kxbd.add(list.get(i));
            }else if (i%3==2){
                kxdb.add(list.get(i));
            }
        }


        //进行系统默认排序
        Collections.sort(kxbb);
        Collections.sort(kxbd);
        Collections.sort(kxdb);
        Collections.sort(kxdd);


        //8,看牌
        for (Integer integer : kxbb) {
            String a = map.get(integer);
            System.out.print(a+" ");
        }
        System.out.println();
        for (Integer integer : kxbd) {
            String b = map.get(integer);
            System.out.print(b+" ");
        }
        System.out.println();
        for (Integer integer : kxdb) {
            String c = map.get(integer);
            System.out.print(c+" ");
        }
        System.out.println();
        for (Integer integer : kxdd) {
            String d = map.get(integer);
            System.out.print(d+" ");
        }
    }
}

2：Arrrylist

public class Work5 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("大王");
        list.add("小王");

        ArrayList<String> colors = new ArrayList<>();
        ArrayList<String> numbers = new ArrayList<>();
        colors.add("♥");
        colors.add("♦");
        colors.add("♠");
        colors.add("♣");
        for (int i = 2; i <=10 ; i++) {
            numbers.add(i+"");
        }
        numbers.add("J");
        numbers.add("Q");
        numbers.add("K");
        numbers.add("A");

        for (String color : colors) {
            for (String number : numbers) {
                list.add(color+number);
            }
        }

        Collections.shuffle(list);

        ArrayList<String> kxbb = new ArrayList<>();
        ArrayList<String> kxbd = new ArrayList<>();
        ArrayList<String> kxdb = new ArrayList<>();
        ArrayList<String> kxdd = new ArrayList<>();
        for (int i = 0; i <list.size(); i++) {
            if (i<=2){
                kxdd.add(list.get(i));
            }else if (i%3==0){
                kxbb.add(list.get(i));
            }else if (i%3==1){
                kxbd.add(list.get(i));
            }else if (i%3==2){
                kxdb.add(list.get(i));
            }
        }
        Collections.sort(kxbb);
        Collections.sort(kxbd);
        Collections.sort(kxdb);
        Collections.sort(kxdd);

        System.out.println(kxbb);
        System.out.println(kxbd);
        System.out.println(kxdb);
        System.out.println(kxdd);

    }
}

课后习题

1：

//1.往一个Map集合中添加若干元素。获取Map中的所有value.
public class Work1 {
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put(1,"a");
        map.put(2,"b");
        map.put(3,"c");
        map.put(4,"d");

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

2：

//2.使用Map集合存储自定义数据类型Car做键(有品牌和颜色)，对应的价格做值。并使用keySet和entrySet两种方式遍历Map集合
public class Work2 {
    public static void main(String[] args) {
        Map<Car,Integer> map = new HashMap<>();
        map.put(new Car("兰博基尼",'橙'),100);
        map.put(new Car("柯尼塞格",'蓝'),200);
        map.put(new Car("法拉利",'黄'),300);
        map.put(new Car("布加迪",'红'),400);
        Iterator<Car> iterator = map.keySet().iterator();
        while (iterator.hasNext()){
            Car next = iterator.next();
            System.out.println(next+" "+map.get(next));
        }
    }
}
class Car{
    private String name;
    private char color;

    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", color=" + color +
                '}';
    }

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

    @Override
    public int hashCode() {
        return Objects.hash(name, color);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public char getColor() {
        return color;
    }

    public void setColor(char color) {
        this.color = color;
    }

    public Car(String name, char color) {
        this.name = name;
        this.color = color;
    }
}

3：

//3.现在有一个map集合如下：
//Map<Integer,String> map =?new?HashMap<Integer, String>();
//map.put(1,"张三丰");
//map.put(2,"周芷若");
//map.put(3,"汪峰");
//map.put(4,"灭绝师太");
//要求：
//1.遍历集合，并将序号与对应人名打印。
//2.向该map集合中插入一个编码为5姓名为李晓红的信息
//3.移除该map中的编号为1的信息
//4.将map集合中编号为2的姓名信息修改为"周林"
public class Work3 {
    public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<>();
        map.put(1,"张三丰");
        map.put(2,"周芷若");
        map.put(3,"汪峰");
        map.put(4,"灭绝师太");

        Iterator<Integer> iterator = map.keySet().iterator();
        while (iterator.hasNext()){
            Integer next = iterator.next();
            System.out.println("序号:"+next+"   名字:"+map.get(next));
        }

        map.put(5,"李晓红");

        map.remove(1);

        map.put(2,"周林");

        while (iterator.hasNext()){
            Integer next = iterator.next();
            System.out.println("序号:"+next+"   名字:"+map.get(next));
        }
    }
}

这道题有点意思

4：

//4.定义一个泛型为String类型的List集合，统计该集合中每个字符出现的次数。
//
//例如：集合中有”abc " bcd”两个元素，程序最终输出格式为：“a = 1,b = 2,c = 2,d = 1”
public class Work4 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("abc");
        list.add("bcd");
        String s = "";
        for (int i = 0; i< list.size(); i++) {
            s += list.get(i);
        }
        Map<Character,Integer> map = new HashMap<>();
        char[] chars = s.toCharArray();
        for (char c : chars) {
            boolean b = map.containsKey(c);
            if (b){
                map.put(c,map.get(c)+1);
            }else {
                map.put(c,1);
            }
        }
        Iterator<Character> iterator = map.keySet().iterator();
        while (iterator.hasNext()){
            Character next = iterator.next();
            System.out.println(next+"="+map.get(next));
        }
    }
}