1 Map集合
1.1 概述和特点
需求
根据学号获取学生姓名
Map接口概述
查看API可以知道：
将键映射到值的对象
一个映射不能包含重复的键
每个键最多只能映射到一个值
Map接口和Collection接口的不同
Map是双列的,Collection是单列的
Map的键唯一,Collection的子体系Set是唯一的
Map集合的数据结构针对键有效，跟值无关;Collection集合的数据结构是针对元素有效
1.2 功能概述
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(): 返回一个键值对的Set集合
V get(Object key): 根据键获取值
Set keySet(): 获取集合中所有键的集合
Collection values(): 获取集合中所有值的集合
e:长度功能
int size()： 返回集合中的键值对的对数
1.3 基本功能测试
案例演示
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()
1.4 获取功能测试
案例演示
V get(Object key)
Set keySet()
Collection values()
1.5 遍历之键找值
键找值思路
获取所有键的集合
遍历键的集合，获取到每一个键
根据键找值
案例演示
Map集合的遍历之键找值
1.6 遍历之键值对对象找键和值
键值对对象找键和值思路
获取所有键值对对象的集合
遍历键值对对象的集合，获取到每一个键值对对象
根据键值对对象找键和值
案例演示
Map集合的遍历之键值对对象找键和值
1.7 遍历的两种方式比较图解
画图演示
Map集合遍历的两种方式比较
2 HashMap集合键
2.1 是Stirng值是String的案例
HashMap 允许插入null键 null值
案例演示
HashMap集合键是Stirng值是String的案例
2.2 是String值是Student的案例
案例演示
HashMap集合键是String值是Student的案例
2.3 是Student值是String的案例
键唯一 注意重写hashCode方法 和 equals 方法
案例演示
HashMap集合键是Student值是String的案例
3 LinkedHashMap
3.1 概述和使用
LinkedHashMap的概述
Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序
LinkedHashMap的特点
底层的数据结构是链表和哈希表 元素有序 并且唯一
元素的有序性由链表数据结构保证 唯一性由 哈希表数据结构保证
Map集合的数据结构只和键有关
案例演示
LinkedHashMap的特点
4 TreeMap集合键
4.1 是String值是String的案例
TreeMap 键不允许插入null
TreeMap: 键的数据结构是红黑树,可保证键的排序和唯一性
排序分为自然排序和比较器排序
线程是不安全的效率比较高
案例演示
TreeMap集合键是Integer值是String的案例
4.2 是Student值是String的案例
案例演示
TreeMap集合键是Student值是String的案例
按照年龄大小进行排序
注意键要实现Comparable 接口
4.3 统计字符串中每个字符出现的次数
案例演示
需求：统计字符串中每个字符出现的次数
“aababcabcdabcde”,获取字符串中每一个字母出现的次数要求结果:a(5)b(4)c(3)d(2)e(1)
import java.util.*;
/* a-----5
b-----4
c-----3
d-----2
e-----1
我们观察发现 这是一种 键值对应关系的数据
对于这种数据我们可以采用双列集合存储集合
遍历双列集合，拼接字符串。
难点在于我们怎么统计字符出现的个数，然后存到集合中
*/
public class MyTest {
public static void main(String[] args) {
HashMap<Character, Integer> hm = new HashMap<>();
System.out.println("请输入字符串");
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
/* //方法一、用字符数组解决
char[] chars=str.toCharArray();
for (int i = 0; i < str.length(); i++) {
if(!hm.containsKey(chars[i])){
hm.put(chars[i],1);
}else{
Integer value=hm.get(chars[i]);
value++;
hm.put(chars[i],value);
}
}
System.out.println(hm);*/
//方法二、遍历字符串
for (int i = 0; i < str.length(); i++) {
char ch = str.charAt(i);
//判断这个键是不是第一次出现，如果不是，我就存进去，值给个1
if (!hm.containsKey(ch)) {
hm.put(ch, 1);//a----1
} else {
//我应该获取出上一次的值，累加一次，再存进去，键相同，值覆盖
Integer value = hm.get(ch);
value++;
//键相同，值覆盖
hm.put(ch, value);
}
}
//遍历集合拼接字符串
StringBuilder sb = new StringBuilder();
Set<Map.Entry<Character, Integer>> entries = hm.entrySet();//将Map集合当中的映射关系取出，存入到Set集合当中
for (Map.Entry<Character, Integer> entry : entries) {
Character key = entry.getKey();
Integer value = entry.getValue();
sb.append(key).append("(").append(value).append(")");
}
String s = sb.toString();
System.out.println(s);
System.out.println(hm);
}
}
集合嵌套之HashMap嵌套HashMap
案例演示
集合嵌套之HashMap嵌套HashMap
基础班
张三 20
李四 22
就业班
王五 21
赵六 23
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.function.BiConsumer;
public class MyTest2 {
public static void main(String[] args) {
HashMap<String,Integer> jcMap = new HashMap<>();
jcMap.put("张三",20);
jcMap.put("李四",22);
HashMap<String,Integer>jyMap=new HashMap<>();
jyMap.put("王五",21);
jyMap.put("赵六",23);
HashMap<String,HashMap<String,Integer>>maxMap=new HashMap<>();
maxMap.put("基础班",jcMap);
maxMap.put("就业班",jyMap);
//方法一：遍历Map集合
Set<String> keySet= maxMap.keySet();
for (String key : keySet) {
System.out.println(key);
HashMap<String,Integer>minMap=maxMap.get(key);
Set<String>keySet1=minMap.keySet();
for (String s : keySet1) {
System.out.println("\t"+s+" "+minMap.get(s));
}
System.out.println();
}
System.out.println("===========================");
//方法二
for(Map.Entry<String,HashMap<String,Integer>> entry:maxMap.entrySet()){
System.out.println(entry.getKey());
for(Map.Entry<String,Integer> en:entry.getValue().entrySet()){
System.out.println("\t"+en.getKey()+" "+en.getValue());
}
System.out.println();
}
System.out.println("===============================");
//方法三
maxMap.forEach(new BiConsumer<String, HashMap<String, Integer>>() {
@Override
public void accept(String key, HashMap<String, Integer> minMap) {
System.out.println(key);
minMap.forEach(new BiConsumer<String, Integer>() {
@Override
public void accept(String s, Integer integer) {
System.out.println("\t"+s+"======="+integer);
}
});
}
});
}
}
集合嵌套之HashMap嵌套ArrayList
案例演示
集合嵌套之HashMap嵌套ArrayList
假设HashMap集合的元素是ArrayList。有3个。
每一个ArrayList集合的值是字符串。
三国演义
吕布
周瑜
笑傲江湖
令狐冲
林平之
神雕侠侣
郭靖
杨过
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Set;
/* 集合嵌套之HashMap嵌套ArrayList
假设HashMap集合的元素是ArrayList。有3个。
每一个ArrayList集合的值是字符串。
三国演义
吕布
周瑜
笑傲江湖
令狐冲
林平之
神雕侠侣
郭靖
杨过*/
public class MyTest3 {
public static void main(String[] args) {
ArrayList<String> sgList = new ArrayList<>();
sgList.add("吕布");
sgList.add("周瑜");
ArrayList<String> xaList = new ArrayList<>();
xaList.add("令狐冲");
xaList.add("林平之");
ArrayList<String> sdList = new ArrayList<>();
sdList.add("郭靖");
sdList.add("杨过");
LinkedHashMap<String, ArrayList<String>> maxMap = new LinkedHashMap<>();
maxMap.put("三国演义",sgList);
maxMap.put("笑傲江湖", xaList);
maxMap.put("神雕侠侣", sdList);
//遍历输出
Set<String> key=maxMap.keySet();
for (String s : key) {
System.out.println(s);
ArrayList<String>value=maxMap.get(s);
/*for(int i=0;i<value.size();i++){
System.out.println("\t"+value.get(i));
}*/
for(String ss:value){
System.out.println("\t"+ss);
}
}
System.out.println();
}
}
集合嵌套之ArrayList嵌套HashMap
案例演示
集合嵌套之ArrayList嵌套HashMap
假设ArrayList集合的元素是HashMap。有3个。
每一个HashMap集合的键和值都是字符串。
周瑜—小乔
吕布—貂蝉
郭靖—黄蓉
杨过—小龙女
令狐冲—任盈盈
林平之—岳灵珊
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
public class MyTest4 {
public static void main(String[] args) {
HashMap<String, String> sg = new HashMap<>();
sg.put("周瑜","小乔");
sg.put("吕布","貂蝉");
HashMap<String, String> sd = new HashMap<>();
sd.put("郭靖","黄蓉");
sd.put(" 杨过","小龙女");
HashMap<String, String> xa = new HashMap<>();
xa.put("令狐冲","任盈盈");
xa.put("林平之"," 岳灵珊");
ArrayList<HashMap<String, String> >list=new ArrayList<>();
list.add(sg);
list.add(sd);
list.add(xa);
for (HashMap<String, String> f : list) {
for(Map.Entry<String,String>en:f.entrySet()){
String key=en.getKey();
String value=en.getValue();
System.out.println(key+"------"+value);
}
}
}
}
HashMap和Hashtable的区别
HashMap和Hashtable的区别: 查看API可以知道
HashMap: 线程不安全,效率高.允许null值和null键
Hashtable: 线程安全 , 效率低.不允许null值和null键
案例演示
HashMap和Hashtable的区别
Collections工具类(针对单链集合)
Collections类概述
针对集合操作 的工具类
Collections成员方法
public static void sort(List list): 排序,默认按照自然顺序
public static int binarySearch(List<?> list,T key): 二分查找
public static T max(Collection<?> coll): 获取最大值
public static void reverse(List<?> list): 反转
public static void shuffle(List<?> list): 随机置换
案例演示
Collections工具类的常见方法讲解
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class MyTest5 {
public static void main(String[] args) {
ArrayList<Integer>list=new ArrayList<>();
list.add(100);
list.add(108);
list.add(600);
list.add(700);
list.add(108);
list.add(110);
/* list.sort(new Comparator<Integer>() {
@Override
public int compare(Integer a,Integer b){
return a-b;
}
});
System.out.println(list);*/
//排序
Collections.sort(list,new Comparator<Integer>(){
public int compare(Integer a,Integer b){
return b-a;
}
});
System.out.println(list);
//反转
Collections.reverse(list);
System.out.println(list);
//二分查找
int index=Collections.binarySearch(list,100);
System.out.println(index);
//获取集合中的最值
Integer max=Collections.max(list);
Integer min=Collections.min(list);
System.out.println(max);
System.out.println(min);
//随机打乱集合中的元素顺序
Collections.shuffle(list);
System.out.println(list);
}
}
模拟斗地主洗牌和发牌
案例演示
模拟斗地主洗牌和发牌，牌没有排序
import java.util.ArrayList;
import java.util.Collections;
public class MyTest {
public static void main(String[] args) {
/* A:
案例演示:
模拟斗地主洗牌和发牌看牌，牌没有排序
一副牌 54 张牌
*/
//1.创建一个牌盒
ArrayList<String> pokerBox = new ArrayList<>();
//2.生成54张牌，装到牌盒里面
//花色 和 序号
String[] colors = {"♣", "♥", "♦", "♠"};
String[] nums = {"A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"};
//组合花色和序号
for (String color : colors) {
for (String num : nums) {
pokerBox.add(color.concat(num));
}
}
//收到添加大小王
pokerBox.add("☀");
pokerBox.add("☂");
//System.out.println(pokerBox);
//斗地主3个人 留一副底牌
ArrayList<String> 星仔 = new ArrayList<>();
ArrayList<String> 刀仔 = new ArrayList<>();
ArrayList<String> 高进 = new ArrayList<>();
ArrayList<String> 底牌 = new ArrayList<>();
//洗牌
Collections.shuffle(pokerBox);
Collections.shuffle(pokerBox);
Collections.shuffle(pokerBox);
// System.out.println(pokerBox);
//斗地主3个人 留一副底牌
//发牌：一人一张轮流张发
// 一次数好发给你
// 星仔 = (ArrayList<String>) pokerBox.subList(0, 17);
//发牌：一人一张轮流发
//星仔：0 3 6 9 12 取余 0
//刀仔: 1 4 7 10 13 取余 1
//高进： 2 5 8 11 14 取余 2
for (int i = 0; i < pokerBox.size(); i++) {
if (i >= pokerBox.size() - 3) {
底牌.add(pokerBox.get(i));
} else if (i % 3 == 0) {
星仔.add(pokerBox.get(i));
} else if (i % 3 == 1) {
刀仔.add(pokerBox.get(i));
} else {
高进.add(pokerBox.get(i));
}
}
//看牌
lookPoker("星仔", 星仔);
lookPoker("刀仔", 刀仔);
lookPoker("高进", 高进);
lookPoker("底牌", 底牌);
}
private static void lookPoker(String name, ArrayList<String> list) {
System.out.println(name);
for (String p : list) {
System.out.print(p + " ");
}
System.out.println();
}
}
模拟斗地主洗牌和发牌并对牌进行排序的原理图解
画图演示
画图说明排序原理
模拟斗地主洗牌和发牌并对牌进行排序的代码实现
案例演示
模拟斗地主洗牌和发牌并对牌进行排序的代码实现
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;
public class 斗地主排序版 {
public static void main(String[] args) {
//创建牌盒
HashMap<Integer, String> hm = new HashMap<>();
//创建索引集合
ArrayList<Integer> indexs = new ArrayList<>();
//花色 和 序号
String[] colors = {"♣", "♥", "♦", "♠"};
String[] nums = {"A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"};
int index = 0;
for (String num : nums) {
for (String color : colors) {
hm.put(index, num.concat(color));
indexs.add(index);
index++;
}
}
hm.put(index, "☀");
indexs.add(index);
index++;
hm.put(index, "☹");
indexs.add(index);
//System.out.println(hm);
//System.out.println(indexs);
//洗牌
Collections.shuffle(indexs);
//发牌
TreeSet<Integer> 星仔 = new TreeSet<Integer>();
TreeSet<Integer> 刀仔 = new TreeSet<Integer>();
TreeSet<Integer> 高进 = new TreeSet<Integer>();
TreeSet<Integer> 底牌 = new TreeSet<Integer>();
for (int i = 0; i < indexs.size(); i++) {
if (i >= indexs.size() - 3) {
底牌.add(indexs.get(i));
} else if (i % 3 == 0) {
星仔.add(indexs.get(i));
} else if (i % 3 == 1) {
刀仔.add(indexs.get(i));
} else {
高进.add(indexs.get(i));
}
}
//看牌，键找值
lookPoker("星仔", 星仔, hm);
lookPoker("刀仔", 刀仔, hm);
lookPoker("高进", 高进, hm);
lookPoker("底牌", 底牌, hm);
}
private static void lookPoker(String name, TreeSet<Integer> set, HashMap<Integer, String> hm) {
System.out.println(name);
for (Integer key : set) {
System.out.print(hm.get(key) + " ");
}
System.out.println();
}
}
6094
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
