/*
Map集合,map集合的两种取出方式。map里面有集合类,map扩展。
*/
/*
Map接口
Map集合:该集合存储键值对。一对一对往里存。而且要保证键的唯一性。
1,添加。
put(K key, V value) 将指定的值与此映射中的指定键关联(可选操作)。
putAll(Map<? extends K,? extends V> m) 从指定映射中将所有映射关系复制到此映射中(可选操作)。
2,删除。
clear() 从此映射中移除所有映射关系(可选操作)。
remove(Object key)
3,判断。
containsValue(Object value)
containsKey(Object key) 如果此映射包含指定键的映射关系,则返回 true。
isEmpty()
4,获取。
get(Object key) 返回指定键所映射的值;如果此映射不包含该键的映射关系,则返回 null。
size() 返回此映射中的键-值映射关系数。
values() 返回此映射中包含的值的 Collection 视图。
Map没有迭代方法,可以用下面二个方式作取出操作。
entrySet() 返回Map.Entry关系的Set集合。
keySet() 返回键的Set集合
Map
|--Hashtable:底层是哈希表数据结构,不可以存入null键null值。该集合是线程同步的。jdk1.0.效率低。
为了成功地在哈希表中存储和获取对象,用作键的对象必须实现 hashCode 方法和 equals 方法。
|--HashMap:底层是哈希表数据结构,允许使用 null 值和 null 键,该集合是不同步的。将hashtable替代,jdk1.2.效率高。
|--TreeMap:底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。
Map和Set很像。 其实:Set底层就是使用了Map集合。
*/
import java.util.*;
class MapDemo
{
public static void main(String[] args)
{
Map<String,String> map = new HashMap<String,String>();
//添加元素,如果添加时,出现相同的键。
//那么后添加的值会覆盖原有键对应值。
//并且put方法会返回被覆盖的原来的值。
System.out.println("put:"+map.put("01","zhangsan1"));
System.out.println("put:"+map.put("01","wangwu"));
map.put("02","zhangsan2");
map.put("03","zhangsan3");
System.out.println("containsKey:"+map.containsKey("022"));
//System.out.println("remove:"+map.remove("02"));先返回再删除,不存在就返回null
System.out.println("get:"+map.get("023"));
//可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断。
//返回null代表不存在。
map.put(null,"aha");//HashMap中null可以作为键存在。
map.put("04",null);
System.out.println("get:"+map.get("04"));
//获取map集合中所有的值。HashMap没有顺序。
map.values();
Collection<String> coll = map.values();
System.out.println(coll);
System.out.println(map);
}
}
/*
map集合的两种取出方式:
1,Set<k> keySet:将map中所有的键存入到Set集合,因为set具备迭代器。
可以迭代方式取出所有的键,在根据get方法。获取每一个键对应的值。
Map集合的取出原理:将map集合转成set集合。在通过迭代器取出。
2,Set<Map.Entry<k,v>> entrySet:将map集合中的映射关系存入到了set集合中,
而这个关系的数据类型就是:Map.Entry
Entry其实就是Map中的一个static内部接口。
为什么要定义在内部呢?
因为只有有了Map集合,有了键值对,才会有键值的映射关系。
关系属于Map集合中的一个内部事物。
而且该事物在直接访问Map集合中的元素。
*/
class MapDemo2
{
public static void main(String[] args)
{
Map<String,String> map1 = new HashMap<String,String>();
map1.put("02","zhangsan2");
map1.put("03","zhangsan3");
map1.put("01","zhangsan1");
map1.put("04","zhangsan4");
//第二种方法。
Set<Map.Entry<String,String>> entrySet = map1.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();
System.out.println("key:"+key+"value:"+value);
}
/*第一种方式;
//先获取map集合的所有键的Set的集合,keySet()方法;
Set<String> keySet = map1.keySet();
//将Map集合中的映射关系取出,存入到Set集合中。
//有了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);
}
*/
}
}
/*练习题
学生属性:姓名,年龄
注意:姓名和年龄相同的视为同一个学生
保证学生的唯一性。
1描述学生
2定义map容器,将学生作为键,地址作为值,存入
3获取map集合中的元素。
*/
import java.util.*;
class Student implements Comparable<Student>
{
private String name;
private int age;
Student(String name,int age)
{
this.name = name;
this.age = 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;
}
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 stu = (Student)obj;
return this.name.equals(stu.name) &&this.age == age;
}
}
class MapTest
{
public static void main(String[] args)
{
HashMap<Student,String> hm = new HashMap<Student,String>();
hm.put(new Student("lisi1",21),"beijing");
hm.put(new Student("lisi2",22),"shanghai");
hm.put(new Student("lisi3",23),"nanjing");
hm.put(new Student("lisi4",24),"wuhan");
//方式一keySet
Set<Student> keySet = hm.keySet();
Iterator<Student> it = keySet.iterator();
while(it.hasNext())
{
Student stu = it.next();
String adds = hm.get(stu);
System.out.println(stu+"..."+adds);
}
// 方式二。entrySet
Set<Map.Entry<Student,String>> keyEntry = hm.entrySet();
Iterator<Map.Entry<Student,String>> iter = keyEntry.iterator();
while(iter.hasNext())
{
Map.Entry <Student,String>me = iter.next();
Student stu = me.getKey();
String adds = me.getValue();
System.out.println(stu+"---"+adds);
}
}
}
/*
需求:对学生对象的年龄进行升序排序
因为数据是以键值对形式存在的。所以要使用可以排序的
Map集合,TreeMap
然后再按名字排.指定比较器
注意:名字相同,再按年龄,二个都相同时,后面的会覆盖前面的。
*/
import java.util.*;
class StudentComp 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 MapTest2
{
public static void main(String[] args)
{
TreeMap<Student,String> tm = new TreeMap<Student,String>(new StudentComp());
tm.put(new Student("lisi1",21),"beijing");
tm.put(new Student("lisi2",22),"shanghai");
tm.put(new Student("lisi3",23),"nanjing");
tm.put(new Student("lisi4",24),"wuhan");
Set<Map.Entry<Student,String>> entrySet = tm.entrySet();
Iterator <Map.Entry<Student,String>> it = entrySet.iterator();
while(it.hasNext())
{
Map.Entry<Student,String> me = it.next();
Student stu = me.getKey();
String s = me.getValue();
System.out.println(stu+"..."+s);
}
}
}
/*
练习:
"sdfgzxcvasdfxcvdf"获取该字符串中的字母出现的次数
希望打印结果:a(1)c(2)
通过结果发现,每一个字母都有对应的次数
说明字母和次数之间都有映射关系
注意了,当发现有映射关系时,可以选择map集合,
因为map集合中存放就是映射关系
什么时候使用map集合呢?
当数据之间存在映射关系时,就要先想到map集合。
思路:第一次用a字母作为键去找集合。那么集合没有
a这个键,所以也没有对应的次数。返回null
如果为null,就将a字母和1存入集合。
如果指定的键已经存在,说明有对应的次数,
那么就将对应的次数取出,自增,再重新存入集合。
1.先将字符串转换成字符数组,因为要对每一个字母操作
2.定义一个map 集合,因为打印结果的字母有顺序,
所以使用TreeMap 集合
3.遍历字符数组。将每一个字母作为键去查map集合
如果返回null,将该字母和1存入到map集合中
如果返回不是null,说明该字母在map集合已经存在并有对应次数
那么就获取该次数并进行自增,然后将该字母和自增后的次数
存入到map集合中,覆盖掉原来键所对应的值。
4.对map集合中的数据变成指定的字符串形式返回。
*/
import java.util.*;
class MapTest3
{
public static void main(String[] args)
{
String s = charCount("sdfgzxcc,vasdfx,.c.vdf");
System.out.println(s);
}
public static String charCount(String str)
{
char[] chs = str.toCharArray();
TreeMap<Character,Integer>map = new TreeMap<Character,Integer>();
for(int i = 0;i<chs.length;i++)
{
if(!(chs[i]>='a' && chs[i]<='z' || chs[i]>='A' && chs[i]<='Z'))
continue;
Integer value = map.get(chs[i]);
int count = 1;
if(value == null)
{
map.put(chs[i],1);
}else
{
count = value +1;
map.put(chs[i],count);
}
}
//System.out.println(map);
StringBuilder sb = new StringBuilder();
Set<Map.Entry<Character,Integer>> entrySet = map.entrySet();
Iterator<Map.Entry<Character,Integer>>it = entrySet.iterator();
while(it.hasNext())
{
Map.Entry<Character,Integer> me = it.next();
Character key = me.getKey();
Integer value = me.getValue();
sb.append(key+"("+value+")");
sb.append(",");
}
return sb.toString();
}
}
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
public class MapDemo3 {
/**map里面有集合类,map扩展
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
getStudent_2();
}
public static void getStudent_2()//这是很常见的。
{
Map<String,HashSet<Student>> czbk = new HashMap<String,HashSet<Student>>();
HashSet<Student> yuye = new HashSet<Student>();
HashSet<Student> zhaoye = new HashSet<Student>();
czbk.put("yuye", yuye);
czbk.put("zhaoye", zhaoye);
yuye.add(new Student("zhaosan",10));
yuye.add(new Student("lisi",12));
zhaoye.add(new Student("wangwu",19));
zhaoye.add(new Student("zhangqi",20));
Iterator<String> it = czbk.keySet().iterator();
while(it.hasNext())
{
String room = it.next();
System.out.println(room);
HashSet<Student> stu = czbk.get(room);
Iterator<Student> iter = stu.iterator();
while(iter.hasNext())
{
Student stuu = iter.next();
System.out.println(stuu.getName()+".."+stuu.getAge());
}
}
}
public static void getStudent()
{
Map<String,HashMap<String,String>> czbk = new HashMap<String,HashMap<String,String>>();
HashMap<String,String> yuye = new HashMap<String,String>();
HashMap<String,String> zhaoye = new HashMap<String,String>();
czbk.put("yuye", yuye);
czbk.put("zhaoye", zhaoye);
yuye.put("001", "zhaosan");
yuye.put("002", "zhanwu");
zhaoye.put("001", "lisi");
zhaoye.put("002", "wangwu");
Iterator<String> it = czbk.keySet().iterator();
while(it.hasNext())
{
String room = it.next();
System.out.println(room);
HashMap<String,String> stu = czbk.get(room);
Iterator<String> iter = stu.keySet().iterator();
while(iter.hasNext())
{
String id = iter.next();
String name = stu.get(id);
System.out.println(id+"::"+name);
}
}
}
}
day16Map集合,map集合的两种取出方式。map里面有集合类,map扩展。
最新推荐文章于 2021-11-30 09:58:41 发布