Java面向对象——集合框架（Map）

欢迎光临新长城博客中心

面向对象

Map<K,V>集合：该集合存储键值对。一对一往里存，而且要保证键的唯一性。

无返回值clear()
          从此映射中移除所有映射关系（可选操作）。布尔型containsKey(Object key)
          如果此映射包含指定键的映射关系，则返回 true。布尔型containsValue(Object value)
          如果此映射将一个或多个键映射到指定值，则返回 true。 Set<Map.Entry<K,V>>entrySet()
          返回此映射中包含的映射关系的 Set 视图。布尔型equals(Object o)
          比较指定的对象与此映射是否相等。 Vget(Object key)
          返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。整数hashCode()
          返回此映射的哈希码值。布尔型isEmpty()
          如果此映射未包含键-值映射关系，则返回 true。 Set<K>keySet()
          返回此映射中包含的键的 Set 视图。 Vput(K key,V value)
          将指定的值与此映射中的指定键关联（可选操作）。无返回值putAll(Map<? extendsK,? extendsV> m)
          从指定映射中将所有映射关系复制到此映射中（可选操作）。 Vremove(Object key)
          如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。整数size()
          返回此映射中的键-值映射关系数。

Map

|--Hashtable：底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。JDK1.0.效率低。

此类实现一个哈希表，该哈希表将键映射到相应的值。任何非null 对象都可以用作键或值。

为了成功地在哈希表中存储和获取对象，用作键的对象必须实现 hashCode 方法和 equals 方法。

|--HashMap：基于哈希表的Map接口的实现。此实现提供所有可选的映射操作，并允许使用null 值和null键。

（除了非同步和允许使用null 之外，HashMap 类与Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。 将 Hashtable替代，JDK1.2.效率高。

 |--TreeMap：基于红黑树（Red-Black tree）的 NavigableMap 实现。该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator（比较器） 进行排序，具体取决于使用的构造方法。 
和Set很像。其实大家，Set底层就是使用了Map集合。线程不同步。可以用于给Map集合中的键进行排序。

代码示例：

import java.util.Map;

import java.util.HashMap;

import java.util.Collection;

public class Test{  

public static void main(String[] args){  

Map<String,String> map = new HashMap<String,String>();

//添加元素

map.put("01","程序员——张三");

map.put("02","程序员——李四");

map.put("03","程序员——王五");

map.put("null","程序员——赵六");/*可以存入空值，但是不常见，所以可以通过get方法的返回值，null来判断一个键的不存在*/

sop(map.containsKey("02"));

sop(map.get("null"));

if(map.get("null")!=null)

map.remove(map.get("null"));

else

sop("Value to Null");

//可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断。

sop(map.remove("02"));/*返回值是删除键的值*/

sop(map.containsKey("02"));

sop("-----------");

//获取map集合中所有的值。

Collection<String> coll = map.values();

sop(coll);

map.put("01","zhangsan1"); /*如果加入的键和值都相同的话，返回null*/

map.put("01","zhangsan2");/*当添加相同的键而值不同，则后添加的值会覆盖原有值，并且返回原有值*/

}  

public static void sop(Object obj){

System.out.println(obj);

}

} 

Map

(1)Map是一个键值对形式的集合。它的元素都是由键和值组成。

(2)Map和Collection的区别?(面试题)

A:Map 是由键值对组成的集合,Map的键是唯一的,值可以重复。

B:Collection 是有单列数据组成的集合,它的儿子List是可以重复的，Set是唯一的。

(3)HashMap和Hashtable的区别?(面试题)

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

Hashtable:线程安全，效率低。不允许null键和值。

Map集合的两种取出方法

1，Set<k> keySet：将Map中所有的键存入到Set集合，因为Set具备迭代器。

所以可以迭代方式取出所有的键，再根据get方法获取每个键对应的值

Map集合取出原理：将Map集合转化成Set集合，再通过迭代器取出。

2Set<Map.Entry<k,v>> entrySet:将Map集合中的映射关系存入到Set集合中，而这个关系的数据类型就是：Map.Entry

根据键获取值（妻子找丈夫）

