-------android培训 、java培训、期待与您交流！ ----------
Map接口 也是一个集合 集合的特点，该集合存储键值对，一对一对往里存，而且要保证键的唯一性。
1 添加
put(K key, V value)
putAll(Map<? extends K,? extends V> m)
2 删除
clear
3 判断
containsKey(Object key)
containsValue(Object value)
isEmpty()
4 获取
get(Object key)
size()
values()
Map
|-- Hashtable 底层是哈希表数据结构，不可以存入null键null值 该集合是线程同步的。效率低 JDK1.0
|-- HashMap 底层是哈希表数据结构， 允许使用null值和null键， 该集合是不同步的。效率高 ＪＤＫ１.２
|--TreeMap 底层是二叉树数据结构， 线程不同步，可以用于给Ｍａｐ集合中的键进行排序
和Ｓｅｔ很像 其实Ｓｅｔ集合底层就是使用了Ｍａｐ集合。
import java.util.*;
class MapDemo
{
public static void main(String[] args)
{
Map<String,String> map = new HashMap<String,String>();
//add
//map.put("01","zhangsan1");
map.put("02","zhangsan2");
map.put("03","zhangsan3");
// 当存入相同键的时候，新的键值会替换老的键值，put方法返回老的那个值。
System.out.println("put : "+map.put("01","zhangsan1"));
System.out.println("put : "+map.put("01","王五"));
System.out.println("containsKey : "+map.containsKey("02"));
System.out.println("remove : "+map.remove("02"));//删
System.out.println("get : "+map.get("01"));
// 可以通过get方法的返回值来判断一个键是否存在，通过返回null来判断。
map.put(null,"hash");
System.out.println("get : "+map.get(null));
System.out.println(map);//打印map集合
//获取map集合的所有值
Collection<String> coll = map.values();
System.out.println(coll);
}
}1. keySet: 将MAP中的所有键值存入到SET集合，因为set具备迭代器，所有可
以迭代方式取出的所有键，在根据get方法，获取每一个键对象的值。
Map集合的取出原理， 将map集合转成set集合，再通过迭代器取出
2.Set<Map.Entry<k,v>> entrySet: 将map集合中的映射关系存入到set集合中，
而这个关系的数据类型就是Map.Entry。
Map.Entry 其实Entry也是一个借口，它是Map借口中的一个内部借口
import java.util.*;
interface Map
{
public static interface Entry
{
public abstract Object getKey();
public abstract Object getValue();
}
}
class HashMap implements Map.Entry
{
class Hah implements Map.Entry
{
public Object getKey(){};
public Object getValue(){};
}
}
class MapDemo2
{
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","zhangsan4");
//将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();
System.out.println("key: "+key+",value"+value);
}
/*
//先后去map集合的所有键的set集合，KeySet();
Set<String> keySet = map.keySet();
//有了Set集合，就可以获取其迭代器
Iterator<String> it = keySet.iterator();
while (it.hasNext())
{
String key = it.next();
//有了键就可以通过map集合的get方法获取其对应的值
String value = map.get(key);
System.out.println("key: "+key+",value"+value);
}
*/
}
}一个例子
每一个学生都有对应的归属地。
学生Student 地址String
学生属性 姓名 年龄
注意 姓名和年龄相同的视为同一个学生，保证学生的唯一性
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 String getName()
{
return name;
}
public int getAge()
{
return age;
}
public String toString()
{
return name+":"+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 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;
}
}
class MapTest
{
public static void main(String[] args)
{
HashMap<Student,String> hm = new HashMap<Student,String>();
hm.put(new Student("lisi",21),"beijing");
hm.put(new Student("lisi2",22),"shanghai");
hm.put(new Student("lisi3",23),"nanjing");
hm.put(new Student("lisi4",24),"wuahn");
//第一种取出方式 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);
}
//第二种取出方式 entrySet
Set<Map.Entry<Student,String>> entrySet = hm.entrySet();
Iterator<Map.Entry<Student,String>> iter = entrySet.iterator();
while (iter.hasNext())
{
Map.Entry<Student,String> me = iter.next();
Student stu = me.getKey();
String addr = me.getValue();
System.out.println(stu+"...+-+-.."+addr);
}
}
}
因为数据时以键值对形式存在的，所以，要使用可以排序的
Map集合，TreeMap。
import java.util.*;
class MapTest2
{
public static void main(String[] args)
{
TreeMap<Student,String> tm = new TreeMap<Student,String>();
tm.put(new Student("lisi",23),"beijing");
tm.put(new Student("lisi2",21),"shanghai");
tm.put(new Student("lisi3",22),"nanjing");
tm.put(new Student("lisi4",24),"wuahn");
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 addr = me.getValue();
System.out.println(stu+"......"+addr);
}
}
}
练习
“asdfghjkloiuytrdasdresadf”获取该字符串中的字母出现的次数
希望打印 a(3)s(3)...
注意了，当发现有映射关系时，可以选择map集合
因为map集合中存放的就是映射关系。
当数据之间存在着映射关系时，就要先想到map集合。
大致过程， 第一次用字母a作为键去找集合，那么集合没有a这个键，所以也没有对应的次数
返回null 如果为null 就将a字母和1存入集合。如果指定的键已经存在，说明有对应的次数
就将对应的次数取出，并自增后再重新存入集合。
第一步 将字符串转换成字符数组，因为要对每一个字母进行操作
第二步 定义一个map集合，因为打印结果的字母有顺序，所以使用treemap集合。
第三步 遍历字符数组，将每一个字母作为键去查map集合，如果返回空就将该字母和1
存入到map集合中 如果返回不是空，表示该字母在map集合中已经存在并有对
应的次数，那么就获取该次数进行自增，然后将该字母和子增厚的次数存入到
map集合中，覆盖掉原来键所对应的值。
第四步 将map集合中的数据，变成指定的字符串形式返回。
import java.util.*;
class MapTest3
{
public static void main(String[] args)
{
String s = charCount("sdasdfsdfweasd");
System.out.println(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++ )
{
Integer value = tm.get(chs[x]);
if (value==null)
{
tm.put(chs[x],1);
}
else
{
value = value + 1;
tm.put(chs[x],value);
}
}
//System.out.println(tm);
StringBuilder sb = new StringBuilder();
Set<Map.Entry<Character,Integer>> entry = tm.entrySet();
Iterator <Map.Entry<Character,Integer>> it = entry.iterator();
while (it.hasNext())
{
Map.Entry<Character,Integer> me = it.next();
Character ch = me.getKey();
Integer value = me.getValue();
sb.append(ch+"("+value+")");
}
return sb.toString();
}
}map集合被使用时因为具备映射关系
一个学校有多个教室，每一个教室都有名称。
就如 黑马是一个学校， 学校里面有预热班和就业班
每个班里面有不一样的学生
比如
预热班 01 号 张三
预热班 02 号 李四
就业班 01 号 王五
就业班 02 号 赵六
把这样的信息存到map里面 分析映射关系 预热班跟张三对应 学生信息里面学号01跟张三对应
那么这种对应关系 可以表示为 班级 ----<学生> 学生里面是学号对应姓名
首先创建两个班级 里面存学生
然后再创建一个学校 里面放两个班级。
再将班级和学生获取出来
import java.util.*;
class Student
{
private String id;
private String name;
Student(String id,String name)
{
this.id=id;
this.name = name;
}
public String toString()
{
return id+":"+name;
}
}
class kuozhan
{
public static void demo()
{
HashMap<String,List<Student>> hm = new HashMap<String,List<Student>>(); //存一个班级名 对应一个学生集合
List<Student> yure = new ArrayList<Student>();//创建一个预热班集合创建一个就业班集合
List<Student> jiuye = new ArrayList<Student>();
//把班级放到学校集合里面
hm.put("预热班",yure);
hm.put("就业班",jiuye);
//把学生添加的班级里面
yure.add(new Student("01","zhangsan"));
yure.add(new Student("02","lisi"));
jiuye.add(new Student("01","wangwu"));
jiuye.add(new Student("02","zhaosi"));
//把班级名字和里面的学生遍历出来
Iterator<String> it = hm.keySet().iterator();
while (it.hasNext())
{
String roomName = it.next();
List<Student> room = hm.get(roomName);
System.out.println(roomName);
getInfos(room);//遍历出班级名字后提出里面的学生
}
}
public static void getInfos(List<Student> list)
{
Iterator<Student> it =list.iterator();
while (it.hasNext())
{
Student s = it.next();
System.out.println(s);
}
}
public static void main(String[] args)
{
/*
下面是基础的方法就出来了 我们现在讲学生提炼出来，
因为 学生的内容有很多 而且学生之间还没有映射关系，所以可以不用map集合 用collection集合
collection集合里面有俩一个是list集合一个是set集合 要是没有实际需求保证唯一的话 所以可以选择list集合
所以准备下面制作一个demo方法来重新设置。
*/
demo(); //上面方法写完了 调用一下 这就成了
/*
HashMap<String,String> jiuye = new HashMap<String,String>(); //创建就业班
HashMap<String,String> yure = new HashMap<String,String>();//预热班
//创建学校
HashMap<String,HashMap<String,String>> hm = new HashMap<String,HashMap<String,String>>();
//创建完学校存班级
hm.put("yureban",yure);
hm.put("jiuyeban",jiuye);
//每个班里面放学生
yure.put("01","zhangsan");
yure.put("02","lisi");
jiuye.put("01","wangwu");
jiuye.put("02","naliu");
//遍历czbk集合，获取所有的教室
Iterator<String> it = hm.keySet().iterator();
while (it.hasNext())
{
String roomName = it.next();//roomName存的是第一个键值
HashMap<String,String> room = hm.get(roomName);//根据第一个键值找映射
System.out.println(roomName);//
getStudentInfo(room);//映射值就是教室名字，通过这个方法调用教室中的学生。
}
//获取班级的学生
//getStudentInfo(jiuye);
//getStudentInfo(yure);
//System.out.println("Hello World!");
*/
}
//获取学生的方法
public static void getStudentInfo(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);
}
}
}
------- android培训 、 java培训 、期待与您交流！ ----------
842
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
