Java(2)--Map集合的操作和使用

前言

• 若问题分析没能清楚表达，请配合代码及注释阅读！！

问题分析

Map集合

• 映射这种数据结构含有两个部分，关键字和值。对于每个关键字都有一个值，即一个关键字映射一个值。映射允许通过关键字访问数据结构。

• Map接口中声明了一对一的映射。当向映射中添加一组关键字和值，若关键字重用，则用新值替换旧值。即Map集合中不存在重复的关键字，但是不同的关键字映射的值可能相同。

  	简述	实现	操作特性	成员要求
  		HashMap	存入顺序和输出顺序无关能满足用户对Map的通用需求	键成员可为任意Object子类的对象，但如果覆盖了equals方法，同时注意修改hashCode方法。
  Map	保存键值对成员，基于键找值操作，使用compareTo或compare方法对键进行排序	TreeMap	支持对键有序地遍历，使用时建议先用HashMap增加和删除成员，最后从HashMap生成TreeMap；附加实现了SortedMap接口，支持子Map等要求顺序的操作	键成员要求实现Comparable接口，或使用Comparator构造TreeMap键成员一般为同一类型。
  		LinkedHashMap	保留键的插入顺序，用equals 方法检查键和值的相等性	成员与HashMap成员类似

Entry< K,V>接口

• 接口Map 并未继承接口Iterable，这与接口 Collection 不同。接口Map 提供了返回值类型为Set<Entry<K,V>>的方法entrySet()。Entry<K,V>是接口Map 的内部接口，表示Map集合项，并提供了从集合项中获取键名的方法getKey() 和获取键值的方法getValue() 等。
• 因为每个 key 键是唯一存在的，所以用 Set 集合对象获取 Map 集合对象中的所有 key 键，然后对 Set 集合对象应用迭代器进行遍历。

iterator迭代器

• 因为是对Set< Entry<K,V>>应用迭代器，所以，可以认为Map 接口间接实现了 Iterable 接口。
• 在使用时，用Set 方法实例化一个对象包含Map 的< K,V>或者< K>，然后对该对象使用迭代器进行遍历。

常用方法

添加、删除操作

• Object put(Object key,Object value)：将一个键－值对存放到Map中。如果出现关键字已存在，则用新值替换映射中原有的值。该方法返回关键字的旧值，如果关键字原先就不存在，则返回null。
• Object remove(Object key)：根据key(键)，移除一个键－值对，并将值返回。
• void putAll(Map mapping)：将另外一个Map中的元素存入当前的Map中。
• void clear() ：清空当前Map中的元素

查询操作

• Object get(Object key)：根据key(键)取得对应的值
• boolean containsKey(Object key) ：判断Map中是否存在某键（key）
• boolean containsValue(Object value)：判断Map中是否存在某值(value)
• int size()：返回Map中 键-值对的个数
• boolean isEmpty()：判断当前Map是否为空

把键和值的组作为集合来处理

• public Set keySet() ：返回所有的键（key，唯一性），并使用Set容器存放 。
• public Collection values() ：返回所有的值（Value，可重复 ），并使用Collection存放。
• public Set entrySet() ：返回一个实现 Map.Entry 接口的元素 Set。

程序实现

Map基本操作

import java.util.*;
public class MapTest {
public static void main(String[] args) {
       Map map1 = new HashMap();
       Map map2 = new HashMap();
       map1.put("1","aaa1");       map1.put("2","bbb2");    
       map2.put("10","aaaa10");       map2.put("11","bbbb11");
	//根据键 "1" 取得值："aaa1" 
       System.out.println("map1.get(\"1\")="+map1.get("1"));
	//根据键 "1" 移除键值对"1"-"aaa1"
       System.out.println("map1.remove(\"1\")="+map1.remove("1")); 
       System.out.println("map1.get(\"1\")="+map1.get("1"));
       map1.putAll(map2);    //将map2全部元素添加到map1中
       map2.clear();	//清空map2
       System.out.println("map1 IsEmpty?="+map1.isEmpty());
       System.out.println("map2 IsEmpty?="+map2.isEmpty());
       System.out.println("map1 中的键值对的个数size = "+map1.size());
       System.out.println("KeySet="+map1.keySet());   //set
       System.out.println("values="+map1.values());    //Collection
       System.out.println("entrySet="+map1.entrySet());     
       System.out.println("map1 是否包含键：11 = "+map1.containsKey("11")); 
       System.out.println("map1 是否包含值：aaa1 = "+map1.containsValue("aaa1"));
    }
}

TreeMap实现重构和排序

import java.util.*;
public class MapSortExample {
  public static void main(String args[]) {
    Map map1 = new HashMap(); 
    Map map2 = new LinkedHashMap();
    for(int i=0;i<10;i++){
       double s=Math.random()*100;
       map1.put(new Integer((int) s),"第 "+i+" 个放入的元素："+s+"\n");
       map2.put(new Integer((int) s),"第 "+i+" 个放入的元素："+s+"\n");
    }
    System.out.println("未排序前HashMap："+map1);
    System.out.println("未排序前LinkedHashMap："+map2);
    //使用TreeMap来对另外的Map进行重构和排序
    Map sortedMap = new TreeMap(map1);
    System.out.println("排序后："+sortedMap);
    System.out.println("排序后："+new TreeMap(map2));
  }
}