/*

1、Set<K> keySet() 
将Map中所有的键存入到Set集合，因为set具备迭代器。
所有可以迭代方式取出所有的键，再根据get方法，获取每一个键对应的值
*/

import java.util.Map;

import java.util.HashMap;

import java.util.Collection;

import java.util.Iterator;

import java.util.Set;
public class Test{  

public static void main(String[] args){  

Map<String,String> map = new HashMap<String,String>();

map.put("01","程序员——张三");

map.put("02","程序员——李四");

map.put("03","程序员——王五");

map.put("04","程序员——赵六");

Set<String> keySet = map.keySet();

for(Iterator<String> iter = keySet.iterator();iter.hasNext();){

String key = iter.next();

String value = map.get(iter.next());

sop("key:"+key+"...value:"+value);

}

}

public static void sop(Object obj){

System.out.println(obj);

}

}

Entry 接口方法

布尔型equals(Object o)
          比较指定对象与此项的相等性。 KgetKey()
          返回与此项对应的键。 VgetValue()
          返回与此项对应的值。整数hashCode()
          返回此映射项的哈希码值。 VsetValue(V value)
          用指定的值替换与此项对应的值（可选操作）。

/*

Set<Map.Entry<K,V>> entrySet() 
返回此映射所包含的映射关系的 Set 视图。 
将Map集合中的映射关系存入到了set集合中，而这个关系的数据类型就是：Map.Entry
entrySet():将Map集合中的映射关系取出。
这个关系就是 Map.Entry 类型
那么关系对象 Map.Entry 获取到后，就可以通过，Map.Entry中getKey和getValue方法获取关系中的键和值
Map.Entry 其实Entry也是一个接口，她是接口中的一个内部接口。

*/

通过映射关系获取键和值(结婚证找妻子丈夫)

代码示例：

import java.util.Map;

import java.util.HashMap;

import java.util.Collection;

import java.util.Iterator;

import java.util.Set;
public class Test{  

public static void main(String[] args){  

Map<String,String> map = new HashMap<String,String>();

map.put("01","程序员——张三");

map.put("02","程序员——李四");

map.put("03","程序员——王五");

map.put("04","程序员——赵六");

Set<Map.Entry<String,String>> entrySet = map.entrySet();

for(Iterator<Map.Entry<String,String>> iter = entrySet.iterator();iter.hasNext();){

Map.Entry<String,String>me = iter.next();

String key = me.getKey();

String value =me.getValue();

sop("key:"+key+"...value:"+value);

}

}

public static void sop(Object obj){

System.out.println(obj);

}

}

集合(Map练习)

/*
每一个学生都有对应的归属地
学生Student,地址String
学生属性：姓名，年龄
主意：姓名和年龄相同的视为同一个学生。
保证学生的唯一性

1、描述学生
2、定义Map容器，将学生作为键，地址作为值，存入
3、获取map集合中元素
*/

import java.util.Map;

import java.util.HashMap;

import java.util.Collection;

import java.util.Iterator;

import java.util.Set;

class Student implements Comparable{

private String name;

private int age;

Student(String name,int age){

this.name = name;

this.age = age;

}

public String getName(){

return name;

}

public int getAge(){

return age;

}

public String toString(){

return name+":"+age;

}

public int hashCode(){ 

return name.hashCode()+age*34;

}

public boolean equals(Object obj){

if(!(obj instanceof Student))

throw new ClassCastException("类型不匹配");

Student s = (Student)obj;

return this.name.equals(s.name) && this.age==s.age;

}

public int compareTo(Object obj){

Student s = (Student)obj;

int num = new Integer(this.age).compareTo(new Integer(s.age));

if(num==0)

return this.name.compareTo(s.name);

return num;

}

}

public class Test{  

public static void main(String[] args){  

Map<Student,String> map = new HashMap<Student,String>();

map.put(new Student("程序员——张三",23),"北京");

map.put(new Student("程序员——李四",24),"上海");

map.put(new Student("程序员——王伍",25),"深圳");

map.put(new Student("程序员——赵六",26),"广州");

sop("第一种方式");

Set <Student> keySet = map.keySet();

for(Iterator<Student> it = keySet.iterator();it.hasNext();){

Student key = it.next();

String value = map.get(key);

sop("key:"+key+"...value:"+value);

}

sop("第二种方式");

Set<Map.Entry<Student,String>> entrySet = map.entrySet();

for(Iterator<Map.Entry<Student,String>> iter = entrySet.iterator();iter.hasNext();){

Map.Entry<Student,String>me = iter.next();

Student key = me.getKey();

String value =me.getValue();

sop("key:"+key+"...value:"+value);

}

}

public static void sop(Object obj){

System.out.println(obj);

}

}

