Java_Map

字典(Map)

概述

HashMap

定义方法

public static void main(String[] args) {
		// HashMap Map = new HashMap(); // 定义方法一
		Map<Integer, String> map = new HashMap<Integer, String>(); // 定义方法二
		// map没有add方法
		map.put(1, "LiHua");
		map.put(2, "zhanghua");
		map.put(3, "huanghuan");
		System.out.println(map);
		/*{1=LiHua, 2=zhanghua, 3=huanghuan}*/
	}
1
2
3
4
5
6
7
8
9
10

常用方法

put()与remove()

public static void main(String[] args) {
		// HashMap Map = new HashMap(); // 定义方法一
		Map<Integer, String> map = new HashMap<Integer, String>();
		// map没有add方法
		map.put(1, "LiHua");
		map.put(2, "zhanghua");
		map.put(3, "huanghuan");
		System.out.println(map);
		/*{1=LiHua, 2=zhanghua, 3=huanghuan}*/
		map.remove(1);
		map.remove(100);
		System.out.println(map);
		/*{2=zhanghua, 3=huanghuan}*/		
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

containsKey()与containsValue()

public static void main(String[] args) {
		// HashMap Map = new HashMap(); // 定义方法一
		Map<Integer, String> map = new HashMap<Integer, String>();
		// map没有add方法
		map.put(1, "LiHua");
		map.put(2, "zhanghua");
		map.put(3, "huanghuan");
		System.out.println(map);
		/*{1=LiHua, 2=zhanghua, 3=huanghuan}*/
		
		System.out.println(map.containsKey(2));
		/*true*/
		
		map.remove(1);
		map.remove(100);
		System.out.println(map);
		/*{2=zhanghua, 3=huanghuan}*/		
		System.out.println(map.containsValue("LiHua"));
		/*false*/
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

V get(Key) 与 V getOrDefault(Key, DefaultValue)

public static void main(String[] args) {
		HashMap<Integer, String> map = new HashMap<Integer, String>();
		map.put(1, "Lihua");
		map.put(2, "Zhanghua");
		map.put(3, "xiaozhang");
		
		// get() 方法通过key值来获取value值
		System.out.println(map.get(1));/*Lihua*/
		
		// getOrDefault()  如果没有找到key 那么返回的value值就用第二个参数代替
		System.out.println(map.getOrDefault(4, "hahaha"));/*hahaha*/
	}
1
2
3
4
5
6
7
8
9
10
11
12

Set keySet

public static void main(String[] args) {
		HashMap<Integer, String> map = new HashMap<Integer, String>();
		map.put(1, "Lihua");
		map.put(2, "Zhanghua");
		map.put(3, "xiaozhang");
		
		// keySet() 返回key值的集合
		System.out.println(map.keySet());
		/*[1, 2, 3]*/
	}
1
2
3
4
5
6
7
8
9
10

Collection values() 返回此字典中包含的Collection视图

public static void main(String[] args) {
		TreeMap<Integer, String> tmap = new TreeMap<>();
		tmap.put(100, "liming");
		tmap.put(1, "dagu");
		tmap.put(2, "xiaolong");
		tmap.put(45, "xidong");
		tmap.put(50, "zhangsan");
		tmap.put(66, "zhangming");
		System.out.println(tmap);
		System.out.println(tmap.values());
		/*{1=dagu, 2=xiaolong, 45=xidong, 50=zhangsan, 66=zhangming, 100=liming}*/
		/*[dagu, xiaolong, xidong, zhangsan, zhangming, liming]*/
	}
1
2
3
4
5
6
7
8
9
10
11
12
13

**V remove(Oject key) ** 返回删除的key对应的value

boolean remove(Object key, Object value) 删除成功的话返回true

public static void main(String[] args) {
		HashMap<Integer, String> map = new HashMap<Integer, String>();
		map.put(1, "Lihua");
		map.put(2, "Zhanghua");
		map.put(3, "xiaozhang");
		
		System.out.println(map.remove(1));
		/*Lihua*/
		System.out.println(map.remove(1));
		/*null*/
		System.out.println(map.remove(2, "Zhanghua"));
		/*true*/
		System.out.println(map.remove(2, "Zhanghua"));
		/*false*/
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

V replace(K key, V value) 把key对应的value换成新的

boolean replace(K key, V oldValue, V newValue)

public static void main(String[] args) {
		HashMap<Integer, String> map = new HashMap<Integer, String>();
		map.put(1, "Lihua");
		map.put(2, "Zhanghua");
		map.put(3, "xiaozhang");
		
		System.out.println(map.replace(1, "xiaolizi")); 
		/*Lihua*/
		System.out.println(map);
		/*{1=xiaolizi, 2=Zhanghua, 3=xiaozhang}*/
		
		System.out.println(map.replace(2, "Zhanghua", "daxiong")); 
		/*true*/
		System.out.println(map.replace(2, "Zhanghua", "daxiong")); 
		/*false*/  // 这里这个value指定错误 然后就不可以换成功
		System.out.println(map);
		/*{1=xiaolizi, 2=daxiong, 3=xiaozhang}*/
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Set> entrySet() 返回的是这个字典对应的键值对的集合

public static void main(String[] args) {
		HashMap<Integer, String> map = new HashMap<Integer, String>();
		map.put(1, "Lihua");
		map.put(2, "Zhanghua");
		map.put(3, "xiaozhang");
		
		System.out.println(map.entrySet()); // 这里返回的是一个Set集合
		// 类型是Set>
		/*[1=Lihua, 2=Zhanghua, 3=xiaozhang]*/
	}
1
2
3
4
5
6
7
8
9
10

遍历方法

方式一

public static void main(String[] args) {
		HashMap<Integer, String> map = new HashMap<Integer, String>();
		map.put(1, "Lihua");
		map.put(2, "Zhanghua");
		map.put(3, "xiaozhang");
		
		for(Integer i : map.keySet())
		{
			System.out.println(i + " " + map.get(i));
		}		
		/*
		   1 Lihua
		   2 Zhanghua
           3 xiaozhang
		 */
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

方式二

public static void main(String[] args) {
		HashMap<Integer, String> map = new HashMap<Integer, String>();
		map.put(1, "Lihua");
		map.put(2, "Zhanghua");
		map.put(3, "xiaozhang");
		
		for (Map.Entry<Integer, String> me: map.entrySet())
		{
			System.out.println(me.getKey() + " " + me.getValue());			
		}
		/*
		 * 1 Lihua
		   2 Zhanghua
           3 xiaozhang
		 * */
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

LinkedHashMap

定义方法

public static void main(String[] args) {
		Map<Integer, String> linkmap = new LinkedHashMap<>();
		linkmap.put(1, "lihua");
		linkmap.put(2, "zhanghua");
		linkmap.put(3, "xiaobizhaizi");	
		System.out.println(linkmap);
		/*{1=lihua, 2=zhanghua, 3=xiaobizhaizi}*/
	}
1
2
3
4
5
6
7
8

常用方法

和HashMap一样

遍历方法

和HashMap一样

TreeMap

定义方法

public static void main(String[] args) {
		TreeMap<Integer, String> tmap = new TreeMap<>();
		tmap.put(100, "liming");
		tmap.put(1, "dagu");
		tmap.put(2, "xiaolong");
		// 默认按照key升序排列
		System.out.println(tmap);
		/*{1=dagu, 2=xiaolong, 100=liming}*/
	}
1
2
3
4
5
6
7
8
9

常用方法

**在HashMap的基础上多一些 **

Map.Entry firstEntry()

K firstKey()

public static void main(String[] args) {
		TreeMap<Integer, String> tmap = new TreeMap<>();
		tmap.put(100, "liming");
		tmap.put(1, "dagu");
		tmap.put(2, "xiaolong");
		tmap.put(45, "xidong");
		System.out.println(tmap.firstEntry()); // 返回最小key对应的映射
		/*1=dagu*/
		System.out.println(tmap.firstKey());  // 返回第一个key
		/*1*/
	}
1
2
3
4
5
6
7
8
9
10
11

Map.Entry floorEntry(K key) 返回小于或等于指定key的最大key的映射

K floorKey(K key) 返回小于或等于指定key的最大的key

public static void main(String[] args) {
		TreeMap<Integer, String> tmap = new TreeMap<>();
		tmap.put(100, "liming");
		tmap.put(1, "dagu");
		tmap.put(2, "xiaolong");
		tmap.put(45, "xidong");
		System.out.println(tmap.floorEntry(3)); 
		/*2=xiaolong*/
		System.out.println(tmap.floorKey(3));
		/*2*/
	}
1
2
3
4
5
6
7
8
9
10
11

Map.Entry ceilingEntry(K key) 返回大于或等于指定key的key的映射

K ceilingKey(K key) 返回大于或等于指定key的key

public static void main(String[] args) {
		TreeMap<Integer, String> tmap = new TreeMap<>();
		tmap.put(100, "liming");
		tmap.put(1, "dagu");
		tmap.put(2, "xiaolong");
		tmap.put(45, "xidong");
		System.out.println(tmap.ceilingEntry(3));
		/*45=xidong*/
		System.out.println(tmap.ceilingKey(3));
		/*45*/
	}
1
2
3
4
5
6
7
8
9
10
11

Map.Entry firstEntry() 返回第一个key对应的映射

K firstKey() 返回第一个key对应的value

public static void main(String[] args) {
		TreeMap<Integer, String> tmap = new TreeMap<>();
		tmap.put(100, "liming");
		tmap.put(1, "dagu");
		tmap.put(2, "xiaolong");
		tmap.put(45, "xidong");
		System.out.println(tmap.firstEntry());
		/*1=dagu*/
		System.out.println(tmap.firstKey());
		/*1*/
	}
1
2
3
4
5
6
7
8
9
10
11

Map.Entry lastEntry() 返回最后一个key对应的映射

K lastKey() 返回最后一个key对应的value

	public static void main(String[] args) {
		TreeMap<Integer, String> tmap = new TreeMap<>();
		tmap.put(100, "liming");
		tmap.put(1, "dagu");
		tmap.put(2, "xiaolong");
		tmap.put(45, "xidong");
		System.out.println(tmap.lastEntry());
		/*100=liming*/
		System.out.println(tmap.lastKey());
		/*100*/
	}
1
2
3
4
5
6
7
8
9
10
11

SortedMap headMap(K toKey) 放回此字典的部分视图 其中key值严格小于toKey的部分

NavigableMap headMap inclusive为true表示有等于的情况

public static void main(String[] args) {
		TreeMap<Integer, String> tmap = new TreeMap<>();
		tmap.put(100, "liming");
		tmap.put(1, "dagu");
		tmap.put(2, "xiaolong");
		tmap.put(45, "xidong");
		tmap.put(66, "zhangming");
		System.out.println(tmap.headMap(45));
		/*{1=dagu, 2=xiaolong}*/
		System.out.println(tmap.headMap(45, true));  // 包含等于的情况
		/*{1=dagu, 2=xiaolong, 45=xidong}*/
	}
1
2
3
4
5
6
7
8
9
10
11
12

SortedMap tailMap(K fromKey) 返回此字典的部分视图 其key大于等于 fromKey

NavigableMap tailMap(K fromKey, boolean inclusive) 这里的inclusive表示是否包含边界 为true包含

public static void main(String[] args) {
		TreeMap<Integer, String> tmap = new TreeMap<>();
		tmap.put(100, "liming");
		tmap.put(1, "dagu");
		tmap.put(2, "xiaolong");
		tmap.put(45, "xidong");
		tmap.put(66, "zhangming");
		System.out.println(tmap.tailMap(2));
		/*{2=xiaolong, 45=xidong, 66=zhangming, 100=liming}*/
		System.out.println(tmap.tailMap(2, false));
		/*{45=xidong, 66=zhangming, 100=liming}*/
	}
1
2
3
4
5
6
7
8
9
10
11
12

Map.Entry higherEntry(K key) 返回大于指定key的最小的一个 如果没有返回null

K higherKey(K key) 返回大于指定key的最小一个key 如果没有返回null

public static void main(String[] args) {
		TreeMap<Integer, String> tmap = new TreeMap<>();
		tmap.put(100, "liming");
		tmap.put(1, "dagu");
		tmap.put(2, "xiaolong");
		tmap.put(45, "xidong");
		tmap.put(50, "zhangsan");
		tmap.put(66, "zhangming");
		System.out.println(tmap);
		/*{1=dagu, 2=xiaolong, 45=xidong, 50=zhangsan, 66=zhangming, 100=liming}*/
		System.out.println(tmap.higherEntry(45));  // 返回大于指定key的最小的一个映射
		/*50=zhangsan*/
		System.out.println(tmap.higherKey(45));	// 返回大于指定key的最小的一个key
		/*50*/
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Map.Entry lowerEntry(K key) 返回小于这个key的最大的一个映射

K lowerKey(K key) 返回小于这个key的最大一个key

public static void main(String[] args) {
		TreeMap<Integer, String> tmap = new TreeMap<>();
		tmap.put(100, "liming");
		tmap.put(1, "dagu");
		tmap.put(2, "xiaolong");
		tmap.put(45, "xidong");
		tmap.put(50, "zhangsan");
		tmap.put(66, "zhangming");
		System.out.println(tmap);
		/*{1=dagu, 2=xiaolong, 45=xidong, 50=zhangsan, 66=zhangming, 100=liming}*/
		System.out.println(tmap.lowerEntry(50));  // 返回小于这个key的最大的一个映射
		/*45=xidong*/
		System.out.println(tmap.lowerKey(50));  // 返回小于这个key的最大一个key
		/*45*/
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Map.Entry pollFirstEntry() 删除并返回此字典的第一个key对应的映射

Map.Entry pollLastEntry() 删除并返回此字典的最后一个key对应的映射

public static void main(String[] args) {
		TreeMap<Integer, String> tmap = new TreeMap<>();
		tmap.put(100, "liming");
		tmap.put(1, "dagu");
		tmap.put(2, "xiaolong");
		tmap.put(45, "xidong");
		tmap.put(66, "zhangming");
		System.out.println(tmap.pollFirstEntry());
		/*1=dagu*/
		System.out.println(tmap);
		/*{2=xiaolong, 45=xidong, 66=zhangming, 100=liming}*/
		System.out.println(tmap.pollLastEntry());
		/*100=liming*/
		System.out.println(tmap);
		/*{2=xiaolong, 45=xidong, 66=zhangming}*/
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

V remove(Object key) 从此TreeMap中删除此key对应的映射（如果存在）

public static void main(String[] args) {
		TreeMap<Integer, String> tmap = new TreeMap<>();
		tmap.put(100, "liming");
		tmap.put(1, "dagu");
		tmap.put(2, "xiaolong");
		tmap.put(45, "xidong");
		tmap.put(66, "zhangming");
		System.out.println(tmap);
		/*{1=dagu, 2=xiaolong, 45=xidong, 66=zhangming, 100=liming}*/
		tmap.remove(2);
		System.out.println(tmap);
		/*{1=dagu, 45=xidong, 66=zhangming, 100=liming}*/
	}
1
2
3
4
5
6
7
8
9
10
11
12
13

NavigableMap subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) 返回的视图 可以设置是否包含左右端点

SortedMap subMap(K fromKey, K toKey) 返回的的字典的集合可以包含左端点 但是不包含右端点

public static void main(String[] args) {
		TreeMap<Integer, String> tmap = new TreeMap<>();
		tmap.put(100, "liming");
		tmap.put(1, "dagu");
		tmap.put(2, "xiaolong");
		tmap.put(45, "xidong");
		tmap.put(50, "zhangsan");
		tmap.put(66, "zhangming");
		System.out.println(tmap);
		/*{1=dagu, 2=xiaolong, 45=xidong, 50=zhangsan, 66=zhangming, 100=liming}*/
		System.out.println(tmap.subMap(2, 66));  // 只包含左边界
		/*{2=xiaolong, 45=xidong, 50=zhangsan}*/
		
		System.out.println(tmap.subMap(2, true, 66, true));  // 可以设置是否包含左右边界
		/*{2=xiaolong, 45=xidong, 50=zhangsan, 66=zhangming}*/
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

遍历方法

和HashMap一样

排序

因为Map数据结构的特殊性质 导致使用Comparator()需要一些技巧

Comparator()只能对key值排序 所以如果想要对Key和Value都排序 可以自定义Pair类 把Key和Value封装在一起

然后把Key值设置为Pair类型 这个时候的Value随便什么都可以

public static void main(String[] args) {
		// 按照Key值从大到小排序
		TreeMap<Integer, String> tmap = new TreeMap<>(new Comparator<Integer>() {
			@Override
			public int compare(Integer o1, Integer o2) {
				int num = 0;
				if (o1 > o2) num = -1;
				else num = 1;
				return num;
			}
		});
		tmap.put(100, "liming");
		tmap.put(1, "dagu");
		tmap.put(2, "xiaolong");
		tmap.put(45, "xidong");
		tmap.put(50, "zhangsan");
		tmap.put(66, "zhangming");
		System.out.println(tmap);
		/*{100=liming, 66=zhangming, 50=zhangsan, 45=xidong, 2=xiaolong, 1=dagu}*/
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20