Java基础入门-15-【集合（Map&可变参数&集合工具类）】
24、集合（Map&可变参数&集合工具类）
双列集合的特点
1.Map集合
1.1 Map集合概述和特点【理解】
-
Map集合概述
interface Map<K,V> K：键的类型；V：值的类型 -
Map集合的特点
- 双列集合,一个键对应一个值
- 键不可以重复,值可以重复
-
Map集合的基本使用
public class MapDemo01 { public static void main(String[] args) { //创建集合对象 Map<String,String> map = new HashMap<String,String>(); //V put(K key, V value) 将指定的值与该映射中的指定键相关联 map.put("itheima001","林青霞"); map.put("itheima002","张曼玉"); map.put("itheima003","王祖贤"); map.put("itheima003","柳岩"); //输出集合对象 System.out.println(map); } }
1.2 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() 集合的长度，也就是集合中键值对的个数 -
示例代码
import java.util.HashMap;
import java.util.Map;
public class MapDemo1 {
public static void main(String[] args) {
/*
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.创建Map集合的对象
Map<String, String> map = new HashMap<>();
//2.添加元素
//put方法的细节：
//添加/覆盖
//在添加数据的时候，如果键不存在，那么直接把键值对对象添加到map集合当中
//在添加数据的时候，如果键是存在的，那么会把原有的键值对对象覆盖，会把被覆盖的值进行返回
map.put("郭靖", "黄蓉");
map.put("韦小宝", "沐剑屏");
map.put("伊志平", "小龙女");
//删除
String result = map.remove("郭靖");
System.out.println("result = " + result);//result = 黄蓉
//清空
//map.clear();
//判断是否包含containsKey、containsValue
boolean keyResult = map.containsKey("伊志平");
System.out.println("keyResult = " + keyResult);//keyResult = true
boolean keyResult1 = map.containsKey("小龙女");
System.out.println("keyResult1 = " + keyResult1);//keyResult1 = false
boolean valueResult1 = map.containsValue("小龙女");
System.out.println("valueResult1 = " + valueResult1);//valueResult1 = true
boolean valueResult2 = map.containsValue("伊志平");
System.out.println("valueResult2 = " + valueResult2);//valueResult2 = false
//判断集合是否为空
boolean isResult = map.isEmpty();
System.out.println("isResult = " + isResult);//isResult = false
//集合的长度，也就是集合中键值对的个数
int size = map.size();
System.out.println("size = " + size);//size = 2
//3.打印集合
System.out.println(map);//{}
}
private static void method2() {
//1.创建Map集合的对象
Map<String, String> map = new HashMap<>();
//2.添加元素
//put方法的细节：
//添加/覆盖
//在添加数据的时候，如果键不存在，那么直接把键值对对象添加到map集合当中
//在添加数据的时候，如果键是存在的，那么会把原有的键值对对象覆盖，会把被覆盖的值进行返回
map.put("郭靖", "黄蓉");
map.put("韦小宝", "沐剑屏");
map.put("伊志平", "小龙女");
//删除
String result = map.remove("郭靖");
System.out.println("result = " + result);//result = 黄蓉
//3.打印集合
System.out.println(map);//{韦小宝=沐剑屏, 伊志平=小龙女}
}
private static void method1() {
//1.创建Map集合的对象
Map<String, String> map = new HashMap<>();
//2.添加元素
//put方法的细节：
//添加/覆盖
//在添加数据的时候，如果键不存在，那么直接把键值对对象添加到map集合当中
//在添加数据的时候，如果键是存在的，那么会把原有的键值对对象覆盖，会把被覆盖的值进行返回
String value1 = map.put("郭靖", "黄蓉");
System.out.println("value1 = " + value1);// value1 = null
map.put("韦小宝", "沐剑屏");
map.put("伊志平", "霜儿");
String value2 = map.put("伊志平", "小龙女");
System.out.println("value2 = " + value2);// value2 = 霜儿
//3.打印集合
System.out.println(map);//{韦小宝=沐剑屏, 伊志平=小龙女, 郭靖=黄蓉}
}
}
1.3 Map集合的获取功能【应用】
-
方法介绍
方法名 说明 V get(Object key) 根据键获取值 Set keySet() 获取所有键的集合 Collection values() 获取所有值的集合 Set<Map.Entry<K,V>> entrySet() 获取所有键值对对象的集合 -
示例代码
public class MapDemo03 { public static void main(String[] args) { //创建集合对象 Map<String, String> map = new HashMap<String, String>(); //添加元素 map.put("张无忌", "赵敏"); map.put("郭靖", "黄蓉"); map.put("杨过", "小龙女"); //V get(Object key):根据键获取值 // System.out.println(map.get("张无忌")); // System.out.println(map.get("张三丰")); //Set<K> keySet():获取所有键的集合 // Set<String> keySet = map.keySet(); // for(String key : keySet) { // System.out.println(key); // } //Collection<V> values():获取所有值的集合 Collection<String> values = map.values(); for(String value : values) { System.out.println(value); } } }
1.4 Map集合的遍历(方式1)【应用】----- 键找值
-
遍历思路
- 我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合
- 把所有的丈夫给集中起来
- 遍历丈夫的集合，获取到每一个丈夫
- 根据丈夫去找对应的妻子
- 我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合
-
步骤分析
- 获取所有键的集合。用keySet()方法实现
- 遍历键的集合，获取到每一个键。用增强for实现
- 根据键去找值。用get(Object key)方法实现
-
代码实现
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.function.Consumer;
public class MapDemo2 {
public static void main(String[] args) {
//Map集合的第一种遍历方式:键找值
//三个课堂练习：
//
//练习一： 利用键找值的方式遍历map集合，要求：装着键的单列集合使用增强for的形式进行遍历
//练习二： 利用键找值的方式遍历map集合，要求：装着键的单列集合使用迭代器的形式进行遍历
//练习三： 利用键找值的方式遍历map集合，要求：装着键的单列集合使用lambda表达式的形式进行遍历
//1.创建Map集合的对象
Map<String, String> map = new HashMap<>();
//2.添加元素
map.put("郭靖", "黄蓉");
map.put("韦小宝", "沐剑屏");
map.put("尹志平", "小龙女");
//map.put("欧阳克", "黄蓉");
//3.通过键找值
//3.1 获取所有的键，把这些键放到一个单列集合当中
//获取所有键的集合。用keySet()方法实现
Set<String> keys = map.keySet();
//3.2 遍历单列集合，得到每一个键
System.out.println("------------------增强for循环遍历----------------");
for (String key : keys) {
//System.out.println(key);
//3.3 利用Map集合中的键获取对应的值 get
String value = map.get(key);
System.out.println(key + " = " + value);
}
System.out.println("---------------迭代器遍历-------------------");
Iterator<String> it = keys.iterator();
while (it.hasNext()) {
String key = it.next();
String value = map.get(key);
System.out.println(key + " = " + value);
}
System.out.println("----------------------------------");
keys.forEach(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s + " = " + map.get(s));
}
});
System.out.println("---------------Lambda表达式遍历-------------------");
keys.forEach(s -> System.out.println(s + " = " + map.get(s)));
}
}
1.5 Map集合的遍历(方式2)【应用】----- 键值对
-
遍历思路
- 我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合
- 获取所有结婚证的集合
- 遍历结婚证的集合，得到每一个结婚证
- 根据结婚证获取丈夫和妻子
- 我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合
-
步骤分析
- 获取所有键值对对象的集合
- Set<Map.Entry<K,V>> entrySet()：获取所有键值对对象的集合
- 遍历键值对对象的集合，得到每一个键值对对象
- 用增强for实现，得到每一个Map.Entry
- 根据键值对对象获取键和值
- 用getKey()得到键
- 用getValue()得到值
- 获取所有键值对对象的集合
-
代码实现
public class MapDemo02 { public static void main(String[] args) { //创建集合对象 Map<String, String> map = new HashMap<String, String>(); //添加元素 map.put("张无忌", "赵敏"); map.put("郭靖", "黄蓉"); map.put("杨过", "小龙女"); //获取所有键值对对象的集合 Set<Map.Entry<String, String>> entrySet = map.entrySet(); //遍历键值对对象的集合，得到每一个键值对对象 for (Map.Entry<String, String> me : entrySet) { //根据键值对对象获取键和值 String key = me.getKey(); String value = me.getValue(); System.out.println(key + "," + value); } } }
import java.util.HashMap;
import java.util.Map;
//import java.util.Map.Entry;
import java.util.Set;
public class MapDemo3 {
public static void main(String[] args) {
//Map集合的第二种遍历方式:键值对
//1.创建Map集合
Map<String, String> map = new HashMap<>();
//2.添加元素
//键:人物的外号
//值:人物的名字
map.put("标枪选手", "马超");
map.put("人物挂件", "明世隐");
map.put("御龙骑士", "伊志平");
//3.Map集合的第二种遍历方式:键值对
//通过键值对对象进行遍历
//3.1 通过一个方法获得所有的键值对对象，返回一个Set集合
Set<Map.Entry<String, String>> entries = map.entrySet();
//3.2 遍历entries这个集合，去得到里面的另一个键值对对象
for (Map.Entry<String, String> entry : entries) {
//3.3 利用entry调用get方法获取键和值
String key = entry.getKey();
String value = entry.getValue();
System.out.println(key + " = " + value);
}
}
}
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.function.BiConsumer;
public class MapDemo4 {
public static void main(String[] args) {
//Map集合的第二种遍历方式:键值对
//三个课堂练习：
//
//练习一： 通过键值对对象进行遍历map集合，要求：装着键值对对象的单列集合使用增强for的形式进行遍历
//练习二： 通过键值对对象进行遍历map集合，要求：装着键值对对象的单列集合使用迭代器的形式进行遍历
//练习三： 通过键值对对象进行遍历map集合，要求：装着键值对对象的单列集合使用lambda的形式进行遍历
//1.创建Map集合
Map<String, String> map = new HashMap<>();
//2.添加元素
//键:人物的外号
//值:人物的名字
map.put("标枪选手", "马超");
map.put("人物挂件", "明世隐");
map.put("御龙骑士", "伊志平");
//3.Map集合的第二种遍历方式:键值对
//通过键值对对象进行遍历
//3.1 通过一个方法获取所有的键值对对象，返回一个Set集合
//3.2 遍历entries这个集合，去得到里面的每一个键值对对象
System.out.println("------------------增强for循环遍历----------------");
for (Map.Entry<String, String> entry : map.entrySet()) {//entry ---> "御龙骑士","尹志平"
//3.3 利用entry调用get方法获取键和值
String key = entry.getKey();
String value = entry.getValue();
System.out.println(key + " = " + value);
}
System.out.println("---------------迭代器遍历-------------------");
Iterator<Map.Entry<String, String>> entryIterator = map.entrySet().iterator();
while (entryIterator.hasNext()) {
Map.Entry<String, String> entry = entryIterator.next();
//利用entry调用get方法获取键和值
String key = entry.getKey();
String value = entry.getValue();
System.out.println(key + " = " + value);
}
System.out.println("----------------------------------");
map.forEach(new BiConsumer<String, String>() {
@Override
public void accept(String key, String value) {
System.out.println(key + " = " + value);
}
});
System.out.println("---------------Lambda表达式遍历-------------------");
map.forEach((key, value) -> System.out.println(key + " = " + value));
}
}
1.6 Map集合的遍历(方式3)【应用】----- Lambda表达式遍历
import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;
public class MapDemo5 {
public static void main(String[] args) {
//Map集合的遍历方式3 : Lambda表达式遍历
//1.创建一个Map集合的对象
Map<String, String> map = new HashMap<>();
//2.添加元素
//键:人物的名字
//值:名人明言
map.put("鲁迅", "这句话是我说的");
map.put("曹操", "不可能绝对不可能");
map.put("刘备", "接着奏乐接着舞");
map.put("柯镇恶", "看我眼色行事");
//3.利用Lambda表达式进行遍历
//底层：
//forEach其实就是利用第二种方式进行遍历，依次得到每一个键和值
//再调用accept方法
map.forEach(new BiConsumer<String, String>() {
@Override
public void accept(String key, String value) {
System.out.println(key + " = " + value);
}
});
System.out.println("----------------------------------");
map.forEach((String key, String value) -> {
System.out.println(key + " = " + value);
}
);
System.out.println("----------------------------------");
map.forEach((key, value) -> System.out.println(key + " = " + value));
}
}
2.HashMap集合
2.1 HashMap集合概述和特点【理解】
- HashMap底层是哈希表结构的
- 依赖hashCode方法和equals方法保证键的唯一
- 如果键要存储的是自定义对象，需要重写hashCode和equals方法
2.2 HashMap的底层原理
2.3 HashMap-----总结
2.4 HashMap集合应用案例------存储学生对象并遍历
-
案例需求
- 创建一个HashMap集合，键是学生对象(Student)，值是居住地 (String)。
- 存储多个元素，并遍历。
- 要求保证键的唯一性：如果学生对象的成员变量值相同，我们就认为是同一个对象
-
代码实现
学生类
import java.util.Objects;
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 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 && Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
public String toString() {
return "Student{name = " + name + ", age = " + age + "}";
}
}
测试类
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.function.BiConsumer;
public class HashMapDemo1 {
public static void main(String[] args) {
/*
需求：创建一个HashMap集合，键是学生对象(Student)，值是籍贯(String)。
存储三个键值对元素，并遍历
要求：同姓名，同年龄认为是同一个学生
核心点：
HashMap的键位置如果存储的是自定义对象，需要重写hashCode和equals方法。
*/
//1.创建HashMap的对象
HashMap<Student, String> hm = new HashMap<>();
//2.创建三个学生对象
Student s1 = new Student("zhangsan", 23);
Student s2 = new Student("lisi", 24);
Student s3 = new Student("wangwu", 25);
Student s4 = new Student("wangwu", 25);
//3.添加元素
hm.put(s1, "江苏");
hm.put(s2, "浙江");
hm.put(s3, "福建");
hm.put(s4, "北京");
//4.遍历集合
Set<Student> keys = hm.keySet();
System.out.println("------------------增强for循环遍历----------------");
for (Student key : keys) {
String value = hm.get(key);
System.out.println(key + " , " + value);
}
Set<Map.Entry<Student, String>> entries = hm.entrySet();
for (Map.Entry<Student, String> entry : entries) {
Student key = entry.getKey();
String value = entry.getValue();
System.out.println(key + " , " + value);
}
System.out.println("---------------迭代器遍历-------------------");
Iterator<Map.Entry<Student, String>> iterator = hm.entrySet().iterator();
while (iterator.hasNext()){
Map.Entry<Student, String> entry = iterator.next();
Student key = entry.getKey();
String value = entry.getValue();
System.out.println(key + " , " + value);
}
System.out.println("----------------------------------");
hm.forEach(new BiConsumer<Student, String>() {
@Override
public void accept(Student key, String value) {
System.out.println(key + " , " + value);
}
});
System.out.println("---------------Lambda表达式遍历-------------------");
hm.forEach((key, value) -> System.out.println(key + " , " + value));
}
}
2.5 HashMap集合应用案例------Map集合案例-统计投票人数
需求
某个班级80名学生，现在需要组成秋游活动，班长提供了四个景点依次是（A、B、C、D)，每个学生只能选择一个景点，请统计出最终哪个景点想去的人数最多。
import java.util.*;
public class HashMapDemo2 {
public static void main(String[] args) {
/*
某个班级80名学生，现在需要组成秋游活动，
班长提供了四个景点依次是（A、B、C、D）,
每个学生只能选择一个景点，请统计出最终哪个景点想去的人数最多。
*/
//1.需要先让同学们投票
//定义一个数组，存储4个景点
String[] arr = {"A", "B", "C", "D"};
//利用随机数模拟80个同学的投票，并把投票的结果存储起来
ArrayList<String> list = new ArrayList<>();
Random r = new Random();
for (int i = 0; i < 80; i++) {
int index = r.nextInt(arr.length);
//System.out.println("arr[" + index + "] = " + arr[index]);
list.add(arr[index]);
}
//2.如果统计的东西比较多，不方便使用计数器思想
//如果可以定义map集合，利用集合进行统计。
HashMap<String, Integer> hm = new HashMap<>();
for (String key : list) {
//判断当前的景点在map集合当中是否存在
if (hm.containsKey(key)) {
//存在
//先获取当前景点已经被投票的次数
int value = hm.get(key);
//表示当前景点又被投了一次
value++;
//把新的次数再次添加到集合当中
hm.put(key, value);
} else {
//不存在
hm.put(key, 1);
}
}
System.out.println(hm);
//3.求最大值
int max = 0;
Set<Map.Entry<String, Integer>> entries = hm.entrySet();
for (Map.Entry<String, Integer> entry : entries) {
Integer count = entry.getValue();
if (count > max) {
max = count;
}
}
System.out.println(max);
//4.判断哪个景点的次数跟最大值一样，如果一样，打印出来
Iterator<Map.Entry<String, Integer>> iterator = entries.iterator();
while (iterator.hasNext()) {
Map.Entry<String, Integer> entry = iterator.next();
Integer count = entry.getValue();
if (max == count) {
System.out.println(entry.getKey());
}
}
//4.判断哪个景点的次数跟最大值一样，如果一样，打印出来
for (Map.Entry<String, Integer> entry : entries) {
int count = entry.getValue();
if(count == max){
System.out.println(entry.getKey());
}
}
}
}
3.LinkedHashMap集合
LinkedHashMap:
由键决定：
有序、不重复、无索引。
有序：
保证存储和取出的顺序一致
原理：
底层数据结构是依然哈希表，只是每个键值对元素又额外的多了一个双链表的机制记录存储的顺序。
代码实现：
import java.util.LinkedHashMap;
public class LinkedHashMapDemo1 {
public static void main(String[] args) {
/*
LinkedHashMap:
由键决定：
有序、不重复、无索引。
有序：
保证存储和取出的顺序一致
原理：
底层数据结构是依然哈希表，只是每个键值对元素又额外的多了一个双链表的机制记录存储的顺序。
*/
//1.创建集合
LinkedHashMap<String, Integer> lhm = new LinkedHashMap<>();
//2.添加元素
lhm.put("z", 789);
lhm.put("a", 123);
lhm.put("a", 123);
lhm.put("b", 456);
lhm.put("b", 111);
lhm.put("c", 789);
//3.打印集合
System.out.println(lhm);
}
}
运行结果
4.TreeMap集合
4.1 TreeMap集合概述和特点【理解】
- TreeMap底层是红黑树结构
- 依赖自然排序或者比较器排序,对键进行排序
- 如果键存储的是自定义对象,需要实现Comparable接口或者在创建TreeMap对象时候给出比较器排序规则
4.2 TreeMap集合应用案例----商品排序
案例需求
TreeMap集合：基本应用
需求1：
键：整数表示id
值：字符串表示商品名称
要求1：按照id的升序排列
要求2：按照id的降序排列
代码实现1：
import java.util.TreeMap;
public class TreeMapDemo1 {
public static void main(String[] args) {
/*
TreeMap集合：基本应用
需求1：
键：整数表示id
值：字符串表示商品名称
要求1：按照id的升序排列
要求2：按照id的降序排列
*/
//1.创建集合对象
//Integer Double 默认情况下都是按照升序排列的
//String 按照字母再ASCII码表中对应的数字升序进行排列
//abcdefg ...
TreeMap<Integer, String> tm = new TreeMap<>();
//2.添加元素
tm.put(5, "可恰可乐");
tm.put(2, "康帅傅");
tm.put(3, "九个核桃");
tm.put(1, "粤利粤");
tm.put(4, "雷碧");
//3.打印集合
System.out.println(tm);//{1=粤利粤, 2=康帅傅, 3=九个核桃, 4=雷碧, 5=可恰可乐}
}
}
代码实现2：
import java.util.Comparator;
import java.util.TreeMap;
public class TreeMapDemo2 {
public static void main(String[] args) {
/*
TreeMap集合：基本应用
需求1：
键：整数表示id
值：字符串表示商品名称
要求1：按照id的升序排列
要求2：按照id的降序排列
*/
//1.创建集合对象
//Integer Double 默认情况下都是按照升序排列的
//String 按照字母再ASCII码表中对应的数字升序进行排列
//abcdefg ...
TreeMap<Integer, String> tm = new TreeMap<>(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
//o1:当前要添加的元素
//o2：表示已经在红黑树中存在的元素
//return o1 - o2;//升序
return o2 - o1;//降序
}
});
//2.添加元素
tm.put(5, "可恰可乐");
tm.put(2, "康帅傅");
tm.put(3, "九个核桃");
tm.put(1, "粤利粤");
tm.put(4, "雷碧");
//3.打印集合
System.out.println(tm);//{1=粤利粤, 2=康帅傅, 3=九个核桃, 4=雷碧, 5=可恰可乐}
}
}
4.3 TreeMap集合应用案例----学生对象
案例需求
- 创建一个TreeMap集合,键是学生对象(Student),值是籍贯(String),学生属性姓名和年龄,按照年龄进行排序并遍历
- 要求按照学生的年龄进行排序,如果年龄相同则按照姓名进行排序
代码实现
public class Student implements Comparable<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;
}
public String toString() {
return "Student{name = " + name + ", age = " + age + "}";
}
@Override
public int compareTo(Student o) {
//要求：按照学生年龄的升序排列，年龄一样按照姓名的字母排列，同姓名年龄视为同一个人。
//this:表示当前要添加的元素
//o:表示已经在红黑树中存在的元素
//返回值：
//负数：表示当前要添加的元素是小的，存左边
//正数：表示当前要添加的元素是大的，存右边
//0：表示当前要添加的元素已经存在，舍弃
//按照年龄进行排序
int i = this.getAge() - o.getAge();
//次要条件，按照姓名排序。
i = i == 0 ? this.getName().compareTo(o.getName()) : i;
return i;
}
}
import java.util.TreeMap;
public class TreeMapDemo3 {
public static void main(String[] args) {
/*
TreeMap集合：基本应用
需求2：
键：学生对象
值：籍贯
要求：按照学生年龄的升序排列，年龄一样按照姓名的字母排列，同姓名年龄视为同一个人。
*/
//1.创建TreeMap集合对象
TreeMap<Student, String> tm = new TreeMap<>();
//2.创建3个学生对象
Student s1 = new Student("张三", 23);
Student s2 = new Student("李四", 24);
Student s3 = new Student("王五", 25);
//3.将学生对象添加到TreeMap集合中
tm.put(s1, "江苏");
tm.put(s2, "天津");
tm.put(s3, "北京");
//4.打印集合
System.out.println(tm);
System.out.println("----------------");
//5.遍历TreeMap集合,打印每个学生的信息
tm.forEach(
(Student key, String value)->{
System.out.println(key + "---" + value);
}
);
}
}
4.4 TreeMap集合应用案例----统计字符串个数
案例需求
需求：
字符串“aababcabcdabcde”
请统计字符串中每一个字符出现的次数，并按照以下格式输出
输出结果：
a（5）b（4）c（3）d（2）e（1）
代码实现
import java.util.StringJoiner;
import java.util.TreeMap;
import java.util.function.BiConsumer;
public class TreeMapDemo4 {
public static void main(String[] args) {
/*
需求：
字符串"aababcabcdabcde"
请统计字符串中每一个字符出现的次数，并按照以下格式输出
输出结果：
a（5）b（4）c（3）d（2）e（1）
新的统计思想：利用map集合进行统计
如果题目中没有要求对结果进行排序，默认使用HashMap
如果题目中要求对结果进行排序，请使用TreeMap
键：表示要统计的内容
值：表示次数
*/
//1.定义字符串
String s = "aababcabcdabcde";
//2.创建集合
TreeMap<Character, Integer> tm = new TreeMap<>();
//3.遍历字符串，得到里面的每一个字符
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
//System.out.println(c);
//拿着C到集合中判断是否存在
//存在，表示当前字符又出现了一次
//不存在，表示当前字符串第一次出现
if (tm.containsKey(c)) {
//存在
//先把已经出现的次数拿出来
Integer count = tm.get(c);
//当前字符又出现了一次
count++;
//把自增之后的结果再添加到集合当中
tm.put(c, count);
} else {
//不存在
tm.put(c, 1);
}
}
//4.遍历集合，并按照指定的格式进行拼接
// a（5）b（4）c（3）d（2）e（1）
System.out.println("-------------第一种拼接方式--------------");
StringBuilder sb = new StringBuilder();
/*tm.forEach(new BiConsumer<Character, Integer>() {
@Override
public void accept(Character key, Integer value) {
sb.append(key).append("(").append(value).append(") ");
}
});*/
tm.forEach((key, value) -> sb.append(key).append("(").append(value).append(") "));
System.out.println("sb = " + sb);
System.out.println("-------------第二种拼接方式--------------");
StringJoiner sj = new StringJoiner("", "", "");
tm.forEach((key, value) -> sj.add(key + "").add("(").add(value + "").add(") "));
System.out.println("sj = " + sj);
}
}
4.5 TreeMap集合----总结
5.HashMap 集合源码超详细解析
1.看源码之前需要了解的一些内容
Node<K,V>[] table 哈希表结构中数组的名字
DEFAULT_INITIAL_CAPACITY： 数组默认长度16
DEFAULT_LOAD_FACTOR： 默认加载因子0.75
HashMap里面每一个对象包含以下内容：
1.1 链表中的键值对对象
包含：
int hash; //键的哈希值
final K key; //键
V value; //值
Node<K,V> next; //下一个节点的地址值
1.2 红黑树中的键值对对象
包含：
int hash; //键的哈希值
final K key; //键
V value; //值
TreeNode<K,V> parent; //父节点的地址值
TreeNode<K,V> left; //左子节点的地址值
TreeNode<K,V> right; //右子节点的地址值
boolean red; //节点的颜色
2.添加元素
HashMap<String,Integer> hm = new HashMap<>();
hm.put("aaa" , 111);
hm.put("bbb" , 222);
hm.put("ccc" , 333);
hm.put("ddd" , 444);
hm.put("eee" , 555);
添加元素的时候至少考虑三种情况：
2.1数组位置为null
2.2数组位置不为null，键不重复，挂在下面形成链表或者红黑树
2.3数组位置不为null，键重复，元素覆盖
//参数一：键
//参数二：值
//返回值：被覆盖元素的值，如果没有覆盖，返回null
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
//利用键计算出对应的哈希值，再把哈希值进行一些额外的处理
//简单理解：返回值就是返回键的哈希值
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
//参数一：键的哈希值
//参数二：键
//参数三：值
//参数四：如果键重复了是否保留
// true，表示老元素的值保留，不会覆盖
// false，表示老元素的值不保留，会进行覆盖
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
//定义一个局部变量，用来记录哈希表中数组的地址值。
Node<K,V>[] tab;
//临时的第三方变量，用来记录键值对对象的地址值
Node<K,V> p;
//表示当前数组的长度
int n;
//表示索引
int i;
//把哈希表中数组的地址值，赋值给局部变量tab
tab = table;
if (tab == null || (n = tab.length) == 0){
//1.如果当前是第一次添加数据，底层会创建一个默认长度为16，加载因子为0.75的数组
//2.如果不是第一次添加数据，会看数组中的元素是否达到了扩容的条件
//如果没有达到扩容条件，底层不会做任何操作
//如果达到了扩容条件，底层会把数组扩容为原先的两倍，并把数据全部转移到新的哈希表中
tab = resize();
//表示把当前数组的长度赋值给n
n = tab.length;
}
//拿着数组的长度跟键的哈希值进行计算，计算出当前键值对对象，在数组中应存入的位置
i = (n - 1) & hash;//index
//获取数组中对应元素的数据
p = tab[i];
if (p == null){
//底层会创建一个键值对对象，直接放到数组当中
tab[i] = newNode(hash, key, value, null);
}else {
Node<K,V> e;
K k;
//等号的左边：数组中键值对的哈希值
//等号的右边：当前要添加键值对的哈希值
//如果键不一样，此时返回false
//如果键一样，返回true
boolean b1 = p.hash == hash;
if (b1 && ((k = p.key) == key || (key != null && key.equals(k)))){
e = p;
} else if (p instanceof TreeNode){
//判断数组中获取出来的键值对是不是红黑树中的节点
//如果是，则调用方法putTreeVal，把当前的节点按照红黑树的规则添加到树当中。
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
} else {
//如果从数组中获取出来的键值对不是红黑树中的节点
//表示此时下面挂的是链表
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
//此时就会创建一个新的节点，挂在下面形成链表
p.next = newNode(hash, key, value, null);
//判断当前链表长度是否超过8，如果超过8，就会调用方法treeifyBin
//treeifyBin方法的底层还会继续判断
//判断数组的长度是否大于等于64
//如果同时满足这两个条件，就会把这个链表转成红黑树
if (binCount >= TREEIFY_THRESHOLD - 1)
treeifyBin(tab, hash);
break;
}
//e： 0x0044 ddd 444
//要添加的元素： 0x0055 ddd 555
//如果哈希值一样，就会调用equals方法比较内部的属性值是否相同
if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))){
break;
}
p = e;
}
}
//如果e为null，表示当前不需要覆盖任何元素
//如果e不为null，表示当前的键是一样的，值会被覆盖
//e:0x0044 ddd 555
//要添加的元素： 0x0055 ddd 555
if (e != null) {
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null){
//等号的右边：当前要添加的值
//等号的左边：0x0044的值
e.value = value;
}
afterNodeAccess(e);
return oldValue;
}
}
//threshold：记录的就是数组的长度 * 0.75，哈希表的扩容时机 16 * 0.75 = 12
if (++size > threshold){
resize();
}
//表示当前没有覆盖任何元素，返回null
return null;
}
6.TreeMap 集合源码超详细解析
1.TreeMap中每一个节点的内部属性
K key; //键
V value; //值
Entry<K,V> left; //左子节点
Entry<K,V> right; //右子节点
Entry<K,V> parent; //父节点
boolean color; //节点的颜色
2.TreeMap类中中要知道的一些成员变量
public class TreeMap<K,V>{
//比较器对象
private final Comparator<? super K> comparator;
//根节点
private transient Entry<K,V> root;
//集合的长度
private transient int size = 0;
3.空参构造
//空参构造就是没有传递比较器对象
public TreeMap() {
comparator = null;
}
4.带参构造
//带参构造就是传递了比较器对象。
public TreeMap(Comparator<? super K> comparator) {
this.comparator = comparator;
}
5.添加元素
public V put(K key, V value) {
return put(key, value, true);
}
参数一：键
参数二：值
参数三：当键重复的时候，是否需要覆盖值
true：覆盖
false：不覆盖
private V put(K key, V value, boolean replaceOld) {
//获取根节点的地址值，赋值给局部变量t
Entry<K,V> t = root;
//判断根节点是否为null
//如果为null，表示当前是第一次添加，会把当前要添加的元素，当做根节点
//如果不为null，表示当前不是第一次添加，跳过这个判断继续执行下面的代码
if (t == null) {
//方法的底层，会创建一个Entry对象，把他当做根节点
addEntryToEmptyMap(key, value);
//表示此时没有覆盖任何的元素
return null;
}
//表示两个元素的键比较之后的结果
int cmp;
//表示当前要添加节点的父节点
Entry<K,V> parent;
//表示当前的比较规则
//如果我们是采取默认的自然排序，那么此时comparator记录的是null，cpr记录的也是null
//如果我们是采取比较去排序方式，那么此时comparator记录的是就是比较器
Comparator<? super K> cpr = comparator;
//表示判断当前是否有比较器对象
//如果传递了比较器对象，就执行if里面的代码，此时以比较器的规则为准
//如果没有传递比较器对象，就执行else里面的代码，此时以自然排序的规则为准
if (cpr != null) {
do {
parent = t;
cmp = cpr.compare(key, t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else {
V oldValue = t.value;
if (replaceOld || oldValue == null) {
t.value = value;
}
return oldValue;
}
} while (t != null);
} else {
//把键进行强转，强转成Comparable类型的
//要求：键必须要实现Comparable接口，如果没有实现这个接口
//此时在强转的时候，就会报错。
Comparable<? super K> k = (Comparable<? super K>) key;
do {
//把根节点当做当前节点的父节点
parent = t;
//调用compareTo方法，比较根节点和当前要添加节点的大小关系
cmp = k.compareTo(t.key);
if (cmp < 0)
//如果比较的结果为负数
//那么继续到根节点的左边去找
t = t.left;
else if (cmp > 0)
//如果比较的结果为正数
//那么继续到根节点的右边去找
t = t.right;
else {
//如果比较的结果为0，会覆盖
V oldValue = t.value;
if (replaceOld || oldValue == null) {
t.value = value;
}
return oldValue;
}
} while (t != null);
}
//就会把当前节点按照指定的规则进行添加
addEntry(key, value, parent, cmp < 0);
return null;
}
private void addEntry(K key, V value, Entry<K, V> parent, boolean addToLeft) {
Entry<K,V> e = new Entry<>(key, value, parent);
if (addToLeft)
parent.left = e;
else
parent.right = e;
//添加完毕之后，需要按照红黑树的规则进行调整
fixAfterInsertion(e);
size++;
modCount++;
}
private void fixAfterInsertion(Entry<K,V> x) {
//因为红黑树的节点默认就是红色的
x.color = RED;
//按照红黑规则进行调整
//parentOf:获取x的父节点
//parentOf(parentOf(x)):获取x的爷爷节点
//leftOf:获取左子节点
while (x != null && x != root && x.parent.color == RED) {
//判断当前节点的父节点是爷爷节点的左子节点还是右子节点
//目的：为了获取当前节点的叔叔节点
if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {
//表示当前节点的父节点是爷爷节点的左子节点
//那么下面就可以用rightOf获取到当前节点的叔叔节点
Entry<K,V> y = rightOf(parentOf(parentOf(x)));
if (colorOf(y) == RED) {
//叔叔节点为红色的处理方案
//把父节点设置为黑色
setColor(parentOf(x), BLACK);
//把叔叔节点设置为黑色
setColor(y, BLACK);
//把爷爷节点设置为红色
setColor(parentOf(parentOf(x)), RED);
//把爷爷节点设置为当前节点
x = parentOf(parentOf(x));
} else {
//叔叔节点为黑色的处理方案
//表示判断当前节点是否为父节点的右子节点
if (x == rightOf(parentOf(x))) {
//表示当前节点是父节点的右子节点
x = parentOf(x);
//左旋
rotateLeft(x);
}
setColor(parentOf(x), BLACK);
setColor(parentOf(parentOf(x)), RED);
rotateRight(parentOf(parentOf(x)));
}
} else {
//表示当前节点的父节点是爷爷节点的右子节点
//那么下面就可以用leftOf获取到当前节点的叔叔节点
Entry<K,V> y = leftOf(parentOf(parentOf(x)));
if (colorOf(y) == RED) {
setColor(parentOf(x), BLACK);
setColor(y, BLACK);
setColor(parentOf(parentOf(x)), RED);
x = parentOf(parentOf(x));
} else {
if (x == leftOf(parentOf(x))) {
x = parentOf(x);
rotateRight(x);
}
setColor(parentOf(x), BLACK);
setColor(parentOf(parentOf(x)), RED);
rotateLeft(parentOf(parentOf(x)));
}
}
}
//把根节点设置为黑色
root.color = BLACK;
}
6.课堂思考问题：
6.1TreeMap添加元素的时候，键是否需要重写hashCode和equals方法？
此时是不需要重写的。
6.2HashMap是哈希表结构的，JDK8开始由数组，链表，红黑树组成的。
既然有红黑树，HashMap的键是否需要实现Compareable接口或者传递比较器对象呢？
不需要的。
因为在HashMap的底层，默认是利用哈希值的大小关系来创建红黑树的
6.3TreeMap和HashMap谁的效率更高？
如果是最坏情况，添加了8个元素，这8个元素形成了链表，此时TreeMap的效率要更高
但是这种情况出现的几率非常的少。
一般而言，还是HashMap的效率要更高。
6.4你觉得在Map集合中，java会提供一个如果键重复了，不会覆盖的put方法呢？
此时putIfAbsent本身不重要。
传递一个思想：
代码中的逻辑都有两面性，如果我们只知道了其中的A面，而且代码中还发现了有变量可以控制两面性的发生。
那么该逻辑一定会有B面。
习惯：
boolean类型的变量控制，一般只有AB两面，因为boolean只有两个值
int类型的变量控制，一般至少有三面，因为int可以取多个值。
6.5三种双列集合，以后如何选择？
HashMap LinkedHashMap TreeMap
默认：HashMap（效率最高）
如果要保证存取有序：LinkedHashMap
如果要进行排序：TreeMap
7.可变参数的练习
案例需求
假如需要定义一个方法求和，该方法可以灵活的完成如下需求：
计算2个数据的和
计算3个数据的和
计算4个数据的和
计算n个数据的和
代码实现
public class ArgsDemo1 {
public static void main(String[] args) {
/*
假如需要定义一个方法求和，该方法可以灵活的完成如下需求：
计算2个数据的和
计算3个数据的和
计算4个数据的和
计算n个数据的和
*/
System.out.println(getSum(10, 20));
System.out.println(getSum(10, 20, 30));
System.out.println(getSum(10, 20, 30, 40));
}
//计算2个数据的和
public static int getSum(int a, int b) {
return a + b;
}
//计算3个数据的和
public static int getSum(int a, int b, int c) {
return a + b + c;
}
//计算4个数据的和
public static int getSum(int a, int b, int c, int d) {
return a + b + c + d;
}
}
public class ArgsDemo2 {
public static void main(String[] args) {
//计算n个数据的和
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int sum = getSum(arr);
System.out.println("sum = " + sum);//sum = 55
}
public static int getSum(int[] arr) {
int sum = 0;
for (int i : arr) {
sum += i;
}
return sum;
}
}
public class ArgsDemo3 {
public static void main(String[] args) {
//JDK5
//可变参数
//方法形参的个数是可以发生变化的，0 1 2 3 ...
//格式：属性类型...名字
//int...args
int sum = getSum(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
System.out.println(sum);
}
//底层：
//可变参数底层就是一个数组
//只不过不需要我们自己创建了，Java会帮我们创建好
public static int getSum(int... args) {
//System.out.println(args);//[I@119d7047
int sum = 0;
for (int i : args) {
sum = sum + i;
}
return sum;
}
}
public class ArgsDemo4 {
public static void main(String[] args) {
//可变参数的小细节：
//1.在方法的形参中最多只能写一个可变参数
//可变参数，理解为一个大胖子，有多少吃多少
//2.在方法的形参当中，如果出了可变参数以外，还有其他的形参，那么可变参数要写在最后
getSum(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
}
public static int getSum(int a, int... args) {
return 0;
}
}
总结
8.集合工具类Collections
Collections常用的API
代码实现
import java.util.ArrayList;
import java.util.Collections;
public class CollectionsDemo1 {
public static void main(String[] args) {
/*
public static <T> boolean addAll(Collection<T> c, T... elements) 批量添加元素
public static void shuffle(List<?> list) 打乱List集合元素的顺序
*/
//addAll 批量添加元素
//1.创建集合对象
ArrayList<String> list = new ArrayList<>();
//2.批量添加元素
Collections.addAll(list, "abc", "cdv", "dfw", "sjkl", "1234", "qwer");
//3.打印集合
System.out.println("list = " + list);//list = [abc, cdv, dfw, sjkl, 1234, qwer]
//shuffle
Collections.shuffle(list);
System.out.println("list = " + list);
}
}
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class CollectionsDemo2 {
public static void main(String[] args) {
/*
public static <T> void sort(List<T> list) 排序
public static <T> void sort(List<T> list, Comparator<T> c) 根据指定的规则进行排序
public static <T> int binarySearch (List<T> list, T key) 以二分查找法查找元素
public static <T> void copy(List<T> dest, List<T> src) 拷贝集合中的元素
public static <T> int fill (List<T> list, T obj) 使用指定的元素填充集合
public static <T> void max/min(Collection<T> coll) 根据默认的自然排序获取最大/小值
public static <T> void swap(List<?> list, int i, int j) 交换集合中指定位置的元素
*/
System.out.println("-------------sort默认规则--------------------------");
//默认规则，需要重写Comparable接口compareTo方法。Integer已经实现，按照从小打大的顺序排列
//如果是自定义对象，需要自己指定规则
ArrayList<Integer> list1 = new ArrayList<>();
Collections.addAll(list1, 10, 1, 2, 4, 8, 5, 9, 6, 7, 3);
Collections.sort(list1);
System.out.println(list1);
System.out.println("-------------sort自己指定规则规则--------------------------");
Collections.sort(list1, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2 - o1;
}
});
System.out.println(list1);
Collections.sort(list1, (o1, o2) -> o2 - o1);
System.out.println(list1);
System.out.println("-------------binarySearch--------------------------");
//需要元素有序
ArrayList<Integer> list2 = new ArrayList<>();
Collections.addAll(list2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
System.out.println(Collections.binarySearch(list2, 9));
System.out.println(Collections.binarySearch(list2, 1));
System.out.println(Collections.binarySearch(list2, 20));
System.out.println("-------------copy--------------------------");
//把list3中的元素拷贝到list4中
//会覆盖原来的元素
//注意点：如果list3的长度 > list4的长度，方法会报错
ArrayList<Integer> list3 = new ArrayList<>();
ArrayList<Integer> list4 = new ArrayList<>();
Collections.addAll(list3, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Collections.addAll(list4, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);
Collections.copy(list4, list3);
System.out.println(list3);
System.out.println(list4);
System.out.println("-------------fill--------------------------");
//把集合中现有的所有数据，都修改为指定数据
ArrayList<Integer> list5 = new ArrayList<>();
Collections.addAll(list5, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Collections.fill(list5, 100);
System.out.println(list5);
System.out.println("-------------max/min--------------------------");
//求最大值或者最小值
ArrayList<Integer> list6 = new ArrayList<>();
Collections.addAll(list6, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
System.out.println(Collections.max(list6));
System.out.println(Collections.min(list6));
System.out.println("-------------max/min指定规则--------------------------");
// String中默认是按照字母的abcdefg顺序进行排列的
// 现在我要求最长的字符串
// 默认的规则无法满足，可以自己指定规则
// 求指定规则的最大值或者最小值
ArrayList<String> list7 = new ArrayList<>();
Collections.addAll(list7, "a","aa","aaa","aaaa");
System.out.println(Collections.max(list7, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.length() - o2.length();
}
}));
System.out.println("-------------swap--------------------------");
ArrayList<Integer> list8 = new ArrayList<>();
Collections.addAll(list8, 1, 2, 3);
Collections.swap(list8,0,2);
System.out.println(list8);
}
}
9.综合练习
9.1 综合练习1-随机点名器的两种实现方式
班级里有N个学生，实现随机点名器。
import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;
public class Test1 {
public static void main(String[] args) {
/*
班级里有N个学生，实现随机点名器。
*/
//1.定义集合
ArrayList<String> list = new ArrayList<>();
//2.添加学生
Collections.addAll(list, "范闲", "范建", "范统", "杜子腾", "杜琦燕", "宋合泛", "侯笼藤", "朱益群", "朱穆朗玛峰", "袁明媛");
//3.随机点名
Random r = new Random();
int index = r.nextInt(list.size());
String name1 = list.get(index);
System.out.println("list = " + list);
System.out.println("name1 = " + name1);
//打乱
Collections.shuffle(list);
//点名
String name2 = list.get(0);
System.out.println("list = " + list);
System.out.println("name2 = " + name2);
}
}
9.2 综合练习2-带有概率的随机点名
班级里有N个学生
要求：
70%的概率随机到男生
30%的概率随机到女生
"范闲","范建","范统","杜子腾","宋合泛","侯笼藤","朱益群","朱穆朗玛峰",
"杜琦燕","袁明媛","李猜","田蜜蜜",
import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;
public class Test2 {
public static void main(String[] args) {
/*
班级里有N个学生
要求：
70%的概率随机到男生
30%的概率随机到女生
"范闲","范建","范统","杜子腾","宋合泛","侯笼藤","朱益群","朱穆朗玛峰",
"杜琦燕","袁明媛","李猜","田蜜蜜",
*/
//1111111 000 抽取0或者1
//1.创建集合
ArrayList<Integer> list = new ArrayList<>();
//2.添加数据
Collections.addAll(list, 1, 1, 1, 1, 1, 1, 1);
Collections.addAll(list, 0, 0, 0);
//3.打乱集合中的数据
Collections.shuffle(list);
System.out.println("list = " + list);
//4.从list集合中随机抽取0或者1
Random r = new Random();
int index = r.nextInt(list.size());
Integer number = list.get(index);
System.out.println("number = " + number);
//5.创建两个集合分别存储男生和女生的名字
ArrayList<String> boyList = new ArrayList<>();
ArrayList<String> girlList = new ArrayList<>();
//6.添加数据
Collections.addAll(boyList, "范闲", "范建", "范统", "杜子腾", "宋合泛", "侯笼藤", "朱益群", "朱穆朗玛峰");
Collections.addAll(girlList, "杜琦燕", "袁明媛", "李猜", "田蜜蜜");
//7.判断此时是从boyList里面抽取还是从girlList里面抽取
if (number == 1) {
//boyList
int boyIndex = r.nextInt(boyList.size());
String boyName = boyList.get(boyIndex);
System.out.println("boyList = " + boyList);
System.out.println("boyName = " + boyName);
} else {
//girlList
Collections.shuffle(girlList);
String girName = girlList.get(0);
System.out.println("girlList = " + girlList);
System.out.println("girName = " + girName);
}
}
}
9.3 综合练习3-不重复的随机点名
班级里有N(5)个学生
要求：
被点到的学生不会再被点到。
但是如果班级中所有的学生都点完了，需要重新开启第二轮点名。
import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;
public class Test3 {
public static void main(String[] args) {
/*
班级里有N(5)个学生
要求：
被点到的学生不会再被点到。
但是如果班级中所有的学生都点完了，需要重新开启第二轮点名。
*/
//1.定义集合
ArrayList<String> list1 = new ArrayList<>();
//2.添加数据
Collections.addAll(list1, "范闲", "范建", "范统", "杜子腾", "杜琦燕", "宋合泛", "侯笼藤", "朱益群", "朱穆朗玛峰", "袁明媛");
//创建临时的集合，用来存储已经被点到学生的名字
ArrayList<String> list2 = new ArrayList<>();
//外循环：表示轮数
for (int i = 1; i <= 10; i++) {
System.out.println("=========第" + i + "轮点名开始了======================");
//3.获取集合的长度
int lenth = list1.size();
//4.随机点名
//内循环：每一轮中随机循环抽取的过程
for (int j = 0; j < lenth; j++) {
int index = new Random().nextInt(list1.size());
//String name = list1.get(index);
String name = list1.remove(index);
list2.add(name);
System.out.println("name = " + name);
}
//此时表示第一轮点名结束
//list1空了 list2 10个学生的名字
System.out.println("list1 = " + list1);
System.out.println("list2 = " + list2);
list1.addAll(list2);
list2.clear();
}
}
}
9.4 综合练习4~5-带权重的随机点名项目
9.5 综合练习6-集合嵌套----省市
需求
定义一个Map集合，键用表示省份名称province，值表示市city，但是市会有多个。
添加完毕后，遍历结果格式如下：
江苏省 = 南京市，扬州市，苏州市，无锡市，常州市
湖北省 = 武汉市，孝感市，十堰市，宜昌市，鄂州市
河北省 = 石家庄市，唐山市，邢台市，保定市，张家口市
import java.util.*;
public class Test4 {
public static void main(String[] args) {
/*
需求
定义一个Map集合，键用表示省份名称province，值表示市city，但是市会有多个。
添加完毕后，遍历结果格式如下：
江苏省 = 南京市，扬州市，苏州市，无锡市，常州市
湖北省 = 武汉市，孝感市，十堰市，宜昌市，鄂州市
河北省 = 石家庄市，唐山市，邢台市，保定市，张家口市
*/
//1.创建Map集合
HashMap<String, ArrayList<String>> hm = new HashMap<>();
//2.创建单列集合存储市
ArrayList<String> city1 = new ArrayList<>();
Collections.addAll(city1, "南京市", "扬州市", "苏州市", "无锡市", "常州市");
ArrayList<String> city2 = new ArrayList<>();
city2.add("武汉市");
city2.add("孝感市");
city2.add("十堰市");
city2.add("宜昌市");
city2.add("鄂州市");
ArrayList<String> city3 = new ArrayList<>();
Collections.addAll(city3, "石家庄市", "唐山市", "邢台市", "保定市", "张家口市");
//3.把省份和多个市添加到map集合
hm.put("江苏省", city1);
hm.put("湖北省", city2);
hm.put("河北省", city3);
System.out.println("hm = " + hm);
Set<Map.Entry<String, ArrayList<String>>> entries = hm.entrySet();
for (Map.Entry<String, ArrayList<String>> entry : entries) {
//entry依次表示每一个键值对对象
String key = entry.getKey();
ArrayList<String> list = entry.getValue();
StringJoiner sj = new StringJoiner(",", "", "");
for (String city : list) {
sj.add(city);
}
System.out.println(key + " = " + sj);
}
}
}
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
