正文
Map的特点？
-
通过Map接口的泛型我们可以看出：Map一次添加一对元素，存储的是键值对；而Collection接口一次添加一个元素。
-
Map接口中的key是唯一的。
Map的常见方法？
1、添加：
value put(key, value);
2、删除：
void clear();
value remove(key);
3、判断：
boolean containsKey(key);
boolean containsValue(value);
boolean isEmpty();
4、获取：
value get(key); // 可以通过此方法的返回值来判断Map是否包含指定键
int size();
既然Map里面存储的是键值对，那么我们怎样取出Map集合中的所有元素呢？一共有下面两种方式：
// 方式一原理：先通过keySet()获取Map的键集(所有键组成的集合)，再通过Set的迭代器获取每一个键，最后对每一个键通过get()获取其对应的键值即可。
import java.util.*;
class Test {
public static void main(String[] args) {
Map<Integer,String> map = new HashMap<Integer,String>();
map.put(8,"zhaoliu");
map.put(2,"zhaoliu");
map.put(7,"xiaoqiang");
map.put(6,"wangcai");
Set<Integer> keySet = map.keySet(); // 1.获取Map的键集
Iterator<Integer> it = keySet.iterator();
while(it.hasNext()){
Integer key = it.next(); // 2.获取每一个键
String value = map.get(key); // 3.获取每一个键对应的键值
System.out.println(key + ":" + value);
}
}
}
// 方式二原理：先通过entrySet()将Map中键和值的映射关系作为对象存储到Set集合，再对该Set集合进行迭代即可。
import java.util.*;
class Test {
public static void main(String[] args) {
Map<Integer,String> map = new HashMap<Integer,String>();
map.put(8,"zhaoliu");
map.put(2,"zhaoliu");
map.put(7,"xiaoqiang");
map.put(6,"wangcai");
Set<Map.Entry<Integer, String>> entrySet = map.entrySet(); // 1.将Map转换成Set
Iterator<Map.Entry<Integer, String>> it = entrySet.iterator(); // 2.再对Set进行遍历即可
while(it.hasNext()){
Map.Entry<Integer, String> me = it.next();
Integer key = me.getKey();
String value = me.getValue();
System.out.println(key + ":" + value);
}
}
}
我们还可以通过以下方式获取到Map中所有的value。
import java.util.*;
class Test {
public static void main(String[] args) {
Map<Integer,String> map = new HashMap<Integer,String>();
map.put(8, "xiaoxiao");
map.put(2, "zhaoliu");
map.put(7, "xiaoqiang");
map.put(6, "wangcai");
Collection<String> values = map.values(); // 1.获取到map中所有value的集合
Iterator<String> it = values.iterator();
while(it.hasNext()){ // 2.遍历即可
System.out.println(it.next());
}
}
}
Map的常用子类？
HashMap？
HashMap内部的数据结构是哈希表；它不是同步的(如果需要实现同步，推荐使用ConcurrentHashMap)；它允许使用null值和null键。
当向HashMap中存储自定义对象时，我们需要注意下面的问题：
import java.util.*;
class Student implements Comparable<Student> {
private String name;
private int age;
public Student() {
super();
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public int compareTo(Student p){
int temp = this.age - p.age;
return temp == 0 ? this.name.compareTo(p.name) : temp;
}
/* 自动生成hashCode()和equals() */
@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;
Student other = (Student) 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 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 "Student:" + getName() + ":" + getAge();
}
}
class Test {
public static void main(String[] args) {
HashMap<Student,String> hm = new HashMap<Student,String>();
hm.put(new Student("lisi",38),"北京");
hm.put(new Student("zhaoliu",24),"上海"); // 1
hm.put(new Student("xiaoqiang",31),"沈阳");
hm.put(new Student("wangcai",28),"大连");
hm.put(new Student("zhaoliu",24),"铁岭"); // 由于与1处的对象key重复，并且我们在Studnet类中覆盖了hashCode()和equals()，所以这个对象的value会覆盖1处对象的value。
Iterator<Student> it = hm.keySet().iterator();
while(it.hasNext()){
Student key = it.next();
String value = hm.get(key);
System.out.println(key.getName()+":"+key.getAge()+"---"+value);
}
}
}
HashMap的子类LinkedHashMap可以实现集合的有序：即向集合中存储数据的顺序与从集合中取出数据的顺序一致。
HashTable？
HashTable内部的数据结构是哈希表；它是同步的；它不允许null作为键，null作为值。另外我们需要注意：HashTable基本上已经被淘汰了。
HashTable下面还有一个子类Properties：它经常被用来存储键值对型配置文件的信息并与IO技术相结合使用。
TreeMap？
TreeMap内部的数据结构是二叉树；它不是同步的；它可以对Map集合中的键进行排序。
当向TreeMap中存储自定义对象并且我们需要对Map集合中的键进行排序时，可以像下面这样：
// Student类代码省略，与上同
// 根据学生姓名进行排序的比较器
class ComparatorByName implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
int temp = o1.getName().compareTo(o2.getName());
return temp==0? o1.getAge()-o2.getAge(): temp;
}
}
class Test {
public static void main(String[] args) {
TreeMap<Student, String> tm = new TreeMap<Student, String>(new ComparatorByName());
tm.put(new Student("lisi", 38), "北京");
tm.put(new Student("zhaoliu", 24), "上海");
tm.put(new Student("xiaoqiang", 31), "沈阳");
tm.put(new Student("wangcai", 28), "大连");
tm.put(new Student("zhaoliu", 24), "铁岭");
Iterator<Student> it = tm.keySet().iterator();
while(it.hasNext()){
Student key = it.next();
String value = tm.get(key);
System.out.println(key.getName() + ":" + key.getAge() + "---" + value);
}
}
}
HashMap、TreeMap与HashSet、TreeSet名称相似，通过查看JDK文档，我们可以发现：Hashset基层基于HashMap实现，TreeSet基层基于TreeMap实现。