Java学习记录（九）双列集合的学习

Map

Map集合是一种双列集合，而他的存储对象是一个个的键值对

例如：

"001","azhang"

"002","xiaolei"

这样的形式是前面为键，后面为值，一个键对应自己的值。

Map的输入数据方法

在创建Map集合的时候，因为Map是一个接口，他不能被实例化对象，所以创建的时候实际上是创建的一个相关类型的实现类，该实现类可以使用Map的相关方法

在Map集合里面添加对象使用的是put方法，而添加数据的时候往往是一对一对的添加数据，例如

"001","azhang"，添加的方式如下：

Map<String,String> m = new HashMap<>();
        //map的添加方法put，一次放入一个键值对，包括键和值
        m.put("001","azhang");
        m.put("002","xiaolei");
        m.put("003","lisi");

而在使用put方法不但可以添加数据，对已经有数据的键值对使用该方法的时候，会直接用新传入的值将之前该键所对应的值覆盖，而覆盖之后其实是会返回一个值，这个值就是被覆盖的值，代码如下：

 //put方法也能用来覆盖一个键值对的值，如下
        String str = m.put("003","我被覆盖了");
        //此时put方法会返回一个值，这个值就是被覆盖的那个值
        System.out.println(str);
        System.out.println(m);

Map集合也是有删除方法，他是根据传入键，删除相关键对应的键值对，该方法也会返回一个值，这个值就是被删除的键值对里面的值，如下：

//map也有删除方法，remove
        String str2 = m.remove("003");//这个方法是删除键值为输入数据的键值对，也会返回被删除的键值对的值
        System.out.println(str2);
        System.out.println(m);

Map集合里面也有判断相关包含的方法，

m.containsKey()判断的是该Map集合里面是否包含传入键对应的键，该方法也会返回一个boolean类型的值，如果该Map集合里面有相关键的键，返回true，否则返回false

m.containsValue()判断的是该集合里面是否包含传入数据对应的值，该方法也会返回一个boolean类型的值，如果该Map集合里面有相关键的值，返回true，否则返回false

具体实现代码如下：

        boolean b = m.containsKey("001");//判断是否包含键为传入数据，有就返回true，没有返回false
        System.out.println(b);
        boolean c = m.containsValue("azhang");//判断是否包含值为传入数据，有就返回true，没有返回false
        System.out.println(c);

遍历Map集合

一、将Map集合里面的键全部取出来，再通过取出来的键得到各自对应的值

先用keySet方法将该集合里面的所有键放入一个set集合中，后面再通过对set的遍历获得相应的键，同时在遍历的时候使用get方法获得对应键的值，具体实现如下：

增强for实现：

        //这是使用增强for的方法来遍历
        //先用keySet方法将双列集合的键放入单列集合set类型的对象中，从而得到双列集合的键
        Set<String> strings = m.keySet();
        //再用单列集合遍历的方法查找每个键以及每个键所对应的值
        for (String key : strings) {
            System.out.println(key);
            //用get方法去得到每个key键所对应的值
            String s = m.get(key);
            System.out.println(s);
        }

迭代器实现：

        //这是使用迭代器的方法来遍历
        Iterator<String> it = strings.iterator();
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
            String tempvalue = m.get(s);
            System.out.println(tempvalue);
        }

用单列集合的foreach方法重写接口里的方法实现

//使用匿名内部类的方法
        strings.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
                String s1 = m.get(s);
                System.out.println(s1);
            }
        });

二、将该集合中整个键值对一个一个的取出来放入set集合中

使用entrySet方法将该Map集合中整个键值对取出放入set集合中，再通过遍历set集合，在遍历时用Map集合自己键值对所带的getKey方法得到键，使用getValue得到值。

具体实现如下：

用增强for实现：

//还可以用entrySet方法来将键值对存储到set集合里
        Set<Map.Entry<String, String>> entries = m.entrySet();
        //这个时候就能再set集合里面用循环调用getKey方法来获取键和getValue方法来获取值
        for (Map.Entry<String, String> entry : entries) {
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + " " + value);
        }

用迭代器实现