集合(TreeMap练习-字母出现的次数)

/*

练习：

"sdfgzxcvasdfxcvdf"获取该字符串中的字母出现的次数

希望打印结果  a(1)c(2)

通过结果发现，每一个字母都有对应的次数

说明字母和次数之间都有映射关系。

注意了，当发现有映射关系时，可以选择Map集合。

因为Map集合中存放的就是映射关系.

什么时候使用Map集合呢？

当数据之间存在这种映射关系时候，就要先想到Map集合。

思路：

1、将字符串转换成字符数组，因为要对每一个字母进行操作

2、定义一个Map集合，因为打印结果的字母有顺序，所以使用TreeMap集合

3、遍历字符数组，

将每一个字母作为键去查map集合

如果返回null，将该字母和1存入到集合中

如果返回不是null，说明该字母在Map集合已存在，并有已存在的次数，那么获取该次数并自增，然后将该字母和自增后的次数存入到Map集合中，覆盖掉原键所对应的值.

4、将Map集合中的数据编程指定的字符串形式返回。

*/

import java.util.Map;

import java.util.Collection;

import java.util.Iterator;

import java.util.Set;

import java.util.TreeMap;

importjava.util.Comparator;

import java.util.TreeSet;

public class Test{  

public static void main(String[] args){  

String str = "sdfgzxcvasdfxcvdf";

System.out.println(keyCount(str));

}

public static String keyCount(String str){

char [] arr = str.toCharArray();

Map<Character,Integer> map =new TreeMap <Character,Integer>();

for(intx=0;x<arr.length;x++){

if(!(arr[x]>='a'&&arr[x]<='z'||arr[x]>='A'&&arr[x]<='Z'))

continue;

Integer value = map.get(arr[x]);

int count = 0;

if(value!=null)

count =value;

count++;

map.put(arr[x],count);

}

StringBuilder sb =new StringBuilder();

Set<Map.Entry<Character,Integer>>entrySet = 

new TreeSet<Map.Entry<Character,Integer>>(new Comparator(){

public int compare(Object obj1,Object obj2){

return 1;

}

}

);

entrySet = map.entrySet();

for(Iterator<Map.Entry<Character,Integer>> it = entrySet.iterator();it.hasNext();){

Map.Entry<Character,Integer> me = it.next();

Character c = me.getKey();

Integer i = me.getValue();

sb.append(c+" ("+i+") ");

}

return sb.toString();

}

}

集合(Map扩展)

/*

Map扩展知识。

Map结合被使用，是因为具备映射关系。

一个学校，每个学校都有班级，班级都有名称

*/

import java.util.HashMap;

import java.util.Map;

import java.util.Iterator;

public class Test{

public static void main(String[] args){

Map<String,String> chongci = new HashMap<String,String>();

chongci.put("01","程序员——张三");

chongci.put("02","程序员——李四");

Map<String,String> jiuye = new HashMap<String,String>();

jiuye.put("01","程序员——王五");

jiuye.put("02","程序员——赵六");

Map<String,Map<String,String>> czbk =  new HashMap<String,Map<String,String>>();

czbk.put("就业班",chongci);

czbk.put("冲刺班",jiuye);

//取出某个班级的学生

//getStudentInfo(yure);

for(Iterator<String> it = czbk.keySet().iterator();it.hasNext();){

String roomName = it.next();

sop(roomName);

getStudentInfo(czbk.get(roomName));

}

}

public static void getStudentInfo(Map<String,String> roomMap){

for(Iterator<String> it = roomMap.keySet().iterator();it.hasNext();){

String key = it.next();

String value = roomMap.get(key);

sop(key+":"+value);

}

}

public static void sop(Object obj){

System.out.println(obj);

}

}