Map集合
![]()
package Map_test.Map_01;
import java.util.HashMap;
import java.util.Map;
public class MapDemo_1 {
public static void main(String[] args) {
//多态的形式, 具体的实现类是HashMap
Map<String,String> map = new HashMap<>();
map.put("001","peppa"); //每个key对应一个值
map.put("002","george");
map.put("003","suzy");
//key的底层是哈希表所以不能重复,用put方法可修改相同key的值.
map.put("001","X-Man"); //相当于修改
System.out.println(map); //HashMap重写了toString方法
}
}
//控制台: {001=X-Man, 002=george, 003=suzy}
![]()
package Map_test.Map_01;
import java.util.HashMap;
import java.util.Map;
/*
Map集合的基本功能
方法名 说明
V put(K key,V value) 添加元素
V remove(Object key) 根据键删除键值对元素
void clear() 移除所有的键值对元素
boolean containsKey(Object key) 判断集合是否包含指定的键
boolean containsValue(Object value) 判断集合是否包含指定的值
boolean isEmpty() 判断集合是否为空
int size() 集合的长度，也就是集合中键值对的个数
*/
public class Map_Method {
public static void main(String[] args) {
Map<String,String> map = new HashMap<>();
//V put(K key,V value) 添加元素
map.put("张无忌","赵敏");
map.put("郭靖","黄蓉");
map.put("杨过","小龙女");
//V remove(Object key) 根据键删除键值对元素
System.out.println(map.remove("张无忌"));
//void clear() 移除所有的键值对元素
// map.clear();
//boolean isEmpty() 判断集合是否为空
System.out.println(map.isEmpty());
//boolean containsKey(Object key) 判断集合是否包含指定的键
System.out.println("是否有key郭靖:"+map.containsKey("郭靖"));
//boolean containsValue(Object value) 判断集合是否包含指定的值
System.out.println("是否有value黄蓉:"+map.containsValue("黄蓉"));
//int size() 集合的长度，也就是集合中键值对的个数
System.out.println("Map集合中有:"+map.size()+"个元素");
System.out.println("分别是"+map);
}
}
/* 控制台:
赵敏
false
是否有key郭靖:true
是否有value黄蓉:true
Map集合中有:2个元素
分别是{杨过=小龙女, 郭靖=黄蓉}
*/
![]()
package Map_test.Map_01;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/*
Map集合的获取功能:
V get(Object key): 根据键获取值
Set<K> keySet(): 获取所有键的集合
Collection<V> values(): 获取所有值的集合
*/
public class MapGet {
public static void main(String[] args) {
Map<String,String> map = new HashMap<>();
map.put("张无忌","赵敏");
map.put("郭靖","黄蓉");
map.put("杨过","小龙女");
// V get(Object key): 根据键获取值
System.out.println("key张无忌的value是:"+map.get("张无忌"));//key张无忌的value是:赵敏
System.out.println("key郭靖的value是:"+map.get("郭靖"));//key郭靖的value是:黄蓉
// Set<K> keySet(): 获取所有键的集合
Set<String> set = map.keySet();
System.out.println("集合中所有键:");
for (String i : set){
System.out.println(i);
}
// Collection<V> values(): 获取所有值的集合
System.out.println("集合中所有值:");
Collection<String> values = map.values();
for (String i : values){
System.out.println(i);
}
System.out.println(map);
}
}
/*控制台输出:
key张无忌的value是:赵敏
key郭靖的value是:黄蓉
集合中所有键:
杨过
郭靖
张无忌
--------
集合中所有值:
小龙女
黄蓉
赵敏
--------
{杨过=小龙女, 郭靖=黄蓉, 张无忌=赵敏}
*/
![]()
package Map_test.Map_01;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/* 遍历Map集合方式(1)
转换为Map集合中的操作：
1. 获取所有键的集合, 用keySet（）方法实现
2. 遍历键的集合, 获取到每一个键。用增强for实现
3. 根据键去找值, 用get（Object key）方法实现
*/
public class traversal_Map {
public static void main(String[] args) {
Map<String,String> map = new HashMap<>();
map.put("杨过","小龙女");
map.put("郭靖","黄蓉");
map.put("张无忌","赵敏");
//1. 获取所有键的集合, 用keySet（）方法实现
Set<String> set = map.keySet();
//2. 遍历键的集合, 获取到每一个键。用增强for实现
for (String key : set){
//3. 根据键去找值, 用get（Object key）方法实现
String value = map.get(key);//用map集合对象的get方法(key)只是键.
System.out.println(key+","+value);
}
}
}
![]()
package Map_test.Map_01;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/* map集合的遍历方式(2)
1. 获取所有键值对对象的集合
Set＜Map.Entry＜K，V＞＞entrySet（）：获取所有键值对对象的集合
2. 遍历键值对对象的集合，得到每一个键值对对象
用增强for实现，得到每一个Map.Entry
3. 根据键值对对象获取键和值
用getKey0得到键
用getValue（）得到值
*/
public class traversal2 {
public static void main(String[] args) {
Map<String,String> map = new HashMap<>();
map.put("杨过","小龙女");
map.put("郭靖","黄蓉");
map.put("张无忌","赵敏");
//1. 获取所有键值对对象的集合
Set<Map.Entry<String, String>> entries = map.entrySet();
//2. 遍历键值对对象的集合，得到每一个键值对对象
for (Map.Entry<String, String> i : entries){
//3. 根据键值对对象获取键和值
// System.out.println(i.getKey()+","+i.getValue());//直接输出
String key = i.getKey(); //获取key , value的值
String value = i.getValue();
System.out.println(key+","+value);
}
}
}
案例1: Map集合存储学生对象并遍历(String,Student)
package Map_test.Map_01;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/*
需求: 创建一个HashMap集合, 键是学号(String), 值是学生对象(Student) . 存储三个键值对元素, 并遍历
思路:
1. 定义学生类
2. 创建HashMap集合对象
3. 创建学生对象
4. 把学生添加到集合
5. 遍历集合
方式1: 键找值
方式2: 键值对对象找键和值
*/
public class case_1 {
public static void main(String[] args) {
// 2. 创建HashMap集合对象
Map<String , Student> map = new HashMap<>();
// 3. 创建学生对象
Student s1 = new Student("Peppa",6);
Student s2 = new Student("Suzy",5);
Student s3 = new Student("George",4);
// 4. 把学生添加到集合
map.put("001",s1); //put方法添加
map.put("002",s2);
map.put("003",s3);
// 5. 遍历集合 方式1: 键找值
Set<String> set = map.keySet(); //keySet方法获取键的集合
for (String i : set){ //遍历键的集合
Student s = map.get(i); //用get(key)方法,根据键(i)获取值的对象.
System.out.println(i+","+s.getName()+","+s.getAge());
}
System.out.println("----------");
// 遍历集合 方式2: 键值对对象找键和值
Set<Map.Entry<String, Student>> entries = map.entrySet();//entrySet方法获取键值对对象的集合
for (Map.Entry<String,Student> i : entries){ //遍历键值对对象的集合
String key = i.getKey(); //根据键值对对象用getKey,getValue方法获得键和值
Student value = i.getValue();
System.out.println(key+","+value.getName()+","+value.getAge());
}
}
}
/*控制台:
001,Peppa,6
002,Suzy,5
003,George,4
----------
001,Peppa,6
002,Suzy,5
003,George,4
*/
案例2: HashMap集合存储学生对象并遍历(Student,String)
package Map_test.Map_01;
//学生类, 重写equals,hashCode方法来实现需求
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
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;
}
//重写的hashCode()方法和equals()方法
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
if (age != student.age) return false;
return name != null ? name.equals(student.name) : student.name == null;
}
@Override
public int hashCode() {
int result = name != null ? name.hashCode() : 0;
result = 31 * result + age;
return result;
}
}
//----------------------------------
package Map_test.Map_01;
import java.util.HashMap;
import java.util.Set;
/*
案例： HashMap集合存储学生对象并遍历
需求：创建一个HashMap集合，键是学生对象（Student），值是居住地（String）。存储多个键值对元素，并遍历。
要求保证键的唯一性：如果学生对象的成员变量值相同，我们就认为是同一个对象
思路:
1. 定义学生类
2. 创建HashMap集合对象
3. 创建学生对象
4. 把学生添加到集合
5. 遍历集合
6. 在学生类中重写两个方法 hashCode() , equals()
*/
public class case_2 {
public static void main(String[] args) {
//2. 创建HashMap集合对象
HashMap<Student,String>map=new HashMap<>();
//3. 创建学生对象
Student s1 = new Student("Peppa",6);
Student s2 = new Student("Suzy",5);
Student s3 = new Student("George",4);
Student s4 = new Student("George",4); //键重复的元素
//4. 把学生添加到集合
map.put(s1,"England,L.City."); //put方法添加
map.put(s2,"America,N.Y.City.");
map.put(s3,"England,K.City.");
map.put(s4,"China,S.Y.City");//想要重复键的元素覆盖原有的元素,就要在学生类重写hashCode,equals方法.
//5. 遍历集合
Set<Student> s = map.keySet();//得到键的集合
for (Student key : s){ //遍历键
String value = map.get(key); //键找值
System.out.println(key.getName()+","+key.getAge()+","+value); //输出键和值
}
}
}
/*控制台:
George,4,China,S.Y.City
Suzy,5,America,N.Y.City.
Peppa,6,England,L.City.
*/
浙公网安备 33010602011771号