Map集合 键值对 映射关系 Hashtable HashMap TreeMap keySet entrySet Map.Entry

Map集合

该集合存储的是键值对，一对一对往里存，而且要保证键值的唯一性。

map跟collection一样，都是集合框架中的顶层接口

collection 单列集合 map 双列集合

将键映射到值得对象，一个映射不能包含重复的键，每个键最多只能映射到一个值

该集合存储键值对，一对一对往里存

put(K key,V value)	存储键值对
putAll(Map<? extendsK,? extends V> m)	将其他键值关系全部复制过来
clear（）	清空映射关系
remove(Object key)	移除映射关系
containsValue（Object value）	是否包含指定的值
containsKey（Object key）	是否包含指定的键
imEmpty（）	判断是否有键值对关系
get（Object key）	给键，获取值
size()	返回键值对长度
values()	获取值，返回来的是个collection的集合

[/code]

Map

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

|---HashMap ：底层是哈希表数据结构，允许存入null键和null值，该集合是线程不同步的。JDK1.2 效率高。

|---TreeMap：底层是二叉树结构。

Map和Set很像，

其实Set底层就是使用了Map集合。

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

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

什么时候使用map集合？

当数据之间存在着映射关系是，先想到map集合

import java.util.*;

class  Test
{
public static void main(String[] args)
{
Map<String,String> map = new HashMap<String,String>();
map.put("01","zhangsan1");
map.put("02","zhangsan2");
map.put("03","zhangsan3");
map.put("04","zhangsan3");

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

sop("containsKey:"+map.remove("02"));
sop(map);

sop("get:"+map.get("03"));
sop("get:"+map.get("05"));

//可以通过get方法的返回值来判断一个键是否存在。
//通过返回null来判断
map.put("06","null");
sop("get:"+map.get("06"));

//获取map中所有的值
Collection<String> coll = map.values();
sop(coll);
sop(map);
}

public static void sop(Object obj)
{
System.out.println(obj);
}
}

Set <> keySet() :

将map中所有的键存放到Set集合。因为set集合具备迭代器

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

entrySet()	将map中的键值关系取出（Map.Entry<k,v>）
Map.Entry（）	存储的是键值对之间的关系
getKey	取出Map.Entry()中的key值
getValue	取出Map.Entry()中的Value值

Map集合的取出原理：

将map集合转成set集合，在通过迭代器取出；

Set <Map.Entry<K,V>> > entrySet() ：

将map集合中的映射关系存入到了Set集合中，这个关系的数据类型就是Map.Entry

Map.Entry将map集合中的映射关系取出。关系类型Map.Entry获取后，

就可以通过Map.Entry中的getKey（）和getValue()方法获取键和值。

Map.Entry 其实就是一个接口，他是Map接口中的一个内部接口。

为什么将Entry定义成map的子接口

因为只有有了map集合，才能有映射关系，映射关系是Map集合内部的事物，它直接访问Map集合内部的元素，所以将Entry定义成内部规则。

Map.Entry 原理

interface Map
{
pulbic static interface Entry
{
public abstract Object getKEY();
public abstract Object getValue();
}
}

class HashMap implements Maps
{
class Hash Implements Map.Entry
{
publice Object getKey(){}
publice Object getValue(){}
}
}

import java.util.*;
class  Test
{
public static void main(String[] args)
{
Map<String,String> map = new HashMap<String,String>();
map.put("01","zhangsan1");
map.put("02","zhangsan2");
map.put("03","zhangsan3");
map.put("04","zhangsan3");

//先获取map集合的所有键的Set集合，keySet();
Set<String> keySet =map.keySet();
Iterator<String> i = keySet.iterator();
while(i.hasNext())
{
String key =i.next();
sop("key="+key);
String value = map.get(key);
sop("value="+value);
}

//将Map集合中的映射关系取出，存入到Set集合中。
Set<Map.Entry<String,String>> entrySet = map.entrySet();
Iterator<Map.Entry<String,String>> it = entrySet.iterator();
while (it.hasNext())
{
Map.Entry<String,String> me = it.next();
String key = me.getKey();
String value = me.getValue();
sop(key);
sop(value);
}
}

public static void sop(Object obj)
{
System.out.println(obj);
}
}

HashMap集合练习
取出对应的键和值

/*
每个学生都有自己的归属地
学生Student 地址 String
学生属性， 姓名 年龄
注意： 姓名和年龄相同的视为同一个学生。
保证学生的唯一性。
1描述学生
2定义map容器，将学生作为键，地址作为值，存入
3获取map集合中的元素
*/
import java.util.*;
class Test
{
public static void main(String[] args)
{
HashMap<Student ,String > map = new HashMap<Student,String>();

map.put(new Student("zhangsan1",21),"beijing");
map.put(new Student("zhangsan2",22),"shagnhai");
map.put(new Student("zhangsan3",21),"wuhan");
map.put(new Student("zhangsan4",23),"najing");
//第一种取出方式
Set<Student> ks = map.keySet();
Iterator<Student> it = ks.iterator();
while(it.hasNext())
{
Student s = it.next();
String addr = map.get(s);
sop(s.toString()+"=="+addr);
}
//第二种取出方式
Set<Map.Entry<Student,String>> entrySet = map.entrySet();
Iterator<Map.Entry<Student,String>> itr = entrySet.iterator();
while(itr.hasNext())
{
Map.Entry<Student,String> me=itr.next();
Student st = me.getKey();
String addrs = me.getValue();
sop(st.toString()+"=="+addrs);
}
}
public static void sop(Object obj)
{System.out.println(obj);}
}
class Student implements Comparable<Student>
{
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*36;}
public boolean equals(Object obj)
{
if (!(obj instanceof Student))
throw new RuntimeException("leixingcuowu");
Student s = (Student)obj;
return this.name.equals(s.name)&&this.age==s.age;
}
public int compareTo(Student s)
{
int num = this.name.compareTo(s.name);
if (num==0)
return new Integer(this.age).compareTo(new Integer(s.age));
return num;
}
}

