黑马程序员——Java基础--集合（五）

时间：2022-06-30 00:31:21

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------

第五讲 Map
一、概述
        存储的是俩个对象，映射键值对(a 1-->键a映射到值1)， 键是唯一的，一对一的关系，Map<K,V> K 键的泛型 V值的泛型，将键值对存储到集合中put(K,V)，put方法没有返回值，返回值数据类型是V类型，格式： V put(K,V)，返回值的意思，存储了重复键，值就会被覆盖，put返回被覆盖之前的值。
        获取格式： V get(K)，根据键获取值，没有这个键，返回null
        Map中的接口方法：
        boolean containsKey(K)判断集合中有么有这个键；
        boolean containsValue(V)判断集合中有么有这个值；
        Collection values() 将Map中的所有值存储到Collection集合。
二、迭代方式
1、keySet方式
必须依赖于Set集合。Map接口中，keySet()；将Map集合，中所有的键存储到Set集合中，迭代Set集合，Map中的键，根据迭代Set的结果来，获取Map中的值。
实现步骤：
        1、调用Map中接口方法keySet,存储到Set集合。Set(K)
        2、迭代Set结合
        3、获取出来的就是Map中所有的键
        4、使用Map接口方法get通过键获取值
应用举例：
package cn.itheima.map;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/*
 * keySet方法
 * 步骤：
 * 1、调用Map中接口方法keySet，存储到集合Set
 * 2、迭代Set集合
 * 3、获取出来的是Map中所有的键
 * 4、用Map中get方法通过键获取值
 */
public class KeySetDemo {
public static void main(String[] args) {
//创建集合对象
Map<String, String> map = new HashMap<String, String>();
//添加元素到集合
map.put("zhangsan", "beijing");
map.put("lisi", "shanghai");
map.put("wangwu", "tianjing");
map.put("zhaoliu", "chongqing");
//调用Map中接口方法keySet，存储到集合Set
Set<String> set = map.keySet();
//迭代Set集合
Iterator<String> it = set.iterator();
while(it.hasNext()){
//获取出来的是Map中所有的键
String next = it.next();
//用Map中get方法通过键获取值
System.out.println(next+"----"+map.get(next));
}
}
}
结果为：
zhaoliu----chongqing
wangwu----tianjing
lisi----shanghai
zhangsan----beijing
2、ntrySet方式
实现步骤：
        1、Map集合方法entrySet,将键值对映射对象Entry存储到Set结合
        2、迭代Set集合
        3、Set集合存储的是Entry接口的实现类对象
        4、利用Entry接口实现类对象的方法getKey getValue
应用举例：
package cn.itheima.map;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

/*
 * entrySet方式 
 * 1、用Map的entrySet方式存储到Set集合
 * 2、迭代Set集合
 * 3、Set集合存储的是Entry接口的实现类对象
 * 4、利用Entry接口实现类对象的方法getKey getValue
 */
public class EntrySetDemo {
public static void main(String[] args) {
//创建集合对象
Map<String, String> map = new HashMap<String, String>();
//添加元素到集合
map.put("zhangsan", "beijing");
map.put("lisi", "shanghai");
map.put("wangwu", "tianjing");
map.put("zhaoliu", "chongqing");
//用Map的entrySet方式存储到Set集合
Set<Map.Entry<String, String>> entrySet = map.entrySet();
//迭代Set集合
Iterator<Map.Entry<String, String>> it = entrySet.iterator();
while(it.hasNext()){
Map.Entry<String, String> next = it.next();
String key = next.getKey();
String value = next.getValue();
System.out.println(key+"-----"+value);
}
}
}

结果为：
zhaoliu-----chongqing
wangwu-----tianjing
lisi-----shanghai
zhangsan-----beijing
三、HashMap
        底层数据结构，线程不安全呢，运行速度快，允许存储null值，null键，保证唯一性，重写HashCode和equals方法，增强for不能直接遍历Map，可以间接遍历。
举例：
学生类
package cn.itheima.hashmap;

public class Student {
private String name;
private int age;
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
}

测试类
package cn.itheima.hashmap;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

/*
 * 案例 HashMap存储自定义对象,并两种方式迭代,自定义对象当作键
 * 
 */
public class HashMapDemo {
public static void main(String[] args) {
//创建集合对象
Map<Student, String> map = new HashMap<Student, String>();
//添加元素到集合
map.put(new Student("zhangsan", 20), "beijing");
map.put(new Student("lisi", 19), "shanghai");
map.put(new Student("wangwu", 22), "tianjing");
//调方法
keySet(map);
System.out.println("-------------------------");
entrySet(map);
}
public static void keySet(Map<Student, String> map){
//调用Map的keySet方法存储到Set集合中
Set<Student> ks = map.keySet();
//迭代
Iterator<Student> it = ks.iterator();
while(it.hasNext()){
Student next = it.next();
System.out.println(next+"----"+map.get(next));
}
}
public static void entrySet(Map<Student, String> map){
//调用Map的entrySet方法存储到Set集合中
Set<Map.Entry<Student, String>> es = map.entrySet();
//迭代
Iterator<Map.Entry<Student, String>> it = es.iterator();
while(it.hasNext()){
Map.Entry<Student, String> next = it.next();
Student key = next.getKey();
String value = next.getValue();
System.out.println(key+"----"+value);
}
}
}

结果：
Student [name=wangwu, age=22]----tianjing
Student [name=lisi, age=19]----shanghai
Student [name=zhangsan, age=20]----beijing
-------------------------
Student [name=wangwu, age=22]----tianjing
Student [name=lisi, age=19]----shanghai
Student [name=zhangsan, age=20]----beijing

