Java编程基础19——Map集合&斗地主案例
文章目录
1_Map集合概述和特点
-
A:Map接口概述
-
查看API可以知道:
- 将键映射到值的对象
- 一个映射不能包含重复的键
- 每个键最多只能映射到一个值
-
-
B:Map接口和Collection接口的不同
- Map是双列的,Collection是单列的
- Map的键唯一,Collection的子体系Set的元素是唯一的
-
Map集合的数据结构只针对键有效,跟值无关;Collection集合的数据结构是针对元素有效
- HashMap: 键是哈希算法
- TreeMap: 键是二叉树算法
- 问: Set集合底层依赖Map,还是Map集合底层依赖Set?
2_Map集合的功能概述
-
A:Map集合的功能概述
-
a:添加功能
-
V put(K key,V value):添加元素。
- 如果键是第一次存储,就直接存储元素,返回null
- 如果键不是第一次存在,就用值把以前的值替换掉,返回以前的值
-
-
b:删除功能
- void clear():移除所有的键值对元素
- V remove(Object key):根据键删除键值对元素,并把值返回
-
c:判断功能
- boolean containsKey(Object key):判断集合是否包含指定的键
- boolean containsValue(Object value):判断集合是否包含指定的值
- boolean isEmpty():判断集合是否为空
-
d:获取功能
- Set<Map.Entry<K,V>> entrySet():
- V get(Object key):根据键获取值
- Set<K> keySet():获取集合中所有键的集合
- Collection<V> values():获取集合中所有值的集合
-
e:长度功能
- int size():返回集合中的键值对的个数
-
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
public class Demo1_Map {
public static void main(String[] args) {
// demo1();
// demo2();
Map<String, Integer> map = new HashMap<>();
Integer i1 = map.put("张三", 23);
Integer i2 = map.put("李四", 24);
Integer i3 = map.put("王五", 25);
Collection<Integer> c = map.values();
System.out.println(c);
System.out.println(map.size());
}
private static void demo2() {
Map<String, Integer> map = new HashMap<>();
map.put("张三", 23);
map.put("李四", 24);
map.put("王五", 25);
// Integer value = map.remove("张三"); //根据键删除键值对元素,并把值返回
// System.out.println(value);
System.out.println(map.containsKey("张三"));//判断集合是否包含指定的键
System.out.println(map.containsValue(23)); //判断集合是否包含指定的值
System.out.println(map);
}
private static void demo1() {
Map<String, Integer> map = new HashMap<>();
Integer i1 = map.put("张三", 23);
Integer i2 = map.put("李四", 24);
Integer i3 = map.put("王五", 25);
Integer i4 = map.put("张三", 26); //相同的键不存储,值覆盖
System.out.println(map);
System.out.println(i1);
}
}
3_Map集合的遍历之键找值
-
A:键找值思路:
- 获取所有键的集合
*Set<K> keySet():获取集合中所有键的集合 - 遍历键的集合,获取到每一个键
- 根据键找值
*V get(Object key):根据键获取值
- 获取所有键的集合
-
B:案例演示
- Map集合的遍历之键找值
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class Demo2_Iterator {
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<>();
Integer i1 = map.put("张三", 23);
Integer i2 = map.put("李四", 24);
Integer i3 = map.put("王五", 25);
// Integer i = map.get("张三");
// System.out.println(i);//根据键获取值
//获取所有的键
Set<String> keySet = map.keySet(); //获取所有键的集合
Iterator<String> it = keySet.iterator();//获取迭代器
while(it.hasNext()) {
String key = it.next(); //获取每一个键
Integer value = map.get(key);
System.out.println(key + "..." + value);
}
//使用增强for循环遍历
for (String key : map.keySet()) {
System.out.println(key + "..." + map.get(key));
}
}
}
4_Map集合的第二种迭代,根据键值对对象找键和值(双列集合不能直接迭代)
-
A:键值对对象找键和值思路:(画图演示)
- 获取所有键值对对象的集合
- 遍历键值对对象的集合,获取到每一个键值对对象
- 根据键值对对象找键和值
-
B:案例演示
- Map集合的遍历之键值对对象找键和值
- Set<Map.Entry<K,V>> entrySet() 返回此映射中包含的映射关系的Set视图
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class Demo3_Iterator {
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<>();
map.put("张三", 23);
map.put("李四", 24);
map.put("王五", 25);
map.put("赵六", 26);
//Map.Entry说明Entry是Map的内部接口,将键和值封装成了Entry对象,并存储在Set集合中
Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
//获取每一个对象
Iterator<Map.Entry<String, Integer>> it = entrySet.iterator();
while(it.hasNext()) {
//获取每一个Entry对象
Map.Entry<String, Integer> en = it.next(); //父类引用指向子类对象
//Entry<String, Integer> en = it.next(); //直接获取的是子类对象
String key = en.getKey(); //根据键值对对象获取键
Integer value = en.getValue(); //根据键值对对象获取值
System.out.println(key + "..." + value);
}
//使用增强for循环迭代
for (Map.Entry<String, Integer> en : map.entrySet()) {
System.out.println(en.getKey() + "..." + en.getValue());
}
}
}
interface Inter {
interface Inter2 {
public void show();
}
}
class Demo implements Inter.Inter2 {
@Override
public void show() {
}
}
5_HashMap集合键是Student值是String的案例
-
A:案例演示
- HashMap集合键是Student值是String的案例
import java.util.HashMap;
import net.allidea.bean.StudentMap;
public class Demo5_HashMap {
//键是学生对象,代表每一个学生
//值是String,代表学生籍贯
public static void main(String[] args) {
HashMap<StudentMap, String> hm = new HashMap<>();
hm.put(new StudentMap("张三", 23), "北京");
hm.put(new StudentMap("张三", 23), "上海");
hm.put(new StudentMap("李四", 24), "武汉");
hm.put(new StudentMap("王五", 25), "天津");
System.out.println(hm);
}
}
package net.allidea.bean;
public class StudentMap {
private String name;
private int age;
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
StudentMap other = (StudentMap) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
public StudentMap() {
super();
}
public StudentMap(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 "StudentMap [name=" + name + ", age=" + age + "]";
}
}
6_LinkedHashMap的概述和使用
-
A:案例演示
-
LinkedHashMap的特点
- 底层是链表实现的可以保证怎么存就怎么取
-
import java.util.LinkedHashMap;
public class Demo6_LinkedHashMap {
public static void main(String[] args) {
LinkedHashMap<String, Integer> lhm = new LinkedHashMap<>();
lhm.put("张三",23);
lhm.put("赵六",26);
lhm.put("李四",24);
lhm.put("王五",25);
System.out.println(lhm);
}
}
7_TreeMap集合键是Student值是String的案例)
-
A:案例演示
- TreeMap集合键是Student值是String的案例
import java.util.Comparator;
import java.util.TreeMap;
import net.allidea.bean.StudentMap;
public class Demo7_TreeMap {
public static void main(String[] args) {
// demo1();
TreeMap<StudentMap, String> tm = new TreeMap<>(new Comparator<StudentMap>() {
@Override
public int compare(StudentMap s1, StudentMap s2) {
int num = s1.getName().compareTo(s2.getName()); //按照姓名比较
return num == 0 ? s1.getAge() - s2.getAge() : num;
}
});
tm.put(new StudentMap("张三", 23), "北京");
tm.put(new StudentMap("赵六", 26), "深圳");
tm.put(new StudentMap("王五", 25), "广州");
tm.put(new StudentMap("李四", 24), "上海");
System.out.println(tm);
}
private static void demo1() {
TreeMap<StudentMap, String> tm = new TreeMap<>();
tm.put(new StudentMap("张三", 23), "北京");
tm.put(new StudentMap("李四", 24), "上海");
tm.put(new StudentMap("王五", 25), "广州");
tm.put(new StudentMap("赵六", 26), "深圳");
System.out.println(tm);
}
}
public class StudentMap implements Comparable<StudentMap>{
private String name;
private int age;
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
StudentMap other = (StudentMap) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
public StudentMap() {
super();
}
public StudentMap(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 "StudentMap [name=" + name + ", age=" + age + "]";
}
@Override
public int compareTo(StudentMap o) {
int num = this.age - o.age; //以年龄为主要条件
return num == 0 ? this.name.compareTo(o.name) : num;
}
}
8_统计字符串中每个字符出现的次数
-
A:案例演示
- 需求:统计字符串中每个字符出现的次数
import java.util.HashMap;
public class Demo8_test1 {
public static void main(String[] args) {
//1.定义一个字符串
String s = "aaaaabbbbbcccccc";
//2.将字符串转换为字符数组
char[] arr = s.toCharArray();
//3.定义双列集合,存储字符串中字符以及字符出现的次数
HashMap<Character, Integer> hm = new HashMap<>();
//4.遍历字符数组获取每一个字符,并将字符存储在双列集合中
for (char c : arr) {
//5.做判断,如果集合不包括这个键,就将该字符当做键,值为1存储,如果集合中包含这个键,就将值加1存储
/*if(hm.containsKey(c)) { //如果不包含这个键
hm.put(c, 1);
}else {
hm.put(c, hm.get(c) + 1);
}*/
hm.put(c, !hm.containsKey(c) ? 1 : hm.get(c) + 1);
}
//6.打印双列结合获取字符出现的次数
for (Character key : hm.keySet()) { //hm.keySet()代表所有键的集合
System.out.println(key + "=" + hm.get(key));//hm.get(ket)根据键获取值
}
}
}
9_集合嵌套之HashMap嵌套HashMap
-
A:案例演示
- 集合嵌套之HashMap嵌套HashMap
- 需求: javaSE有A班和B班,定义成双列集合,键是学生对象,值是学生的归属地,为了便于管理,把a和b期都归属JavaSE这个大的集合中.
import java.util.HashMap;
import net.allidea.bean.StudentMap;
public class Demo9_HashMapHashMap {
public static void main(String[] args) {
HashMap<StudentMap, String> hmA = new HashMap<>();
hmA.put(new StudentMap("张三", 23), "北京");
hmA.put(new StudentMap("李四", 24), "北京");
hmA.put(new StudentMap("王五", 25), "上海");
hmA.put(new StudentMap("赵六", 26), "杭州");
HashMap<StudentMap, String> hmB = new HashMap<>();
hmB.put(new StudentMap("唐三", 32), "北京");
hmB.put(new StudentMap("悟空", 15), "北京");
hmB.put(new StudentMap("悟能", 10), "上海");
hmB.put(new StudentMap("悟净", 20), "杭州");
HashMap<HashMap<StudentMap, String>, String> hm = new HashMap<>();
hm.put(hmA, "班级A");
hm.put(hmB, "班级B");
//遍历双列结合
for (HashMap<StudentMap, String> h : hm.keySet()) { //hm.keySet()代表的是双列集合中键的集合
String value = hm.get(h); //get(h)根据键对象获取值对象
//遍历键的双列集合对象
for (StudentMap key : h.keySet()) { //h.keySet()获取集合中所有的学生键对象
String value2 = h.get(key);
System.out.println(key + "..." + value2 + "..." + value);
}
}
}
}
10_HashMap和Hashtable的区别)
-
A:共同点:
- 底层都是哈希算法,都是双列集合
-
B:区别
- 1.Hashtable是JDK1.0版本出现的,是线程安全的,效率低; HashMap是JDK1.2版本出现的,是线程不安全的,效率高
- 2.Hashtable不可以存储null键和null值; HashMap可以存储null键和null值(目的是为了让后续代码可以继续执行)
-
C:案例演示
- HashMap和Hashtable的区别
public static void main(String[] args) {
HashMap<String, Integer> hm = new HashMap<>();
hm.put(null, 23);
hm.put("李四", null);
System.out.println(hm);
Hashtable<String, Integer> ht = new Hashtable<>();
ht.put(null, 23);
ht.put("李四", null);
System.out.println(ht);
}
11_Collections工具类的概述和常见方法讲解
-
A:Collections类概述
- 针对集合操作 的工具类
- B:Collections成员方法
public static <T> void sort(List<T> list) 根据元素的自然顺序 对指定列表按升序进行排序。
public static <T> int binarySearch(List<?> list,T key) 使用二分搜索法搜索指定列表,以获得指定对象
public static <T> T max(Collection<?> coll) 根据元素的自然顺序,返回给定 collection 的最大元素。
public static void reverse(List<?> list) 反转指定列表中元素的顺序。
public static void shuffle(List<?> list) 使用默认随机源对指定列表进行置换。
import java.util.ArrayList;
import java.util.Collections;
public class Demo1_Collections {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("c");
list.add("d");
list.add("e");
Collections.sort(list); //将集合排序
System.out.println(Collections.binarySearch(list, "e"));//使用二分搜索法搜索指定列表,以获得指定对象
System.out.println(Collections.max(list)); //根据元素的自然顺序,返回给定 collection 的最大元素。
Collections.reverse(list); //反轉集合
Collections.shuffle(list); //随机置换,洗牌
System.out.println(list);
}
}
12_模拟斗地主洗牌和发牌
-
A:案例演示
- 模拟斗地主洗牌和发牌,牌没有排序
import java.util.ArrayList;
import java.util.Collections;
public class Demo2_test {
public static void main(String[] args) {
//1.定义一副扑克牌
String[] num = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
String[] color = {"红桃","黑桃","方片","梅花"};
ArrayList<String> poker = new ArrayList<>();
//拼接花色和数字
for(String s1 : color) {
for(String s2 : num) {
poker.add(s1.concat(s2)); //concat链接两个字符串
}
}
poker.add("小王");
poker.add("大王");
//2.洗牌
Collections.shuffle(poker);
//3.发牌
ArrayList<String> dushen = new ArrayList<>();
ArrayList<String> dusheng = new ArrayList<>();
ArrayList<String> duxia = new ArrayList<>();
ArrayList<String> dipai = new ArrayList<>();
for (int i = 0; i < poker.size(); i++) {
if(i >= poker.size() - 3) {
dipai.add(poker.get(i)); //将三张底牌存储在底牌集合中
} else if(i % 3 == 0) {
dushen.add(poker.get(i));
} else if(i % 3 == 1) {
dusheng.add(poker.get(i));
} else{
duxia.add(poker.get(i));
}
}
//4.看牌
System.out.println(dushen);
System.out.println(dusheng);
System.out.println(duxia);
System.out.println(dipai);
}
}
14_模拟斗地主洗牌和发牌并对牌进行排序的代码实现
-
A:画图演示
- 画图说明排序原理
-
B:案例演示
- 模拟斗地主洗牌和发牌并对牌进行排序的代码实现
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;
public class Demo3_test {
public static void main(String[] args) {
//1.定义一副扑克牌
String[] num = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
String[] color = {"红桃","黑桃","方片","梅花"};
HashMap<Integer, String> hm = new HashMap<>(); //存储索引和扑克牌
ArrayList<Integer> list = new ArrayList<>(); //存储索引
int index = 0;
//拼接扑克牌并将索引和扑克牌存储在hm中
for (String s1 : num) { //获取数字
for(String s2 : color) { //获取颜色
hm.put(index, s2.concat(s1));
list.add(index); //将索引0-51添加到list集合中
index++;
}
}
//将小王添加到双列集合中
hm.put(index, "小王");
list.add(index); //将索引52添加到list集合中
index++;
hm.put(index, "大王");
list.add(index); //将索引53添加到list集合中
//洗牌
Collections.shuffle(list);
//发牌
TreeSet<Integer> dushen = new TreeSet<>();
TreeSet<Integer> dusheng = new TreeSet<>();
TreeSet<Integer> duxia = new TreeSet<>();
TreeSet<Integer> dipai = new TreeSet<>();
for(int i = 0; i < list.size(); i++) {
if(i >= list.size() - 3) {
dipai.add(list.get(i)); //将三张底牌存储在底牌集合中
}else if(i % 3 == 0) {
dushen.add(list.get(i));
}else if(i % 3 == 1) {
dusheng.add(list.get(i));
}else{
duxia.add(list.get(i));
}
}
//看牌
lookPoker(hm, dushen, "赌神");
lookPoker(hm, dusheng, "赌圣");
lookPoker(hm, duxia, "赌侠");
lookPoker(hm, dipai, "底牌");
}
//返回值类型void,参数列表HashMap、TreeSet、String name
public static void lookPoker(HashMap<Integer, String> hm,TreeSet<Integer> ts , String name) {
System.out.print(name + "的牌是:");
for(Integer i : ts) { //i代表双列集合中的每一个键
System.out.print(hm.get(i) + " ");
}
System.out.println();
}
}
15_集合框架(泛型固定下边界)
- ? super E
public class Demo4_Genric {
public static void main(String[] args) {
TreeSet<StudentMap> ts1 = new TreeSet<>(new CompareByAge());
ts1.add(new StudentMap("张三", 23));
ts1.add(new StudentMap("李四", 14));
ts1.add(new StudentMap("王五", 23));
ts1.add(new StudentMap("赵六", 33));
TreeSet<Student> ts2 = new TreeSet<>(new CompareByAge());
ts2.add(new Student("张三", 23));
ts2.add(new Student("李四", 14));
ts2.add(new Student("王五", 23));
ts2.add(new Student("赵六", 33));
System.out.println(ts2);
}
}
class CompareByAge implements Comparator<StudentMap> {
@Override
public int compare(StudentMap s1, StudentMap s2) {
int num = s1.getAge() - s2.getAge();
return num == 0 ? s1.getName().compareTo(s2.getName()) : num;
}
}
16_集合总结
-
Collection
-
List(存取有序,有索引,可以重复)
-
ArrayList
- 底层是数组实现的,线程不安全,查找和修改快,增和删比较慢
-
LinkedList
- 底层是链表实现的,线程不安全,增和删比较快,查找和修改比较慢
-
Vector
- 底层是数组实现的,线程安全的,无论增删改查都慢
- 如果查找和修改多,用ArrayList
- 如果增和删多,用LinkedList
- 如果都多,用ArrayList
-
-
Set(存取无序,无索引,不可以重复)
-
HashSet
- 底层是哈希算法实现
-
LinkedHashSet
- 底层是链表实现,但是也是可以保证元素唯一,和HashSet原理一样
-
TreeSet
- 底层是二叉树算法实现
- 一般在开发的时候不需要对存储的元素排序,所以在开发的时候大多用HashSet,HashSet的效率比较高
- TreeSet在面试的时候比较多,问你有几种排序方式,和几种排序方式的区别
-
-
Map
-
HashMap
- 底层是哈希算法,针对键
-
LinkedHashMap
- 底层是链表,针对键
-
TreeMap
- 底层是二叉树算法,针对键
- 开发中用HashMap比较多
-
-
评论
登录后参与技术讨论,分享你的经验与见解。
登录 / 注册暂无评论