Java集合-Map

时间  2020-07-10
标签 java 集合 map 栏目 Java 繁體版
原文   原文链接

Map集合

特色

  • 双列集合<K,V>
  • Key 和 Value一一对应
  • K不容许重复，V能够重复
  • K,V的数据类型能够相同，也可不一样

经常使用方法

方法 描述
V put(K key, V value) 将指定的值与该映射中的指定键相关联（可选操做）。
V remove(Object key) 若是存在（从可选的操做），从该地图中删除一个键的映射。
V get(Object key) 返回到指定键所映射的值，或 null若是此映射包含该键的映射。
boolean containsKey(Object key) 若是此映射包含指定键的映射，则返回 true 。
Set keySet() 返回此地图中包含的键的Set视图。
Set<Map.Entry<K,V>> entrySet() 返回此地图中包含的映射的Set视图。

内部接口：Entry<K,V>java

做用：当Map集合建立，就会建立一个Entry对象，用来存储键值对。面试

测试代码

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

/**
 * 测试Map集合的经常使用方法
 * add、remove、get、containKey、keySet、entrySet
 */
public class TestMap {
    public static void main(String[] args) {
        HashMap<String, String> map = new HashMap<>();
        // put的返回值是被替代的V，若是原来没有就是null
        System.out.println(map.put("1001", "张三"));
        System.out.println(map.put("1001", "张三丰"));
        map.put("1002", "李四");
        map.put("1003", "王五");
        System.out.println(map);

        // remove返回被删除的V,Key不存在则返回null
        System.out.println(map.remove("1005"));
        System.out.println(map.remove("1003"));
        System.out.println(map);

        // get返回key对应的value, 无则null
        System.out.println(map.get("1002"));
        System.out.println(map.get("1003"));
        // containsKey 包含key返回true
        System.out.println(map.containsKey("1002"));
        System.out.println(map.containsKey("1003"));

        System.out.println("遍历方式1：将全部key取出来存到set集合");
        Set<String> keys = map.keySet();
        for (String key : keys) {
            System.out.println("K:"+key+" V:"+map.get(key));
        }

        System.out.println("遍历方式2：将全部Entry<K,V>对象取出来存到set集合");
        for (Map.Entry<String, String> entry : map.entrySet()) {
            System.out.println(entry.getKey() + "=" + entry.getValue());
        }
    }
}

运行结果数组

null
张三
{1003=王五, 1002=李四, 1001=张三丰}
null
王五
{1002=李四, 1001=张三丰}
李四
null
true
false
遍历方式1：将全部key取出来存到set集合
K:1002 V:李四
K:1001 V:张三丰
遍历方式2：将全部Entry<K,V>对象取出来存到set集合
1002=李四
1001=张三丰

HashMap（重点）

基于哈希表的实现的Map接口。 此实现提供了全部可选的Map操做，并容许null值和null键。安全

底层原理

底层是哈希表，查询速度超级快！多线程

JDK8以前：数组+链表ide

JDK8以后：数组+链表 / 数组+红黑树学习

HashMap面试须要更深的理解，深刻底层！测试

目前停留于了解原理，掌握运用。this

测试代码

存储自定义对象

首先建立一个学生类线程

package map;

public class Student{
    private int id;
    private String name;
    private int age;

