Java Collection体系特点 Set集合体系 Map集合体系
一.set系列集合
1.set系列集系概述
package com.wjh_Set_Map.d1_set;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;
public class SetDemo1 {
public static void main(String[] args) {
//看看set系列集合的特点:
// 1.HashSet -> 无序,不重复,无索引
// (1)LinkedHashSet -> 有序,不重复,无索引
// 2.TreeSet -> 排序,不重复,无索引
Set sets = new HashSet<>(); //多态;经典写法
sets.add("MySql");
sets.add("Java");
sets.add("Java");
sets.add("MyBatis");
sets.add("HTML");
sets.add("SpringBoot");
sets.add("HTML");
sets.add("SpringBoot");
System.out.println(sets);
//[Java, MySql, MyBatis, HTML, SpringBoot]
//无序,不重复,无索引
}
}
[Java, MySql, MyBatis, HTML, SpringBoot]
进程已结束，退出代码为 0
2.HashSet元素无序的底层原理:哈希表
package com.wjh_Set_Map.d1_set;
public class SetDemo2 {
public static void main(String[] args) {
//目标:学会获取对象的哈希值,并确认一下
String name = "iKun";
System.out.println(name.hashCode()); //3203867
System.out.println(name.hashCode()); //3203867
String name1 = "iKuu";
System.out.println(name1.hashCode()); //3203874
System.out.println(name1.hashCode()); //3203874
}
}
3203867
3203867
3203874
3203874进程已结束，退出代码为 0
3.HashSet元素去重复的底层原理
Student学生类:
package com.wjh_Set_Map.d1_set;
import java.util.Objects;
public class Student {
private String name;
private int age;
private char sex;
public Student() {
}
public Student(String name, int age, char sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
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;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
/**
* 只要两个对象内容一样,结果一定是true
* @param o
* @return
*/
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age && sex == student.sex && Objects.equals(name, student.name);
}
/*
s1 = new Student("小明", 23,'男');
s2 = new Student("小红", 18,'女');
s3 = new Student("小琳", 22,'女');
s4 = new Student("小琳", 22,'女');
*/
/**
*
* @return
*/
@Override
public int hashCode() {
return Objects.hash(name, age, sex);
}
/**
*
* @return
//重写toString方法 : 输入toS 快捷生成
*/
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", sex=" + sex +
'}';
}
}
测试类:
package com.wjh_Set_Map.d1_set;
/*
目标:让Set集合把重复内容的对象去掉一个(去重复)
*/
import java.util.HashSet;
import java.util.Set;
public class SetDemo3 {
public static void main(String[] args) {
Student s1 = new Student("小明", 23,'男');
Student s2 = new Student("小红", 18,'女');
Student s3 = new Student("小琳", 22,'女');
Student s4 = new Student("小琳", 22,'女');
System.out.println(s1.hashCode()); //727252094
System.out.println(s2.hashCode()); //733291443
System.out.println(s3.hashCode()); //730724736 一样
System.out.println(s4.hashCode()); //730724736 一样
//Set集合去重复原因:先判断哈希值 再判断equals
Set sets = new HashSet<>();
sets.add(s1);
sets.add(s2);
sets.add(s3);
sets.add(s4);
System.out.println(sets);
// [Student{name='小红', age=18, sex=女}, Student{name='小琳', age=22, sex=女}, Student{name='小明', age=23, sex=男}, Student{name='小琳', age=22, sex=女}]
}
}
727252094
733291443
730724736
730724736
[Student{name='小明', age=23, sex=男}, Student{name='小红', age=18, sex=女}, Student{name='小琳', age=22, sex=女}]进程已结束，退出代码为 0
4.实现类:LinkedHashSet
package com.wjh_Set_Map.d1_set;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;
public class SetDemo4 {
public static void main(String[] args) {
//看看set系列集合的特点:
// 1.HashSet -> 无序,不重复,无索引
// (1)LinkedHashSet -> 有序,不重复,无索引
// 2.TreeSet -> 排序,不重复,无索引
Set sets = new LinkedHashSet<>(); //多态;经典写法
sets.add("MySql");
sets.add("Java");
sets.add("Java");
sets.add("MyBatis");
sets.add("HTML");
sets.add("SpringBoot");
sets.add("HTML");
sets.add("SpringBoot");
System.out.println(sets);
//[Java, MySql, MyBatis, HTML, SpringBoot]
//无序,不重复,无索引
}
}
[MySql, Java, MyBatis, HTML, SpringBoot]
进程已结束，退出代码为 0
5.实现类:TreeSet
Apple类:
package com.wjh_Set_Map.d1_set;
/*
由于TreeSet中自定义数据类型不能比较
所以要在该类中 implements Comparable<类名称>
之后 Alt + Enter 重写方法
*/
public class Apple implements Comparable{
private String name;
private String color;
private Double weight;
private int much;
public Apple() {
}
public Apple(String name, String color, Double weight, int much) {
this.name = name;
this.color = color;
this.weight = weight;
this.much = much;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public Double getWeight() {
return weight;
}
public void setWeight(Double weight) {
this.weight = weight;
}
public int getMuch() {
return much;
}
public void setMuch(int much) {
this.much = much;
}
// toString 重写方法
@Override
public String toString() {
return "Apple{" +
"name='" + name + '\'' +
", color='" + color + '\'' +
", weight=" + weight +
", much=" + much +
'}';
}
/**
* 方式一:类自定义比较规则
* o1.compareTo(o2)
* @param o
* @return
*/
@Override
public int compareTo(Apple o) {
//按照重量进行比较
return (int) (this.weight - o.weight); //去重量重复的元素
//return (int) (this.weight - o.weight) >= 0 ? 1 : -1;
//保留重量重复的元素
}
}
测试类:
package com.wjh_Set_Map.d1_set;
/*
目标:观察TreeSet对于有值特性的数据如何排序
学会自定义类型的对象进行指定规则排序
*/
import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;
public class SetDemo5 {
public static void main(String[] args) {
//创建一个TreeSet多态对象,特点:可排序,去重复,无索引
Set treeSet = new TreeSet<>();
treeSet.add(23);
treeSet.add(24);
treeSet.add(8);
treeSet.add(12);
System.out.println(treeSet);
//[8, 12, 23, 24] -> 整数类型 按照升序排列
Set treeSet1 = new TreeSet<>();
treeSet1.add("Java");
treeSet1.add("HTML");
treeSet1.add("Home");
treeSet1.add("Apple");
treeSet1.add("APods");
treeSet1.add("Adidas");
treeSet1.add("Python");
treeSet1.add("UI");
treeSet1.add("Zip");
treeSet1.add("UI");
System.out.println(treeSet1);
//[APods,Adidas, Apple, HTML, Home, Java, Python, UI, Zip]
// -> 字符串类型 按照首字母顺序排列(大写有优先权)
System.out.println("-------试试自定义类型排序--------");
//方式一:定制比较规则
//Set apples = new TreeSet<>();
//方式二:集合自带比较器对象进行比较规则定制
Set apples = new TreeSet<>(new Comparator() {
@Override
public int compare(Apple o1, Apple o2) {
//return (int)(o1.getWeight() - o2.getWeight()); //按重量升序
return (int)(o2.getWeight() - o1.getWeight()); //按重量降序
//浮点型建议直接使用(Double.compare(o2, o1)
//return Double.compare(o2.getPrice() , o1.getPrice());
}
});
apples.add(new Apple("红富士", "红色", 6.5, 5));
apples.add(new Apple("蛇果", "酒红色", 10.2, 2));
apples.add(new Apple("青苹果", "红色", 15.9, 9));
apples.add(new Apple("苹果14ProMax暗夜紫1TB", "土豪金", 0.65, 1));
System.out.println(apples);
for (Apple a : apples) {
System.out.println("名称:" + a.getName());
System.out.println("颜色:" + a.getColor());
System.out.println("重量:" + a.getWeight() + "kg");
System.out.println("个数:" + a.getMuch());
System.out.println();
}
}
}
[8, 12, 23, 24]
[APods, Adidas, Apple, HTML, Home, Java, Python, UI, Zip]
-------试试自定义类型排序--------
[Apple{name='苹果14ProMax暗夜紫1TB', color='土豪金', weight=0.65, much=1}, Apple{name='红富士', color='红色', weight=6.5, much=5}, Apple{name='蛇果', color='酒红色', weight=10.2, much=2}, Apple{name='青苹果', color='红色', weight=15.9, much=9}]
名称:苹果14ProMax暗夜紫1TB
颜色:土豪金
重量:0.65kg
个数:1名称:红富士
颜色:红色
重量:6.5kg
个数:5名称:蛇果
颜色:酒红色
重量:10.2kg
个数:2名称:青苹果
颜色:红色
重量:15.9kg
个数:9
进程已结束，退出代码为 0
TreeSet自定义比较规则中建议使用: -> 集合自带比较器对象进行比较规则定制,重写比较规则
（两个比较器都有的话默认也是使用的集合自带的比较器）
(集合自带比较器对象进行比较规则定制,重写比较规则) 代码简化:
//代码简化:
Set apples = new TreeSet<>((o1, o2) -> Double.compare(o2.getMuch() , o1.getMuch()));
//浮点型用Double.compare(o1, o2) 
PS: (自己写的,代码还待优化,哈哈哈)
Student类:
package com.wjh_Set_Map.d11_Student_TreeSet;
//1.定义学生类
public class Student {
private String name;
private Double chinese;
private Double math;
private Double english;
private Double score;
public Student() {
}
public Student(String name, Double chinese, Double math, Double english, Double score) {
this.name = name;
this.chinese = chinese;
this.math = math;
this.english = english;
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Double getChinese() {
return chinese;
}
public void setChinese(Double chinese) {
this.chinese = chinese;
}
public Double getMath() {
return math;
}
public void setMath(Double math) {
this.math = math;
}
public Double getEnglish() {
return english;
}
public void setEnglish(Double english) {
this.english = english;
}
public Double getScore() {
return score;
}
public void setScore(Double score) {
this.score = score;
}
// toString 重写方法
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", chinese=" + chinese +
", math=" + math +
", english=" + english +
", score=" + score +
'}';
}
}
测试类:
package com.wjh_Set_Map.d11_Student_TreeSet;
import java.util.Comparator;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;
/*
TreeSet集合进行对象排序
需求：键盘录入3个学生信息(姓名,语文成绩,数学成绩,英语成绩)
按照总分从高到低输出到控制台
分析
定义学生类
创建TreeSet集合对象，通过比较器排序进行排序
创建学生对象
把学生对象添加到集合
遍历集合
*/
//Set apples = new TreeSet<>((o1, o2) -> Double.compare(o2.getMuch() , o1.getMuch()));
浮点型用Double.compare(o1, o2)
public class Test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//2.创建TreeSet集合对象，通过比较器排序进行排序
Set stu = new TreeSet<>(((o1, o2) -> Double.compare(o2.getScore(), o1.getScore())));
Student s = new Student();
System.out.println("-----欢迎使用学生成绩系统-----");
for (int i = 1; i <= 3; i++) {
System.out.print("请输入学生"+ i +"姓名:");
String name = sc.next();
System.out.print("请输入学生"+ i +"语文成绩:");
double chinese = sc.nextDouble();
System.out.print("请输入学生"+ i +"数学成绩:");
double math = sc.nextDouble();
System.out.print("请输入学生"+ i +"英语成绩:");
double english = sc.nextDouble();
double scores = chinese + math + english;
s.setScore(scores);
stu.add(new Student(name,chinese,math,english,scores));
}
System.out.println("-----学生信息如下-----");
for (Student ss : stu) {
System.out.println("姓名:" + ss.getName() +"\t\t"+ "语文:" + ss.getChinese() + "\t\t"+ "数学:" + ss.getMath() + "\t\t"+ "英语" + ss.getEnglish() + "\t\t" + "总分" + ss.getScore());
}
}
}
-----欢迎使用学生成绩系统-----
请输入学生1姓名:小明
请输入学生1语文成绩:66
请输入学生1数学成绩:78.5
请输入学生1英语成绩:80
请输入学生2姓名:小黑
请输入学生2语文成绩:56
请输入学生2数学成绩:59.5
请输入学生2英语成绩:30
请输入学生3姓名:小林
请输入学生3语文成绩:98
请输入学生3数学成绩:99
请输入学生3英语成绩:99.5
-----学生信息如下-----
姓名:小林 语文:98.0 数学:99.0 英语99.5 总分296.5
姓名:小明 语文:66.0 数学:78.5 英语80.0 总分224.5
姓名:小黑 语文:56.0 数学:59.5 英语30.0 总分145.5进程已结束，退出代码为 0
二.Collection体系的特点(重点)
适用场景:
(1) ArrayList: 增删相对慢(忽略不计)
(2)LinkedList: 栈,队列(如排队系统)
(3)HashSet:
(4)LinkedHashSet:
(5)TreeSet:
三.补充知识:可变参数
package com.wjh_Set_Map.d2_params;
import java.lang.reflect.Array;
import java.util.Arrays;
public class MethodDemo {
public static void main(String[] args) {
sum(); //1.不传参数
sum(10); //2.传一个参数
sum(10,20,30); //3.传多个参数
sum(new int[]{10, 20, 30, 40, 50}); //4.传输数组
}
/**
* (int...nums)作用:可以传一个参数,多个参数,一个数组
* @param nums
*/
public static void sum(int...nums){
//注意:可变参数在方法内部就是一个数组,nums
System.out.println("元素个数:" + nums.length);
System.out.println("元素内容:" + Arrays.toString(nums));
System.out.println();
}
}
元素个数:0
元素内容:[]元素个数:1
元素内容:[10]元素个数:3
元素内容:[10, 20, 30]元素个数:5
元素内容:[10, 20, 30, 40, 50]
进程已结束，退出代码为 0
* 注意:一个形参列表只能有一个可变参数,可变参数必须放在形参列表后面
四.补充知识:集合工具类Collection
五.Collection体系的综合案例
package com.wjh_Set_Map.d22_doudizhu;
/*
需求：在启动游戏房间的时候，应该提前准备好54张牌，完成洗牌、发牌、牌排序、逻辑。
分析：
1：当系统启动的同时需要准备好数据的时候，就可以用静态代码块了。
2：洗牌就是打乱牌的顺序。
3：定义三个玩家、依次发出51张牌
4：给玩家的牌进行排序(拓展)
5：输出每个玩家的牌数据。
功能:
1.做牌
2.洗牌
3.定义3个玩家
4.发牌
5.排序(拓展,了解,作业)
6.看牌
*/
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Test {
/**
* 1.定义一个静态的集合存储54个对象
*/
public static List allCard = new ArrayList<>();
/*
2.做牌:定义静态代码块进行排数据
*/
static {
//3.定义点数:个数确定,类型确定,使用数组
String[] size = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
//4.定义花色:个数确定,类型确定,使用数组
String[] color = {"♠", "♦", "♣", "♥"};
//5.组合点数 和 花色
int index = 0; //记录牌的大小
for (String s : size) {
index++; //index + 1
for (String c : color) {
//6.封装成一个牌对象
Card card = new Card(s,c,index);
//7.存入到集合容器中去
allCard.add(card);
}
}
//8.大小王没有花色
Card c1 = new Card("","D",14);
Card c2 = new Card("","X",15);
//9.将大小王添加到容器中去
Collections.addAll(allCard,c1,c2);
System.out.println("新牌:" + allCard);
}
public static void main(String[] args) {
Collections.shuffle(allCard);
System.out.println("牌洗好了:" + allCard);
System.out.println("共有" + allCard.size() + "张牌");
//10.定义三个玩家,开始发牌(每个玩家的牌也是一个集合容器)
List iKUN = new ArrayList<>();
List cTRL = new ArrayList<>();
List xHZ = new ArrayList<>();
//11.开始发牌(从集合中发出51张牌,剩余三张作为底牌)
for (int i = 0; i < allCard.size() - 3; i++) {
//先拿到当前牌对象
Card c = allCard.get(i);
if(i % 3 == 0){
iKUN.add(c);
}else if(i % 3 == 1){
cTRL.add(c);
}else if(i % 3 == 2){
xHZ.add(c);
}
}
//难点:新API subList(size1,size2):包前不包后
//12.拿到最后3张底牌(把最后三张牌截取成一个子集合)
List lastThreeCards = allCard.subList(allCard.size() - 3, allCard.size());
//13.给玩家排序(从大到小)
//Collections.sort(apples,(o1,o2) -> Double.compare(o1.getWeight(), o2.getWeight()));
descCards(iKUN);
descCards(cTRL);
descCards(xHZ);
//14.输出玩家的牌
System.out.println(lastThreeCards);
System.out.println("iKUN有"+iKUN.size() + "张:" + iKUN);
System.out.println("cTRL有"+cTRL.size() + "张:" + cTRL);
System.out.println("xHZz有" +xHZ.size() + "张:" + xHZ);
}
/**
* 给玩家的牌排序
* @param cards
*/
public static void descCards(List cards){
Collections.sort(cards,((o2, o1) -> Double.compare(o1.getIndex(),o2.getIndex())));
}
}
新牌:[3♠, 3♦, 3♣, 3♥, 4♠, 4♦, 4♣, 4♥, 5♠, 5♦, 5♣, 5♥, 6♠, 6♦, 6♣, 6♥, 7♠, 7♦, 7♣, 7♥, 8♠, 8♦, 8♣, 8♥, 9♠, 9♦, 9♣, 9♥, 10♠, 10♦, 10♣, 10♥, J♠, J♦, J♣, J♥, Q♠, Q♦, Q♣, Q♥, K♠, K♦, K♣, K♥, A♠, A♦, A♣, A♥, 2♠, 2♦, 2♣, 2♥, D, X]
牌洗好了:[Q♣, J♠, A♣, K♥, 10♦, Q♥, 8♣, 10♣, 5♦, X, 3♥, 3♣, 9♣, 6♣, 9♠, 7♠, A♦, 10♠, 5♥, 2♠, 6♥, A♠, 5♠, 2♥, Q♦, J♣, 9♥, D, 3♠, 6♠, 2♦, J♥, 5♣, 2♣, Q♠, 10♥, 8♠, K♦, 4♥, 4♠, 7♣, 9♦, 6♦, 4♦, 7♦, 4♣, J♦, 3♦, 8♥, 8♦, K♠, K♣, A♥, 7♥]
共有54张牌
[K♣, A♥, 7♥]
iKUN有17张:[X, D, 2♦, 2♣, A♠, K♥, Q♣, Q♦, 9♣, 8♣, 8♠, 8♥, 7♠, 6♦, 5♥, 4♠, 4♣]
cTRL有17张:[2♠, A♦, K♦, Q♠, J♠, J♣, J♥, J♦, 10♦, 10♣, 8♦, 7♣, 6♣, 5♠, 4♦, 3♥, 3♠]
xHZz有17张:[2♥, A♣, K♠, Q♥, 10♠, 10♥, 9♠, 9♥, 9♦, 7♦, 6♥, 6♠, 5♦, 5♣, 4♥, 3♣, 3♦]进程已结束，退出代码为 0
六.Map集合体系
1.Map集合的概述
2.Map集合体系特点
package com.wjh_Set_Map.d5_map;
/*
认识Map体系的特点:
无序,不重复,无索引,值不做要求
*/
import java.util.HashMap;
import java.util.Map;
public class MapDemo {
public static void main(String[] args) {
//1.创建一个Map集合对象
Map maps = new HashMap<>(); //一行经典代码(多态)
maps.put("咖啡",5);
maps.put("纯牛奶",10);
maps.put("可乐",15);
maps.put("矿泉水",50);
maps.put(null,null);
System.out.println(maps);
}
}
{null=null, 咖啡=5, 纯牛奶=10, 矿泉水=50, 可乐=15}
进程已结束，退出代码为 0
3.Map集合常用API
package com.wjh_Set_Map.d6_map_api;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapDemo {
public static void main(String[] args) {
//1.添加元素:无序,不重复,无索引.
Map maps = new HashMap<>(); //一行经典代码(多态)
maps.put("咖啡",5);
maps.put("纯牛奶",100);
maps.put("矿泉水",50);
maps.put("咖啡",5);
maps.put("纯牛奶",10); //Map集合后面重复的键对应的元素会覆盖前面重复的整个元素
maps.put("可乐",15);
maps.put(null,null);
System.out.println(maps);
//{null=null, 咖啡=5, 纯牛奶=10, 矿泉水=50, 可乐=15}
//2.清空集合
// maps.clear();
// System.out.println(maps); //{}
//
// //3.判断集合是否为空,为空返回true,不为空返回false
// System.out.println(maps.isEmpty()); //true
//4.根据键获取对应值:public V get(Object key)
Integer key = maps.get("咖啡");
System.out.println(key); //5
System.out.println(maps.get("可乐")); //15
System.out.println(maps.get("石楠花水")); //null
//5.根据键删除整个元素(删除会返回键的值)
System.out.println(maps.remove("咖啡")); //5
System.out.println(maps.remove("咖啡水")); //null
System.out.println(maps); //此时咖啡已经被删除
//{null=null, 纯牛奶=10, 矿泉水=50, 可乐=15}
//6.判断是否包含某个键,包含返回true,不包含返回false
System.out.println(maps.containsKey("可乐")); //true
System.out.println(maps.containsKey("百事可乐")); //false
//7.判断是否包含某个值.
maps.containsValue(50); //true
maps.containsValue(51); //false
//{}
//8.获取全部键的集合:public Set keySet()
Set keys = maps.keySet();
System.out.println(keys); [null, 纯牛奶, 矿泉水, 可乐]
System.out.println(maps.keySet()); //[null, 纯牛奶, 矿泉水, 可乐]
//9.获取全部值的集合:Collection values();
Collection values = maps.values();
System.out.println(values); //[null, 10, 50, 15]
System.out.println(maps.values()); //[null, 10, 50, 15]
//10.集合的大小
System.out.println(maps.size()); //4
//11.合并其他Map集合(拓展)
Map newMap = new HashMap<>();
newMap.put("Java", 5);
Map oldMap = new HashMap<>();
oldMap.put("C++", 5);
newMap.putAll(oldMap); //把集合old的元素拷贝(合并)到new里面,old不发生改变
System.out.println(newMap); //{Java=5, C++=5}
System.out.println(oldMap); //{C++=5}
}
}
{null=null, 咖啡=5, 纯牛奶=10, 矿泉水=50, 可乐=15}
5
15
null
5
null
{null=null, 纯牛奶=10, 矿泉水=50, 可乐=15}
true
false
[null, 纯牛奶, 矿泉水, 可乐]
[null, 纯牛奶, 矿泉水, 可乐]
[null, 10, 50, 15]
[null, 10, 50, 15]
4
{Java=5, C++=5}
{C++=5}进程已结束，退出代码为 0
4.Map集合的遍历方式一：键找值
package com.wjh_Set_Map.d7_map_traversal;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapDemo3 {
public static void main(String[] args) {
Map maps = new HashMap<>(); //一行经典代码(多态)
maps.put("咖啡",5);
maps.put("纯牛奶",10);
maps.put("可乐",15);
maps.put("矿泉水",50);
maps.put(null,null);
System.out.println(maps);
//{null=null, 咖啡=5, 纯牛奶=10, 矿泉水=50, 可乐=15}
//1.键找值 第一步:先拿到集合的全部键
Set keys = maps.keySet();
//2.遍历每个键,根据键提取值
for (String k : keys) {
Integer value = maps.get(k); //用int出现问题
System.out.println(k + "---->" + value);
}
}
}
{null=null, 咖啡=5, 纯牛奶=10, 矿泉水=50, 可乐=15}
null---->null
咖啡---->5
纯牛奶---->10
矿泉水---->50
可乐---->15进程已结束，退出代码为
5.Map集合的遍历方式二：键值对
package com.wjh_Set_Map.d7_map_traversal;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapDemo2 {
public static void main(String[] args) {
Map maps = new HashMap<>(); //一行经典代码(多态)
maps.put("咖啡",5);
maps.put("纯牛奶",10);
maps.put("可乐",15);
maps.put("矿泉水",50);
maps.put(null,null);
System.out.println(maps);
//{null=null, 咖啡=5, 纯牛奶=10, 矿泉水=50, 可乐=15}
//可以通过Map的方法 entrySet把Map集合转换成Set集合形式
//1.把Map集合转换成Set集合
//输入maps.entrySet() 按ctrl + alt + v 自动生成
Set> entries = maps.entrySet();
//2.开始遍历
for (Map.Entry entry : entries) {
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println(key + " --> " + value);
}
}
}
{null=null, 咖啡=5, 纯牛奶=10, 矿泉水=50, 可乐=15}
null --> null
咖啡 --> 5
纯牛奶 --> 10
矿泉水 --> 50
可乐 --> 15
进程已结束，退出代码为 0
6.Map集合的遍历方式三：lambda表达式
package com.wjh_Set_Map.d7_map_traversal;
import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;
public class MapDemo1 {
public static void main(String[] args) {
Map maps = new HashMap<>(); //一行经典代码(多态)
maps.put("咖啡",5);
maps.put("纯牛奶",10);
maps.put("可乐",15);
maps.put("矿泉水",50);
maps.put(null,null);
System.out.println(maps);
//{null=null, 咖啡=5, 纯牛奶=10, 矿泉水=50, 可乐=15}
// maps.forEach(new BiConsumer() {
// @Override
// public void accept(String s, Integer integer) {
// System.out.println(s + "--->" +integer);
// }
// });
maps.forEach((key, value) -> System.out.println(key + "--->" + value));
//JDK1.8 开始
}
}
{null=null, 咖啡=5, 纯牛奶=10, 矿泉水=50, 可乐=15}
null--->null
咖啡--->5
纯牛奶--->10
矿泉水--->50
可乐--->15进程已结束，退出代码为 0
package com.wjh_Set_Map.d8_mapTest;
/*
Map集合案例:统计投票人数
需求:
某个班级80名学生，现在需要组成秋游活动，班长提供了四个景点依次是（A、B、C、D）,
每个学生只能选择一个景点，请统计出最终哪个景点想去的人数最多。
分析
将80个学生选择的数据拿到程序中去。
定义Map集合用于存储最终统计的结果。
遍历80个学生选择的数据，看Map集合中是否存在，不存在存入“数据=1“，存在则其对应值+1,
*/
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
public class Test {
public static void main(String[] args) {
//1.把80个数据学生选择的数据拿到集合中去
String[] selects = {"A","B","C","D"};
StringBuilder sb = new StringBuilder();
Random r = new Random();
for (int i = 0; i < 80; i++) {
sb.append(selects[r.nextInt(selects.length)]);
}
System.out.println(sb);
//2.定义一个Map集合记录最终统计的结果
Map maps = new HashMap<>(); //{}
//3.遍历80个学生选择的数据
for (int i = 0; i < sb.length(); i++) {
//4.提取当前字符
char ch = sb.charAt(i);
//5.判断结合是否存在键
if(maps.containsKey(ch)){
//让其值+1
maps.put(ch,maps.get(ch)+1);
}else{
//说明此景点是第一次被选择
maps.put(ch,1);
}
}
//输出集合
System.out.println(maps);
}
}
DCCCDABBADCCABADABAADCBDBBBCADBADBADDCDBABCDCDDDACDDBBAACBBCADABBDCACDBBBABCBADA
{A=20, B=23, C=16, D=21}进程已结束，退出代码为 0
7.Map集合的实现类HashMap
8.Map集合的实现类LinkedHashMap
package com.wjh_Set_Map.d9_map_ipml;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
public class LinkedHashMapDemo2 {
public static void main(String[] args) {
//1.创建一个Map集合对象
Map maps = new LinkedHashMap<>(); //一行经典代码(多态)
maps.put("咖啡",5);
maps.put("纯牛奶",10);
maps.put("可乐",15);
maps.put("矿泉水",50);
maps.put(null,null);
System.out.println(maps);
//{咖啡=5, 纯牛奶=10, 可乐=15, 矿泉水=50, null=null}
//HashMap无序 不重复 无索引
//LinkedHashMap有序 不重复 无索引
}
}
{咖啡=5, 纯牛奶=10, 可乐=15, 矿泉水=50, null=null}
9.Map集合的实现类TreeMap
Map map = new TreeMap<>();
map.put("1",5);
map.put("2",10);
map.put("3",15);
map.put("5",50);
map.put("4",null);
System.out.println(map);
//{1=5, 2=10, 3=15, 4=null, 5=50} package com.wjh_Set_Map.d9_map_ipml;
import java.util.Map;
import java.util.TreeMap;
public class TreeMapDemo3 {
public static void main(String[] args) {
//TreeMap集合自带排序;只能对键进行排序
//可排序 去重复 无索引
Map map = new TreeMap<>();
map.put(13,"n");
map.put(10,"s");
map.put(88,"c");
map.put(2,"y");
map.put(1,"o");
System.out.println(map);
//{1=o, 2=y, 10=s, 13=n, 88=c}
}
}
Student类:
package com.wjh_Set_Map.d9_mapTest;
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;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
测试类:
package com.wjh_Set_Map.d9_mapTest;
/*
需求：创建一个TreeMap集合，键是学生对象(Student)，值是籍贯(String)。
学生属性姓名和年龄，按照年龄进行排序并遍历。
思路：
定义学生类
创建TreeMap集合对象
创建学生对象
把学生添加到集合
遍历集合
*/
import java.util.Comparator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
public class mapDemo1 {
public static void main(String[] args) {
//在TreeMap括号里创建比较规则
Map maps = new TreeMap<>(new Comparator() {
@Override
public int compare(Student o1, Student o2) {
return Integer.compare(o1.getAge(), o2.getAge());
}
});
maps.put(new Student("小黑子",18),"北京");
maps.put(new Student("周扒皮",59),"上海");
maps.put(new Student("篮球哥",16),"武汉");
maps.put(new Student("篮球哥",16),"武汉");
maps.put(new Student("蜘蛛侠",30),"广州");
//1.键找值 第一步:先拿到集合的全部键
Set keys = maps.keySet();
//2.遍历每个键,根据键提取值
for (Student k : keys) {
System.out.println("姓名:" + k.getName());
System.out.println("年龄:" + k.getAge());
System.out.println();
}
}
}
姓名:篮球哥
年龄:16姓名:小黑子
年龄:18姓名:蜘蛛侠
年龄:30姓名:周扒皮
年龄:59
进程已结束，退出代码为 0
package com.wjh_Set_Map.d9_mapTest;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/*
需求：字符串“aababcabcdabcde”
请统计字符串中每一个字符出现的次数，并按照以下格式输出
输出结果：
a（5）b（4）c（3）d（2）e（1）
*/
public class mapDemo2 {
public static void main(String[] args) {
//1.把字符串放入集合中
String[] ab = {"a", "b", "c", "d", "e"};
String s = "aababcabcdabcde";
StringBuilder sb = new StringBuilder();
for (int i = 0; i < s.length(); i++) {
sb.append(s.charAt(i));
}
System.out.println(sb);
//aababcabcdabcde
//2.定义一个Map集合记录最终结果
Map maps = new HashMap<>();
//3.遍历字符串的数据
for (int i = 0; i < sb.length(); i++) {
//4.提取当前字符
char ch = sb.charAt(i);
//5.判断集合是否存在键
if(maps.containsKey(ch)){
//让其值+1
maps.put(ch,maps.get(ch)+1);
}else{
//说明是第一次选择
maps.put(ch,1);
}
}
//创建set集合
Set keys = maps.keySet();
//2.遍历每个键,根据键提取值
for (Character k : keys) {
Integer value = maps.get(k); //用int出现问题
System.out.print(k + " (" + value + ")");
//a (5)b (4)c (3)d (2)e (1)
}
}
}
七:补充知识:集合的嵌套
package com.wjh_Set_Map.d77_mapTest;
/*
需求
某个班级多名学生，现在需要组成秋游活动，班长提供了四个景点依次是（A、B、C、D）,
每个学生可以选择多个景点，请统计出最终哪个景点想去的人数最多。
分析
将80个学生选择的数据拿到程序中去，需要记住每个学生选择的情况。
定义Map集合用于存储最终统计的结果。
*/
import java.util.*;
public class ABCD {
public static void main(String[] args) {
//1.把80个数据学生选择的数据拿到集合中去
//使用哟个Map集合储存
Map> date = new HashMap<>();
String[] selects = {"A","B","C","D"};
Random r = new Random();
//2.把学生选择的数据存入进去.
List list = new ArrayList<>();
List list1 = new ArrayList<>();
List list2 = new ArrayList<>();
List list3 = new ArrayList<>();
Collections.addAll(list,"A","C");
Collections.addAll(list1,"A","B","C");
Collections.addAll(list2,"A","B","C","D");
Collections.addAll(list3,"A","C","D");
date.put("罗勇",list);
date.put("娜娜",list1);
date.put("明明",list2);
date.put("嘻嘻",list3);
System.out.println(date);
//3.统计每个选择的人数
Map maps = new HashMap<>();
//4.提取所有人选择的景点数据信息
Collection> values = date.values();
//value = []
for (List v: values) {
for (String s : v) {
//有没有包含这个景点
if (maps.containsKey(s)){
maps.put(s, maps.get(s) + 1);
}else{
maps.put(s,1);
}
}
}
System.out.println(maps);
//{嘻嘻=[A, C, D], 娜娜=[A, B, C], 明明=[A, B, C, D], 罗勇=[A, C]}
//{A=4, B=2, C=4, D=2}
}
}
{嘻嘻=[A, C, D], 娜娜=[A, B, C], 明明=[A, B, C, D], 罗勇=[A, C]}
{A=4, B=2, C=4, D=2}进程已结束，退出代码为 0