//这是使用迭代器的方法来遍历
        Iterator<Map.Entry<String, String>> it2 = entries.iterator();
        while(it2.hasNext()){
            Map.Entry<String, String> next = it2.next();
            System.out.println(next.getKey()+ "="+next.getValue());
        }

用set集合的foreach方法实现对接口内部的方法重写实现，这种方法

entries.forEach(new Consumer<Map.Entry<String, String>>() {
            @Override
            public void accept(Map.Entry<String, String> stringStringEntry) {
                System.out.println(stringStringEntry.getKey()+"="+stringStringEntry.getValue());
            }
        });

三、Map集合的第三种遍历方式

使用map集合里自带的foreach方法进行遍历，并重写所对应的接口里的方法，这个重写方法会返回两个值，而这两个值就是我们map集合里面的每一对键和值，这样也能遍历咱们的map集合

代码实现如下：

//使用map集合里的foreach方法进行遍历
        m.forEach(new BiConsumer<String, String>() {
            @Override
            public void accept(String s, String s2) {
                System.out.println(s+ "="+ s2);
            }
        });

Hashmap

Hashmap是map集合的一个实现类，这个实现类可以使用map集合里所有的方法

Hashmap也遵循无序，不重复，无索引特点，但是这仅仅是指的是键，也就是说Hashmap所自带的属性只与集合里键值对的键相关，值不满足该特性。他的底层原理跟Hashset一样，但唯一有区别的就是在存入数据的时候，他只会用键来进行哈希运算，从而找到所对应的数组位置，但是因为他存入数据时采用的是put方法，所以如果键相同，他就会存储到相同数组下的位置，这个时候由于put的覆盖性，键相同时，后来的键的值会覆盖掉前一个值

同样，在写入数据的键不是基础数据类型我们需要重写他的equals方法和hashCode方法，因为是自定义的数据类型的话，他会默认用地址值来进行比较，而不是键

（注意：整个Hashset在存入数据的时候一直考虑的是键，所有的值不参与存入时的计算）

下面是一个Hashmap的小案例，要求10个学生投票"A","B","C","D",要求求出哪个字母的投票数最多，并且打印出投票数最多的字母。（按照题目要求，一个字母对应一个投票数，跟我们的Map集合里面的键值对非常接近，所以我们用创建map集合的实现类对象也就是Hashmap来实现）

具体代码如下：

package com.itazhang.map02;

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

public class HashmapDemo3 {
    public static void main(String[] args) {
        Map<Student,Character> m = new HashMap<>();
        Student stu1 = new Student("lei",22);
        Student stu2 = new Student("azhang",23);
        Student stu3 = new Student("aaa",22);
        Student stu4 = new Student("bbb",22);
        Student stu5 = new Student("ccc",22);
        Student stu6 = new Student("ddd",22);
        Student stu7 = new Student("eee",22);
        Student stu8 = new Student("fff",22);
        Student stu9 = new Student("ggg",22);
        Student stu10 = new Student("hhh",22);
        m.put(stu1,'A');
        m.put(stu2,'B');
        m.put(stu3,'C');
        m.put(stu4,'D');
        m.put(stu5,'A');
        m.put(stu6,'B');
        m.put(stu7,'C');
        m.put(stu8,'D');
        m.put(stu9,'A');
        m.put(stu10,'A');
        int count1=0,count2=0,count3=0,count4=0;
        Set<Map.Entry<Student, Character>> entries = m.entrySet();
        for (Map.Entry<Student, Character> entry : entries) {
            if(entry.getValue()=='A'){
                count1++;
            }else if(entry.getValue() == 'B'){
                count2++;
            }else if(entry.getValue() == 'C'){
                count3++;
            }else if(entry.getValue() == 'D'){
                count4++;
            }
        }
        Map<Character,Integer> m2 = new HashMap<>();
        m2.put('A',count1);
        m2.put('B',count2);
        m2.put('C',count3);
        m2.put('D',count4);
        int max =0;
        char temp='A';
        Set<Map.Entry<Character, Integer>> entries1 = m2.entrySet();
        for (Map.Entry<Character, Integer> characterIntegerEntry : entries1) {
            if(characterIntegerEntry.getValue()>max){
                max = characterIntegerEntry.getValue();
            };
            if(max == characterIntegerEntry.getValue()){
                temp = characterIntegerEntry.getKey();
            }
        }
        System.out.println(temp+" "+max);
    }
}

