黑马程序员---Java中的映射Map

关于Java中的映射Map
--------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

1. Map 集合

Map派系的顶层接口。Map<K,V> K表示键的泛型，V表示值的泛型

Map集合自身特点
A. Map集合存储的键值对
B. Map集合必须保证键的唯一性
C. 一个键只能映射一个值

//=============================================
2. Map接口中的方法
找Map接口的实现类HashMap来使用

A. V put(K key, V value) 存储到Map集合 。返回值是V类型，返回的是值
一般情况下，put方法返回值，返回null
但是如果存储了重复键，会覆盖原有的值
put方法，会返回被覆盖之前的值

B. clear()清除Map集合中，所有的键值对

C. size()返回键值对的个数

D. boolean containsKey(键) 判断集合中，有没有这个键

E. boolean containsValue(值) 判断集合中，有没有这个值

F. V get(K) 通过键，获取值，传递键，返回键映射的值

G. V remove(Object key) 通过键，删除映射关系，键值对，返回被删除之前的值

H. Collection values() 将Map集合中，所有的值，存储到一个Collection集合

//=============================================
3. 获取出Map集合中的键值对
Map集合取出方法有两个方法

第一个方法，在Map接口中有一个方法 keySet()
返回一个Set集合，将Map中的所有的键，存储到一个Set集合
涉及到的方法，keySet()
Map接口中的get()方法

/*
* Map集合的获取方式
* 第一种 ，利用keySet方法进行获取
*/
import java.util.*;
public class MapDemo1 {
public static void main(String[] args) {
Map<String,Integer> map = new HashMap<String, Integer>();
map.put("a", 11);
map.put("b", 12);
map.put("c", 13);
map.put("d", 14);
//获取Map集合键值对
//第一步，调用Map集合中的方法keySet，将键存储到Set集合
Set<String> set = map.keySet();
//第二步，迭代器，迭代Set集合
Iterator<String> it = set.iterator();
while(it.hasNext()){
//it.next()返回的是什么，肯定String，这个返回值String，对应的就是Map集合中的键
String key = it.next();
//第三步，获取到了键，通过Map集合的get方法
Integer value = map.get(key);
System.out.println(key+"..."+value);
}
}
}

Map集合第二种取出方法
利用键值对的映射关系
映射关系也是一个对象，对象的，描述接口
就是Map接口中的内部接口 interface Entry{}
针对于现在HashMap子类，实现了Entry接口
K getKey()
返回与此项对应的键。
V getValue()
返回与此项对应的值。

实现步骤：
第一步，通过Map集合中的方法 entrySet()获取Entry类型对象
第二步，自动完成，将获取到的Entry类型对象，存储到了Set集合
第三步，程序人员拿到的是存储键值对关系的对象(Entry)的Set集合
Set中，存储的是Entry对象
第四步，迭代Set集合
迭代器获取的it.next()返回的是Entry对象
第五步，通过Entry对象，单独获取键，获取值

/*
* 使用Map.Entry内部接口，实现获取功能
* 通过键值对关系获取，结婚证
* 第一步，通过Map集合中的方法 entrySet()获取Entry类型对象
第二步，自动完成，将获取到的Entry类型对象，存储到了Set集合
第三步，程序人员拿到的是存储键值对关系的对象(Entry)的Set集合
Set中，存储的是Entry对象
第四步，迭代Set集合
迭代器获取的it.next()返回的是Entry对象
第五步，通过Entry对象，单独获取键，获取值

*/
import java.util.*;
public class MapDemo2 {
public static void main(String[] args) {
Map<String,Integer> map = new HashMap<String, Integer>();
map.put("a", 1);
map.put("b", 2);
map.put("c", 3);
map.put("d", 4);
//第一步
Set<Map.Entry<String, Integer>> set = map.entrySet();
//第四步
Iterator <Map.Entry<String, Integer>> it = set.iterator();
while(it.hasNext()){
//it.next()返回值，是Map.Entry
Map.Entry<String, Integer> me = it.next();
//第五步
String key = me.getKey();
Integer value = me.getValue();
System.out.println(key+"..."+value);
}

}
/* private static void method(){
Map<String,Integer> map = new HashMap<String, Integer>();
map.put("s",1);
Set<Map.Entry<String, Integer>> set = map.entrySet();
Iterator<Map.Entry<String, Integer>> it = set.iterator();
while(it.hasNext()){
Map.Entry<String, Integer> me = it.next();
System.out.println(me.getKey()+".."+me.getValue());
}
}*/

}

