黑马程序员-Java基础:集合(Map)

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

双列集合-Map总结

一、Map概述

Map集合中存储的元素为键值对形式，即所有元素都是键值对的映射 .

特点：一个映射不能包含重复的键；每个键最多只能映射到一个值 .

主要功能 :

a: 添加

    V put(K key, V value):
添加元素.

b: 删除

    void clear(): 移除所有的元素.

    V remove(Object key): 根据指定的键进行删除.

c: 获取功能

   Set<Map.Entry<K,V>> entrySet(): 获取所有的键值对对象的Set集合(重点).

   V get(Object key): 根据键获取值.

   Set<K> keySet(): 获取所有的键对应的Set集合(重点).

   Collection<V> values(): 获取所有的值对应的Collection集合

 d: 长度功能

   int size(): 获取集合的长度.

 e: 判断功能 

   boolean containsKey(Object key): 判断这个集合是否包含指定的key.

   boolean containsValue(Object value): 判断这个集合是否包含指定的value.

   boolean isEmpty():
判断集合是否为空.

Map 和 Collection 集合区别:

a: Map集合属于双列集合,Collection集合属于单列集合

b: Map集合的数据结构只针对键有效,而Collection集合的数据结构对存储的元素有效

c: Map集合的键唯一 , 而Collection集合中的Set集合可以保证元素的唯一性

例1-1：基本功能

public class MapDemo {

public static void main(String[] args) {

/**
* V put(K key,V value): 添加元素
V remove(Object key): 根据指定的key删除元素
void clear(): 移除所有的元素
boolean containsKey(Object key): 判断是否包含指定的key
boolean containsValue(Object value):判断是否包好指定的value
boolean isEmpty(): 判断集合是否为空
int size(): 获取集合的长度
*/
// 创建对象
Map<String , String> map = new HashMap<String , String>() ;

// V put(K key,V value): 添加元素
/**
* V: 如果是第一次添加那么返回的就是null,如果不是第一次添加,如果键相同那么返回的就是上一次键对应的值
*/
System.out.println(map.put("文章", "马伊琍")) ;
System.out.println(map.put("文章", "姚笛")) ;

// V remove(Object key):根据指定的key删除元素
/**
* V: 返回的是键对应的值
*/
System.out.println(map.remove("文章"));

// void clear():
map.clear() ;

// boolean containsKey(Object key): 判断是否包含指定的key
System.out.println(map.containsKey("文章"));
System.out.println(map.containsKey("文章2"));

// boolean containsValue(Object value):判断是否包好指定的value
System.out.println(map.containsValue("马伊琍"));
System.out.println(map.containsValue("姚笛"));

// boolean isEmpty(): 判断集合是否为空
System.out.println(map.isEmpty());

// int size(): 获取集合的长度
System.out.println(map.size());

// 输出
System.out.println("Map :" + map);

}

}
例1-2：Map集合遍历
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
* Map集合的遍历: 根据键获取值的遍历
* 步骤:
* a: 创建集合对象
* b: 添加元素
* c: 获取所有的键对应的Set集合
* e: 遍历当前的Set集合获取每一个元素,而每一个元素就是键 , 然后根据当前遍历的键获取对应的值
*/
public class MapDemo3 {

public static void main(String[] args) {

// 创建集合对象
Map<String , String> map = new HashMap<String, String>() ;

// 添加元素
map.put("乔峰", "阿朱") ;
map.put("段誉", "王语嫣") ;
map.put("虚竹", "梦姑") ;
map.put("方丈", "叶二娘") ;

// 获取所有的键对应的Set集合
Set<String> keys = map.keySet() ;

// 遍历
for(String s : keys) {

// 根据当前遍历的元素获取对应的值
String value = map.get(s) ;

// 输出
System.out.println(s + "----" + value);
}
}

}输出结果：
方丈----叶二娘

虚竹----梦姑

乔峰----阿朱

段誉----王语嫣

二、HashMap

HashMap是基于哈希表的Map接口实现 

哈希表的作用是用来保证键的唯一性的。 

类似于HashSet集合，键中元素需要重写hashCode()和equals()方法 

元素的使用和Map集合相同。

HashMap和Hashtable的区别：

HashMap: 线程不安全 , 效率高  , 允许null值和null键

Hashtable:线程安全 , 效率低 , 不允许null和null键

列2-1：HashMap的遍历

需求:HashMap集合键是String值是Student