LinkedHashmap

这个结构是在Hashmap的基础上增加了一个用于存储该地址的值，也就是各个键值对之间组成了双链表，这样就会得到有序，不重复，无索引特点。这种结构就会怎么存储，怎么取出，存入的顺序跟取出的顺序相同。

具体代码实现如下：这个时候添加的顺序就会跟输出的顺序一样

package com.itazhang.map02;

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

public class HashmapDemo4 {
    public static void main(String[] args) {
        Map<String,String> m = new LinkedHashMap<>();
        m.put("001","aaa");
        m.put("002","bbb");
        m.put("003","ccc");
        m.put("004","ddd");
        m.put("005","eee");
        System.out.println(m);
    }
}

Treemap

底层是红黑树结构，同样的他的属性由键决定

键：不重复，无索引，可排序

他的排序是对键值对中的键进行排序，跟值无关，同时他也满足Tree结构的特点，他会在输入数据的时候对数据进行自动排序，在输入键是默认数据类型时，他会采用默认的比较方法进行比较，而如果输入的键是自定义的数据类型时，他会根据创建Treemap时所提供的比较器里面的内容来进行排序例如：

TreeMap<Student,String> m =new TreeMap<>(new Comparator<Student>() {
    @Override
    public int compare(Student o1, Student o2) {
       int i = o1.getAge()-o2.getAge();
       i = i == 0? o1.getName().compareTo(o2.getName()):i;
       return i;
    }
});

下面为具体实现案例代码，要求存入学生对象，学生对象为键，学生籍贯为值，且输出时按照学生年龄的升序排列，年龄一样按照姓名的字母排列，同姓名年龄视为同一个人。

package com.itazhang.map03;

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

public class Test1 {
    public static void main(String[] args) {
        TreeMap<Student,String> m =new TreeMap<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
               int i = o1.getAge()-o2.getAge();
               i = i == 0? o1.getName().compareTo(o2.getName()):i;
               return i;
            }
        });
        Student stu1 = new Student("azhang",20);
        Student stu2 = new Student("lei",21);
        Student stu3 = new Student("wangwu",21);
        Student stu4 = new Student("lisi",23);
        Student stu5 = new Student("lisi",23);
        m.put(stu1,"四川");
        m.put(stu2,"江苏");
        m.put(stu3,"重庆");
        m.put(stu4,"湖北");
        m.put(stu5,"山东");
        m.forEach(new BiConsumer<Student, String>() {
            @Override
            public void accept(Student student, String s) {
                System.out.println(student + s);
            }
        });
    }
}

以下为一个案例练习，要求统计"aababcabcdabcde"中字符出现的次数，并按照以下格式输出

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

具体实现代码如下：具体比较规则在创建Treemap时将比较器写入

package com.itazhang.map03;

import java.util.Comparator;
import java.util.TreeMap;
import java.util.function.BiConsumer;

public class TreemapDemo1 {
    public static void main(String[] args) {
        String str = "aababcabcdabcde";
        TreeMap<Character,Integer> m =new TreeMap<>(new Comparator<Character>() {
            @Override
            public int compare(Character o1, Character o2) {
                int i = o1-o2;
                return i;
            }
        });

        int count1= 1,count2=1,count3=1,count4=1,count5=1;
        for (int i = 0; i < str.length(); i++) {
            switch (str.charAt(i)){
                case 'a'->{
                    m.put('a',count1);
                    count1++;
                }
                case 'b'->{
                    m.put('b',count2);
                    count2++;
                }
                case 'c'->{
                    m.put('c',count3);
                    count3++;
                }
                case 'd'->{
                    m.put('d',count4);
                    count4++;
                }
                case 'e'->{
                    m.put('e',count5);
                    count5++;
                }
            }
        }
        m.forEach(new BiConsumer<Character, Integer>() {
            @Override
            public void accept(Character character, Integer integer) {
                System.out.print(character+ " "+"("+integer+")"+" ");
            }
        });
    }
}