文章讲述了使用Java编程解决一系列问题，包括使用集合类如Set、TreeMap等数据结构处理社团成员关系，按银牌数量排序队伍信息，分析字符串处理性能，统计网页文本单词频率，计算菜单价格，以及时间间隔计算等。
（1）张三、李四等人是A社团成员，李四、王五等人是B社团成员，编写一个Java应用程序（要求使用集合类），输出参加A社团的人、参加B社团的人、以及同时参加两个社团的人。
package 选实验4;
import java.util.HashSet;
import java.util.Set;
public class task1 {
public static void main(String[] args) {
//创建A社团成员集合
Set <String> clubASet = new HashSet<String>();
clubASet.add("张三");
clubASet.add("李四");
//创建B社团成员集合
Set <String> clubBSet = new HashSet<String>();
clubBSet.add("王五");
clubBSet.add("李四");
//创建参加A和B两个社团成员集合，初始为A
Set <String> clubABSet = new HashSet<String>(clubASet);
//与B进行交集
clubABSet.retainAll(clubBSet);
//输出结果
System.out.println("参加A社团的人: " + clubASet);
System.out.println("参加B社团的人: " + clubBSet);
System.out.println("同时参加两个社团的人: " + clubABSet);
}
}
（2）在2023年杭州亚运会中，获得奖牌数最多的十支队伍的金、银、铜牌数量如下表所示:
将上面表格信息作为输入（顺序不变），编写一个Java应用程序，使用TreeMap<K,V>，按照银牌数量从小到大排序输出10支队伍的信息，要求通过两种方式实现：通过实现Comparator接口和通过实现Comparable接口。
package 选实验4;
import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeMap;
//定义Team类，包括队名、金、银、铜牌数量、总奖牌数量
class Team {
String Name;
int Gold;
int Silver;
int Bronze;
int Total;
Team(String n, int g, int s, int b, int t) {
Name = n;
Gold = g;
Silver = s;
Bronze = b;
Total = t;
}
}
// 定义 TeamComparator 实现 Comparator 接口来自定义排序
class TeamComparator implements Comparator<Team> {
@Override
public int compare(Team t1, Team t2) {
return t1.Silver - t2.Silver; // 按银牌数量升序排序
}
}
public class task2_1 {
public static void main(String[] args) {
Scanner reader = new Scanner(System.in);
// 使用自定义的 TeamComparator 来实现按银牌数量升序排序
TreeMap<Team, Integer> teamMap = new TreeMap<>(new TeamComparator());
for (int i = 0; i < 10; i++) {
System.out.println("请输入队名: ");
String n = reader.nextLine();
System.out.println("请输入金牌数量: ");
int g = reader.nextInt();
System.out.println("请输入银牌数量: ");
int s = reader.nextInt();
System.out.println("请输入铜牌数量: ");
int b = reader.nextInt();
System.out.println("请输入总奖牌数量: ");
int t = reader.nextInt();
reader.nextLine(); // 消耗掉换行符
Team team = new Team(n, g, s, b, t);
teamMap.put(team, i); // 使用队伍信息作为键，为了避免重复键，使用 i 作为值
}
for (Team team : teamMap.keySet()) {
System.out.printf("队名:%30s:-金牌:%-3d-银牌:%-3d-铜牌:%-3d-总牌:%-3d\n",
team.Name, team.Gold, team.Silver, team.Bronze, team.Total);
}
reader.close();
}
}
package 选实验4;
import java.util.Scanner;
import java.util.TreeMap;
// 定义 Team1 类实现 Comparable 接口
// 包括队名、金、银、铜牌数量、总奖牌数量
// 以及重定义 compareTo 方法
class Team1 implements Comparable<Team1> {
String Name;
int Gold;
int Silver;
int Bronze;
int Total;
Team1(String n, int g, int s, int b, int t) {
Name = n;
Gold = g;
Silver = s;
Bronze = b;
Total = t;
}
@Override
public int compareTo(Team1 o) {
return this.Silver - o.Silver; // 按银牌数量升序排序
}
}
public class task2_2 {
public static void main(String[] args) {
Scanner reader = new Scanner(System.in);
// 创建一个 TreeMap 以按银牌数量升序排序队伍信息
TreeMap<Team1, Integer> teamMap = new TreeMap<>();
for (int i = 0; i < 10; i++) {
System.out.println("请输入队名: ");
String n = reader.nextLine();
System.out.println("请输入金牌数量: ");
int g = reader.nextInt();
System.out.println("请输入银牌数量: ");
int s = reader.nextInt();
System.out.println("请输入铜牌数量: ");
int b = reader.nextInt();
System.out.println("请输入总奖牌数量: ");
int t = reader.nextInt();
reader.nextLine(); // 消耗掉换行符
Team1 team = new Team1(n, g, s, b, t);
teamMap.put(team, i);
// 使用队伍信息作为键，为了避免重复键，使用 i 作为值
}
for (Team1 team : teamMap.keySet()) {
System.out.printf("队名:%30s:-金牌:%-3d-银牌:%-3d-铜牌:%-3d-总牌:%-3d\n",
team.Name, team.Gold, team.Silver, team.Bronze, team.Total);
}
reader.close();
}
}
package 选实验4;
import java.util.Scanner;
import java.util.TreeMap;
//定义Team类，包括队名、金、银、铜牌数量、总奖牌数量
class Team2 {
String Name;
int Gold;
int Silver;
int Bronze;
int Total;
Team2(String n, int g, int s, int b, int t) {
Name = n;
Gold = g;
Silver = s;
Bronze = b;
Total = t;
}
}
public class task2_3 {
public static void main(String[] args) {
Scanner reader = new Scanner(System.in);
TreeMap<Integer, Team2> teamMap = new TreeMap<>(); // 使用银牌数量作为键
for (int i = 0; i < 10; i++) {
System.out.println("请输入队名: ");
String n = reader.nextLine();
System.out.println("请输入金牌数量: ");
int g = reader.nextInt();
System.out.println("请输入银牌数量: ");
int s = reader.nextInt();
System.out.println("请输入铜牌数量: ");
int b = reader.nextInt();
System.out.println("请输入总奖牌数量: ");
int t = reader.nextInt();
reader.nextLine(); // 消耗掉换行符
Team2 team = new Team2(n, g, s, b, t);
teamMap.put(s, team); // 使用银牌数量作为键
}
for (Team2 team : teamMap.values()) {
System.out.printf("队名:%30s:-金牌:%-3d-银牌:%-3d-铜牌:%-3d-总牌:%-3d\n",
team.Name, team.Gold, team.Silver, team.Bronze, team.Total);
}
reader.close();
}
}
（3）编写Java应用程序。新建一个ArrayList对象、一个LinkedList对象，一个HashSet对象、一个LinkedHashSet对象、以及一个TreeSet对象。每个对象都包含1到50000的所有整数，顺序随机。现进行如下测试：i) 产生10000个随机整数，每个对象调用contains方法判断这些整数是否在该对象中；ii）计算每个对象执行这10000次操作所需要的时间，并进行对比分析。
package 选实验4;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.TreeSet;
import java.util.concurrent.ThreadLocalRandom;
public class task_3 {
public static void main(String[] args) {
int range = 50000;
int test_number = 10000;
//新建五个对象
ArrayList <Integer> arrayList = new ArrayList<Integer>();
LinkedList <Integer> linkedList = new LinkedList<Integer>();
HashSet <Integer> hashSet = new HashSet<Integer>();
LinkedHashSet <Integer> linkedHashSet = new LinkedHashSet<Integer>();
TreeSet <Integer> treeSet = new TreeSet<Integer>();
//填充各个对象
for(int i = 1; i <= range; i++)
{
int randomX = ThreadLocalRandom.current().nextInt(1,range+1);
arrayList.add(randomX);
linkedList.add(randomX);
hashSet.add(randomX);
linkedHashSet.add(randomX);
treeSet.add(randomX);
}
//测试数组存储10000个随机整数
int [] randomArray = new int[test_number];
for(int i = 0;i < test_number; i++)
{
randomArray[i] = ThreadLocalRandom.current().nextInt(1,range+1);
}
//定义用来比较运行时间的变量
long startTime,endTime,runTime;
//对ArrayList对象进行测试
startTime = System.currentTimeMillis();
for(int x : randomArray)
{
arrayList.contains(x);
}
endTime = System.currentTimeMillis();
runTime = endTime - startTime;
System.out.println("ArrayList操作时间："+runTime+"ms");
//对LinkedList对象进行测试
startTime = System.currentTimeMillis();
for(int x : randomArray)
{
linkedList.contains(x);
}
endTime = System.currentTimeMillis();
runTime = endTime - startTime;
System.out.println("LinkedList操作时间："+runTime+"ms");
//对HashSet对象进行测试
startTime = System.currentTimeMillis();
for(int x : randomArray)
{
hashSet.contains(x);
}
endTime = System.currentTimeMillis();
runTime = endTime - startTime;
System.out.println("HashSet操作时间："+runTime+"ms");
//对LinkedHashSet对象进行测试
startTime = System.currentTimeMillis();
for(int x : randomArray)
{
linkedHashSet.contains(x);
}
endTime = System.currentTimeMillis();
runTime = endTime - startTime;
System.out.println("LinkedHashSet操作时间："+runTime+"ms");
//对TreeSet对象进行测试
startTime = System.currentTimeMillis();
for(int x : randomArray)
{
treeSet.contains(x);
}
endTime = System.currentTimeMillis();
runTime = endTime - startTime;
System.out.println("TreeSet操作时间："+runTime+"ms");
}
}
（4）编写Java应用程序，统计分析网页About-Shenzhen University (SZU) 中关于深圳大学的介绍的英文文章（包括题目About）中每个英文单词出现的次数（不区分大小写，不要写爬虫，可以把整篇文章的内容当作一个字符串读入），并输出出现次数最多的50个英文单词（按出现次数排序，每行输出10个英文单词，共5行）。
package 选实验4;
import java.util.*;
import java.util.regex.*;
//定义 WordNumComparator 实现 Comparator 接口来自定义排序
class WordNumComparator implements Comparator<Map.Entry<String, Integer>> {
@Override
public int compare(Map.Entry<String, Integer> entry1, Map.Entry<String, Integer> entry2) {
return entry2.getValue().compareTo(entry1.getValue()); // 按值降序排序
}
}
public class task4 {
public static void main(String[] args) {
Scanner reader = new Scanner(System.in);
// 创建一个 StringBuilder 对象，用于读入文章
StringBuilder article = new StringBuilder();
String line;
// 从标准输入读取整篇文章，直到遇到空行
while (reader.hasNextLine() && !(line = reader.nextLine().trim()).isEmpty()) {
article.append(line).append(" ");
}
//分割单词，并存进words数组
String[] words = article.toString().toLowerCase().split("\\s+");
// 创建单词统计的 HashMap
Map<String, Integer> wordNum = new HashMap<>();
// 遍历单词并统计
for (String word : words) {
Matcher matcher = Pattern.compile("[^a-z-]").matcher(word);
word = matcher.replaceAll("");
if (!word.isEmpty()) {
wordNum.put(word, wordNum.getOrDefault(word, 0) + 1);
}
}
// 转换HashMap为列表，用于排序
List<Map.Entry<String, Integer>> wordList = new ArrayList<>(wordNum.entrySet());
// 使用自定义的降序排序器对列表进行排序
Collections.sort(wordList, new WordNumComparator());
// 输出前50个单词，每行10个单词，按降序
int count = 0;
for (Map.Entry<String, Integer> entry : wordList) {
System.out.print(entry.getKey() + ": " + entry.getValue() + "\t");
count++;
if (count == 10) {
System.out.println();
count = 0;
}
}
reader.close();
}
}
(5). 编写Java应用程序，计算菜单“北京烤鸭：199.1元；西芹炒肉：11.8元；酸菜鱼：59.1元；铁板牛柳：33.1元”的总价格。
package 选实验4;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
//创建菜肴dish类
class dish
{
String name;
double price;
dish(String n,double p)
{
name = n;
price = p;
}
}
public class task5 {
public static void main(String[] args) {
//创建菜单列表
List<dish>menuDishs = new ArrayList<dish>();
//加入菜单信息
menuDishs.add(new dish("北京烤鸭", 199.1));
menuDishs.add(new dish("西芹炒肉", 11.8));
menuDishs.add(new dish("酸菜鱼", 59.1));
menuDishs.add(new dish("铁板牛柳", 33.1));
// 使用迭代器遍历菜单并计算总价格
double sum = 0.0;
Iterator<dish>iterator = menuDishs.iterator();
while(iterator.hasNext())
{
dish d = iterator.next();
System.out.println(d.name+": "+d.price);
sum += d.price;
}
//输出总价格，保留两位小数
System.out.printf("总价格为：%.2f元\n", sum);
}
}
(6). 编写Java应用程序，每次从键盘读入一个包含有大写英文字母、小写英文字母和数字混杂的字符串(例如Aa123bEFGaaa49023)，要求按顺序输出大写英文字母（例如AEFG）、小写英文字母（abaaa）和数字（12349023）。要求循环连续测试10次。
package 选实验4;
import java.io.CharConversionException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;
public class task6 {
public static void main(String[] args) {
Scanner reader = new Scanner(System.in);
//连续测试10次
for(int i=1;i<=10;i++)
{
String string = reader.nextLine();
//创建三个列表 upCharacters、lowCharacters 和 integers
//分别用于存储大写字母、小写字母和数字
List<Character>upCharacters = new ArrayList<Character>();
List<Character>lowCharacters = new ArrayList<Character>();
List<Character>integers = new ArrayList<Character>();
//遍历字符串中的每个字符
for(int j=0; j<string.length();j++)
{
char ch = string.charAt(j);
if (Character.isUpperCase(ch))
{
upCharacters.add(ch);
}
else if(Character.isLowerCase(ch))
{
lowCharacters.add(ch);
}
else if(Character.isDigit(ch))
{
integers.add(ch);
}
}
//遍历upCharacters,打印大写字母
for(Character item : upCharacters)
{
System.out.print(item);
}
System.out.println();
//遍历lowCharacters,打印小写字母
for(Character item : lowCharacters)
{
System.out.print(item);
}
System.out.println();
//遍历integers,打印数字
for(Character item : integers)
{
System.out.print(item);
}
System.out.println();
}
reader.close();
}
}
(7). 编写Java应用程序，根据用户输入的5个时间（每行一个时间），计算相邻两个时间之间的间隔，共4个结果。注：用户输入的时间格式为“××××年××月××日××时××分××秒”，输出的时间格式为“××日××时××分××秒”。
package 选实验4;
import java.util.Date;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Scanner;
public class task7 {
public static void main(String[] args) {
Scanner reader = new Scanner(System.in);
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy年MM月dd日HH时mm分ss秒");
SimpleDateFormat outputFormat = new SimpleDateFormat("dd日HH时mm分ss秒");
Date[] inputTimes = new Date[5];
for (int i = 0; i < 5; i++) {
System.out.println("请输入第" + (i + 1) + "个时间");
String s = reader.nextLine();
try {
inputTimes[i] = dateFormat.parse(s);
} catch (ParseException e) {
System.err.println("输入无效！");
return;
}
}
// 计算相邻时间的间隔
for (int i = 0; i < 4; i++)
{
long intervalTime = Math.abs(inputTimes[i + 1].getTime() - inputTimes[i].getTime());
Date intervalDate = new Date(intervalTime);
System.out.println("第" + (i + 1) + "个时间和第" + (i + 2) +
"个时间的间隔：" + outputFormat.format(intervalDate));
}
}
}
扫一扫
834
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
