Map
Map集合:该集合存储的是键值对,一个键对应一个值,一对一对的往集合里存,需要保证键的唯一性
添加 :
- put(K key, V value) ------将指定的值与此映射中的指定键关联
- putAll(Map<? extends K,? extends V> m)
删除 :
- remove(Object key) ------如果存在一个键的映射关系，则将其从此映射中移除
- clear() ------从此映射中移除所有映射关系
判断 :
- containsKey(Object key) ------ 如果此映射包含指定键的映射关系，则返回 true。
- containsValue(Object value) -------如果此映射将一个或多个键映射到指定值，则返回 true。
获取 :
- entrySet() ----- 返回此映射中包含的映射关系的 Set 视图。
- keySet() ------- 返回此映射中包含的键的 Set 视图。
.- get(Object key) -------返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
- size() ------返回此映射中的键-值映射关系数。
- values() -------返回此映射中包含的值的 Collection 视图
Map集合常见集合容器:(其实 Set底层就是使用Map集合)
- Hashtable : 底层是哈希表数据结构,不可以存入null键null值, 线程同步(不常用)
- HashMap : 底层是哈希表数据结构,可以存入null键null值,线程不同步
- TreeMap : 底层是二叉树结构 ,可以对Map集合中的键进行排序 , 线程不同步
代码演示------
public class DEMO {
public static void main(String[] args) {
HashMap<String, String> hm = new HashMap<>();
sop("put : " + hm.put("01", "张一"));
sop("put : " + hm.put("01", "张0")); //键相同,后添加的会覆盖原先的值,并 put方法会返回被覆盖的值
hm.put("02", "张二");
hm.put("03", "张三");
hm.put("55", "张四");
hm.put("45", "张五");
sop("containsKey: " + hm.containsKey("01"));
sop("remove: " + hm.remove("02")); //移除该键对应的值,并返回该值
sop("get: " + hm.get("03")); //获取该键对应的值,并返回该值
Collection<String> c = hm.values(); //获取集合所有值
sop(c);
sop(hm);
}
public static void sop(Object obj) {
System.out.println(obj);
}
}
KeySet , entrySet(Map集合取出方式)
Map集合取出原理:将Map集合转成Set集合,通过Set集合的迭代器取出元素
- Set < K > | KeySet() : 该方法会返回一个K类型的Set集合…将Map集合中所有的 键 存入到Set集合,因为Set具备迭代器, 以迭代方式取出所有键,再依据 get方法, 获取每一个键对应的值
- Set<Map.Entry<K,V>> | entrySet() : 返回一个Set集合,将Map集合中的映射关系 (K----V)存入到Set集合中,这个映射关系的数据类型是 : Map.Entry<K ,V>,
KsySet();方法代码演示-----
public class DEMO {
public static void main(String[] args) {
HashMap<String, String> hm = new HashMap<>();
hm.put("02", "张二");
hm.put("03", "张三");
hm.put("55", "张四");
hm.put("45", "张五");
Set<String> keySet = hm.keySet(); //keSet(),该方法会返回一个Set, 所有的键都会存入该Set集合
Iterator<String> it = keySet.iterator(); //有了Set集合就可以获取迭代器对键进行迭代
while (it.hasNext()) {
String key = it.next(); //获取键
String values = hm.get(key); //有了键,就可以通过map集合的get方法获取其对应的值
System.out.println("key: " + key + " | values :" + values);
}
}
}
EntrySet();方法代码演示-----
public class DEMO {
public static void main(String[] args) {
HashMap<String, String> hm = new HashMap<>();
hm.put("02", "张二");
hm.put("03", "张三");
hm.put("55", "张四");
hm.put("45", "张五");
Set<Map.Entry<String, String>> entrySet = hm.entrySet(); //Map集合中的映射关系存入Set集合中,数据类型是Map.Entry
Iterator <Map.Entry<String, String>> it = entrySet.iterator(); //迭代
while (it.hasNext()){
Map.Entry<String,String> me=it.next(); //获取Map.Entry类型对象,泛型为<String,String>
String key=me.getKey(); //调用Map.Entry对象中的方法
String values=me.getValue();
System.out.println("key: "+key+" values: "+values);
}
}
}
Map练习-----
/*
每一个学生都有对应的归属地
学生Student,地址String
学生属性:姓名 年龄
同一姓名,年龄视为同一学生
保证学生唯一性
学生对象可能存到HashMap或者TreeMap,所以都要定义这两个容器该有的属性
1,描述学生对象
2,定义Map容器,将学生作为键,地区作为值,存入
3,获取Map集合中的元素
*/
class Student implements Comparable<Student> { //让学生对象具备可比性,自然排序
private int age;
private String name;
Student(String name, int age) {
this.name = name;
this.age = age;
}
public int hashCode() { //根据条件自定义哈希值
return name.hashCode() + age * 29;
}
public boolean equals(Object obj) { //重写equals 方法,自定义判断条件
if (!(obj instanceof Student)) {
throw new ClassCastException("类型异常");
}
Student s = (Student) obj;
return this.name.equals(s.name) && this.age == s.age;
}
public int compareTo(Student s) { //以名字为主条件排序,年龄为副条件的自然排序
int num = this.getName().compareTo(s.getName());
if (num == 0) {
return new Integer(this.getAge()).compareTo(s.getAge());
}
return num;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public String toString() { //建立学生对象自定义的字符串
return name + ":" + age;
}
}
class AgeCompare implements Comparator<Student>{ //定义根据年龄为主条件排序.姓名为副条件的比较器
public int compare(Student s1,Student s2){
int num =new Integer(s1.getAge()).compareTo(s2.getAge());
if (num==0){
return s1.getName().compareTo(s2.getName());
}
return num;
}
}
public class DEMO {
public static void main(String[] args) {
Map<Student, String> hm = new TreeMap<>(new AgeCompare()); //插入比较器
hm.put(new Student("lisi 4", 15), "中山");
hm.put(new Student("lisi 4", 15), "佛山");
hm.put(new Student("lisi 3", 18), "西安");
hm.put(new Student("lisi 1", 16), "武汉");
hm.put(new Student("lisi 2", 10), "北京");
sop("keySet;");
//第一种方式取出: keySet();
Set<Student> keySet = hm.keySet();
Iterator<Student> it = keySet.iterator();
while (it.hasNext()) {
Student s = it.next();
System.out.println(s.toString() + " 地区" + hm.get(s));
}
sop("-----------------------------------");
sop("entrySet();");
//第二种方式取出 : entrySet();
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();
Student sd = me.getKey();
String s = me.getValue();
System.out.println(sd.toString()+" 地区:"+s);
}
}
public static void sop(Object obj) {
System.out.println(obj);
}
}
TreeMap练习-----字符串中字母出现的次数
import java.util.*; //导入集合类包
/*
获取 fds**fae++ws--dsa 字符串中字母出现的次数,
希望打印的结果是a(2)b(3)....
字母 与 出现次数, 存在映射关系 可以使用Map集合
*/
public class DEMO {
public static void main(String[] args) {
String s= charCount("fdsfae++wsdsa");
sop(s);
}
public static void sop(Object obj) {
System.out.println(obj);
}
public static String charCount(String str) { //定义功能
char[] chs = str.toCharArray(); //将字符串转换成字符数组,对每一个字母进行操作
Map<Character, Integer> tm = new TreeMap<>(); //因为打印的字母有顺序,所以使用TreeMap集合
int num=0;
for (int i = 0; i < chs.length; i++) { //对夫妇数组进行遍历
if (!(chs[i]>='a'&&chs[i]<='z' ||chs[i]>='A'&&chs[i]<='Z')){ //只输出大小写字母
continue;
}
if (!tm.containsKey(chs[i])) { //判断集合中是否有该键
tm.put(chs[i], 1); //没有该键,则向元素添加键值
} else {
tm.put(chs[i], tm.get(chs[i]) + 1); //如果有该键,则获取该键对应的值然后+1
}
//其他方法
// Integer values =tm.get(chs[i]); //获取values
// if (values!=null){ //判断values 是否为空
// num=values+1; 如果不为空,则+1
// }else {
// num++;
// }
// tm.put(chs[i],num);
// num=0;
}
StringBuilder sb=new StringBuilder(); //定义StringBuilder 储存数据
Set<Character> ketSet = tm.keySet();
Iterator<Character> it = ketSet.iterator();
while (it.hasNext()) {
Character c = it.next();
Integer i = tm.get(c);
//System.out.print(c+"("+i+")");
sb.append(c+"("+i+")");
}
return sb.toString(); //返回字符串
}
}
Map集合拓展,循环嵌套(一对多)
学校—教室—学生 存在映射关系
将学校看成一个集合 里面存储着每个教室
而教室也可以看成一个集合, 存储着每个学生
这样就是集合中存放集合
import java.util.*; //导入集合类包
class Student {
private String ID;
private String name;
public int hashCode() {
return ID.hashCode();
}
Student(String ID, String name) {
this.name = name;
this.ID = ID;
}
public String toString() { //自定义字符串
return ID + ":::" + name;
}
}
public class DEMO {
public static void main(String[] args) {
Map<String, List<Student>> school = new HashMap<>(); // 学校为Map集合,
List<Student> class1 = new ArrayList<>(); //班级也为集合,存放学生对象
class1.add(new Student("01", "zhangsan"));
class1.add(new Student("02", "lisi"));
class1.add(new Student("03", "chener"));
List<Student> class2 = new ArrayList<>();
class2.add(new Student("01", "wangwu"));
class2.add(new Student("02", "goudan"));
class2.add(new Student("03", "qinhan"));
school.put("一班", class1); //将班级名字作为Key,班级对象作为Values存入Map集合中
school.put("二班", class2);
getInfos(school); //使用自定义功能打印学校的学生信息
}
public static void getInfos(Map<String, List<Student>> school) { //定义一个打印学校 学生信息的功能
// Set<String> keySet = school.keySet(); //使用keySet();
// Iterator<String> it = keySet.iterator(); //获取keySet迭代器遍历 Key
// while (it.hasNext()) {
// String className = it.next(); //获取班级名字
// System.out.println(className); //打印班级名字
// List<Student> al = school.get(className); //根据Key ,获取Student 对象
//--------------------------------------- 两种方法---------------------------------------
Set<Map.Entry<String,List<Student>>> entrySet=school.entrySet(); //使用entrySet方法
Iterator<Map.Entry<String,List<Student>>> it=entrySet.iterator(); //获取迭代器遍历Map.Entry类型对象
while (it.hasNext()){
Map.Entry<String,List<Student>> me=it.next(); //获取Map.Entry类型对象
String className =me.getKey(); //获取班级名字
System.out.println(className); //打印班级名字
List<Student> al=me.getValue(); //获取班级集合
Iterator<Student> it1 = al.iterator(); //获取班级集合的迭代器遍历学生对象
while (it1.hasNext()) {
Student s = it1.next(); //获取学生对象
System.out.println(s); //打印学生信息
}
}
}
public static void sop(Object obj) {
System.out.println(obj);
}
}
421
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
