集合练习题归总
1.键盘录入3个学生信息(姓名,语文成绩,数学成绩,英语成绩),按照总分从高到低输出到控制台。
解题思路：
1.创建1个学生类
2.创建1个TreeSet集合对象（使用自然排序或者比较器排序皆可）
3.键盘录入学生的数据，然后把学生的数据封装成一个学生对象，再把学生对象添加到集合中
4.遍历集合
方法1:使用TreeSet的空参构造进行自然排序
public class Student implements Comparable<Student>{
private String name;
private int ChineseScore;
private int MathScore;
private int EnglishScore;
public Student() {
}
public Student(String name, int chineseScore, int mathScore, int englishScore) {
this.name = name;
ChineseScore = chineseScore;
MathScore = mathScore;
EnglishScore = englishScore;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getChineseScore() {
return ChineseScore;
}
public void setChineseScore(int chineseScore) {
ChineseScore = chineseScore;
}
public int getMathScore() {
return MathScore;
}
public void setMathScore(int mathScore) {
MathScore = mathScore;
}
public int getEnglishScore() {
return EnglishScore;
}
public void setEnglishScore(int englishScore) {
EnglishScore = englishScore;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", ChineseScore=" + ChineseScore +
", MathScore=" + MathScore +
", EnglishScore=" + EnglishScore +
'}';
}
//定义语文数学英语的总和
public int sumScore(){
return ChineseScore+MathScore+EnglishScore;
}
@Override
public int compareTo(Student stu) {
//比较两个对象的总和
int num = sumScore() - stu.sumScore();
//如果两个对象的总分相同，比较两个对象的姓名
int num2=num==0?this.name.compareTo(stu.name):num;
return -num2;
}
}
//测试类：
public class MyTest {
public static void main(String[] args) {
/*需求：键盘录入3个学生信息(姓名,语文成绩,数学成绩,英语成绩),
按照总分从高到低输出到控制台。
*/
TreeSet<Student> set = new TreeSet<>();
for (int i = 1; i <= 3; i++) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入第"+i+"学生的姓名：");
String name = scanner.nextLine();
Student student = new Student();
student.setName(name);
System.out.println("请输入第"+i+"学生的语文成绩：");
int yw = scanner.nextInt();
student.setChineseScore(yw);
System.out.println("请输入第"+i+"学生的数学成绩：");
int sx= scanner.nextInt();
student.setMathScore(sx);
System.out.println("请输入第"+i+"学生的英语成绩：");
int yy= scanner.nextInt();
student.setEnglishScore(yy);
set.add(student);
}
int index = 1;
for (Student student : set) {
System.out.println("序号："+(index++) + "\t" +"姓名："+ student.getName() + "\t" +"语文成绩："+
student.getChineseScore() + "\t" +"数学成绩："+ student.getMathScore() + "\t" + "英语成绩："
+student.getEnglishScore() + "\t" +"总分为："+ student.sumScore());
}
}
}
运行后的结果为：
方法2:使用TreeSet的有参构造比较器进行比较
学生类：
public class Student {
private String name;
private int ChineseScore;
private int MathScore;
private int EnglishScore;
public Student() {
}
public Student(String name, int chineseScore, int mathScore, int englishScore) {
this.name = name;
ChineseScore = chineseScore;
MathScore = mathScore;
EnglishScore = englishScore;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getChineseScore() {
return ChineseScore;
}
public void setChineseScore(int chineseScore) {
ChineseScore = chineseScore;
}
public int getMathScore() {
return MathScore;
}
public void setMathScore(int mathScore) {
MathScore = mathScore;
}
public int getEnglishScore() {
return EnglishScore;
}
public void setEnglishScore(int englishScore) {
EnglishScore = englishScore;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", ChineseScore=" + ChineseScore +
", MathScore=" + MathScore +
", EnglishScore=" + EnglishScore +
'}';
}
//定义语文数学英语的总和
public int sumScore(){
return ChineseScore+MathScore+EnglishScore;
}
}
//测试类：
import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;
public class MyTest {
public static void main(String[] args) {
//利用比较器进行排序，需要重写compare方法
TreeSet<Student> treeSet = new TreeSet<>(new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
//按照总分进行排序
int num = s1.sumScore() - s2.sumScore();
//总分相同比较姓名
int num2=num==0?s1.getName().compareTo(s2.getName()):num;
return -num2;
}
});
for (int i = 1; i <= 3; i++) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入第"+i+"学生的姓名：");
String name = scanner.nextLine();
Student student = new Student();
student.setName(name);
System.out.println("请输入第"+i+"学生的语文成绩：");
int yw = scanner.nextInt();
student.setChineseScore(yw);
System.out.println("请输入第"+i+"学生的数学成绩：");
int sx= scanner.nextInt();
student.setMathScore(sx);
System.out.println("请输入第"+i+"学生的英语成绩：");
int yy= scanner.nextInt();
student.setEnglishScore(yy);
treeSet.add(student);
}
int index = 1;
for (Student student : treeSet) {
System.out.println("序号："+(index++) + "\t" +"姓名："+ student.getName() + "\t" +"语文成绩："+
student.getChineseScore() + "\t" +"数学成绩："+ student.getMathScore() + "\t" + "英语成绩："
+student.getEnglishScore() + "\t" +"总分为："+ student.sumScore());
}
}
}
运行后的结果为：
2.统计字符串中每个字符出现的次数"aababcabcdabcde",获取字符串中每一个字母出现的次数要求结果:a(5)b(4)c(3)d(2)e(1)
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
public class MyTest {
public static void main(String[] args) {
/*
统计字符串中每个字符出现的次数"aababcabcdabcde",
获取字符串中每一个字母出现的次数要求结果:a(5)b(4)c(3)d(2)e(1)
案例演示:
需求：统计字符串中每个字符出现的次数
"aababcabcdabcde", 获取字符串中每一个字母出现的次数要求结果:a(5) b(4) c(3) d(2) e(1)
a-----5
b-----4
c-----3
d-----2
e-----1
我们观察发现 这是一种 键值对应关系的数据
对于这种数据我们可以采用双列集合存储集合
遍历双列集合，拼接字符串。
*/
HashMap<Character, Integer> map = new HashMap<>();
Scanner scanner = new Scanner(System.in);
System.out.println("请输入字符串：");
String s = scanner.nextLine();
for (int i = 0; i < s.length(); i++) {
char ch = s.charAt(i);
//判断这个键是不是第一次出现，如果不是，就存进去，值给个1
if(!map.containsKey(ch)){
map.put(ch,1);
}else{
//获取出上一次的值，累加一次，再存进去，键相同，值覆盖
Integer value = map.get(ch);
value++;
//键相同，值覆盖
map.put(ch,value);
}
}
StringBuffer sb = new StringBuffer();
Set<Map.Entry<Character, Integer>> entries = map.entrySet();
for (Map.Entry<Character, Integer> entry : entries) {
Character key = entry.getKey();
Integer value = entry.getValue();
sb.append(key).append("(").append(value).append(")");
}
String str = sb.toString();
System.out.println(str);
}
}
运行后的结果为：
3.集合嵌套之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 MyTest {
public static void main(String[] args) {
/* 基础班
张三 20
李四 22
就业班
王五 21
赵六 23
*/
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);
//遍历方式1：通过keyset方式进行遍历
Set<String> keySet = MaxMap.keySet();
for (String key : keySet) {
System.out.println(key);
HashMap<String, Integer> hashMap = MaxMap.get(key);
Set<String> map = hashMap.keySet();
for (String key1 : map) {
Integer integer = hashMap.get(key1);
System.out.println("\t"+key1+" "+integer);
}
}
System.out.println("================");
//遍历方式2：通过entryset方式进行遍历
Set<Map.Entry<String, HashMap<String, Integer>>> entries = MaxMap.entrySet();
for (Map.Entry<String, HashMap<String, Integer>> entry : entries) {
String key = entry.getKey();
System.out.println(key);
HashMap<String, Integer> value = entry.getValue();
Set<Map.Entry<String, Integer>> entries1 = value.entrySet();
for (Map.Entry<String, Integer> stringIntegerEntry : entries1) {
String key1 = stringIntegerEntry.getKey();
Integer value1 = stringIntegerEntry.getValue();
System.out.println("\t"+key1+" "+value1);
}
}
System.out.println("==================");
//遍历方式三：通过foreach方法进行遍历
MaxMap.forEach(new BiConsumer<String, HashMap<String, Integer>>() {
@Override
public void accept(String s, HashMap<String, Integer> stringIntegerHashMap) {
System.out.println(s);
stringIntegerHashMap.forEach(new BiConsumer<String, Integer>() {
@Override
public void accept(String key, Integer value) {
System.out.println("\t"+key+" "+value);
}
});
}
});
}
}
运行后的结果为：
4.集合嵌套之HashMap嵌套ArrayList
集合嵌套之HashMap嵌套ArrayList
用集合来存储下面的元素，并进行遍历如下的结果：
三国演义
吕布
周瑜
笑傲江湖
令狐冲
林平之
神雕侠侣
郭靖
杨过
import java.util.ArrayList;
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) {
/*
三国演义
吕布
周瑜
笑傲江湖
令狐冲
林平之
神雕侠侣
郭靖
杨过
*/
ArrayList<String> list1 = new ArrayList<>();
list1.add("吕布");
list1.add("周瑜");
ArrayList<String> list2 = new ArrayList<>();
list2.add("令狐冲");
list2.add("林平之");
ArrayList<String> list3 = new ArrayList<>();
list3.add("郭靖");
list3.add("杨过");
HashMap<String, ArrayList<String>> map = new HashMap<>();
map.put("三国演义",list1);
map.put("笑傲江湖",list2);
map.put("神雕侠侣",list3);
Set<String> set = map.keySet();
//遍历方式一：通过keySet方式进行遍历
for (String key: set) {
ArrayList<String> minlist = map.get(key);
System.out.println(key);
for (String s : minlist) {
System.out.println("\t"+s);
}
}
System.out.println("============");
//遍历方式二：通过entryset方法及逆行遍历
Set<Map.Entry<String, ArrayList<String>>> entries = map.entrySet();
for (Map.Entry<String, ArrayList<String>> entry : entries) {
String key = entry.getKey();
System.out.println(key);
ArrayList<String> value = entry.getValue();
for (String s : value) {
System.out.println("\t"+s);
}
}
System.out.println("========");
//遍历方式三：通过forEach方法进行遍历
map.forEach(new BiConsumer<String, ArrayList<String>>() {
@Override
public void accept(String s, ArrayList<String> strings) {
System.out.println(s);
for (String string : strings) {
System.out.println("\t"+string);
}
}
});
}
}
运行后的结果为：
4.集合嵌套之ArrayList嵌套HashMap
集合嵌套之ArrayList嵌套HashMap
用集合来存储下面的元素，并进行遍历如下的结果：
周瑜---小乔
吕布---貂蝉
郭靖---黄蓉
杨过---小龙女
令狐冲---任盈盈
林平之---岳灵珊
import java.util.Map;
import java.util.Set;
import java.util.function.BiConsumer;
public class MyTest3 {
public static void main(String[] args) {
/*周瑜---小乔
吕布---貂蝉
郭靖---黄蓉
杨过---小龙女
令狐冲---任盈盈
林平之---岳灵珊
*/
HashMap<String, String> sgmap = new HashMap<>();
sgmap.put("周瑜","小乔");
sgmap.put("吕布","貂蝉");
HashMap<String, String> xamap = new HashMap<>();
xamap.put("郭靖","黄蓉");
xamap.put("杨过","小龙女");
HashMap<String, String> sdmap = new HashMap<>();
sdmap.put("令狐冲","任盈盈");
sdmap.put("林平之","岳灵珊");
ArrayList<HashMap<String, String>> list = new ArrayList<>();
list.add(sgmap);
list.add(xamap);
list.add(sdmap);
for (HashMap<String, String> hashMap : list) {
Set<String> keySet = hashMap.keySet();
for (String key : keySet) {
System.out.println(key+"---"+hashMap.get(key));
}
}
System.out.println("=======================");
for (HashMap<String, String> hashMap1 : list) {
Set<Map.Entry<String, String>> entries = hashMap1.entrySet();
for (Map.Entry<String, String> entry : entries) {
System.out.println(entry.getKey()+"---"+entry.getValue());
}
}
System.out.println("============================");
for (HashMap<String, String> hashMap2 : list) {
hashMap2.forEach(new BiConsumer<String, String>() {
@Override
public void accept(String key, String value) {
System.out.println(key+"---"+value);
}
});
}
}
}
运行后的结果为：
总结
本节主要练习了TreeSet的自然排序与比较器排序，以及集合之间的嵌套使用和遍历。这些都是最基本的练习，是作为集合知识点中必须掌握的。
1211
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