    public Student() {
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    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{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

测试类

package map;
import java.util.HashMap;

/**
 * 若以自定义类做键存放，必须说明键重复的规则
 * 实体类重写hashCode方法和equals方法
 * 好比学生类中，同名不必定是同一个对象，同窗号说明是同一个学生
 */
public class TestHashMap {
    public static void main(String[] args) {
        Student student1 = new Student(1001, "张三", 18);
        Student student2 = new Student(1002, "李四", 17);
        Student student3 = new Student(1001, "张三", 19);
        Student student4 = new Student(1004, "李四", 20);
        HashMap<Student, String> map = new HashMap<>();
        map.put(student1, "第一名");
        map.put(student2, "第二名");
        map.put(student3, "第三名");
        map.put(student4, "第四名");
        System.out.println(map);
    }
}

运行结果

{Student{id=1004, name='李四', age=20}=第四名, Student{id=1002, name='李四', age=17}=第二名, Student{id=1001, name='张三', age=18}=第一名, Student{id=1001, name='张三', age=19}=第三名}

此时观察student1 和 student3 的学号相同，对象重复，为何还会添加到map中呢？

image-20200709162818912

有提示要重写Student类的hashCode方法和equals方法。

修改后的Student.java

package map;

import java.util.Objects;

public class Student{
    private int id;
    private String name;
    private int age;

    public Student() {
    }

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

    // ...get/set省略
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return id == student.id;
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}

再次运行测试类的代码获得的结果

{Student{id=1001, name='张三', age=18}=第三名, Student{id=1002, name='李四', age=17}=第二名, Student{id=1004, name='李四', age=20}=第四名}

分析：第一次添加1001学生时，value是第一名，再次遇到1001学生，覆盖了原来的value

深刻理解HashMap

更加详细的学习会写到另外一篇

LinkedHashMap

哈希表和链表实现的Map接口，具备可预测的迭代次序。有序集合！

public class LinkedHashMap<K,V>extends HashMap<K,V>implements Map<K,V>{}

底层原理

  • 哈希表 -> 继承自HashMap
  • 链表 -> 记录元素顺序

测试代码

import java.util.*;

public class TestLinkedHashMap {
    public static void main(String[] args) {
        HashMap<String, String> map = new HashMap<>();
        map.put("1001", "张三");
        map.put("1002", "李四");
        map.put("1003", "王五");
        map.put("1004", "赵六");
        System.out.println("map的数据无序，取出的结果与存入顺序不一致：");
        System.out.println(map);
        System.out.println();

        LinkedHashMap<String, String> link = new LinkedHashMap<>();
        link.put("1001", "张三");
        link.put("1002", "李四");
        link.put("1003", "王五");
        link.put("1004", "赵六");
        System.out.println("在map外层加一层链表记录元素存入的顺序：");
        System.out.println(link);
    }
}

运行结果

map的数据无序，取出的结果与存入顺序不一致：
{1004=赵六, 1003=王五, 1002=李四, 1001=张三}

在map外层加一层链表记录元素存入的顺序：
{1001=张三, 1002=李四, 1003=王五, 1004=赵六}

Hashtable

Hashtable 和 Vector 同样都是上古级别的集合，在jdk1.2版本以后被更先进的HashMap及ArrayList集合取代。

值得注意的是，Hashtable的子类Properties目前依旧活跃着，它是惟一和IO流结合的集合。

Hashtable 与 HashMap 的区别

底层都是哈希表，元老级更注重线程安全。

Hashtable

  • 线程安全—>单线程集合—>速度慢
  • 不能存储 null ，K,V都不能够

HashMap

  • 线程不安全—>多线程集合—>速度快
  • 能够存储 null
    • K 只能存储一个 null ，保证K的惟一性
    • V 能够存储任意个 null

测试代码

import java.util.HashMap;
import java.util.Hashtable;

public class TestHashtable {
    public static void main(String[] args) {
        HashMap<String, String> map = new HashMap<>();
        map.put(null, null);
        map.put("A", null);
        map.put(null, "B");
        System.out.println(map);

        Hashtable<String, String> table = new Hashtable<>();
        //table.put(null, null);//NullPointerException
        //table.put("A", null);//NullPointerException
        //table.put(null, "B");//NullPointerException
        System.out.println(table);
    }
}

运行结果

{null=B, A=null}
{}

HashMap中以null做为键时，再次添加null的键会覆盖以前的value值。

Hashtable只要涉及到null，就会报空指针异常。

集合练习

  1. 判断字符串中某个字符出现的次数

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

/**
 * 判断字符串中某个字符出现的次数
 */
public class MapPractice {
    public static void main(String[] args) {
        Map<Character, Integer> map = new LinkedHashMap<>();
//        Scanner sc = new Scanner(System.in);
//        String str = sc.nextLine();
        String str = "aaabbcdaabb";
        char[] chars = str.toCharArray();
        for (char ch : chars) {
            if (map.get(ch) == null) {
                map.put(ch, 1);
            } else {
                int count = map.get(ch);
                map.put(ch, ++count);
            }
        }
        // 使用linkedHashMap保证从前日后统计的顺序
        System.out.println(map);
    }
}

  2. 斗地主发牌

    import java.util.*;

/**
 * 扑克发牌并按大小排序
 */
public class PracticePoker {
    public static void main(String[] args) {
        // 存放索引的map，一个索引对应一张牌，按照必定规则定制
        Map<Integer, String> map = new HashMap<>();

        // 存放牌色♠♥♦♣、数字的列表
        List<String> colors = new ArrayList<>();
        List<String> numbers = new ArrayList<>();
        Collections.addAll(colors, "♠", "♥", "♣", "♦");
        Collections.addAll(numbers, "2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3");

        // 创建索引与牌的映射 0-"大王" 1-"小王" 2-"2♠" 3-"2♥" ...
        int idx = 0;
        map.put(idx++, "大王");
        map.put(idx++, "小王");
        for (String number : numbers) {
            for (String color : colors) {
                map.put(idx++, number + color);
                //System.out.print(number + color + " ");
            }
        }

        // 发牌发的是索引，便于比大小 , 由于set是无序的，不能洗牌
        Set<Integer> idxSet = map.keySet();
        ArrayList<Integer> idxList = new ArrayList<>(idxSet);
        // System.out.println("洗牌前" + idxList);
        Collections.shuffle(idxList);
        // System.out.println("洗牌后" + idxList);

        // 玩家的牌用列表接收，便于排序
        ArrayList<Integer> playA = new ArrayList<>();
        ArrayList<Integer> playB = new ArrayList<>();
        ArrayList<Integer> playC = new ArrayList<>();
        ArrayList<Integer> special = new ArrayList<>();

        // 发牌
        special.add(idxList.get(0));
        special.add(idxList.get(1));
        special.add(idxList.get(2));
        for (int i = 3; i < idxList.size(); i++) {
            if (i % 3 == 0) {
                playA.add(idxList.get(i));
            } else if (i % 3 == 1) {
                playB.add(idxList.get(i));
            } else if (i % 3 == 2) {
                playC.add(idxList.get(i));
            }
        }
        // 排序
        Collections.sort(playA);
        Collections.sort(playB);
        Collections.sort(playC);
        Collections.sort(special);

        // 看牌
        lookPoker("刘德华", playA, map);
        lookPoker("周润发", playB, map);
        lookPoker("周星驰", playC, map);
        lookPoker("底牌", special, map);
    }

    public static void lookPoker(String name, List<Integer> idxList, Map<Integer, String> poker) {
        System.out.print(name + "的牌为：");
        for (Integer idx : idxList) {
            System.out.print(poker.get(idx) + " ");
        }
        System.out.println();
    }
}

    结果

    刘德华的牌为：2♥ 2♦ A♥ A♣ A♦ K♠ K♦ Q♥ J♠ 10♠ 8♥ 8♦ 7♠ 6♣ 5♣ 4♣ 3♥ 
周润发的牌为：2♠ 2♣ K♣ Q♠ J♣ J♦ 9♥ 9♦ 8♠ 7♣ 7♦ 6♥ 5♠ 5♥ 4♥ 4♦ 3♠ 
周星驰的牌为：大王 小王 A♠ K♥ Q♣ Q♦ J♥ 10♣ 10♦ 9♠ 8♣ 7♥ 6♠ 6♦ 5♦ 4♠ 3♦ 
底牌的牌为：10♥ 9♣ 3♣
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程