遍历Map（重点）

通过key键遍历

System.out.println("Traverse by key!");
        for (int i : map.keySet()) {
            System.out.println("Key:" + i + " Value:" + map.get(i));
        }

通过Value值遍历

因为一个Key键只映射一个Value值，但是一个Value值可能被多个Key键映射，所以通过Value值遍历时不能同时查询Key键！

System.out.println("Traverse by Value!");
        for (String i : map.values()) {
            System.out.println("Value:" + i);
        }

通过Entry< K,V>接口遍历

System.out.println("Traverse by Entry!");
        for (Map.Entry<Integer, String> entry : map.entrySet()) {
            System.out.println("Key:" + entry.getKey() + " Value:" + entry.getValue());
        }

用Iterator通过Key键遍历

System.out.println("Traverse by KeyIterator!");
        Set<Integer> set = map.keySet();
        Iterator<Integer> iter = set.iterator();
        // Iterator<Integer> iter = map.keySet().iterator();// 前面两行可以简写为此行
        while (iter.hasNext()) {// iter的起始地址在第一个Integer元素前
            int i = iter.next();// 调用next()之后，返回Key键，并且迭代器移到下一个元素
            System.out.println("Key:" + i + " Value:" + map.get(i));
        }

用Iterator通过Entry接口遍历

System.out.println("Traverse by EntryIterator!");
        Set<Map.Entry<Integer, String>> set_2 = map.entrySet();
        Iterator<Map.Entry<Integer, String>> iter_2 = set_2.iterator();
        // Iterator<Map.Entry<Integer, String>> iter_2 = map.entrySet().iterator();// 前面两行可以简写为此行
        while (iter_2.hasNext()) {// iter的起始地址在第一个Integer元素前
            Map.Entry<Integer, String> entry = iter_2.next();// 调用next()之后，返回Entry键值对，并且迭代器移到下一个元素
            System.out.println("Key:" + entry.getKey() + " Value:" + entry.getValue());// 也可以通过map.get(entry.getKey())得到Value值
        }

全篇代码

import java.util.*;

public class MapTraverse {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<Integer, String>();
        int key;
        String value;
        int count;
        Scanner scan = new Scanner(System.in);
        System.out.print("Enter the Count:");
        count = scan.nextInt();
        for (int i = 0; i < count; i++) {
            System.out.print("Enter the " + (i + 1) + "th Key:");
            key = scan.nextInt();
            System.out.print("Enter the " + (i + 1) + "th Value:");
            value = scan.next();
            map.put(key, value);
        }

        System.out.println("Traverse by key!");
        for (int i : map.keySet()) {
            System.out.println("Key:" + i + " Value:" + map.get(i));
        }

        System.out.println("Traverse by Value!");
        for (String i : map.values()) {
            System.out.println("Value:" + i);
        }

        System.out.println("Traverse by Entry!");
        for (Map.Entry<Integer, String> entry : map.entrySet()) {
            System.out.println("Key:" + entry.getKey() + " Value:" + entry.getValue());
        }

        System.out.println("Traverse by KeyIterator!");
        Set<Integer> set = map.keySet();
        Iterator<Integer> iter = set.iterator();
        // Iterator<Integer> iter = map.keySet().iterator();
        while (iter.hasNext()) {// iter的起始地址在第一个Integer元素前
            int i = iter.next();// 调用next()之后，返回Key键，并且迭代器移到下一个元素
            System.out.println("Key:" + i + " Value:" + map.get(i));
        }

        System.out.println("Traverse by EntryIterator!");
        Set<Map.Entry<Integer, String>> set_2 = map.entrySet();
        Iterator<Map.Entry<Integer, String>> iter_2 = set_2.iterator();
        // Iterator<Map.Entry<Integer, String>> iter_2 = map.entrySet().iterator();
        while (iter_2.hasNext()) {
            Map.Entry<Integer, String> entry = iter_2.next();
            System.out.println("Key:" + entry.getKey() + " Value:" + entry.getValue());// map.get(entry.getKey())
        }

        scan.close();
    }
}

示例输入输出

List集合内嵌Map集合

import java.util.ArrayList;
/*
 * 在List集合里嵌套Map集合，存储二维表数据
 */
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class MapInList {
    public static void main(String[] args) {        
        List<Map<String, Object>> persons = new ArrayList<Map<String, Object>>();  //二维表数据
        Map<String, Object> person1 = new HashMap<String, Object>();  //记录
        person1.put("id", 1);
        person1.put("name", "张三");
        person1.put("salary", 5000);
        persons.add(person1); // 将Map对象person1加入List对象person
        Map<String, Object> person2 = new HashMap<String, Object>();
        person2.put("id", 2);
        person2.put("name", "李四");
        person2.put("salary", 5800);
        persons.add(person2);
        Map<String, Object> person3 = new HashMap<String, Object>();
        person3.put("id", 3);
        person3.put("name", "王五");
        person3.put("salary", 5500);
        persons.add(person3);
        System.out.println("遍历结果如下：");
        for(int i=0;i<persons.size();i++) {
            System.out.println(persons.get(i));
        }
    }
}

下期预告

• Collections包装类