public class HashMapDemo2 {

public static void main(String[] args) {

// 创建集合对象
HashMap<String , Student> map = new HashMap<String , Student>() ;

// 创建自定义对象
Student s1 = new Student("刘亦菲" , 18) ;
Student s2 = new Student("赵丽颖" , 16) ;
Student s3 = new Student("陈伟博" , 16) ;
Student s4 = new Student("裴杲琪" , 18) ;

// 把自定义对象添加到集合中
map.put("001", s1) ;
map.put("002", s2) ;
map.put("003", s3) ;
map.put("004", s4) ;

// 遍历
// 第一种遍历: 通过键获取值进行遍历
Set<String> keys = map.keySet() ;

// 循环
for(String key : keys) {

// 通过键获取值
Student s = map.get(key) ;

// 输出
System.out.println(key + "---" + s.getName() + "----" + s.getAge());
}

System.out.println("---------------------------");

// 第二种遍历方式: 通过键值对对象进行遍历
Set<Entry<String,Student>> entrySet = map.entrySet() ;

// 循环
for(Entry<String,Student> en : entrySet) {

// 获取键
String key = en.getKey() ;

// 获取值
Student s = en.getValue() ;

// 输出
System.out.println(key + "---" + s.getName() + "----" + s.getAge());

}

}

}

三、LinkedHashMap 

是Map接口的哈希表和链接列表实现，具有可预知的迭代顺序， 有序 , 并且键是唯一的。 
由哈希表保证键的唯一性 
由链表保证键的有序(存储和取出的顺序一致) 
例：遍历
public class LinkedHashMapDemo {

public static void main(String[] args) {

// 创建对象
LinkedHashMap<String , String> map = new LinkedHashMap<String , String>() ;

// 添加元素
map.put("hello", "你好") ;
map.put("world", "世界") ;
map.put("java", "爪哇") ;
map.put("java", "爪哇2") ;

// 遍历集合
// 第二种遍历方式: 根据键值对对象遍历集合
// 获取到键值对对象对应的Set集合
Set<Entry<String,String>> entrySet = map.entrySet() ;

// 遍历
for(Entry<String,String> en : entrySet) {

// 获取键
String key = en.getKey() ;

// 获取值
String value = en.getValue() ;

// 输出
System.out.println(key + "----" + value);

}

}

}
四、TreeMap

TreeMap : 底层的数据结构是二叉树, 可以对元素进行排序,而排序有分为两种方式:

第一种是自然排序 。

第二种是比较器排序, 那么我们区分到底使用的是那种排序主要依赖于构造方法。

Map集合的数据结构只针对键有效

例4-1:自然排序

public class TreeMapDemo {
public static void main(String[] args) {
// 创建一个集合对象
TreeMap<Integer , String> map = new TreeMap<Integer , String>() ;
// 添加元素
map.put(23, "乔丹") ;
map.put(24, "科比") ;
map.put(3, "艾弗森") ;
map.put(1, "麦迪") ;
map.put(1, "姚明") ;
// 遍历
// 第一种遍历: 使用键获取值的遍历
Set<Integer> keySet = map.keySet() ;
// 循环
for(Integer i : keySet) {
// 获取值
String value = map.get(i) ;
// 输出
System.out.println(i + "----" + value);
}
System.out.println("------------------------------");
// 第二种遍历方式: 获取键值对对象进行遍历
Set<Entry<Integer,String>> entrySet = map.entrySet() ;

// 循环
for(Entry<Integer,String> en : entrySet) {

// 获取键
Integer key = en.getKey() ;

// 获取值
String value = en.getValue() ;

// 输出
System.out.println(key + "----" + value);
}
}
}运行结果：
1----姚明

3----艾弗森

23----乔丹

24----科比

------------------------------

1----姚明

3----艾弗森

23----乔丹

24----科比

例4-2:比较器排序
public class TreeMapDemo {
public static void main(String[] args) {
// 创建对象
TreeMap<Student, String> map = new TreeMap<Student ,String>(new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
// 比较年龄
int num = s1.getAge() - s2.getAge() ;
// 比较姓名
int num2 = (num == 0) ? s1.getName().compareTo(s2.getName()) : num ;
return num2 ;
}
}) ;
// 创建自定义对象
Student s1 = new Student("太上老君" , 300) ;
Student s2 = new Student("元始天尊" , 200) ;
Student s3 = new Student("玉皇大帝" , 400) ;
Student s4 = new Student("孙悟空" , 100) ;

// 把自定义对象添加到集合中
map.put(s1, "帅呆了") ;
map.put(s2, "酷毙了") ;
map.put(s3, "无法比喻了") ;
map.put(s4, "还有谁?") ;

// 遍历
// 第二种方式: 获取所有的键值对对象进行遍历
Set<Entry<Student,String>> entrySet = map.entrySet() ;

// 循环
for(Entry<Student,String> en : entrySet) {

// 获取键
Student key = en.getKey() ;

// 获取值
String value = en.getValue() ;

// 输出
System.out.println(key.getName() + "----" + key.getAge() + "---" + value);
}
}
}运行结果：
孙悟空----100---还有谁?

元始天尊----200---酷毙了

太上老君----300---帅呆了

玉皇大帝----400---无法比喻了

五、TreeMap

对集合进行操作的工具类，都是静态方法。 

简单介绍几种方法，如过需要详细了解请查阅API文档：

public static <T> void sort(List<T> list)：排序 默认情况下是自然顺序。
public static <T> int binarySearch(List<?> list,T key):二分查找
public static <T> T max(Collection<?> coll):最大值
public static void reverse(List<?> list):反转
public static void shuffle(List<?> list):随机置换