HashTree集合练习取出对应的键和值

/*
需求：对学生对象的年龄进行升序排序

因为数据是以键值对形式存在的
所以要使用可以排序的Map集合。 TreeMap
*/
import java.util.*;
class Test
{
public static void main(String[] args)
{
TreeMap<Student ,String > map = new TreeMap<Student,String>(new MyComparator());

map.put(new Student("zhangsan3",21),"beijing");
map.put(new Student("zhangsan2",23),"shagnhai");
map.put(new Student("zhangsan3",20),"wuhan");
map.put(new Student("zhangsan4",24),"handan");
map.put(new Student("zhangsan2",23),"najing");

Set<Student> keySet = map.keySet();
Iterator<Student> it = keySet.iterator();
while(it.hasNext())
{
Student s = it.next();
String add = map.get(s);
sop(s.toString()+"=="+add);
}
Set<Map.Entry<Student,String>> entrySet = map.entrySet();
Iterator<Map.Entry<Student,String>> itr= entrySet.iterator();
while(itr.hasNext())
{
Map.Entry<Student,String> me= itr.next();
Student st = me.getKey();
String addr = me.getValue();
sop(st.toString()+"===="+addr);
}

}
public static void sop(Object obj)
{System.out.println(obj);}
}
class MyComparator implements Comparator<Student>
{
public int compare(Student s1,Student s2)
{
int num= s1.getName().compareTo(s2.getName());
if (num==0)
return new Integer (s1.getAge()).compareTo(new Integer (s2.getAge()));
return num;
}
}
class Student implements Comparable<Student>
{
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*36;}
public boolean equals(Object obj)
{
if (!(obj instanceof Student))
throw new RuntimeException("leixingcuowu");
Student s = (Student)obj;
return this.name.equals(s.name)&&this.age==s.age;
}
public int compareTo(Student s)
{
int num = new Integer(this.age).compareTo(new Integer(s.age));
if (num==0)
return  this.name.compareTo(s.name);
return num;
}
}

map练习

/*
联系
“sdafuinfsdfjdsguienfdsahk"获取该字符串中的字母出现的次数
希望打印的结果是 a(1)c(2....)

通过结果发现，每个字母都有对应的次数
说明字母和次数之间都有映射关系

注意了。当发现有映射关系时，可以选择map集合
因为map集合中存放的就是映射关系

什么时候使用map集合？
当数据之间存在着映射关系是，先想到map集合

思路
1将字符串转换成字符数组，因为要对每一个字母进行操作
2定义一个map集合，因为打印结果的字母有顺序，所以使用treeMap集合
3遍历字符数组
将每一个字母作为键去查map集合，
如果返回null，该字母和1存入map集合中
如果返回不是null，说明该字母在map集合已经存在并对应次数
那么就获取该次数并进行自增，然后将该子母和自增后的次数存入到map集合中，
覆盖调用原键所对应的值
4将map集合中的数据变成指定的字符串形式返回

*/

import java.util.*;

class Test
{
public static void main(String [] args)
{
String s=charCount("sd#@afuin_+fs+dfjdsguienfdsahk");
sop(s);
}
public static String charCount (String str)
{
char[] chs=str.toCharArray();
TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();
for (int x=0 ;x<chs.length ;x++ )
{
if(!( chs[x]>='a'&&chs[x]<='z'||chs[x]>='A'&&chs[x]<='Z') )
continue;
Integer value=tm.get(chs[x]);
int count =0;
if (value !=null)
count = value;
count++;
tm.put(chs[x],count);
count = 0;
}
sop(tm);

StringBuffer sb = new StringBuffer();
Set<Map.Entry<Character,Integer>> entrySet = tm.entrySet();
Iterator<Map.Entry<Character,Integer>> it = entrySet.iterator();
while (it.hasNext())
{
Map.Entry<Character,Integer> me=it.next();
Character ch = me.getKey();
Integer i =me.getValue();
sb.append(ch+"["+i+"] ");

}

return sb.toString();
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}

Map扩展知识

/*
map扩展知识

map集合被使用是因为具备映射关系
*/
import java.util.*;
class Test
{
public static void main(String[] args)
{
HashMap<String,HashMap<String,String>> czbk = new HashMap<String,HashMap<String,String>>();
HashMap<String,String> yure=new HashMap<String,String>();
HashMap<String,String> jiuye=new HashMap<String,String>();

czbk.put("yureban",yure);
czbk.put("jiuyeban",jiuye);

yure.put("01","zhangsan");
yure.put("02","li");

jiuye.put("01","wangwu");
jiuye.put("02","zhaoliu");

Iterator <String> it = czbk.keySet().iterator();
while (it.hasNext())
{
String roomName = it.next();
HashMap<String,String>room= czbk.get(roomName);
System.out.println(roomName);
getStudnetInfo(room);
}

getStudnetInfo(yure);

}

public static void getStudnetInfo(HashMap<String,String> roomMap)
{
Iterator<String> it = roomMap.keySet().iterator();
while (it.hasNext())
{
String id=it.next();
String name=roomMap.get(id);
System.out.println(id+"--"+name);

}
}

}