Java容器——Map接口

1.定义

Map用于保存存在映射关系<key, value>的数据。其中key值不能重复（使用equals()方法比较），value值可以重复。

2.常用实现类

HashMap：和HashSet类似，键按键的HashCode()方法确定存储位置，无序

TreeMap：用于对键进行排序，方式与TreeSet相同

LinkedHashMap：和LinkedHashSet类似

3.方法

3.1 HashMap常用方法

void clear()：移除所有映射

Object clone()：浅拷贝原映射

boolean containsKey(Object key)：判断是否包含指定键

boolean containsValue(Object value)：判断是否包含指定值

Set<Map.Entry<K,V>> entrySet()：返回包含映射关系的set集合

V get(Object key)：查找给定键的值

boolean isEmpty()：判断是否为空

Set<K> keySet()：返回map中键的set集合

V put(K key, V value)：存入键值对

V putIfAbsent(K key, V value)：存入键值对，如果该键未存在map中

V remove(Object key)：移除给定键的键值对

boolean remove(Object key, Object value)：移除给定的键值对

V replace(K key, V value)：替换给定键的值

boolean replace(K key, V oldValue, V newValue)：如果键值对符合要求，替换新值

int size()：返回键值对数目

Collection<V> values()：返回value集合

注：Map接口没有继承Iterable接口，所以不能直接通过map.iterator进行遍历(List，Map拥有该接口，可以直接遍历)，需要先转化为set类型，使用entrySet()方法，Map.Entry<k,v>中含有方法getKey()和getValue()，获取对应的键和值。

4.示例

MapFunc.java

import java.util.*;

public class MapFunc {
    public static void main(String[] args) {

        HashMap<String, Customer> hm1 = new HashMap<>();
        hm1.put("a", new Customer(1,"AA"));
        hm1.put("b", new Customer(2,"BB"));
        hm1.put("c", new Customer(3,"CC"));
        hm1.put("d", new Customer(4,"DD"));
        hm1.put("e", new Customer(5,"EE"));

        /*
        * Map的几种遍历方法
        * keySet、values、entrySet、entrySet.iterator
        * */
        // 利用keySet()遍历
        Set<String> keys = hm1.keySet();
        System.out.println("keys= "+ keys);  // [a, b, c, d]
        for(String key: keys){
            System.out.println("key= "+ key + " and value= " + hm1.get(key));
        }

        // 利用values()遍历，无法遍历key
        Collection<Customer> values = hm1.values();
        System.out.println("values= "+ values);   // [Customer：[Id=1, Name=AA],...]
        for(Customer cus: values){
            System.out.println("value= " + cus);
        }

        // 利用entrySet遍历
        Set<Map.Entry<String,Customer>> entries = hm1.entrySet();
        System.out.println("entries= "+ entries);    // [a=Customer：[Id=1, Name=AA],...]
        for(Map.Entry<String, Customer> entry: entries){
            System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
        }

        // 利用entrySet().iterator()遍历
        Iterator<Map.Entry<String, Customer>> it = hm1.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry<String, Customer> entry = it.next();
            System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
        }

        /*
        * HashMap常用方法示例
        * */
        // get
        Customer b = hm1.get("b");
        System.out.println(b);      // Customer：[Id=2, Name=BB]

        // putIfAbsent, key值存在，不覆盖value
        hm1.putIfAbsent("e",new Customer(5,"EEE"));
        System.out.println(hm1);

        // containsKey
        boolean flag = hm1.containsKey("b");
        System.out.println(flag);     // true

        // containsValue
        flag = hm1.containsValue(b);
        System.out.println(flag);

        // remove
        hm1.remove("c");
        System.out.println(hm1);             // Customer：[Id=3, Name=CC]
        flag = hm1.remove("b", new Customer(1,"BB"));
        System.out.println(flag);         // false

        // replace
        hm1.replace("b", new Customer(2,"BBB"));
        System.out.println(hm1);
        hm1.replace("d",new Customer(4,"D"),
                new Customer(4,"DDD"));    // 注意!!!
        System.out.println(hm1);

        // clone
        HashMap<String, Customer> hm2 = (HashMap<String, Customer>)hm1.clone();
        System.out.println(hm2);
        // clear
        hm2.clear();
        System.out.println(hm2);     // {}
        System.out.println(hm1);
        // isEmpty
        flag = hm2.isEmpty();
        System.out.println(flag);   // true
        // size
        int size = hm1.size();
        System.out.println(size);   // 4

    }
}

Customer.java

import java.util.Objects;

public class Customer implements Comparable<Customer>{

    private int customerId;
    private String customerName;

    public Customer(Integer customerId, String customerName) {
        this.customerId = customerId;
        this.customerName = customerName;
    }

    public int getCustomerId() {
        return customerId;
    }
    public String getCustomerName() {
        return customerName;
    }

    @Override
    public String toString() {
        return "Customer：[Id=" + customerId + ", Name=" + customerName + "]";
    }

     /*
     * 重写compareTo方法
     * 按Id或者name排序
     * 可以对整体添加负号决定升降序
     * */
    @Override
    public int compareTo(Customer o) {
//        return this.customerId - o.customerId;
        return this.customerName.compareTo(o.customerName);
    }

    /*
    * 重写equals和hashcode方法
    * 这里id和name相同则为同一对象
    * */
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Customer)) return false;
        Customer customer = (Customer) o;
        return customerId == customer.customerId &&
                Objects.equals(customerName, customer.customerName);
    }

    @Override
    public int hashCode() {
        return Objects.hash(customerId, customerName);
    }

}

CustomerComparator.java

import java.util.Comparator;

public class CustomerComparator implements Comparator<Customer> {

    @Override
    public int compare(Customer c1, Customer c2) {
        // 按Id排序
        return c1.getCustomerId() - c2.getCustomerId();
     }
}

!!!