Java入门-14、Map集合及其子类

Map集合

Map 中的集合，元素是成对存在的 。每个元素由键与值两部分组成，通过键可以找对所对应的值。Map 中的集合称为双列集合。

需要注意的是， Map 中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。

 

相比Collection集合，Collection集合称为单列集合，采用一个个元素的方式进行存储。

 

 

Map的常用子类（HashMap、LinkedHashMap）

 

 

HashMap ：

特点：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode() 方法、 equals() 方法。

 

常用方法：

public V put(K key, V value) : 把指定的键与指定的值添加到 Map 集合中。

public V remove(Object key) : 把指定的键 所对应的键值对元素 在 Map 集合中删除，返回被删除元素的 值。

public V get(Object key) 根据指定的键，在 Map 集合中获取对应的值。

public Set<K> keySet() : 获取 Map 集合中所有的键，存储到 Set 集合中。

public Set<Map.Entry<K,V>> entrySet() : 获取到 Map 集合中所有的键值对对象的集合 (Set 集合 ) 。

 

 

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

class Person {

    private String name;

    private Integer age;

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

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

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

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

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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


public class MapDemo01 {
    public static void main(String[] args) {
        Person person = new Person("张三", 20);
        Person person1 = new Person("李四", 19);
        Person person2 = new Person("王五", 23);

        HashMap<String, Person> map = new HashMap<String, Person>();
        //添加元素
        map.put("001", person);
        map.put("002", person1);
        map.put("003", person2);

        System.out.println(map);
        //移除指定键值对元素
        map.remove("003");

        //根据指定的键，在Map集合中获取对应的值。
        System.out.println(map.get("002"));


        //获取Map集合中所有的键，存储到Set集合中。
        Set<String> set = map.keySet();
        System.out.println(set);

        //获取到Map集合中所有的键值对对象的集合(Set集合)。
        Set<Map.Entry<String, Person>> entrySet = map.entrySet();
        System.out.println(entrySet);

        //判断该集合中是否有此键。
        System.out.println(map.containsKey("001"));

        //遍历
        Set<String> set1 =map.keySet();
        for (String s : set1) {
            Person person3 =map.get(s);
            System.out.println(s+"====="+person3);
        }

    }
}

LinkedHashMap ：

特点： 存储数据采用的哈希表结构 + 链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的 hashCode()方法、equals() 方法。

 

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;

public class LinkedHashMapDemo01 {
    public static void main(String[] args) {
        LinkedHashMap<String, String> map = new LinkedHashMap<String, String>();
        map.put("001", "小红");
        map.put("002", "小冰");
        map.put("003", "小白");
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        for (Map.Entry<String, String> entry : entrySet) {
            System.out.println(entry.getKey() + " " + entry.getValue());
        }
    }
}