面向对象
Map<K,V>集合:该集合存储键值对。一对一往里存,而且要保证键的唯一性。
无返回值
clear()
从此映射中移除所有映射关系(可选操作)。布尔型
containsKey(Object key)
如果此映射包含指定键的映射关系,则返回 true。布尔型
containsValue(Object value)
如果此映射将一个或多个键映射到指定值,则返回 true。Set<Map.Entry<K,V>>
entrySet()
返回此映射中包含的映射关系的Set
视图。布尔型
equals(Object o)
比较指定的对象与此映射是否相等。V
get(Object key)
返回指定键所映射的值;如果此映射不包含该键的映射关系,则返回null
。整数 hashCode()
返回此映射的哈希码值。布尔型 isEmpty()
如果此映射未包含键-值映射关系,则返回 true。Set<K>
keySet()
返回此映射中包含的键的Set
视图。V
put(K key,V value)
将指定的值与此映射中的指定键关联(可选操作)。无返回值 putAll(Map<? extendsK,? extendsV> m)
从指定映射中将所有映射关系复制到此映射中(可选操作)。V
remove(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)
比较指定对象与此项的相等性。K
getKey()
返回与此项对应的键。V
getValue()
返回与此项对应的值。整数
hashCode()
返回此映射项的哈希码值。V
setValue(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也是一个接口,她是接口中的一个内部接口。*/
集合(Map练习)
代码示例:
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);
}
}
/*
每一个学生都有对应的归属地
学生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);
}