//=============================================
4. HashMap
底层结构也是哈希表，存储对象的时候，存储哈希值
线程不安全的，执行效率高
存储null,当作键，当做值

存储到哈希表中的键对象，必须重写hashCode , equals方法
保证键的唯一性

/*
* HashMap存储自定义对象，并采用两种方式获取
*/
import java.util.*;
public class HashMapDemo {
public static void main(String[] args) {
HashMap<Person,String> hm = new HashMap<Person, String>();
hm.put(new Person("lisi",20), "海淀区");
hm.put(new Person("aiyi",10), "宣武区");
hm.put(new Person("aiyi",10), "宣武区");
hm.put(new Person("zhangsan",15), "昌平区");
hm.put(new Person("write",20), "延庆县");
hm.put(new Person("write",20), "延庆县");
hm.put(new Person("jordan",20), "门头沟区");

//第一种keySet()方法
Set<Person> set = hm.keySet();
Iterator<Person> it = set.iterator();
while(it.hasNext()){
//it.next()方法，获取到的，是Person对象
Person p = it.next();
//获取值，通过Map集合中的get方法
String value = hm.get(p);
System.out.println(p+"..."+value);
}
System.out.println("=============忧郁的分割线===================");

//第二种entrySet()方法
Set<Map.Entry<Person, String>> setEntry = hm.entrySet();
Iterator<Map.Entry<Person, String>> itEntry = setEntry.iterator();
while(itEntry.hasNext()){
//it.next()获取的是Map.Entry对象
Map.Entry<Person, String> me = itEntry.next();
//通过键值对关系对象，单独的获取值值，获取键
Person p = me.getKey();
String value = me.getValue();
System.out.println(p+"..."+value);
}
}
}

//=============================================
5. Hashtable
开始于JDK1.0开始
从JDK1.2开始，实现Map接口
早期，没有集合框架概念，存储键值对，只能依靠Hashtable

Hashtable
底层数据结构，也是哈希表
线程是安全的，执行效率低
不允许存储null

由于线程安全，不允许存储null,从JDK1.2版本开始，被HashMap取代

但是Hashtable虽然已经郁郁而终，但是他的孩子Properties，至今活跃在开发的舞台

Properties
继承自Hashtable，
这个集合线程安全的！
持久的属性集可以实现永久存储
可保存在流中或从流中加载，IO流
这个集合，可以配合IO流使用，实现数据的永久保存

Properties泛型,目前为止，只能写Object
IO配合以后，这个集合的泛型固定为String,String

//=============================================
6. LinkedHashMap
有序的Map集合，怎么存储的就怎么取出来、
和LinkedHashSet用法一致

//=============================================
7. TreeMap
TreeMap集合特点
对存储到这个集合中的对象，进行排序
对象的自然顺序，比较器
线程不安全的集合，执行效率高
底层数据结构红黑树(自然平衡二叉树)

存储自定义对象，排序，对键排序

案例：

统计每个字符的出现次数
qwasddfgtnbvwqeashhwrethj
结果是：a出现1次，b出现2次, C出现5次，r出现6次
键值对 a=1 b=5

/*
* 字符串中，单个字符的出现次数
*/
import java.util.*;
public class TreeMapTest {
public static void main(String[] args) {
String str = new Scanner(System.in).nextLine();
//将字符串转成字符数组
char[] ch = str.toCharArray();
//建立Map集合，TreeMap,键就是单个字符，值就是出现次数
TreeMap<Character,Integer> tm = new TreeMap<Character, Integer>();
//遍历数组
for(int x = 0 ; x < ch.length ; x++){
//用数组中的每一个元素，作为集合的键，去获取值
Integer i = tm.get(ch[x]);
//获取的结果只有两种结果 i==null i!=null
if(i==null){
//说明这个字符在集合中，没有这个键，将字符和数字1存储到集合
tm.put(ch[x],1);
}else{
//i!=null,集合中有这个键，将这个键存储回集合，并且值++;
tm.put(ch[x], ++i);
}
}

Set<Character> set = tm.keySet();
Iterator<Character> it = set.iterator();
while(it.hasNext()){
Character c = it.next();
Integer value = tm.get(c);
System.out.println("字符"+c+" 出现了"+value+"次");
}
}
}

- -------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------