Java集合详解(二)：Map

Java集合详解(二)：Map

Collection和Map比较

Collection<E>

--->是一个单列的集合

Map<K, V>

map中需要存放两个元素
一个是K：Key-->键
一个是V：Value--->Value
----->map是一个双列的集合
每一个K和V之间存在着映射关系

Map的特点：

map的每一个对元素都是以键值对儿的形式存在的。map中的键是唯一的，只能通过键来唯一的获取值。

Map常用的方法：

1、增

put(K key, V value)

putAll(Map<? extends K,? extends V> m)

2、删

clear();

V remove(Object key)://移除掉Key对应的键值对，返回Key对应的Value

3、改

put(K key, V value)

4、查

get(Object key)

int size()；

values();

5、判断：

containsKey(Object key)

containsValue(Object value)

isEmpty()

常用的子类

HashTable:底层的数据结构是哈希表，K-V不可以存在null值，Hashtable是同步的
，效率低，jdk1.0
HashMap:底层的数据结构是哈希表，K-V可以存在null值，HashMap是不同步的
，效率高，jdk1.2
TreeMap:底层的数据结构是二叉树，如果要对我们的map进行排序，就是使用treemap，是按照映射关系中的key来进行排序

Map操作程序示例

public class MapDemo {

public static void main(String[] args) {
Map<Integer, String> map = new HashMap<Integer, String>();
//添加元素
/**
* put的返回值为老版本K对应的V，如果是第一次存入，那么返回值为null
*/
System.out.println("1返回值=" + map.put(1, "zs"));
System.out.println("2返回值=" + map.put(1, "zs007"));
System.out.println("3返回值=" + map.put(2, "lisi"));
System.out.println("4返回值=" + map.put(2, "lisi110"));
map.put(3, "wangwu");
map.put(4, "zhaoliu");

//打印map集合 打印格式为{K1=V1, K2=V2,...Kn=Vn}
System.out.println(map);

//通过get(key)来获取key对应的value 当我们的key对应的值不存在，那么也就是说map当中没有这个KV对儿，返回为null
String v1 = map.get(5);
System.out.println("v1=" + v1);

//判断containsXxx() 判断K或者V中是否存在对应的键或者值，返回值为true|false
System.out.println(map.containsKey(2));
System.out.println(map.containsKey(6));
System.out.println(map.containsValue("wangwu"));
System.out.println(map.containsValue("zhouqi"));

//删除元素 remove 删除的时候返回值为K对应的V，如果K不在map中，不会抛异常，返回值为null
String removed = map.remove(5);
System.out.println("removed =" + removed);

//获取所有的值values(); 值的注意的是values的返回值类型为Collection<V>
Collection<String> col = map.values();
System.out.println(col);

}
}

Map的两种取元素方式

Set<K> keySet:

获取map中的所有的key组成一个集合Set，通过我们Set来进行操作，得到Iterator，迭代每一个元素(Key),然后在通过map.get(Key)获得对应的value。

程序示例：

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>();
//添加元素
map.put(1, "zs1");
map.put(2, "lisi");
map.put(3, "wangwu");
map.put(4, "zhaoliu");

//获取键值对映射关系的集合entrySet
Set<Map.Entry<Integer, String>> entrySet = map.entrySet();

//获取集合entrySet的迭代器
Iterator<Map.Entry<Integer, String>> it = entrySet.iterator();

//迭代每一个元素
while(it.hasNext()) {   //判断是否还有下一个元素
Map.Entry<Integer, String> me = it.next();   //获取集合中映射关系元素
Integer key = me.getKey();  //得到映射元素中的key
String value = me.getValue();   //得到映射元素中的value
System.out.println("key=" + key + ", value=" + value);
}
}
}

Set<Map.Entry<K,V>> entrySet:

获取map中所有的k-v的映射关系—》Set集合,通过我们Set来进行操作，得到Iterator，迭代器的每一个元素都是一个映射关系的实例，通过实例提供的api(getKey,getValue)来获取我们map中的每一对儿键值对。

程序示例：

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>();
//添加元素
map.put(1, "zs1");
map.put(2, "lisi");
map.put(3, "wangwu");
map.put(4, "zhaoliu");

//step1、获取key对应的一个集合
Set<Integer> keySet = map.keySet();

//step2、获得keySet对应的迭代器
Iterator<Integer> it = keySet.iterator();

