Java中的Map_java map put return-优快云博客

本文链接：https://blog.youkuaiyun.com/M_ount/article/details/79155963

Map：

1.双列集合的根接口
2.以键值对形式保存数据（key---value）
3.键保持唯一

这里写图片描述

举例：

public static void fun() {
    HashMap<String,Integer> map = new HasMap<>();
    Integer i1 = map.put("张三", 15);
    Integer i2 = map.put("张三", 20);
    Integer i3 = map.put("李四", 16);
    Integer i4 = map.put("王五", 14);
    System.out.println(map);
    System.out.println(i1);
    System.out.println(i2);
    System.out.println(i3);
    System.out.println(i4);
}

运行结果：

{张三=20, 李四=16, 王五=14}
null
15
null
null

HashMap：

HashSet与HashMap的联系：

1.底层都是哈希算法 
2.根据HashSet中add(E e) 方法内部执行
  public boolean add(E e) {
      return map.put(e, PRESENT)==null;
  }
  得出结论：
  HashSet底层是依赖HashMap去实现的
  添加到Set中的值，实际是添加到Map键的位置

HashMap中的基础方法：

public static void fun() {
    HashMap<String, Integer> map = new HashMap<>();
    map.put("张三", 15);
    map.put("李四", 15);
    map.put("王五", 16);
    map.put("赵六", 18);
    System.out.println(map);
    //  值找键
    boolean key = map.containsKey("王五");
    System.out.println(key);
    //  键找值
    boolean value = map.containsValue(16);
    System.out.println(value);
    //  键获取对应值
    Integer value = map.get("张三");
    System.out.println(value);
    //  key的集合
    Set<String> key = map.keySet();
    System.out.println(key);
    //  value的集合
    Collection<Integer> values = map.values();
    System.out.println(values);
    //  key删除整个键值对
    Integer remove = map.remove("赵六");
    System.out.println(remove);
    System.out.println(map);
    //  清空map
    map.clear();
    System.out.println(map);
}

运行结果：

{李四=15, 张三=15, 王五=16, 赵六=18}
true
true
15
null
[李四, 张三, 王五, 赵六]
[15, 15, 16, 18]
18
{李四=15, 张三=15, 王五=16}
{}

几种遍历Map的方法：

public static void fun() {
    HashMap<String, Integer> map = new HashMap<>();
    map.put("张三", 15);
    map.put("李四", 15);
    map.put("王五", 16);
    map.put("赵六", 18);

    /*方法一
    //  将键转换成Set遍历
    Set<String> key = map.keySet();
    //  迭代器
    Iterator<String> iterator = key.iterator();
    while(iterator.hasNext()) {
        String key = iterator.next();
        Integer value = map.get(key);
        System.out.println(key + "=" + value);
    }
    */

    /*方法二
    //  foreach
    Set<String> keySet = map.keySet();
    for(String key : keySet) {
        Integer value = map.get(key);
        System.out.println(key + "=" + value);
    }
    */

    /*方法三
    //  Entry<K, V>
    Set<Entry<String, Integer>> entrySet = map.entrySet();
    Iterator<Entry<String, Integer>> iterator = entrySet.iterator();
    while (iterator.hasNext()) {
        Entry<String, Integer> entry = iterator.next();
        String key = entry.getKey();
        Integer value = entry.getValue();
        System.out.println(key + "=" + value);
    }
    */

    //  Entry<K, V>与foreach连用
    Set<Entry<String, Integer>> entrySet = map.entrySet();
    for (Entry<String, Integer> entry : entrySet) {
        String key = entry.getKey();
        Integer value = entry.getValue();
        System.out.println(key + "=" + value);
    }
}

运行结果：

李四=15
张三=15
王五=16
赵六=18

HashMap去重：

/*
 * 学生类
 */
public class 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 "姓名：" + name + ", 年龄：" + age + " ";
    }
    @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;
    }
}

//  创建一个map key保存学生 value保留 户籍
public static void fun() {
    HashMap<Student, String> hashMap = new HashMap<>();
    hashMap.put(new Student("张三", 24), "江苏");
    hashMap.put(new Student("张三", 24), "浙江");
    hashMap.put(new Student("李四", 26), "安徽");
    hashMap.put(new Student("王五", 22), "河南");
    System.out.println(hashMap);
}

运行结果：

