Java学习之集合（Map）

Map：存储键值对数据，map集合必须保证键的唯一性

一、常用方法：
1、添加
　　value put(K key,V value); 返回前一个和Key关联的值，如果没有就返回null
2、删除
　　void clear();
　　value remove(K key);根据指定的key删除这个键值对
3、判断
　　boolean containsKey(key);
　　boolean containsValue(value);
　　boolean isEmpty();
4、获取
　　value get(key);通过键获取值，如果没有该键返回null
　　　　　　　　　　当然可以通过返回null，判断是否包含指定键
　　int size();获取键值对的个数
 
　　Set<K> keySet();
　　Set<Map.Entry<K,​V>> entrySet();
　　Collection<V> values();

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

public class MapDemo {

    public static void main(String[] args) {
    Map<Integer, String> map = new HashMap<Integer, String>();
    method(map);
    getData(map);
    }

    public static void getData(Map<Integer, String> map) {
    map.put(8, "wangwu");
    map.put(2, "zhaoliu");
    map.put(5, "lisi");
    map.put(3, "xiaoqiang");
    map.put(7, "zhouqi");
    
    Collection<String> values = map.values();
    Iterator<String> it = values.iterator();
    while (it.hasNext()) {
        String value = it.next();
    }
    
    /*
     * 取出map中所有元素 
     * 原理：通过keySet方法获取map中所有键的Set集合 
     * 通过Set集合的迭代器获取到每一个键
     * 通过map的get方法获取键对应的值
     * 
     */
    //第一种方式：
    Set<Integer> keySet = map.keySet();
    Iterator<Integer> itInteger = keySet.iterator();
    while (itInteger.hasNext()) {
        Integer key = itInteger.next();
        String value = map.get(key);
    }
    
    //第二种方式：
    Set<Map.Entry<Integer, String>> entryMaps = map.entrySet();

    Iterator<Map.Entry<Integer, String>> itEntry = entryMaps.iterator();

    while (itEntry.hasNext()) {
        Map.Entry<Integer, String> entry = itEntry.next();

        Integer key = entry.getKey();
        String value = entry.getValue();
        System.out.println(key + ":" + value);
    }
    }

    public static void method(Map<Integer, String> map) {
    // 添加元素
    System.out.println(map.put(8, "wangcai"));
    System.out.println(map.put(8, "xiaoqiang"));//新值替换旧值，并返回旧值没有旧值返回null
    map.put(2, "zhangsan");
    map.put(6, "lisi");
    System.out.println(map);

    // 删除
    System.out.println("remove:" + map.remove(2));

    // 判断
    System.out.println("containsKey:" + map.containsKey(6));

    // 获取数据
    System.out.println("get:" + map.get(6));

    }
}

结果：

二、Map常用子类
　　|--HashTable：内部结构是哈希表数据结构，是同步的。不允许null键，null值
　　　　|--Properties：用于存储键值对型的配置文件的信息，可以和IO技术相结合
　　|--HashMap：内部结构是哈希表，不同步。允许null键，null值
　　　　|--LinkedHashMap：有序
　　|--TreeMap：内部结构是二叉树，不同步。可以对Map集合中的键进行排序　

共享类型

public class Person implements Comparable {

    private String name;
    private int age;

    public Person() {
    super();
    }

    public Person(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 int hashCode() {
    System.out.println(this + ":-------hashCode");
    return this.name.hashCode() + this.age;
    }

    @Override
    public boolean equals(Object obj) {
    System.out.println(this + ":-------equals-------" + obj);
    if (!(obj instanceof Person))
        throw new ClassCastException("类型不对");
    Person person = (Person) obj;
    return this.name.equals(person.name) && person.age == this.age;
    }

    @Override
    public String toString() {

    return this.name + ":" + this.age;
    }

    @Override
    public int compareTo(Object o) {
    //定义Person类型的自然顺序为：根据年龄排序，年龄相同在根据名称排序
    if(!(o instanceof Person)){
        throw new ClassCastException("类型错误");
    }
    Person p=(Person)o;
    int temp=this.age-p.age;
    return temp==0?this.name.compareTo(p.name):temp;
    }
}

三、HashMap

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

import cn.marw.common.bean.Person;

public class HashMapDemo {

    public static void main(String[] args) {

    HashMap<Person, String> hm = new HashMap<Person, String>();

    hm.put(new Person("lisi", 38), "北京");
    hm.put(new Person("wangwu", 24), "上海");
    hm.put(new Person("qianyi", 31), "沈阳");
    hm.put(new Person("zhangsan", 28), "大连");
    hm.put(new Person("wangwu", 24), "安徽");

    Iterator<Person> it = hm.keySet().iterator();
    while (it.hasNext()) {
        Person p = it.next();
        String value = hm.get(p);
        System.out.println(p.getName() + ":" + p.getAge() + "------" + value);
    }

    }
}

结果：

 很眼熟和HashSet很像，可以通过hashCode和equals方法，实际上HashSet底层实现就是HashMap。

四、TreeMap

import java.util.Iterator;
import java.util.Map;
import java.util.TreeMap;

import cn.marw.collections.treeset.demo.PersonComparatorByName;
import cn.marw.common.bean.Person;

public class TreeMapDemo {

    public static void main(String[] args) {
    TreeMap<Person, String> tm = new TreeMap<Person, String>(new PersonComparatorByName());

    tm.put(new Person("lisi", 38), "北京");
    tm.put(new Person("wangwu", 24), "上海");
    tm.put(new Person("qianyi", 31), "沈阳");
    tm.put(new Person("zhangsan", 28), "大连");
    tm.put(new Person("wangwu", 24), "安徽");

    Iterator<Map.Entry<Person,String>> it = tm.entrySet().iterator();
    while (it.hasNext()) {
        Map.Entry<Person,String> entry = it.next();
        Person p=entry.getKey();
        String value = entry.getValue();
        System.out.println(p.getName() + ":" + p.getAge() + "------" + value);
    }
    }
}

PersonComparatorByName比较器代码：

public class PersonComparatorByName implements Comparator {

    @Override
    public int compare(Object o1, Object o2) {
    //只比较name
    if(!(o1 instanceof Person)||!(o2 instanceof Person))
        throw new ClassCastException("类型错误");
    
    return ((Person)o1).getName().compareTo(((Person)o2).getName());
    }

}

结果：

和TreeSet很像，其实TreeSet基于的实现TreeMap,那么TreeMap的键（Key）元素要么具有比较性（自然顺序），要么就要自定义比较器。