四、TreeMap
       底层结果红黑树，对存储（键）的对象进行排序，线程不安全，运行速度快。其排序方式有自然排序和比较器排序。
举例：TreeMap存储自定义对象,并两种方式迭代,自定义对象当作键。
学生类
package cn.itheima.treemap;

public class Student implements Comparable<Student>{
private String name;
private int age;
public int compareTo(Student s) {
//姓名为主要比较条件
int num = this.name.compareTo(s.name);
return num==0?this.age-s.age:num;
}
public int hashCode() {
return this.name.hashCode()+this.age*31;
}
public boolean equals(Object obj) {
if (obj==null) {
return false;
}if(this==obj){
return true;
}if(obj instanceof Student){
Student s = (Student)obj;
return this.name.equals(s.name)&&this.age==s.age;
}
return false;
}

public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}


}
比较器
package cn.itheima.treemap;

import java.util.Comparator;

public class MyComparator implements Comparator<Student> {

public int compare(Student s1, Student s2) {
//比较年龄主要条件
int age = s1.getAge()-s2.getAge();
return age==0?s1.getName().compareTo(s2.getName()):age;
}
}

测试类
package cn.itheima.treemap;

import java.util.Iterator;
import java.util.Set;
import java.util.TreeMap;
import cn.itheima.treemap.Student;


/*
 *  案例 TreeMap存储自定义对象,并两种方式迭代,自定义对象当作键
 * 
 */
public class TreeMapDemo {
public static void main(String[] args) {
//创建集合对象
TreeMap<Student,String> map = new TreeMap<Student, String>(new MyComparator());
//添加元素到集合
map.put(new Student("zhangsan", 20), "beijing");
map.put(new Student("lisi", 19), "shanghai");
map.put(new Student("wangwu", 22), "tianjing");
keySet(map);
}
public static void keySet(TreeMap<Student, String> map){
Set<Student> ks = map.keySet();
Iterator<Student> it = ks.iterator();
while(it.hasNext()){
Student next = it.next();
System.out.println(next+"----"+map.get(next));
}
}
}

结果为：
Student [name=lisi, age=19]----shanghai
Student [name=zhangsan, age=20]----beijing
Student [name=wangwu, age=22]----tianjing

五、Map集合嵌套（俩种方式）
package cn.itheima.mapqiantao;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

/*
 * Map嵌套
 * 分析：
 * 1、Java班分为基础班和就业班
 *  2、基础班有学生信息 学号"001" "张三" "002" "李四"
 *  3、就业班有学生信息 学号"001" "王五" "002" "赵六"
 *  4、Java班是一个集合，存储班级
 *  5、基础班和就业班分别是一个集合存储学生信息
 * 
 */
public class MapMapTest {
public static void main(String[] args) {
//创建Java班级集合
Map<String, Map<String, String>> map = new HashMap<String, Map<String,String>>();
//创建基础班集合
Map<String, String> jichu = new HashMap<String, String>();
Map<String, String> jiuye = new HashMap<String, String>();
//添加元素到基础班和就业班集合中
jichu.put("001", "张三");
jichu.put("002", "李四");
jiuye.put("001", "王五");
jiuye.put("002", "赵六");
//将班级集合添加到Java班级集合中
map.put("基础班", jichu);
map.put("就业班", jiuye);
//调方法
keySet(map);
System.out.println("-------------------");
entrySet(map);
}
//keySet方法
public static void keySet(Map<String, Map<String, String>> map){
//调用Map中keySet方法存储到Set集合中
Set<String> ks = map.keySet();
Iterator<String> it = ks.iterator();
while(it.hasNext()){
//next获取的Map 中的键,班级名字
String next = it.next();
//集合方法get获取值,值是一个集合,集合存储的是学生信息
Map<String, String> map2 = map.get(next);
//调用Map2中keySet方法存储到Set集合中
Set<String> ks2 = map2.keySet();
Iterator<String> it2 = ks2.iterator();
while(it2.hasNext()){
//next2获取的Map2 中的键,学生学号
String next2 = it2.next();
System.out.println(next+"----"+next2+"----"+map2.get(next2));
}
}
}
//entrySet方法
public static void entrySet(Map<String, Map<String, String>> map){
//调用Map中entrySet方法存储到Set集合中
Set<Map.Entry<String, Map<String, String>>> entrySet = map.entrySet();
Iterator<Map.Entry<String, Map<String, String>>> it = entrySet.iterator();
while(it.hasNext()){
//next获取的Map 中的键,班级名字
Map.Entry<String, Map<String, String>> next = it.next();
//键是班级名字
String key = next.getKey();
//值,是存储学生信息的班级集合
Map<String, String> map2 = next.getValue();
//调用Map2中entrySet方法存储到Set集合中
Set<Map.Entry<String, String>> entrySet2 = map2.entrySet();
Iterator<Map.Entry<String, String>> it2 = entrySet2.iterator();
while(it2.hasNext()){
//班级集合迭代器 next方法,获取到的是班级集合的键值对关系对象Entry
Map.Entry<String, String> next2 = it2.next();
//Entry方法getKey  getValue获取键值对,键是学号,值就是姓名
String key2 = next2.getKey();
String value = next2.getValue();
System.out.println(key+"----"+key2+"----"+value);
}
}
}
}

结果为：
就业班----001----王五
就业班----002----赵六
基础班----001----张三
基础班----002----李四
-------------------
就业班----001----王五
就业班----002----赵六
基础班----001----张三
基础班----002----李四

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------
标签：

相关文章