{姓名：李四, 年龄：26 =安徽, 姓名：张三, 年龄：24 =浙江, 姓名：王五, 年龄：22 =河南}

结论：

1.key相同时，map重写，value会被新值覆盖
2.要去重就要重写hashCode和equals

练习：

需求：
键盘输入字符串 统计字符串中每个字符出现的次数

public static void fun() {
    System.out.println("请输入一个字符串：");
    Scanner scanner = new Scanner(System.in);
    String string = scanner.nextLine();
    //  获取每个字符串
    char[] array = string.toCharArray();
    HashMap<Character, Integer> map = new HashMap<>();
    for(i = 0; i < array.length; i++) {
        char key = array[i];
        if(!map.containsKey(key){
            map.put(key, 1);
        }else {
            Integer value = map.get(key);
            value = value + 1;
            map.put(key, value);
        }
    }
    scanner.close();
    System.out.println(map);
}

运行结果：

请输入一个字符串：
asdadadsasdasdasdasd
{a=7, s=6, d=7}

LinkedHashMap:

特点：有序 打印时，按输入顺序打印

public static void fun() {
    LinkedHashMap<String, Integer> map = new LinkedHashMap<>();
    map.put("张三", 15);
    map.put("李四", 15);
    map.put("王五", 15);
    map.put("赵六", 15);
    System.out.println(map);
}

运行结果：

{张三=15, 李四=15, 王五=15, 赵六=15}

TreeMap：

public static void fun() {
    TreeMap<Student, String> map = new TreeMap<>();
    map.put(new Student("张三", 15), "江苏");
    map.put(new Student("李四", 18), "安徽");
    map.put(new Student("王五", 13), "湖南");
    map.put(new Student("赵六", 19), "浙江");
    System.out.println(map);
}

TreeMap中要进行对象属性排序，要继承Comparable<>接口，重写compareTo()方法

运行结果：

{姓名：王五, 年龄：13 =湖南, 姓名：张三, 年龄：15 =江苏, 姓名：李四, 年龄：18 =安徽, 姓名：赵六, 年龄：19 =浙江}

Collections类中方法：

public static void fun3() {
    ArrayList<Integer> list = new ArrayList<>();
    list.add(10);
    list.add(15);
    list.add(14);
    list.add(18);
    //  随机交换集合中值得位置
    Collections.shuffle(list);
    System.out.println(list);
    //  排序
    Collections.sort(list);
    System.out.println(list);
    //  查找
    int index = Collections.binarySearch(list, 15);
    System.out.println(index);  
    //  反转集合
    Collections.reverse(list);
    System.out.println(list);
}

运行结果：

[18, 10, 14, 15]
[10, 14, 15, 18]
2
[18, 15, 14, 10]

综合练习：

/*
 * 模拟三人斗地主：洗牌；发牌；看牌。
 * /

//  ArrayList<>方法
public static void fun() {
    ArrayList<String> pokers = new ArrayList<>();
    String[] s1 = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
    String[] s2 = {"黑桃","红桃","梅花","方块"};
    for (int i = 0; i < s1.length; i++) {
        for (int j = 0; j < s2.length; j++) {
            String pokerStr = s2[j] + s1[i];
            pokers.add(pokerStr);
        }
    }
    pokers.add("大王");
    pokers.add("小王");
    Collections.shuffle(pokers);
    ArrayList<String> list1 = new ArrayList<>();
    ArrayList<String> list2 = new ArrayList<>();
    ArrayList<String> list3 = new ArrayList<>();        
    ArrayList<String> dipai = new ArrayList<>();
    for (int i = 0; i < pokers.size(); i++) {
        String poker = pokers.get(i);
        if (i >= pokers.size() - 3) {
            dipai.add(poker);
        }else if (i % 3 == 0) {
            list1.add(poker);
        }else if (i % 3 == 1) {
            list2.add(poker);
        }else {
            list3.add(poker);
        }
    }
    System.out.println(list1);
    System.out.println(list2);
    System.out.println(list3);
    System.out.println(dipai);
}

运行结果：

[红桃A, 方块J, 黑桃6, 黑桃8, 黑桃K, 红桃K, 方块3, 方块K, 黑桃Q, 方块8, 方块Q, 红桃10, 黑桃2, 黑桃5, 红桃7, 红桃J, 黑桃9]
[红桃8, 方块6, 梅花K, 梅花Q, 黑桃A, 红桃4, 黑桃3, 黑桃7, 梅花9, 梅花4, 红桃5, 梅花6, 大王, 方块2, 黑桃4, 红桃6, 红桃3]
[方块5, 梅花10, 红桃Q, 方块9, 梅花A, 梅花2, 黑桃J, 方块4, 梅花3, 红桃2, 方块10, 红桃9, 方块A, 梅花5, 方块7, 小王, 梅花J]
[梅花8, 梅花7, 黑桃10]

缺点：

无法给发到手的牌进行排序

//  HashMap<K, V>方法
public static void fun() {
    HashMap<Integer, String> pokers = new HashMap<>();
    ArrayList<Integer> list = new ArrayList<>();
    int index = 0;
    String[] card = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
    String[] huaSe = {"黑桃","红桃","梅花","方块"};
    for (int i = 0; i < card.length ; i++) {
        for (int j = 0; j < huaSe.length; j++) {
            String string = huaSe[j] + card[i];
            pokers.put(index, string);
            list.add(index);
            index++;
        }
    }
    pokers.put(index, "小王");
    list.add(index);
    index++;
    pokers.put(index, "大王");
    list.add(index);
    Collections.shuffle(list);
    TreeSet<Integer> one = new TreeSet<>();
    TreeSet<Integer> two = new TreeSet<>();
    TreeSet<Integer> three = new TreeSet<>();
    TreeSet<Integer> dipai = new TreeSet<>();
    for (int i = 0; i < list.size(); i++) {
        int num = list.get(i);
        if (i >= pokers.size() - 3) {
            dipai.add(num);
        }else if (i % 3 == 0) {
            one.add(num);
        }else if (i % 3 == 1) {
            two.add(num);
        }else {
            three.add(num);
        }
    }
    lookPoker(pokers, one, "张三");
    lookPoker(pokers, two, "李四");
    lookPoker(pokers, three, "王五");
    lookPoker(pokers, dipai, "底牌");
}

public static void lookPoker(HashMap<Integer, String> pokers, TreeSet<Integer> set, String name) {
    System.out.println(name + "的手牌是：");
    for (Integer key : set) {
        String string = pokers.get(key);
        System.out.print(string + " ");
    }
    System.out.println();
}

运行结果：

张三的手牌是：
方块3 黑桃4 方块6 梅花7 方块8 方块9 红桃10 梅花10 红桃J 梅花J 方块J 红桃Q 梅花Q 方块K 黑桃A 黑桃2 红桃2 
李四的手牌是：
红桃3 梅花3 方块4 黑桃5 方块5 梅花6 红桃7 方块7 梅花8 梅花9 方块10 黑桃J 黑桃Q 黑桃K 梅花K 梅花2 小王 
王五的手牌是：
黑桃3 红桃4 梅花4 红桃5 梅花5 黑桃6 红桃6 黑桃7 红桃8 黑桃9 红桃9 黑桃10 红桃A 梅花A 方块A 方块2 大王 
底牌的手牌是：
黑桃8 方块Q 红桃K

Map的嵌套：

public static void fun() {
    HashMap<Student, String> classes1 = new HashMap<>();
    classes1.put(new Student("张三", 22), "上海");
    classes1.put(new Student("李四", 20), "安徽");
    classes1.put(new Student("王五", 23), "浙江");
    HashMap<Student, String> classes2 = new HashMap<>();
    classes2.put(new Student("赵六", 22), "江苏");
    classes2.put(new Student("孙七", 20), "黑龙江");
    classes2.put(new Student("周八", 23), "湖南");

    HashMap<HashMap<Student, String>, String> javaMap = new HashMap<>();
    javaMap.put(classes1, "java1班");
    javaMap.put(classes2, "java2班");

    for (HashMap<Student, String> ban : javaMap.keySet()) {
        String javaMapValue = javaMap.get(ban);
        System.out.println(javaMapValue);
        for (Student student : ban.keySet()) {
            String banValue = ban.get(student);
            System.out.println(student + "----" + banValue);
        }
        System.out.println();
    }
}

运行结果：

java1班
姓名：李四, 年龄：20 ----安徽
姓名：王五, 年龄：23 ----浙江
姓名：张三, 年龄：22 ----上海

java2班
姓名：赵六, 年龄：22 ----江苏
姓名：周八, 年龄：23 ----湖南
姓名：孙七, 年龄：20 ----黑龙江