学习目标:
- 学会使用Map集合接口;
- 能够熟练使用接口中的方法。
学习内容:
一、Map集合接口
1、简介
- 双列集合
- 键值对(键唯一,值可以重复,一个键对应一个值,成对存在,通过键能够找到对应的值)
- java.util.Map
2、特点
- 一个元素包括key,value两个值
- key和value数据类型可以相同也可以不同
- key不可以重复,value可以重复
- key,value一一对应
3、Map常用实现类
- HashMap
- 特点
- 允许null键和值
- 多线程
- 底层是哈希表
- 无序的集合
- 特点
- LinkedHashMap
- 特点
- 底层是哈希表+链表(保证迭代顺序)
- 有序的集合
- 特点
- HashTable
- 特点
- 不允许null键和值
- 最早的双列集合
- 单线程(速度慢)
- 底层是哈希表
- 无序的集合
- PS:
- 子类Propreties依然活跃在历史舞台
- 该子类是唯一一个和IO流相结合的集合
- 特点
4、常用方法
- put方法
- 将指定的键与值添加到集合中,返回被替换的值
- public V put(K key,V value);
- 返回值规则:
- 存储数据时,key不重复,返回null
- 存储数据时,key重复,新值覆盖原值,返回原值(被替换的值)
- get方法
- 获取指定的键对应的键值对元素对应的值
- public V get(K key);
- 返回值规则:
- 获取数据时,key不存在,返回null
- 获取数据时,key存在,返回对应的值
- remove方法
- 将指定的键值对从集合中删除,并返回删除元素的值
- public V remove(K key);
- 返回值规则:
- 删除数据时,key存在,返回对应value值
- 删除数据时,key不存在,返回null
- containsKey方法
- 判断集合中是否包含指定的键
- public boolean containsKey(K key);
- 返回值规则:
- 包含该key时,返回true
- 不包含该key时,返回false
5、遍历Map集合的方法
-
keySet方法
- 获取Map集合中的所有键的集合
- public Set keySet();
- 遍历步骤:
- 先通过此方法获取所有的键;
- 然后用迭代的方法遍历所有的键;
- 通过Map.get方法获取对应的值
-
entrySet方法
- 获取Map集合中的所有键值对对象entrySet的集合
- public Entry<K,V> entrySet();
- 遍历步骤:
- 先通过此方法获取所有的Entry对象
- 然后遍历Entry对象
- 最后通过Entry的getKey与getValue方法获取对应元素的键与值
6、传递自定义的键或值
- 自定义类型的键
- 自定义的类型要重写equals与hashCode方法,保证键唯一
- 自定义类型的值
- 对值无特殊要求
二、JDK9新特性
1、List、Set、Map接口,里边增加一个静态方法of,可以给集合一次性添加多个元素
- static List of(E… elements);
2、使用前提
-
集合中存储元素个数确定,不再改变时使用
-
PS:
- of方法只适用于上述3个接口,不适用于接口的实现类
- of方法的返回值是一个不能改变的集合,集合不能再使用add,put方法添加元素,会抛出异常
- Set与Map接口在使用of方法时,不能有重复元素,否则会抛出异常
学习产出:
1、Map接口方法
package mypackage.day11.demo01;
import java.util.HashMap;
import java.util.Map;
public class DemoMapMethod {
public static void main(String[] args) {
tianjia();
shanchu();
huoqu();
panduan();
}
private static void panduan() {
System.out.println("=======判断元素是否存在========");
Map<String, String> hashMap = new HashMap<>();
String v1 = hashMap.put("Jim","Tom");
String v2 = hashMap.put("Smith","Mary");
String v3 = hashMap.put("Harry","Lily");
boolean containsKey = hashMap.containsKey("Smith");
System.out.println("判断Smith结果:"+containsKey);
boolean containsKey1 = hashMap.containsKey("dashduak");
System.out.println("判断dashduak结果:"+containsKey1);
}
private static void huoqu() {
System.out.println("=======获取元素========");
Map<String, String> hashMap = new HashMap<>();
String v1 = hashMap.put("Jim","Tom");
String v2 = hashMap.put("Smith","Mary");
String v3 = hashMap.put("Harry","Lily");
String s = hashMap.get("Harry");
System.out.println("获取到的元素的值:"+s);
}
private static void shanchu() {
System.out.println("=======删除键值对========");
Map<String, String> hashMap = new HashMap<>();
String v1 = hashMap.put("Jim","Tom");
String v2 = hashMap.put("Smith","Mary");
String v3 = hashMap.put("Harry","Lily");
System.out.println("移除元素前的集合:"+hashMap);
String s = hashMap.remove("Smith");
System.out.println("移除的元素的值:"+s);
System.out.println("移除元素后的集合:"+hashMap);
}
private static void tianjia() {
System.out.println("=========添加键值对=========");
Map<String, String> hashMap = new HashMap<>();
String v1 = hashMap.put("Jim","Tom");
System.out.println("添加新key元素返回的值:"+v1);
String v2 = hashMap.put("Jim","Mary");
System.out.println("添加已有key返回的值:"+v2);
System.out.println("最终的集合值:"+hashMap);
}
}
2、遍历循环Map集合
package mypackage.day11.demo01;
//用接口中的方法辅助遍历循环Map集合
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class DemoMapQuery {
public static void main(String[] args) {
bianli1();
bianli2();
}
private static void bianli2() {
System.out.println("==========entrySet方法===========");
Map<String, String> hashMap = new HashMap<>();
String v1 = hashMap.put("Jim","Tom");
String v2 = hashMap.put("Smith","Mary");
String v3 = hashMap.put("Harry","Lily");
Set<Map.Entry<String, String>> entries = hashMap.entrySet();
System.out.println("------迭代器方法--------");
Iterator<Map.Entry<String, String>> iterator = entries.iterator();
while (iterator.hasNext()){
Map.Entry<String, String> entry = iterator.next();
System.out.println(entry.getKey()+":"+entry.getValue());
}
System.out.println("------增强for方法--------");
for (Map.Entry<String, String> entry : entries) {
System.out.println(entry.getKey()+":"+entry.getValue());
}
}
private static void bianli1() {
System.out.println("==========keySet方法===========");
Map<String, String> hashMap = new HashMap<>();
String v1 = hashMap.put("Jim","Tom");
String v2 = hashMap.put("Smith","Mary");
String v3 = hashMap.put("Harry","Lily");
Set<String> keySet = hashMap.keySet();
System.out.println("------迭代器方法--------");
Iterator<String> iterator = keySet.iterator();
while (iterator.hasNext()){
String key = iterator.next();
System.out.println(hashMap.get(key));
}
System.out.println("------增强for方法--------");
for (String key : keySet) {
System.out.println(hashMap.get(key));
}
}
}
3、 向Map集合中传递自定义类型
package mypackage.day11.demo01;
import java.util.Objects;
public class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// 自定义equals和hashCode方法,保证key值唯一
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age &&
Objects.equals(name, person.name);
}
@Override
public int hashCode() {
return Objects.hash(name, 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;
}
}
package mypackage.day11.demo01;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class DemoMapDefineBySelf {
public static void main(String[] args) {
definekey();
definevalue();
}
private static void definevalue() {
System.out.println("=========自定义value值=========");
HashMap<String,Person> hashMap = new HashMap<>();
hashMap.put("English",new Person("Jim",18));
hashMap.put("America",new Person("Tom",28));
hashMap.put("China",new Person("Mary",18));
hashMap.put("French",new Person("Jim",18));
Set<Map.Entry<String,Person >> entries = hashMap.entrySet();
for (Map.Entry<String, Person > entry : entries) {
System.out.println(entry.getKey()+":"+entry.getValue().getName());
}
}
private static void definekey() {
System.out.println("=========自定义键值=========");
HashMap<Person, String> hashMap = new HashMap<>();
hashMap.put(new Person("Jim",18),"English");
hashMap.put(new Person("Tom",28),"America");
hashMap.put(new Person("Mary",18),"China");
hashMap.put(new Person("Jim",18),"French");
Set<Map.Entry<Person, String>> entries = hashMap.entrySet();
for (Map.Entry<Person, String> entry : entries) {
System.out.println(entry.getKey().getName()+":"+entry.getValue());
}
}
}
4、练习:计算一个字符串中每个字符出现的次数。
package mypackage.day11.demo02;
/*
要求:
计算一个字符串中每个字符出现的次数。
思路:
1、使用Scanner让用户输入一个字符串;
2、创建Map集合,key是字符串的字符,value是字符个数;
2、遍历字符串,获取每一个字符;
3、使用Map集合中的方法判断集合中是否存在该字符:
若存在该字符,将对应的个数value++
若不存在该字符,将该字符添加Map集合
4、遍历Map集合并输出结果
*/
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
public class DemoMapTrain {
public static void main(String[] args) {
// 获取用户输入的字符串
Scanner scanner = new Scanner(System.in);
System.out.println("请输入字符串:");
String s = scanner.next();
// 建立hashMap集合
HashMap<Character, Integer> hashMap = new HashMap<>();
// 遍历字符串,并进行判断添加
char[] array = s.toCharArray();
for (char c : array) {
if (hashMap.containsKey(c)){
int value = hashMap.get(c);
Integer put = hashMap.put(c, ++value);
}else {
Integer put = hashMap.put(c, 1);
}
}
// 遍历集合,输出结果
System.out.println("========输出结果============");
Set<Map.Entry<Character, Integer>> entries = hashMap.entrySet();
for (Map.Entry<Character, Integer> entry : entries) {
System.out.println(entry.getKey()+":"+entry.getValue());
}
}
}
5、java9新特性----of方法
package mypackage.day11.demo03;
// java9新特性----of方法
import java.util.List;
import java.util.Map;
import java.util.Set;
public class DemoJava09Of {
public static void main(String[] args) {
System.out.println("========List========");
List<String> list = List.of("Jim","Tom","Mary","Tom");
// list.add("Smith");
System.out.println(list);
System.out.println("========Set========");
Set<String> set = Set.of("Jim","Tom","Mary"); // ,"Tom"
// set.add("Smith");
System.out.println(set);
System.out.println("========Map========");
Map<String,Integer> map = Map.of("Jim",17,
"Tom",21,"Mary",11); // ,"Tom"
// map.put("Smith",99);
System.out.println(map);
}
}
6、斗地主案例
package mypackage.day11.demo04;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
public class DemoBeatDiZhu {
public static void main(String[] args) {
// 准备牌
HashMap<Integer,String> puke = new HashMap<>();
List<Integer> pukeindex = new ArrayList<>();
List<String> color = List.of("红桃", "黑桃", "方片", "花子");
List<String> number = List.of("2","A","K","Q","J","10","9",
"8","7","6","5","4","3");
int index = 0;
puke.put(index,"大王");
pukeindex.add(index);
index++;
puke.put(index,"小王");
pukeindex.add(index);
index++;
for (String s : number) {
for (String s1 : color) {
puke.put(index,s1+s);
pukeindex.add(index);
index++;
}
}
// 洗牌
Collections.shuffle(pukeindex);
// 发牌
ArrayList<Integer> player1 = new ArrayList<>();
ArrayList<Integer> player2 = new ArrayList<>();
ArrayList<Integer> player3 = new ArrayList<>();
ArrayList<Integer> remain = new ArrayList<>();
for (int i = 0; i < pukeindex.size(); i++) {
if (i>=51){
remain.add(pukeindex.get(i));
}else if (i%3==0){
player1.add(pukeindex.get(i));
}else if (i%3==1){
player2.add(pukeindex.get(i));
}else if (i%3==2){
player3.add(pukeindex.get(i));
}
}
// 看牌
show("Jim",puke,player1);
show("Tom",puke,player2);
show("Mary",puke,player3);
show("DiPai",puke,remain);
}
private static void show(String name, HashMap<Integer, String> puke, ArrayList<Integer> player1) {
Collections.sort(player1);
System.out.println("\n"+name+": ");
for (Integer index : player1) {
System.out.print(puke.get(index)+" ");
}
}
}