//step3、迭代每一个元素
while(it.hasNext()) {//判断是否有下一个元素
//3.1、获取每一个key
Integer key = it.next();
String value = map.get(key);
System.out.println("key=" + key + ", value=" + value);
}
}
}

Map中两种比较器示例

Comparable接口

程序示例：

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

/**
*  业务：每一个的学生（Student）都有自己的籍贯
*  有属性：姓名name，年龄age
注意：姓名和年龄相同则视为同一个学生，需要保证学生的唯一性。
*/
public class MapTest1 {

public static void main(String[] args) {
Map<Student, String> stuMap = new HashMap<Student, String>();
stuMap.put(new Student("zhangsan", 18), "北京");
stuMap.put(new Student("lisi",19), "上海");
stuMap.put(new Student("wangwu",22), "江苏苏州");
stuMap.put(new Student("zhaoliu",24), "甘肃酒泉");
Set<Student> keySet = stuMap.keySet();
Iterator<Student> it1 = keySet.iterator();
while(it1.hasNext()) {
Student stu = it1.next();
System.out.println(stu + "\t籍贯是：" + stuMap.get(stu));
}
}
}

class Student implements Comparable<Student> {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public Student() {
}
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;
}

public int hashCode() {
return name.hashCode() + age * 31;
}
@Override
public boolean equals(Object obj) {
if (null == obj) {
throw new RuntimeException("元素为空，不能存进去");
}
if (!(obj instanceof Student)) {
throw new RuntimeException("元素不是Student类型的，不能存进去");
}
Student stu = (Student)obj;
return this.name.equals(stu.name) && this.age == stu.age;
}

@Override
public String toString() {
return "name="+ name + ", age=" + age;
}
@Override
public int compareTo(Student stu) {
int result = new Integer(this.age).compareTo(new Integer(stu.age));
if(result == 0) {
result = this.name.compareTo(stu.name);
}
return result;
}
}

Comparator接口

程序示例：

import java.util.*;

/**
* 需求：对学生对象的年龄进行升序排序。(student为上一示例的student类)
按照学生姓名进行排序。---Comparator接口
*
*/
public class MapTest2 {

public static void main(String[] args) {
Map<Student, String> stuMap = new TreeMap<Student, String>(new MyComparator());
stuMap.put(new Student("zhangsan",22), "江苏苏州");
stuMap.put(new Student("lisi",19), "上海");
stuMap.put(new Student("wangwu", 18), "北京");
stuMap.put(new Student("zhaolliu",24), "甘肃酒泉");

Set<Map.Entry<Student, String>> entrySet = stuMap.entrySet();
Iterator<Map.Entry<Student, String>> it2 = entrySet.iterator();
while(it2.hasNext()) {
Map.Entry<Student, String> me = it2.next();
Student stu = me.getKey();
String val = me.getValue();
System.out.println(stu + "\t籍贯是：" + val);
}
}
}

class MyComparator implements Comparator<Student> {
@Override
public int compare(Student stu1, Student stu2) {
int result = stu2.getName().compareTo(stu1.getName());
if(result == 0) {
result = new Integer(stu2.getAge()).compareTo(new Integer(stu1.getAge()));
}
return result;
}
}

TreeMapTest使用示例

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

/**
* 需求：对"adfafea"进行统计，统计出每个字符在字符串中出现的次数，
* 要求最后的打印结果为a(3)d(1)e(1)f(2)
*/
public class TreeMapTest {

public static void main(String[] args) {
String result = method_count("adfafea");
System.out.println(result);
}

public static String method_count(String src) {
char[] chs = src.toCharArray();
Map<Character, Integer> chsMap = new TreeMap<Character, Integer>();
for (int x = 0; x < chs.length; x++) {
chsMap.put(chs[x], chsMap.get(chs[x]) == null ? 1 : chsMap.get(chs[x]) + 1);
}

StringBuilder sb = new StringBuilder();
Set<Map.Entry<Character, Integer>> entrySet = chsMap.entrySet();
Iterator<Map.Entry<Character, Integer>> it2 = entrySet.iterator();
while (it2.hasNext()) {
Map.Entry<Character, Integer> me = it2.next();
char ch = me.getKey();
int count = me.getValue();
sb.append(ch + "(" + count + ")");
}
return sb.toString();
}
}