Java中Map集合及其子类

Collection集合的特点是每次进行单个对象的保存，如果现在要进行一对对象的保存，就只能用Map集合来完成，即Map集合中会一次性保存两个对象，且这两个对象的关系：key = value结构。这种结构的最大特点是可以通过key找到对应的value内容。
1.Map接口
Map接口定义：
public interface Map<K,V>

在Map接口中有如下常用方法：

Map本身是一个接口，要使用Map需要通过子类进行对象实例化。Map接口的常用子类有如下四个：HashMap、HashTable、TreeMap、ConcurrentHashMap。
2.HashMap子类

如：基本操作

public class Test{
	public static void main(String[] args) {
		Map<Integer, String> map = new HashMap<>();
		map.put(1, "A");
		map.put(1, "A+");
		map.put(2, "B");
		map.put(3, "C");
		System.out.println(map);
		System.out.println(map.get(2));  //根据key取得value
		System.out.println(map.get(10));  //找不到返回null
		
		//取得Map中所有key信息
		Set<Integer> set = map.keySet();
		Iterator<Integer> iterator = set.iterator();
		while(iterator.hasNext()) {
			System.out.println(iterator.next());
		}
	}
}

注意：
(1)key值不允许重复，如果重复，则会把对应value值更新；
(2)key和value都允许为null，key为null有且只有一个。
HashMap原理：在数据量小的(JDK1.8后阈值为8)时候，HashMap是按照链表的模式存储的；当数据量变大之后，为了进行快速查找，会将这个链表变为红黑树(均衡二叉树)来进行保存，用hash来进行查找。
3.HashTable子类

如：HashTable使用

public class Test{
	public static void main(String[] args) {
		Map<Integer, String> map = new Hashtable<>();
		map.put(1, "A");
		map.put(1, "A+");
		map.put(3, "C");
		map.put(2, "B");
		System.out.println(map);
	}
}

注意：key、value均不允许为null。

4.ConcurrentHashMap子类
ConcurrentHashMap的特点：Hashtable的线程安全性 + HashMap的高性能。在使用ConcurrentHashMap处理的时候，既可以保证多个线程更新数据的同步，又可以保证很高效的查询速度。ConcurrentHashMap不允许key和value为null。
高性能：
(1)数据更新的时候只锁对应区域(桶)，而其他区域的访问不受影响；
(2)在锁的区域使用读写锁，读异步而写同步，即便在同一个桶中，数据读取依然不受影响。

如：使用ConcurrentHashMap

public class Test{
	public static void main(String[] args) {
		Map<Integer, String> map = new ConcurrentHashMap<>();
		map.put(1, "A");
		map.put(1, "A+");
		map.put(3, "C");
		map.put(2, "B");
		System.out.println(map);
	}
}

5.Map集合使用Iterator输出
(1)Iterator只存在于Collection及其子类中；
(2)把Map集合转为Set集合：public Set<Map.Entry<K, V>> entrySet();
(3)set.iterator;

如：通过Iterator输出Map集合

public class Test {
	public static void main(String[] args) {
		Map<Integer, String> map = new HashMap<>();
		map.put(1, "A");
		map.put(2, "B");
		map.put(3, "C");
		// 1.将Map集合转为Set集合
		Set<Map.Entry<Integer, String>> set = map.entrySet();
		// 2.获取Iterator对象
		Iterator<Map.Entry<Integer, String>> iterator = set.iterator();
		// 3.输出
		while (iterator.hasNext()) {
			// 4.取出每一个Map.Entry对象
			Map.Entry<Integer, String> entry = iterator.next();
			// 5.获取key和value
			System.out.println(entry.getKey() + " = " + entry.getValue());
		}
	}
}

6.关于Map中的key
在Map集合中如果使用自定义类作为key，一定要覆写Object类中的hashCode()与equals()方法。

如：HashMap使用自定义类作为key

class Person{
	private String name;
	private int age;
	public Person(int age,String name) {
		this.age = age;
		this.name = name;
	}
	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 "Person [name=" + name + ", age=" + age + "]";
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Person other = (Person) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	
}
public class Test{
	public static void main(String[] args) {
		Map<Person, String> map = new HashMap<>();
		map.put(new Person(10, "张三"), "ZS");
		System.out.println(map.get(new Person(10, "张三")));
	}
}

7.TreeMap子类
TreeMap是一个可以排序的Map子类，它是按照key的内容排序的。

如：TreeMap的使用

public class Test{
	public static void main(String[] args) {
		Map<Integer, String> map = new TreeMap<>();
		map.put(2, "B");
		map.put(1, "A");
		map.put(3, "C");
		System.out.println(map);  //输出：{1=A, 2=B, 3=C}
	}
}

如：TreeMap使用自定义类作为key

class Person implements Comparable<Person>{
	private String name;
	private int age;
	public Person(int age,String name) {
		this.age = age;
		this.name = name;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", 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 compareTo(Person o) {
		if(this.age > o.age) {
			return 1;
		}else if(this.age < o.age) {
			return -1;
		}else {
			return this.name.compareTo(o.name);
		}
		
	}
}
public class Test{
	public static void main(String[] args) {
		Map<Person, String> map = new TreeMap<>();
		map.put(new Person(10, "张三"), "ZS");
		System.out.println(map.get(new Person(10, "张三")));
	}
}