java之16天 Map集合 (一)
Map 集合的使用
Map 集合的两种取出方式
Map练习
/**
* Map集合: 该集合存储键值对,一对一对往里存,而且要保证键的唯一性
* 1.添加
* put(K key,V value)
* void putAll(Map<? extends K,? extends V> m)
* 2.删除
* clear()
* remove()
* 3.判断
* containsKey(Object Key)
* containsValue(Object value)
* isEmpty()
*
* 4.获取
* get(Object key)
* size()
* values()
* Set<Map.Entry<K,V>> entrySet()
* Set<K> keySet()
*
* Map
* |--HashTable: 底层是哈希表数据结构,不可以存入null键 和 null值,该集合是线程同步JDK 1.0. 无序
* |--HashMap:底层是哈希表数据结构,并允许使用null键null值,该集合不同步.JDK 1.2 效率高,无序
* |--TreeMap:底层是二叉树数据结构,线程不同步,可以用于给Map集合中的键排序.
*
* 和 Set 很像
* 其实,Set底层就是使用Map集合.
*
*/
public class MapDemo {
public static void main(String[] args) {
Map<String,String> map=new HashMap<String,String>();
//添加元素,如果出现添加元素时,相同的键,那么后添加的值会覆盖原来键的对应值,并会返回被覆盖的值.
map.put("01", "zhangsan1");
map.put("02", "zhangsan2");
System.out.println("put:"+map.put("03", "zhangsan3")); //put 会返回 这个键对应的原来的值
System.out.println("put:"+map.put("03", "zhangsan4"));
System.out.println("containsKey:"+map.containsKey("022"));
System.out.println("remove:"+map.remove("002"));//不存在的可以 就返回 null
System.out.println("remove:"+map.remove("02")); //存在的 删除 并返回 要删除的对象
System.out.println(map);
System.out.println("get:"+map.get("03")); //可以通过get方法的返回值来判断键是否存在
map.put(null, "hah"); //HashMap可以使用 null键 null值 所以下面的能够取到值 HashTable就不行
System.out.println("nullKey:"+map.get(null));
map.put("04",null);
System.out.println("nullValue:"+map.get("04"));
//获取Map集合中所有的值
Collection<String> values=map.values();
System.out.println(values);
//获取Map集合的Key的所有值
Set<String> keys=map.keySet();
System.out.println(keys);
}
}
Map 集合的两种取出方式
/**
*Map 集合的两种取出方式
* 1.Set<key> keySet: 将Map中的所有键存入的到Set集合中,因为Set具有迭代,所以可以用迭代方式取出所有的键
* 然后根据get方式,获取每个键对应的值
*
* Map集合的取出原理: 将Map集合 转成 Set集合 再通过迭代器
*
* 2.Set<Map.Entry<K,V>> entrySet: 将Map集合中的映射关系,存入Set集合中,
* 而这个关系的数据类型就是Map.entry
*
* Map.Entry<K,V>:其实Entry也是一个接口,他是Map接口中的一个内部接口
*
* interface Map<K,V>{
* public static interface Entry<K,V>{
* public abstract K getKey();
* public abstract V getValue();
* }
*
* }
*
*/
/*interface Map<K,V>{
public static interface Entry<K,V>{
public abstract K getKey();
public abstract V getValue();
}
}*/
public class MapDemo2 {
public static void main(String[] args) {
Map<String,String> map=new HashMap<String,String>();
map.put("01", "zhangsan1");
map.put("02", "zhangsan2");
System.out.println("put:"+map.put("03", "zhangsan3")); //put 会返回 这个键被覆盖的值
System.out.println("put:"+map.put("03", "zhangsan4"));
//1.使用 keySet
//先获取Map集合的所有键的Set集合,KeySet();
Set<String> keySet=map.keySet();
//有了Set集合就可以获取其迭代器
Iterator<String> it=keySet.iterator();
while(it.hasNext()){
String key=it.next();
String value=map.get(key);
System.out.println("Key:"+key+",value:"+value);
}
System.out.println("==========================");
//2.entrySet 将map集合中的隐射关系取出,存入到Set集合这个
Set<Map.Entry<String, String>> entrySet=map.entrySet();
Iterator<Map.Entry<String, String>> it1=entrySet.iterator();
while(it1.hasNext()){
Map.Entry<String, String> me=it1.next();
System.out.println("Key:"+me.getKey()+",value:"+me.getValue());
}
}
}
Map练习
/** Map练习
* 每一个学生都有对应的归属地
* 学生Student,地址 String
* 学生属性 姓名 年龄
* 注意:姓名和年龄相同视为同一个学习
* 保证学生的唯一性.
*
* 1.描述学习
* 2.定义Map容器,将学生作为键,地址作为值,存入
* 3.获取Map集合中的元素.
*
*/
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;
}
@Override
public String toString() {
return name+":"+age;
}
@Override
public int hashCode() {
// TODO Auto-generated method stub
return name.hashCode()+age*2;
}
@Override
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;
}
@Override
public int compareTo(Student o) {
int num=new Integer(this.age).compareTo(new Integer(o.age));
if(num==0)
return this.name.compareTo(o.name);
return num;
}
}
class StuNameComparator implements Comparator<Student>{
@Override
public int compare(Student o1, Student o2) {
int num=o1.getName().compareTo(o2.getName());
if(num==0)
return new Integer(o1.getAge()).compareTo(o2.getAge());
return num;
}
}
public class MapDemo3 {
public static void main(String[] args) {
method();
System.out.println("====================");
method1();
}
//需求变了 需要保存进去的学生信息按 年龄排序
public static void method1(){
TreeMap<Student,String> tm=new TreeMap<Student,String>(new StuNameComparator());
tm.put(new Student("lisi01",21), "北京");
tm.put(new Student("lisi01",21), "天津");
tm.put(new Student("alisi02",22), "上海");
tm.put(new Student("elisi03",23), "武汉");
tm.put(new Student("clisi04",24), "南京");
Set<Map.Entry<Student, String>> entrySet=tm.entrySet();
Iterator<Map.Entry<Student, String>> it1=entrySet.iterator();
while(it1.hasNext()){
Map.Entry<Student, String> me=it1.next();
System.out.println(me.getKey()+"......"+me.getValue());
}
}
public static void method(){
HashMap<Student,String> hm=new HashMap<Student,String>();
hm.put(new Student("lisi01",21), "北京");
hm.put(new Student("lisi01",21), "天津");
hm.put(new Student("lisi02",22), "上海");
hm.put(new Student("lisi03",23), "武汉");
hm.put(new Student("lisi04",24), "南京");
//第一种取出方式 keySet
Set<Student> keySet=hm.keySet();
Iterator<Student> it=keySet.iterator();
while(it.hasNext()){
Student stu=it.next();
String addr=hm.get(stu);
System.out.println(stu+"......"+addr);
}
System.out.println("========================");
//第二种取出方式
Set<Map.Entry<Student, String>> entrySet=hm.entrySet();
Iterator<Map.Entry<Student, String>> it1=entrySet.iterator();
while(it1.hasNext()){
Map.Entry<Student, String> me=it1.next();
System.out.println(me.getKey()+"......"+me.getValue());
}
}
}