11111
7-3 jmu-Java-02基本语法-03-身份证排序
7-4 jmu-Java-02基本语法-04-动态数组
7-5 jmu-Java-02基本语法-05-浮点数的精确计算
7-6 jmu-Java-02基本语法-06-枚举
7-7 jmu-Java-02基本语法-07-大整数相加
7-11 jmu-java-m02-使用二维数组存储多元线性方程组
7-21 学投资
7-27 以英里计的平均速度
7-42 二进制的前导的零
7-43 JAVA-水仙花数
7-53 666
7-56 上三角数字三角形
7-57 又来一个上三角数字三角形
7-68 阶乘计算
7-72 分解质因数
一 ctrl+alt+l
7-1 jmu-Java-01入门-第一个PTA上Java程序
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
// while (input.hasNextLine()) {//易错点1 input.hasNextLine 和 input.hasNextLine的区别
while (input.hasNextInt()) {
int a = input.nextInt();
int b = input.nextInt();
if(Math.abs(a)>1000) {
System.out.println("|a|>1000");
}
else {
System.out.println(a + b);
}
}
}
}input.hasNextLine 和 input.hasNextLine在此题
-
while (input.hasNextLine())：不适用，因为它无法直接处理每行的两个整数，且无法保证输入格式正确。 -
while (input.hasNextInt())：正确，因为它确保了每次循环都能读取到一个整数，且逻辑上能够正确处理成对的整数输入。
*7-3 jmu-Java-01入门-取数字浮点数
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
while (input.hasNextLine()) {//这个可以使用input.hasNextLine() 因为是一句一句输入
String line = input.nextLine();
int sum = 0;
for (int i = 0; i < line.length(); i++) {
if(line.charAt(i)>='0' && line.charAt(i)<='9') {//注意这边的line.charAt(i)还不是正数形式
sum+=line.charAt(i)-'0';
}
}
System.out.println(sum);
}
}
}**re7-4 jmu-Java-02-使用逐步逼近法求开根号
错误代码
import java.util.*;
import java.util.function.BiConsumer;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
while(input.hasNextLine()) {
double x = input.nextDouble();
if(x<0){
System.out.println("NaN");
}else{
double y=0;
while(Math.pow(y, 2)<x && Math.abs(x-Math.pow(y, 2))>0.0001){
y+=0.0001;
}
System.out.printf("%.6f\n",y);
}
}
}
}
这个使得程序非0返回 为什么呢？
我猜测是在处理最后一行程序时 换行可以被hasnextLine检测到导致nextDouble输入错误
而用hasnext不会出现这样的问题 因为直接跳过换行符->检测到缓冲区没有剩余字符 nextDouble就不会有输入
而用hasnextLine会导致nextDouble输入换行
import java.util.*;
import java.util.function.BiConsumer;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
while(input.hasNext()) {
double x = input.nextDouble();//hasnext nextdouble99
if(x<0){
System.out.println("NaN");
}else{
double y=0;
while(Math.pow(y, 2)<x && Math.abs(x-Math.pow(y, 2))>0.0001){
y+=0.0001;
}
System.out.printf("%.6f\n",y);
}
}
}
}
从0开始逐步逼近 n为目标
*7-5 jmu-Java-01入门-格式化输入输出与字符串
两种代码 一种用
1.input.nextLine()(这个更麻烦 解释在下边)
一种
2.input.next() （推荐这种 更方便）
1.
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
while (input.hasNextLine()) { // 使用 hasNextLine() 确保有下一行输入
String str = input.nextLine(); // 读取当前行并去除首尾空格
if (str.isEmpty()) { // 如果是空行，跳过处理
continue;
}
System.out.println("choice=" + str);
if (str.equals("double")) {
double a = input.nextDouble();
double b = input.nextDouble();
double c = input.nextDouble();
System.out.printf("%-5.2f,%5.2f,%.2f\n", a, b, c);
input.nextLine(); // 消耗换行符
} else if (str.equals("int")) {
int a = input.nextInt();
int b = input.nextInt();
int c = input.nextInt();
System.out.println(a + b + c);
input.nextLine(); // 消耗换行符
} else if (str.equals("str")) {
String a = input.nextLine();
String[] arr = a.split(" ");
for (int i = arr.length - 1; i >= 0; i--) {
System.out.print(arr[i]);
}
System.out.println();
} else if (str.equals("line")) {
String a = input.nextLine();
System.out.println(a.toUpperCase());
} else {
System.out.println("other");
}
}
}
}2.
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
while (input.hasNextLine()) { // 使用 hasNextLine() 确保有下一行输入
String str = input.nextLine().trim(); // 读取当前行并去除首尾空格
if (str.isEmpty()) { // 如果是空行，跳过处理
continue;
}
System.out.println("choice=" + str);
if (str.equals("double")) {
double a = input.nextDouble();
double b = input.nextDouble();
double c = input.nextDouble();
System.out.printf("%-5.2f,%5.2f,%.2f\n", a, b, c);
input.nextLine(); // 消耗换行符
} else if (str.equals("int")) {
int a = input.nextInt();
int b = input.nextInt();
int c = input.nextInt();
System.out.println(a + b + c);
input.nextLine(); // 消耗换行符
} else if (str.equals("str")) {
String a = input.nextLine();
String[] arr = a.split(" ");
for (int i = arr.length - 1; i >= 0; i--) {
System.out.print(arr[i]);
}
System.out.println();
} else if (str.equals("line")) {
String a = input.nextLine();
System.out.println(a.toUpperCase());
} else {
System.out.println("other");
}
}
}
}对于1的解释
关键问题：nextDouble() 和 nextInt() 的行为
-
input.nextDouble()和input.nextInt()：-
这些方法只读取数值，不会读取换行符。换行符会留在输入流中。
-
如果在读取数值后直接调用
input.nextLine()，nextLine()会读取到这个换行符，并返回一个空字符串。
-
-
input.nextLine()：-
这个方法会读取一整行，包括换行符。
-
如果在读取数值后，需要读取下一行的内容，必须先调用
nextLine()来消耗换行符，否则会导致逻辑错误。
-
为什么需要在某些分支中调用 input.nextLine()？
1. double 和 int 分支
在这些分支中，你使用了 input.nextDouble() 和 input.nextInt() 来读取数值。这些方法不会读取换行符，因此换行符会留在输入流中。如果不调用 input.nextLine()，下一次循环读取时会直接跳过当前行，导致逻辑错误。
java复制
if (str.equals("double")) {
double a = input.nextDouble();
double b = input.nextDouble();
double c = input.nextDouble();
System.out.printf("%-5.2f,%5.2f,%.2f\n", a, b, c);
input.nextLine(); // 消耗换行符
}-
input.nextLine()的作用：-
在读取完数值后，调用
nextLine()来消耗换行符，确保下一次循环可以正确读取下一行输入。
-
2. str 和 line 分支
在这些分支中，你直接调用了 input.nextLine() 来读取下一行内容。由于 nextLine() 会读取一整行并消耗换行符，因此不需要额外调用 nextLine() 来清除缓冲区。
java复制
else if (str.equals("str")) {
String a = input.nextLine();
String[] arr = a.split("\\s+");
for (int i = arr.length - 1; i >= 0; i--) {
System.out.print(arr[i] + " ");
}
System.out.println();
}-
为什么不需要额外调用
nextLine()：-
在这些分支中，你已经使用
nextLine()读取了下一行内容，换行符已经被消耗，因此不需要额外调用。
-
总结
-
在
double和int分支中：-
使用
nextDouble()和nextInt()后，必须调用nextLine()来消耗换行符，否则会导致逻辑错误。
-
-
在
str和line分支中：-
直接使用
nextLine()读取下一行内容，换行符已经被消耗，不需要额外调用。
-
示例输入和输出
假设输入如下：
复制
double
1.578 3.0 3.14259
line
aaaaaaaaaa
int
1 2 3
str
321 654 987
line
dddddddddd
end输出：
复制
choice=double
1.58, 3.00,3.14
choice=line
AAAAAAAAAA
choice=int
6
choice=str
987 654 321
choice=line
DDDDDDDDDD
choice=end
other关键点
-
nextDouble()和nextInt()：-
不会读取换行符，需要调用
nextLine()来清除缓冲区。
-
-
nextLine()：-
会读取一整行并消耗换行符，不需要额外调用。
-
*7-7 jmu-java-m01-Scanner入门
// import java.util.Scanner;
// import static java.lang.Math.pow;
// import static java.lang.Math.sqrt;
// public class Main {
// public static void main(String[] args) {
// Scanner sc = new Scanner(System.in);
// int a=sc.nextInt();
// double b=sc.nextDouble();
// double c=(double)a+b;
// System.out.println(c);
// System.out.println(sqrt(c));
// String str=String.valueOf(sqrt(c));
// str=str.substring(0,6);
// System.out.println(str);
// }}
import java.util.*;
import java.util.function.BiConsumer;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int a=input.nextInt();
double b=input.nextDouble();
double c=(double) a+b;
System.out.println(c);
// System.out.printf("%f\n",Math.sqrt(c));
// System.out.print(Math.sqrt(c));System.out.printf("\n");这几个输出的小数位数是不一致的 printf默认输出六位小数
System.out.println(Math.sqrt(c));
System.out.printf("%s\n",String.valueOf(Math.sqrt(c)).substring(0,6));
}
}
二
*7-2 jmu-Java-02基本语法-02-StringBuilder
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
while (in.hasNext()){
int n=in.nextInt();
int begin=in.nextInt();
int end=in.nextInt();
StringBuilder str=new StringBuilder();
for (int i=0;i<n;i++)
{
str.append(i);
}
System.out.println(str.substring(begin,end));
}
}
}StringBuilder str=new StringBuilder(); 构建一个str 这种情况下构建的str可以高效拼接
str.append(i); 字符串拼接函数
(str.substring(begin,end) 字符串提取函数
*7-3 re jmu-Java-02基本语法-03-身份证排序
先描述一下思路
1.输入n 再输入n个身份证号
2.进行排序 （由小到大也就是升序）
3.排序完成之后根据输入的是 sort1还是sort2分类排序
sort1按年-月-日格式组装输出 sort2直接输出
写代码时依旧是nextInt和nextLine的问题
lamdba延长版本
import java.util.*;
import java.util.function.BiConsumer;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int n = input.nextInt();
ArrayList<String> list = new ArrayList<>();
for (int i = 0; i < n; i++) {
list.add(input.next());
}
Collections.sort(list,new Comparator<String>() {
@Override
public int compare(String list1, String list2) {
String str1=list1.substring(7,14);
String str2=list2.substring(7,14);
return str1.compareTo(str2);
}
});
while (true){
String s = input.next();
if(s.equals("sort1")){
for (String ss : list) {
System.out.println(ss.substring(6,10)+"-"+ss.substring(10,12)+"-"+ss.substring(12,14));//取头不取尾
}
} else if (s.equals("sort2")) {
for(String list1 : list){
System.out.println(list1);
}
}else{
System.out.println("exit");
break;
}
}
}
}
方法1
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// 读取身份证的数量
int n = Integer.parseInt(scanner.nextLine());
List<String> idCards = new ArrayList<>();
// 读取 n 个身份证号
for (int i = 0; i < n; i++) {
idCards.add(scanner.nextLine());
}
// 读取排序指令
Collections.sort(idCards,
Comparator.comparing(idCard -> idCard.substring(6, 14)));
while (scanner.hasNext()) {
String sort = scanner.nextLine();
if (sort.equals("sort1")) {
for (String idCard : idCards) {
String year = idCard.substring(6, 10);
String month = idCard.substring(10, 12);
String day = idCard.substring(12, 14);
System.out.println(year + "-" + month + "-" + day);
}
} else if (sort.equals("sort2")) {
for (String idCard : idCards) {
System.out.println(idCard);
}
} else {
System.out.println("exit");
}
}
scanner.close();
}
}int n = Integer.parseInt(scanner.nextLine());
int类型是不能使用nextLine的 可以转换为String类型再->int类型
因为输入是一行且包括换行 要不然使用这个方法 要不然就是用input.nextLine吃掉换行
方法2
nextInt：
-
如果输入是一个整数后跟一个换行符（例如
5\n），nextInt()只会读取5，而换行符\n仍然留在输入流中。
import java.util.ArrayList;
import java.util.*;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
ArrayList<String> list=new ArrayList<>();
int n= in.nextInt();//读取单个数值 但不跳过换行
in.nextLine();
for (int i=0;i<n;i++)
{
list.add(in.nextLine());
}
Collections.sort(list,Comparator.comparing(list1->list1.substring(7,14)));
while (in.hasNext())
{
String str=in.nextLine();
if (str.equals("sort1"))
{
for (String s:list) {
System.out.println(s.substring(6, 10) + "-" + s.substring(10, 12) + "-" + s.substring(12, 14));
}
}
else if(str.equals("sort2")) {
for (String s:list) {
System.out.println(s);
}
}
else {
System.out.println("exit");
break;
}
}
}
}易错点1：
Collections.sort(list,Comparator.comparing(list1->list1.substring(7,14)));Collections.sort(比较的对象,用于比较的方法)
Comparator.comparing(list1->list1.substring(7,14)) 提取index为6-13的数字进行排序
Q:为什么要用Comparator.comparing？
Collections.sort 方法有两种常见用法：
-
无参数版本：
Collections.sort(list)
这种方式要求集合中的元素必须实现Comparable接口，按照元素的自然顺序进行排序。 -
带
Comparator参数版本：Collections.sort(list, Comparator)
这种方式允许你自定义排序规则，通过传入一个Comparator对象来指定如何比较集合中的元素。
在你的代码中，身份证号码是字符串，而字符串的自然顺序（字典序）可能不符合你的需求。因此，你需要自定义排序规则，即通过 Comparator 来指定按照身份证号码的第7到第14位进行排序。
2. Comparator.comparing 的作用
Comparator.comparing(list1 -> list1.substring(6, 14))-
list1 -> list1.substring(6, 14)是一个 lambda 表达式，实现了Function接口。 -
它的作用是从每个字符串（身份证号码）中提取第7到第14位的子字符串（出生日期部分）。
-
Comparator.comparing根据提取的子字符串生成一个Comparator，这个Comparator会按照子字符串的字典序对集合进行排序。
-
Comparator：定义排序规则，告诉
sort怎么排。 -
comparing：快速生成
Comparator的工具，你只需要提供“用什么来比较”，它就会生成规则。
易错点2：
subList 和 substring
subList 方法
-
适用对象：
List类型（例如ArrayList、LinkedList等）。 -
作用：从列表中提取一个子列表。
-
方法签名：
java复制
List<E> subList(int fromIndex, int toIndex); -
参数：
-
fromIndex：子列表的起始索引（包含）。 -
toIndex：子列表的结束索引（不包含）。
-
* re7-4jmu-Java-02基本语法-04-动态数组
import javax.swing.plaf.synth.SynthOptionPaneUI;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
while (input.hasNext()) {
int n = input.nextInt();
String [][]arr=new String[n][n];
for(int i = 0; i < n; i++){
for(int j = 0; j <=i; j++){
String str=(i+1)+"*"+(j+1)+"="+(j+1)*(i+1);
arr[i][j]=str;
System.out.print(str);
if(j<i){
int space=Math.max(7-str.length(),0);
for(int k=0;k<space;k++){
System.out.print(" ");
}
}
}
System.out.println();
}
System.out.println(Arrays.deepToString(arr).replace(", null",""));
}
}
}7-5 jmu-Java-02基本语法-05-浮点数的精确计算
BigDecimal的使用 先称之为大小数?
（嗯 有大小数应该也是有大整数的）
import javax.swing.plaf.synth.SynthOptionPaneUI;
import java.math.BigDecimal;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
while (input.hasNextBigDecimal()) {
BigDecimal a=new BigDecimal(input.next());
BigDecimal b=new BigDecimal(input.next());
System.out.println(a.add(b));
// System.out.println(a.subtract(b));减
System.out.println(a.multiply(b));
}
}
}还有两数之间的处理
System.out.println(a.add(b));加
System.out.println(a.subtract(b));减
System.out.println(a.multiply(b));乘
*7-6re jmu-Java-02基本语法-06-枚举
import javax.swing.plaf.synth.SynthOptionPaneUI;
import java.math.BigDecimal;
import java.util.*;
enum Grade{
A,B,C,D,E
}
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
while(input.hasNext()){
int n=input.nextInt();
Grade dj=getGrade(n);
switch(dj){
case A:System.out.println("Excellent");break;
case B:System.out.println("Good");break;
case C:System.out.println("Average");break;
case D:System.out.println("Fair");break;
case E:System.out.println("Poor");break;
}
printGradeInfo(dj);
}
}
static Grade getGrade(int score){
if(score>=90 &&score<=100){return Grade.A;}
else if(score>=80 &&score<90){return Grade.B;}
else if(score>=70 &&score<80){return Grade.C;}
else if(score>=60 &&score<70){return Grade.D;}
else{return Grade.E;}
}
public static void printGradeInfo(Grade grade){
System.out.println("class name="+Grade.class);
System.out.println("grade value="+grade);
}
}
7-7 jmu-Java-02基本语法-07-大整数相加
import java.math.BigInteger;
import java.util.*;
public class Main {
public static void main(String[] args) {
BigInteger b = new BigInteger("0");
Scanner input = new Scanner(System.in);
while (true) {
String s = input.nextLine();
if (s.equals("e")||s.equals("E")) {
break;
}
b=b.add(new BigInteger(s));//BigInteger 的构造函数接受一个字符串 但必须是数值
}
System.out.println(b);
}
}
补药忘记import java.math.BigInteger;头文件啊
7-11 jmu-java-m02-使用二维数组存储多元线性方程组
import java.math.BigInteger;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int n=input.nextInt();
double [][]arr=new double[n][n+1];
for (int i=0;i<n;i++)
{
for (int j=0;j<n+1;j++){
arr[i][j]=input.nextDouble();
}
}
System.out.println(Arrays.deepToString(arr));
for (int i=0;i<n;i++)
{
for (int j=0;j<n+1;j++)
{
System.out.print(arr[i][j]);
if(j<n-1){
System.out.print(", ");
}else if(j==n-1){
System.out.print(" = ");
}
}
System.out.println();
}
}
}
*integer.toString7-12 十进制转十六进制
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner input = new Scanner(System.in);
int n = input.nextInt();
if(n>=0&&n<=15){
System.out.println(Integer.toString(n, 16).toUpperCase());
//Integer.toString(n, 16) n转16进制
}
else {
System.out.println("Invalid input");
}
}
}
// import java.math.BigInteger;
// import java.util.*;
// public class Main {
// public static void main(String[] args) {
// Scanner input = new Scanner(System.in);
// int n=input.nextInt();
// if(n>=0 && n<=15){
// if(n<10){
// System.out.println(n);
// }else {
// System.out.printf("%c",'A'+n%10);
// }
// }else{
// System.out.println("Invalid input");
// return;
// }
// }
// }
两个代码都可以
Integer.toString(n, 16) n转16进制
7-15 编程题：统计符合条件元素的个数
// import java.util.*;
// public class Main{
// public static void main(String[] args){
// Scanner input = new Scanner(System.in);
// int n = input.nextInt();
// int count1=0,count2=0;
// for (int i=1;i<=n;i++){
// if (i%3==0){
// if (i%2==0)
// {
// count2++;
// }
// else {
// count1++;
// }
// }
// }
// System.out.printf("%d,%d",count1,count2);
// }
// }
import java.math.BigInteger;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int n = input.nextInt();
int j=0,o=0;
for(int i = 1; i <= n; i++){
if(i%3==0)
{
if(is(i)==2){
o++;
}else{
j++;
}
}
}
System.out.printf("%d,%d",j,o);
}
static int is(int n){
if(n%2==0) {
return 2;
}
else {
return 1;
}
}
}
两方法
re**7学投资
import java.math.BigInteger;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int m = input.nextInt();
double p=input.nextDouble();
int n=input.nextInt();
double f=m;
double ff;
ff= m * (1 + p*n);//表示每年的本金加上 n 年的总收益
for( int i=1;i<=n;i++)
{
f=f*(1+p);//新的本金=当前本金+当前本金×利率
}
System.out.printf("%d %d %d",(int)Math.round(f),(int)Math.round(ff),(int)Math.round(f)-(int)Math.round(ff));
}
}
7-22 计算钱币
纸币的种类有十元、五元、一元，硬币的种类有五角、一角、贰分、壹分。
10 5 1 0.5 0.1 0.02 0.01 为了方便计算x1000
10000 5000 500 100 20 10
import java.math.BigInteger;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
double totalMoney = in.nextDouble();
int total = (int)(totalMoney*1000);
int ten=0,five=0,one=0,five1=0,one1=0,two=0,one2=0;
//10000,5000,1000,500,100,20,10
ten=total/10000;
five=total%10000/5000;
one=total%5000/1000;
five1=total%1000/500;
one1=total%500/100;
two=total%100/20;
one2=total%20/10;
System.out.println( ten +" 张十元");
System.out.println( five +" 张五元");
System.out.println( one +" 张一元");
System.out.println( five1 +" 个五角");
System.out.println( one1 +" 个一角");
System.out.println( two +" 个贰分");
System.out.println( one2 +" 个壹分");
}
}
7-27 以英里计的平均速度
// import java.util.*;
// public class Main
// {
// public static void main(String arg[])
// {
// int m,s,d;
// Scanner input=new Scanner(System.in);
// m=input.nextInt();
// s=input.nextInt();
// d=input.nextInt();
// double 英里=(double)d/1.6;
// int 秒=m*60+s;
// double 速度=英里/秒*3600;
// System.out.println( String .format( "%.2f" , 速度));
// }
// }
import java.math.BigInteger;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int m = in.nextInt();
int s = in.nextInt();
int d = in.nextInt();
double sd=0.0;
double h=(m*60+s)/3600.0;
sd=d/h/1.6;
System.out.printf("%.2f",sd);
}
}
7-31 编程题：复杂情况下的数据统计问题
// import java.util.*;
// public class Main{
// public static void main(String[] args){
// Scanner input = new Scanner(System.in);
// String a = input.nextLine();
// int flag=0;//默认为没有字母
// int sum=0;
// String[] str=a.split(" ");//按空格分割输入字符串
// for(String s: str){
// //try{}catch{}语句的使用方法
// try{
// int num = Integer.valueOf(s);//尝试将字符串转换为整数
// sum += num;
// }catch(Exception e){
// flag=1;
// }
// }
// System.out.println(sum);
// if(flag==1) {
// System.out.println("attention");
// }
// }
// }
import java.math.BigInteger;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String num = in.nextLine();
int sum = 0;
int flag=0;
String []arr=num.split(" ");
for(String s:arr){
try{
sum+=Integer.parseInt(s);
}catch(Exception e){
// System.out.println("attention");放在这里会提前输出
flag=1;
}
}
System.out.println(sum);
if(flag==1){
System.out.println("attention");
}
}
}
*7-38 Java中二进制位运算
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner input = new Scanner(System.in);
int a = input.nextInt();
char b = input.next().charAt(0);
if(b == '&'){
int c = input.nextInt();
System.out.printf("%d & %d = %d\n", a, c, a&c);
}
else if(b=='|'){
int c = input.nextInt();
System.out.printf("%d | %d = %d\n", a, c, a|c);
}else if(b=='^'){
int c = input.nextInt();
System.out.printf("%d ^ %d = %d\n", a, c, a^c);
}
else {
System.out.println("ERROR");
}
}
}
char b = input.next().charAt(0);//读取一个单词并取第一个字符，直到遇到空格或换行符为止。
*re7-42 二进制的前导的零 这个也再来一次
import java.math.BigInteger;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int a=input.nextInt();
int count=0;
for (int i=31;i>=0;i--) {//位运算中最低位是0位
int c=(a&(1<<i))==0?0:1;
if (c==0) {
count++;
}
else{
System.out.println(count);
return;
}
}
System.out.println(count);
}
}
** 7-43 re JAVA-水仙花数
不建议math.pow在调用函数中使用 会超级超时
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for(int i = (int)Math.pow(10,n-1); i < (int)Math.pow(10,n); i++){
if (issx(n,i)==i){
System.out.println(i);
}
}
}
public static int issx(int n, int k) {
int sum=0;
while (k != 0) {
int a = k % 10;
int b = 1;//这个用来计算个位上的数字的N次幂之和
for (int i = n; i > 0; i--) {
// a *= a;这种写法错误 因为a*a的同时 自身也在变化 所以需重新定义一个函数=1 来计算当个位数的n次
b*=a;
}
sum+=b;
k /= 10;
}
return sum;
}*reRE7-44 JAVA-求整数序列中出现次数最多的数 HASHMAP的方法
思路：遍历所有数值 数值中再嵌套一个循环去遍历除当前数值外的数值 （记录count和数值） 判断是否有重复 后再判断重复出现的次数是否超过当前的最大次数 是的话则打擂 再次记录count和数值
import java.math.BigInteger;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int []brr = new int[input.nextInt()];
for (int i = 0; i < brr.length; i++) {
brr[i] = input.nextInt();
}
int count=0;
int num=0;
for (int i = 0; i < brr.length; i++) {
int countfinaly=0;
for (int j = i + 1; j < brr.length; j++) {
if (brr[i] == brr[j]) {
countfinaly++;
}
if(count< countfinaly) {
count=countfinaly;
num=brr[i];
}
}
}
System.out.println(num+" "+(count+1));
}
}
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int n=input.nextInt();
HashMap<Integer,Integer> map=new HashMap<>();
for (int i = 0; i < n; i++) {
int num=input.nextInt();
map.put(num,map.getOrDefault(num,0)+1);
}
int max=Collections.max(map.values());//找到了最大value 接下来通过value找key
Set<Map.Entry<Integer, Integer>> entries = map.entrySet();
int a=0,b=0;
for (Map.Entry<Integer, Integer> entry : entries) {
if (entry.getValue()==max)
System.out.println(entry.getKey()+" "+entry.getValue());
}
}
}
*7-45 统计正数和负数的个数然后计算这些数的平均值
第一个测试点 测试案例
第二个测试点 0（count为0时直接return）
第三四测试点 double的结果是没有小数位数要求的
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
int z=0,f=0,sum=0;
// int []arr=Integer.parseInt(str.split(" ")); 这种写法是错误的
String[] words = str.split(" ");
int []arr = new int[words.length];
for (int i = 0; i < words.length; i++) {
arr[i] = Integer.parseInt(words[i]);
sum+=arr[i];
}
int count=0;
for(Integer i : arr) {
if (i < 0) {
f++;
count++;
} else if (i > 0) {
z++;
count++;
} else {
break;
}
}
if(count==0){
return;
}
System.out.println(z);
System.out.println(f);
System.out.println(sum);
System.out.println((double)sum/count);
}
}**7-49 re 兔子繁殖问题
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int a=1,b=1;int c=0;
// if (n == 1 || n == 2) {
// System.out.println(1);
// return;
// }正常是1 1 2 3 5 这个题是1 2 3 5 8
if (n == 1) {
System.out.println(1);
return;
}
for(int i = 2; i <= n; i++){
c=a+b;
a=b;
b=c;
}
System.out.println(c);
}
}
7-50 作品评分
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
double max=0.0;
double min=100;
double sum=0.0;
for (int i = 0; i < n; i++) {
double a = sc.nextDouble();
sum+=a;
if(a>max)
{
max=a;
}
if (a<min)
{
min=a;
}
}
sum=sum-max-min;
System.out.printf("%.2f",(double)sum/(n-2));
}
}
记得最后n要-2
7-51 re369寝室
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int x = sc.nextInt();
int y = sc.nextInt();
int z = sc.nextInt();
int count = 0;
while (count<=100) {
count++;
// x += count;
// y += count;
// z += count;
// int x1 = x % 10;
// int y1 = y % 10;
// int z1 = z % 10; 这种写法更改了每次计算时 变量的初始值
int x1 = (x+count) % 10;
int y1 = (y+count) % 10;
int z1 = (z+count) % 10;
if (x1 == 3 && y1 == 6 && z1 == 9 || x1 == 3 && y1 == 9 && z1 == 6 || x1 == 6 && y1 == 3 && z1 == 9 || x1 == 6 && y1 == 9 && z1 == 3 || x1 == 9 && y1 == 3 && z1 == 6 || x1 == 9 && y1 == 6 && z1 == 3) {
System.out.println(count);
return;
}
}
System.out.println("so sad!");
}
}
！！超级方法
import java.util.HashSet;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int x=sc.nextInt();
int y=sc.nextInt();
int z=sc.nextInt();
int count=0;
while(count<=100){
count++;
HashSet<Integer> set=new HashSet<>();
int x1=(x+count)%10;
int y1=(y+count)%10;
int z1=(z+count)%10;
set.add(x1);
set.add(y1);
set.add(z1);
if(set.contains(3)&&set.contains(6)&&set.contains(9)){//不加引号：set.contains(6) 检查集合中是否存在值为 6 的整数。
//加引号：set.contains("3") 检查集合中是否存在值为 "3" 的字符串。
System.out.println(count);
return;
}
}
System.out.println("so sad!");
}
}7-52 等腰直角三角形
这题的关键在必须要用字符串输出
用正常方法会超时
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
String str="";
for (int i = 0; i < n; i++) {
str+="*";
System.out.println(str);
}
}
}用这种方法只需要一个循环就可以了 因为不需要换行
每次叠加一个的* 然后输出
7-53 re 666
// import java.util.Scanner;
// public class Main {
// public static void main(String[] args) {
// Scanner in = new Scanner(System.in);
// int n = in.nextInt();
// if(n==0){
// System.out.println("0");
// return;
// }
// int sum=0;
// int a=1;
// for(int i=1; i<n; i++){//从第二项开始计算
// a=a*10+1;
// sum+=a;
// }
// sum*=6;
// System.out.println(sum+6);//+上第一项
// }
// }
import java.util.HashSet;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int m=1;
int sum=0;
//1+11+111
if (n==0){
System.out.println("0");
return;
}
for (int i = 2; i <= n; i++) {
m=m*10+1;
sum+=m;
}
System.out.println(sum*6+6);
}
}**7-55 re空心字母金字塔
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
char zm=sc.next().charAt(0);
int height=zm-'A'+1;
for(int i=0;i<height;i++){
for(int j=0;j<39-i;j++){
System.out.print(" ");
}
System.out.print((char) ('A'+i));
for(int j=0;j<=2*i-1;j++){
if(i!=height-1)
{
if(j==2*i-1){
System.out.print((char) ('A'+i));
}else{
System.out.print(' ');
}
}else {
System.out.print((char) ('A'+i));
}
}
System.out.println();
}
}
}
7-56 上三角数字三角形
// import java.util.Scanner;
// public class Main {
// public static void main(String[] args) {
// Scanner sc = new Scanner(System.in);
// int n = sc.nextInt();
// int m=1;
// for (int i = n; i >=1; i--) {
// for (int j = 1; j <= i; j++) {
// System.out.printf("%4d",m);
// m++;
// }
// System.out.println();
// }
// }
// }
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int count = 1;
for (int i = 1; i <= n; i++) {
for (int j = n; j >= i; j--) {//开头n个 随着i增加 循环减少
System.out.printf("%4d",count++);
}
System.out.println();
}
}
}
**7-57 re又来一个上三角数字三角形
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int num=1;
int [][]arr=new int[n][n];//数组默认是0
for (int i = 0; i < n; i++) {
for (int j = 0; j < n-i; j++) {
arr[i][j]=num;//重点在这 输入的时候完成排列
num++;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n-i; j++) {
System.out.printf("%4d",arr[j][i]);//行->列 列->行只要反一下数组里的行列就可以了
}
System.out.println();
}
}
}*7-58 re组合找出最大值和最小值
一种是先判断输入是否错误
一种是try catch捕捉
//以下方法可以
// import java.util.Arrays;
// import java.util.Scanner;
// public class Main {
// public static void main(String[] args) {
// Scanner scanner = new Scanner(System.in);
// int[] a = new int[4];
// for (int i = 0; i < 4; i++) {
// // 检查输入是否为整数
// while (!scanner.hasNextInt()) {
// System.out.print("number input error");
// return;
// }
// a[i] = scanner.nextInt();
// if (a[i] > 9 || a[i] < 0) {
// System.out.print("Numerical range error\n");
// return;
// }
// }
// Arrays.sort(a);
// int max = a[3] * 1000 + a[2] * 100 + a[1] * 10 + a[0];
// int min = a[0] * 1000 + a[1] * 100 + a[2] * 10 + a[3];
// System.out.print(max + " " + min);
// }
// }
//这个方法也可以
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int []a=new int[4];
for(int i=0;i<4;i++) {
try {
int n=sc.nextInt();
if(n>=0 && n<=9) {
a[i]=n;
}else {
System.out.println("Numerical range error");
return;
}
}catch (Exception e) {
System.out.println("number input error");
return;
}
}
Arrays.sort(a);//默认小->大
int max=a[3]*1000+a[2]*100+a[1]*10+a[0];
int min=a[0]*1000+a[1]*100+a[2]*10+a[3];
System.out.print(max + " " + min);
System.out.println();
}
}
我感觉这个最好
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int []arr=new int[4];
for(int j=0;j<4;j++){
try {
int n=in.nextInt();
if(n<0 || n>9){
throw new Exception("Numerical range error");
}
arr[j]=n;
}catch(InputMismatchException e){
System.out.println("number input error");
return;
}catch(Exception e){
System.out.println(e.getMessage());
return;
}
}
Arrays.sort(arr);
int max=arr[3]*1000+arr[2]*100+arr[1]*10+arr[0];
int min=arr[0]*1000+arr[1]*100+arr[2]*10+arr[3];
System.out.print(max + " " + min);
System.out.println();
}
}
**7-59 re图片旋转
梳理一下判断 //我真的麻了 最先判断r
先输入m n（m和n好像是不需要判断的）
再输入 r 在这里的时候判断r是否是90 180 -90中的一个，否则提示：angle data error
最后输入矩阵中的数值 输入时判断是否整数
import java.util.Scanner;
//TIP To <b>Run</b> code, press <shortcut actionId="Run"/> or
// click the <icon src="AllIcons.Actions.Execute"/> icon in the gutter.
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
int [][]arr = new int[20][20];
int r = sc.nextInt();
if(r!=90 && r!=180 && r!=-90) {
System.out.println("angle data error");
return;
}
for(int i=0;i<n;i++) {
for(int j=0;j<m;j++) {
if(sc.hasNextInt()) {
arr[i][j] = sc.nextInt();
}
else {
System.out.println("data type error");
return;
}
if(arr[i][j]<0 || arr[i][j]>255) {
System.out.println("matrix data error");
}
}
}//在这里完成了输入与判断
if (r==90){
for(int i=m-1;i>=0;i--) {
for(int j=0;j<n;j++) {//修改j变的是列之间的顺序
if(j!=n-1) {
System.out.print(arr[j][i] + " ");
}else{
System.out.print(arr[j][i]);
}
}
System.out.println();
}
}
else if(r==180){
for(int i=n-1;i>=0;i--) {
for(int j=m-1;j>=0;j--) {
if(j!=0) {
System.out.print(arr[i][j]+" ");
}
else {
System.out.print(arr[i][j]);
}
}
System.out.println();
}
}
else if(r==-90) {
for (int i = 0; i <m; i++) {
for (int j = n-1; j >=0; j--) {//修改j变的是列之间的顺序
if(j!=0) {
System.out.print(arr[j][i]+" ");
}
else{
System.out.print(arr[j][i]);
}
}
System.out.println();
}
}
}
}7-61 求质数
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
for (int i = 2; i < n; i++) {
if (isPrime(i)) {//int 类型必须要等于一个数值 布尔类型不用
System.out.printf(i+" ");
}
}
}
public static boolean isPrime(int a) {
if (a < 2) {
return false;
}
for (int i = 2; i * i <= a; i++) { // 只需检查到 sqrt(a)
if (a % i == 0) {
return false;
}
}
return true;
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for (int i = 2; i <= n; i++) {
if(pri(i)==1){//int 类型必须要等于一个数值 布尔类型不用
System.out.print(i+" ");
}
}
}
public static int pri(int a) {
if(a<2)return 0;
int flag=1;
for(int i=2;i*i<a;i++)//开根
{
if(a%i==0){
flag=0;
}
}
return flag;
}
}
两个都可以
7-63 倒顺字母字符串
// import java.util.*;
// public class Main {
// public static void main(String[] args) {
// Scanner scanner = new Scanner(System.in);
// int n = scanner.nextInt();
// if(n==1)
// {
// System.out.println("a");
// return;
// }
// for (int i = 0; i < n; i++) {
// System.out.printf("%c ",'a'+i);
// }
// for (int i = n-2; i >=0; i--) {
// if(i!=0)
// {
// System.out.printf("%c ",'a'+i);
// }
// else {
// System.out.printf("%c",'a'+i);
// }
// }
// }
// }
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
if(n==1){
System.out.println("a");
return;
}
for (int i = 0; i < n; i++) {
System.out.printf("%c",'a'+i);
System.out.printf(" ");
}
for (int i = n-2; i >=0; i--) {
if (i != 0) {
System.out.printf("%c", 'a' + i);
System.out.printf(" ");
}else {
System.out.printf("%c", 'a' + i);
}
}
}
}
有一个测试点是n==1的时候只输出a没有" "
*re7-66 First 50 Prime Numbers
题目要求从2开始前n个质数相加的和
// import java.util.*;
// public class Main {
// public static void main(String[] args) {
// Scanner scanner = new Scanner(System.in);
// int n = scanner.nextInt();
// int count=0;
// int sum = 0;
// int num = 2;
// while (count<n) {
// if (isPrime(num)) {
// sum += num;
// count++;
// }
// // num++;
// num += (num == 2) ? 1 : 2; // 如果 num 是 2，加 1；否则加 2，跳过偶数
// }
// System.out.printf("%d",sum);
// }
// public static boolean isPrime(int a) {
// if (a < 2) {
// return false;
// }
// for (int i = 2; i * i <= a; i++) {
// if (a % i == 0) {
// return false;
// }
// }
// return true;
// }
// }
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();//从2开始前n个素数的和
int count=0;
int num=2;
int sum=0;
while (count<n) {
if(isprime(num)) {
count++;
sum+=num;
}
num++;
}
System.out.println(sum);
}
static boolean isprime(int n) {
if(n<2){return false;}
for(int i=2;i<=Math.sqrt(n);i++){
if(n%i==0){
return false;
}
}
return true;
}
}
可以在num不为2的时候每次+2增加效率
**7-67 使用二维数组实现Matrix(矩阵)。
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int x1 = sc.nextInt();
int y1= sc.nextInt();
int [][] arr = new int[x1][y1];//y1=x2
for (int i = 0; i < x1; i++) {
for (int j = 0; j < y1; j++) {
arr[i][j] = sc.nextInt();
}
}
int x2=sc.nextInt();
int y2=sc.nextInt();
int [][]brr = new int[x2][y2];//m=w
for (int i = 0; i < x2; i++) {
for (int j = 0; j < y2; j++) {
brr[i][j] = sc.nextInt();
}
}
int [][]crr=new int[x1][y2];
for (int i = 0; i < x1; i++) {
for (int j = 0; j < y2; j++) {
for (int k = 0; k < y1; k++) {
crr[i][j] +=arr[i][k]*brr[k][j] ;
}
}
}
for (int i = 0; i < x1; i++) {
for (int j = 0; j < y2; j++) {
System.out.print(crr[i][j]+" ");
}
System.out.println();
}
}
}
输入案例是
2 3
1 2 3
4 5 6
3 2
7 8
9 0
1 2
第三个数组是这样实现的如下 所以新数组的行由第一个数组的行数决定（代码中是x1） 列由第二个数组的列决定 （代码中是y2）
三重循环 一：遍历x1 二：遍历y2 三：遍历公共 也就是y1或x2
第一行第一个数值
由 1 2 3（第一个数组的行 分别乘上
7 9 1（第二个数组的列 相加得到第一个 由此可推
第一行第二个数值
1 2 3
8 0 2
第二行第一个
4 5 6
7 9 1
第二行第二个
4 5 6
8 0 2
****7-68 re阶乘计算（高精度算法 日后再回头复习第一个方法？
嘿嘿这个方法比较难 建议直接使用BigInteger
import java.math.BigInteger;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int len=1;
int[] a=new int[1000];
a[0]=1;
for(int i=2;i<=n;i++){
int t=0;
for(int j=0;j<len;j++){//但这个循环实际是从前往后进行运算 进位也是前往后进位 所以之后需要逆序输出
int sum=a[j]*i+t;//总和 用作过渡
a[j]=sum%10;//表示当前位
t=sum/10;//进位且方便加入下一位计算
if(t!=0 && j==len-1)
{
len++;
}
}
}
for (int i=len-1;i>=0;i--){
System.out.print(a[i]);
}
}
}
import java.math.BigInteger;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
BigInteger big=new BigInteger("1");
for (int i = 1; i <= n; i++) {
big=big.multiply(BigInteger.valueOf(i));
}
System.out.println(big);
}
}请记住biginteger是math库里的 用uilt.*会报错噢噢噢噢
big=big.multiply(BigInteger.valueof(i))
BigInteger.valueof(i)转换成超级大数 记一下语法欸欸欸欸
7-69 re字母图形
// import java.math.BigInteger;
// import java.util.*;
// public class Main {
// public static void main(String[] args) {
// Scanner scanner = new Scanner(System.in);
// int n = scanner.nextInt();
// int m = scanner.nextInt();
// char [][] arr = new char[n][m];
// for(int i = 0; i < n; i++) {
// for(int j = 0; j < m; j++) {
// char c=((char) ('A'+Math.abs(i-j)));
// //A+(i与j之间的差值) 0 1 2 3 4 5 6
// // 1 0 1 2 3 4 5
// // 2 1 0 1 2 3 4...
// System.out.printf("%c",c);
// }
// System.out.println();
// }
// }
// }
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
System.out.printf("%c",('A'+Math.abs(i-j)));
}
System.out.println();
}
}
}**re7-71 特殊回文数
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for (int i = 10000; i < 1000000; i++) {
if(ishw(i)){
if(sum(i)==n){
System.out.println(i);
}
}
}
}
public static boolean ishw(int n){
String s = Integer.toString(n);
for (int i = 0; i <= s.length()/2; i++){
if (s.charAt(i) !=s.charAt(s.length()-1-i)){
return false;
}
}
return true;
}
public static int sum(int n){
int sum = 0;
while (n!=0){
sum+=n%10;
n/=10;
}
return sum;
}
}** re 7-72 分解质因数
// import java.util.*;
// public class Main {
// public static void main(String[] args) {
// Scanner scanner = new Scanner(System.in);
// int a = scanner.nextInt();
// int b = scanner.nextInt();
// for (int i =a ; i <= b; i++) {
// zys(i);
// System.out.println();
// }
// }
// public static void zys(int n)
// { int flag=1;
// int originalN=n;
// System.out.printf(n+"=");
// for (int i = 2; i*i<= n; i++) {
// while (n % i == 0) {
// if(flag==1)
// {
// System.out.printf("%d", i);
// flag=0;
// }
// else {
// System.out.printf("*%d", i);
// }
// n = n / i;
// }
// }
// if (n == originalN) {//如果n没有变化
// System.out.printf("%d", n);
// } else if (n > 1) { // 如果 n > 1，说明 n 本身是一个质数
// System.out.printf("*%d", n);
// }
// }
// }
import java.math.BigInteger;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a=sc.nextInt();
int b=sc.nextInt();
for (int i=a;i<=b;i++) {
zys(i);
System.out.println();
}
}
static void zys(int n){
System.out.printf(n+"=");
int flag=0;
int ncopy=n;
for (int i=2;i*i<=n;i++) {
if (n%i==0) {
while (n%i==0) {
if(flag==0) {
System.out.printf("%d",i);
flag=1;
}
else{
System.out.printf("*"+i);
}
n/=i;
}
}
}
//如果n没有变化说明n本身就是n的质因数
if(n==ncopy) {
System.out.printf("%d",n);//这个情况就是只有一个数值
}//同时上面那个循环只检查到比n的开方小的数值 不够全面如果有的数值可以%自己的一半==0时 不能被输出 而且此时的n也会大于1所以！
if(n>1 && n!=ncopy) {
System.out.printf("*%d",n);//这个情况有多个数值
}
}
}import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int a=in.nextInt();
int b=in.nextInt();
for (int i = a; i <= b ; i++) {
zys(i);
System.out.println();
}
}
static void zys(int n){
System.out.printf("%d=", n);
int flag = 1;
for (int i = 2; i*i <= n; i++) {
if (n % i == 0) {
while (n % i == 0) {
if(flag == 1){
System.out.printf("%d",i);
flag=0;
}else{
System.out.printf("*%d",i);
}
n /= i;
}
}
}
if(flag == 1){
System.out.printf("%d",n);
}else if(n>1){
System.out.printf("*%d",n);
}
}
}7-75 求1+2+...+n的和
// import java.util.Scanner;
// public class Main {
// public static void main(String[] args) {
// Scanner scanner = new Scanner(System.in);
// int n = scanner.nextInt();
// for(int i=1;i<n;i++){
// System.out.print(i + "+");
// }
// System.out.print(n + "=");
// System.out.println((1 + n )*n/2);
// }
// }
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int sum = 0;
for (int i = 1; i <= n; i++) {
if (i != 1) {
System.out.print("+" + i);
} else {
System.out.print(i);
}
sum += i;
}System.out.printf("=" + sum);
}
}三
7-1 定义完数方法
import java.math.BigInteger;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
if(yes(n))
{
System.out.printf("%d:Yes\n",n);
}
else{
System.out.printf("%d:No\n",n);
}
}
public static boolean yes(int n) {
int sum = 0;
for (int i = 1; i <= n / 2; i++) {
if (n % i == 0) {
sum += i;
}
}
if(sum == n){
return true;
}
return false;
}
}7-2 判断一个点是否在园内
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int n = input.nextInt();
int m = input.nextInt();
int k = input.nextInt();
if(inCircle(n,m,k)){
System.out.println("yes");
}
else {
System.out.println("no");
}
}
public static boolean inCircle(int x,int y,int r){
double sum=Math.sqrt(x*x+y*y);
if(sum<=r){
return true;
}
else{
return false;
}
}
}7-6 re求一元二次方程
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
double a=0,b=0,c=0;
try {
a = input.nextDouble();
b = input.nextDouble();
c = input.nextDouble();
if(a==0){
throw new ArithmeticException();
}
}catch (Exception e){
System.out.println("Wrong Format");
return;
}
int delta=(int)(b*b-4*a*c);
if(delta<0){
System.out.println("The equation has no roots");
return;
}else if(delta==0){
double x1=(-b+Math.sqrt(b*b-4*a*c))/(2*a);
System.out.printf("The equation has one root: %.4f",x1);
return;
}else if(delta>0){
double x1=(-b+Math.sqrt(b*b-4*a*c))/(2*a);
double x2=(-b-Math.sqrt(b*b-4*a*c))/(2*a);
System.out.printf("The equation has two roots: %.4f and %.4f",x1,x2);
}
}
}7-8 自恋的水仙花
import java.math.BigInteger;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int a = input.nextInt();
if(a>=1000 || a<100){
System.out.printf("error\n");
}
else if (isDaffodilf(a)) {
System.out.println("yes");
} else {
System.out.println("no");
}
System.out.println("153");
System.out.println("370");
System.out.println("371");
System.out.println("407");
}
public static boolean isDaffodilf(int num){
int sum=0;
int num2=num;
while (num!=0){
sum+=Math.pow((num%10),3);
num/=10;
}
if(sum==num2){
return true;
}
return false;
}
}**7-9 求某位同学的平均分
// import java.math.BigInteger;
// import java.util.*;
// public class Main {
// public static void main(String[] args) {
// Scanner input = new Scanner(System.in);
// String input1 = input.nextLine();
// String input2 = input.nextLine();
// getAvg(input1);
// getAvg(input2);
// }
// public static void getAvg(String input){
// String[] parts=input.split("\\s+");
// String name = parts[0];
// int sum=0;
// for(int i=1;i<parts.length ;i++){
// sum+=Integer.parseInt(parts[i]);//字符串转换 parse
// }
// int avg=sum/(parts.length-1);
// System.out.printf("%s:%d\n",name,avg);
// }
// }
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String str = input.nextLine();
String str2 = input.nextLine();
getAvg(str);
getAvg(str2);
}
public static void getAvg(String name)
{
String []names = name.split(" ");
int sum=0;
for (int i = 1; i < names.length; i++)
{
sum+=Integer.parseInt(names[i]);
}
System.out.println(names[0]+":"+sum/(names.length-1));
}
}四
7-1 jmu-Java-03面向对象基础-01-构造方法与toString
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int n = input.nextInt();
Person[] persons = new Person[n];//这种写法只是申请空间而已 但创建新对象还需要其他的
for (int i = 0; i < n; i++) {
// persons[i]=new Person();//加上这句才是创建完成
// persons[i].setName(input.next());
// persons[i].setAge(input.nextInt());
// persons[i].setGender(input.nextBoolean()); 这样的写法会导致无参函数的先行调用
String name = input.next();
int age = input.nextInt();
boolean gender = input.nextBoolean();
persons[i]=new Person(name,age,gender,0);
}
for (int i = n-1; i >=0; i--) {
System.out.println(persons[i].toString());
}
Person P=new Person();
System.out.println(P.toString());
}
}
class Person {
private String name;
private int age;
private boolean gender;
private int id;
Person() {
System.out.println("This is constructor");
System.out.println(name+","+age+","+gender+","+id);//这里+this和不加的区别
}
Person(String name, int age, boolean gender, int id) {
this.name = name;
this.age = age;
this.gender = gender;
this.id = id;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public void setGender(boolean gender) {
this.gender = gender;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public boolean getGender() {
return gender;
}
public int getId() {
return id;
}
@Override
public String toString() {
return "Person [" +
"name=" + name +
", age=" + age +
", gender=" + gender +
", id=" + id +
']';
}
}**re 7-2 jmu-Java-03面向对象基础-02-构造方法与初始化块
这里涉及到了
-
静态初始化块（static{}）：用于初始化静态变量。静态初始化块在类首次被加载到JVM时执行，且只执行一次。它们按照在类中出现的顺序执行。
-
非静态初始化块（{}）：用于初始化实例变量。非静态初始化块在每次创建类的实例时执行。它们在构造函数之前执行，并且按照在类中出现的顺序执行。
做题过程中有个问题：
最开始我将id直接作为静态变量使用 导致输出错误
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int n = input.nextInt();
Person[] persons = new Person[n];
for (int i = 0; i < n; i++) {
String name = input.next();
int age = input.nextInt();
boolean gender = input.nextBoolean();
persons[i] = new Person(name,age,gender);
}
for (int i = 0; i < n; i++) {
System.out.println(persons[i].toString());
}
Person person = new Person();
System.out.println(person);
}
}
class Person {
private String name;
private boolean gender;
private int age;
private static int id=0;
static{
System.out.println("This is static initialization block");
}
Person() {
System.out.println("This is constructor ");
System.out.println(name+","+age+","+gender+","+id);
}
Person(String name, int age, boolean gender) {
this.name = name;
this.gender = gender;
this.age = age;
}
{
System.out.println("This is initialization block, id is "+id);
id++;
}
@Override
public String toString() {
return "Person[" +
"name=" + name +
", gender=" + gender +
", age=" + age +", id=" + id +
']';
}
}运行结果为
This is static initialization block
This is initialization block, id is 0
This is initialization block, id is 1
This is initialization block, id is 2
Person[name=a, gender=false, age=11, id=3]
Person[name=b, gender=true, age=12, id=3]
Person[name=c, gender=false, age=10, id=3]
This is initialization block, id is 3
This is constructor
null,0,false,4
Person[name=null, gender=false, age=0, id=4]
中间的id一致为3 这是因为id设置为static之后每个 Person 对象共享同一个 id 值，而不是每个对象有自己的 id 值。在new的过程中使id增加到了3 导致后续输出也都是3
那么如何解决呢？
可以重新定义一个static的count用来计算id数值 在初始化块中将id=count；count++；这就使得每个对象有自己的 id 值
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int n = input.nextInt();
Person[] persons = new Person[n];
for (int i = 0; i < n; i++) {
String name = input.next();
int age = input.nextInt();
boolean gender = input.nextBoolean();
persons[i] = new Person(name,age,gender);
}
for (int i = n-1; i >=0; i--) {
System.out.println(persons[i].toString());
}
Person person = new Person();
System.out.println(person);
}
}
class Person {
private String name;
private boolean gender;
private int age;
private int id;
private static int count=0;
static{
System.out.println("This is static initialization block");
}
Person() {
System.out.println("This is constructor");
System.out.println(name+","+age+","+gender+","+id);
}
Person(String name, int age, boolean gender) {
this.name = name;
this.gender = gender;
this.age = age;
}
{
id=count;
System.out.println("This is initialization block, id is "+id);
count++;
}
@Override
public String toString() {
return "Person [" +
"name=" + name +", age=" + age +
", gender=" + gender +
", id=" + id +
']';
}
}结果
This is static initialization block
This is initialization block, id is 0
This is initialization block, id is 1
This is initialization block, id is 2
Person [name=c, age=10, gender=false, id=2]
Person [name=b, age=12, gender=true, id=1]
Person [name=a, age=11, gender=false, id=0]
This is initialization block, id is 3
This is constructor
null,0,false,3
Person [name=null, age=0, gender=false, id=3]
7-4 jmu-Java-03面向对象基础-04-形状-继承
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int n = input.nextInt();
Shape [] shapes = new Shape[n];
for (int i = 0; i < n; i++) {
// String str = input.nextLine();
String str = input.next();//不要用上面那个 多了换行试试
if(str.equals("rect")){
int width = input.nextInt();
int length = input.nextInt();
shapes[i] = new Rectangle(width,length);
}else{
int radius = input.nextInt();
shapes[i] = new Circle(radius);
}
}
double sumAllArea=0;
double sumAllPerimeter=0;
for(int i=0;i<n;i++){
sumAllArea+=shapes[i].getArea();
sumAllPerimeter+=shapes[i].getPerimeter();
}
System.out.println(sumAllPerimeter);
System.out.println(sumAllArea);
System.out.println(Arrays.toString(shapes));
for(int j=0;j<n;j++){
System.out.println(shapes[j].getClass()+","+shapes[j].getClass().getSuperclass());
}
}
}
abstract class Shape{
final double PI=3.14;
abstract public double getPerimeter();//抽象父类的方法也是抽象的
abstract public double getArea();
}
class Rectangle extends Shape {
int width,length;
Rectangle(int width,int length){
this.width=width;
this.length=length;
}
public double getPerimeter(){
return (width+length)*2;
}
public double getArea(){
return width*length;
}
@Override
public String toString() {
return "Rectangle [" +
"width=" + width +
", length=" + length +
']';
}
}
class Circle extends Shape {
int radius;
Circle(int radius){
this.radius=radius;
}
public int getRadius() {
return radius;
}
public double getPerimeter(){
return 2*PI*radius;
}
public double getArea(){
return PI*radius*radius;
}
@Override
public String toString() {
return "Circle [" +
"radius=" + radius +
']';
}
}-
next()方法：-
next()方法读取下一个完整的 token（标记）。一个 token 是由空白字符（空格、制表符、换行符等）分隔的字符串序列中的一部分。 -
next()方法会跳过任何前导空白字符，然后读取下一个 token。这意味着它不会读取空格，而是将其视为分隔符。 -
如果输入中包含空格，
next()方法只会读取空格前的部分。
-
-
nextLine()方法：-
nextLine()方法读取一行输入，直到遇到换行符（\n）或输入结束。 -
它不会跳过任何空白字符，包括空格和换行符，而是将它们包含在读取的字符串中。
-
所以以后只要不需要整行的输入就用next吧 不要用nextline了
***re7-5 jmu-Java-03面向对象基础-05-覆盖
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int n1 = input.nextInt();
ArrayList <PersonOverride> persons1=new ArrayList<>();
for(int i=0;i<n1;i++){
// persons1 [i]=new PersonOverride();这种写法是错误的
//正确写法有两种 1.PersonOverride persons=new PersonOverride();
// persons1.add(persons);
// 2.persons1.add(new PersonOverride());
persons1.add(new PersonOverride());
}
int n2 = input.nextInt();
ArrayList <PersonOverride> persons2=new ArrayList<>();
for(int j=0;j<n2;j++){
String name = input.next();
int age = input.nextInt();
boolean gender = input.nextBoolean();
PersonOverride person=new PersonOverride(name,age,gender);
// if(persons2.contains(person)==false){
// persons2.add(person);
// }用这种方法是行不通的
int flag=0;
for(PersonOverride p:persons2){
if(p.equals(person)){//使用equals函数时必须重写 要不然只比较引用 但只比较引用远远不够
flag=1;
}
}
if(flag==0){
persons2.add(person);
}
}
for(PersonOverride person:persons1){
System.out.println(person);
}
for(PersonOverride person:persons2){
System.out.println(person);
}
System.out.println(persons2.size());
System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));
//使用这个函数时必须构造函数前缀有public 且输出的顺序和构造函数的顺序有关
}
}
class PersonOverride{
private String name;
private int age;
private boolean gender;
public PersonOverride() {
this("default",1,true);
}
public PersonOverride(String name, int age, boolean gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
@Override
public String toString() {
return name + "-" + age + "-" + gender;
}
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
//是否为同一个对象的引用 引用就是new出来的变量的地址
if(obj==null || this.getClass()!=obj.getClass()) return false;
//引用为空或者类名不同
PersonOverride obj1=(PersonOverride)obj;
return this.name.equals(obj1.name) && this.age==obj1.age && this.gender==obj1.gender;
}
}import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n1=in.nextInt();
PersonOverride []persons1=new PersonOverride[n1];
for(int i=0;i<n1;i++) {
persons1[i] = new PersonOverride();
}
int n2=in.nextInt();
ArrayList<PersonOverride> persons2=new ArrayList<>();
for (int i=0;i<n2;i++)
{
PersonOverride person = new PersonOverride(in.next(), in.nextInt(), in.nextBoolean());
// if(persons2.equals(person))这种写法也是错的
if(persons2.contains(person))
//contains是一整个里是否包含一个 而equals方法是一个一个比较 没有遍历的情况下 就是错误的写法
{
}else{
persons2.add(person);
}
}
// System.out.println(persons1);此时直接打印数组会有问题
//为什么会有问题呢？ java中直接打印数组是打印数组的地址 那什么情况下可以打印数组呢 我写在代码之外
for(PersonOverride person:persons1){
System.out.println(person);
}
for (PersonOverride person:persons2){
System.out.println(person);
}
System.out.println(persons2.size());
System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));
}
}
class PersonOverride{
private String name;
private int age;
private boolean gender;
public PersonOverride() {
this("default",1,true);
}
public PersonOverride(String name, int age, boolean gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
public void setAge(int age) {
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public void setGender(boolean gender) {
this.gender = gender;
}
@Override
public String toString() {
return name + "-" + age + "-" + gender;
}
@Override
public boolean equals(Object o) {
if (o == null || getClass() != o.getClass()) return false;
PersonOverride that = (PersonOverride) o;
return age == that.age && gender == that.gender && Objects.equals(name, that.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age, gender);
}
}
如果你定义了一个数组并直接打印它，但看到的不是数组的引用地址，而是数组的内容，那么可能是因为你使用了某种方式对数组进行了格式化输出，而不是直接打印数组对象本身。
在Java中，数组本身没有重写toString方法，因此直接打印数组对象通常会输出其引用地址（例如[LPersonOverride;@1051b1c3）。但是，如果你使用了Arrays.toString方法或其他方式对数组进行了格式化，那么输出就会是数组的内容。
示例分析
假设你定义了一个数组并打印它，但看到的是数组的内容，而不是引用地址。这可能是以下几种情况之一：
1. 使用了Arrays.toString方法
如果你在打印数组时使用了Arrays.toString方法，那么输出会是数组的内容。例如：
java复制
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] arr = {1, 23, 4, 5};
System.out.println(Arrays.toString(arr)); // 使用 Arrays.toString 方法
}
}输出结果：
[1, 23, 4, 5]
2. 使用了Arrays.deepToString方法
如果你的数组是多维数组，你可能使用了Arrays.deepToString方法。例如：
java复制
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[][] arr = {{1, 23}, {4, 5}};
System.out.println(Arrays.deepToString(arr)); // 使用 Arrays.deepToString 方法
}
}输出结果：
[[1, 23], [4, 5]]
3. 手动遍历数组
如果你手动遍历数组并打印每个元素，那么输出也会是数组的内容。例如：
java复制
public class Main {
public static void main(String[] args) {
int[] arr = {1, 23, 4, 5};
for (int num : arr) {
System.out.print(num + " ");
}
}
}输出结果：
1 23 4 5
4. 使用了其他库或工具
如果你使用了某些库（如Apache Commons Lang的ArrayUtils）或其他工具来格式化数组，那么输出也可能是数组的内容。
你的代码中的问题
在你的代码中，你定义了一个PersonOverride数组persons1，并使用了无参构造器初始化它。如果你直接打印persons1，而没有使用Arrays.toString方法，那么输出会是数组的引用地址，而不是数组的内容。
java复制
PersonOverride[] persons1 = new PersonOverride[3];
for (int i = 0; i < 3; i++) {
persons1[i] = new PersonOverride(); // 使用无参构造器初始化
}
System.out.println(persons1); // 直接打印数组对象输出结果：
[LPersonOverride;@1051b1c3
如果你希望打印数组的内容，应该使用Arrays.toString方法：
java复制
import java.util.Arrays;
System.out.println(Arrays.toString(persons1)); // 使用 Arrays.toString 方法输出结果：
[default-1-true, default-1-true, default-1-true]
总结
-
直接打印数组对象：会输出数组的引用地址（例如
[LPersonOverride;@1051b1c3）。 -
使用
Arrays.toString方法：会输出数组的内容（例如[default-1-true, default-1-true, default-1-true]）。 -
使用
Arrays.deepToString方法：会输出多维数组的内容。 -
手动遍历数组：也可以输出数组的内容。
如果你看到的是数组的内容而不是引用地址，那么很可能是因为你使用了某种方式对数组进行了格式化输出。
还有错误代码实例
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n1=in.nextInt();
PersonOverride []persons1=new PersonOverride[n1];
for(int i=0;i<n1;i++) {
persons1[i] = new PersonOverride();
}
int n2=in.nextInt();
ArrayList<PersonOverride> persons2=new ArrayList<>();
for (int i=0;i<n2;i++)
{
PersonOverride person = new PersonOverride(in.next(), in.nextInt(), in.nextBoolean());
// if(persons2.equals(person))这种写法也是错的
if(persons2.contains(person))
{
}else{
persons2.add(person);
}
}
// System.out.println(persons1);此时直接打印数组会有问题
System.out.println(persons1.toString());
System.out.println(persons2.toString());
//而在这里person1和person2相同的清空下为什么打印的效果不同？解答在外
System.out.println(persons2.size());
System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));
}
}
class PersonOverride{
private String name;
private int age;
private boolean gender;
public PersonOverride() {
this("default",1,true);
}
public PersonOverride(String name, int age, boolean gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
public void setAge(int age) {
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public void setGender(boolean gender) {
this.gender = gender;
}
@Override
public String toString() {
return name + "-" + age + "-" + gender;
}
@Override
public boolean equals(Object o) {
if (o == null || getClass() != o.getClass()) return false;
PersonOverride that = (PersonOverride) o;
return age == that.age && gender == that.gender && Objects.equals(name, that.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age, gender);
}
}
person1和person2相同的清空下为什么打印的效果不同？
-
因为
persons2是一个集合（ArrayList），而persons1是一个数组，它们的打印行为才会不同。这是因为它们的toString方法的实现方式不同。核心原因
-
数组（
persons1）：-
数组是Java的基本数据结构，它继承自
Object类，但没有重写toString方法。 -
默认情况下，数组的
toString方法会返回数组的类名和哈希码（内存地址），例如[LPersonOverride;@1051b1c3。 -
如果你想打印数组的内容，需要显式地使用
Arrays.toString方法来格式化输出。
-
-
集合（
persons2）：-
ArrayList是一个集合类，它继承自AbstractList，并重写了toString方法。 -
ArrayList的toString方法会遍历集合中的每个元素，并调用每个元素的toString方法，最终生成一个格式化的字符串，例如[Alice-25-true, Bob-30-false]。 -
因此，你可以直接打印
ArrayList的内容，而不需要额外的格式化方法。
-
7-7 定义类与创建对象
public class Main {
public static void main(String[] args) {
Person per1 = new Person("lili",19);
Person per2 = new Person("lucy",20);
}
}
class Person
{
String name;
int age;
Person(){
}
Person(String name,int age){
this.name=name;
this.age=age;
System.out.printf("this person is %s,her age is %d\n",name,age);
}
}这题的重点应该就是被调用的构造函数会执行函数里的所有命令
7-9 re职工排序题
类的比较没写 复习的时候写一下
import java.util.*;
public class Main {
public static void main(String[] args) {
ArrayList<Staff> arr = new ArrayList<>();
arr.add(new Staff(1,500,400,"职工1","female"));
arr.add(new Staff(2,400,600,"职工2","female"));
arr.add(new Staff(3,600,300,"职工3","male"));
arr.add(new Staff(4,800,200,"职工4","female"));
arr.add(new Staff(5,500,700,"职工5","male"));
Collections.sort(arr);
System.out.println("编号,团险,个险,姓名,性别");
for(Staff i : arr) {
System.out.println(i.toString());
}
}
}
class Staff implements Comparable<Staff> {
int id;
int tx;
int gx;
String name;
String gender;
Staff(int id, int tx, int gx, String name, String gender) {
this.id = id;
this.tx = tx;
this.gx = gx;
this.name = name;
this.gender = gender;
}
@Override
public int compareTo(Staff o) {
return this.tx - o.tx+this.gx - o.gx;
}
@Override
public String toString() {
return id+","+tx+","+gx+","+name+","+gender;
}
}
在Java中，Collections.sort和List的sort方法虽然都用于对集合进行排序，但它们的使用方式和适用场景有所不同。你提到的两种写法——Collections.sort(arr); 和 arr.sort(new newComparator());——在语法和语义上存在明显差异，原因在于它们的调用方式和上下文不同。
1. Collections.sort方法
Collections.sort是一个静态方法，用于对实现了List接口的集合进行排序。它的签名如下：
java复制
public static <T extends Comparable<? super T>> void sort(List<T> list)或者：
java复制
public static <T> void sort(List<T> list, Comparator<? super T> c)-
第一个版本：适用于集合中的元素实现了
Comparable接口的情况。 -
第二个版本：允许你传入一个自定义的
Comparator来定义排序规则。
示例代码
java复制
import java.util.*;
public class Main {
public static void main(String[] args) {
List<PersonOverride> list = new ArrayList<>();
list.add(new PersonOverride("Alice", 25, true));
list.add(new PersonOverride("Bob", 30, false));
// 使用自定义 Comparator
Collections.sort(list, new Comparator<PersonOverride>() {
@Override
public int compare(PersonOverride p1, PersonOverride p2) {
return Integer.compare(p1.age, p2.age); // 按年龄排序
}
});
System.out.println(list);
}
}2. List的sort方法
从Java 8开始，List接口提供了一个sort方法，用于对列表进行排序。它的签名如下：
java复制
default void sort(Comparator<? super E> c)这个方法允许你直接在列表上调用sort方法，并传入一个Comparator来定义排序规则。
示例代码
java复制
import java.util.*;
public class Main {
public static void main(String[] args) {
List<PersonOverride> list = new ArrayList<>();
list.add(new PersonOverride("Alice", 25, true));
list.add(new PersonOverride("Bob", 30, false));
// 使用自定义 Comparator
list.sort(new Comparator<PersonOverride>() {
@Override
public int compare(PersonOverride p1, PersonOverride p2) {
return Integer.compare(p1.age, p2.age); // 按年龄排序
}
});
System.out.println(list);
}
}3. 为什么写法不同
-
Collections.sort：-
是一个静态方法，属于
Collections工具类。 -
需要显式地传入一个
List对象作为参数。 -
适用于所有实现了
List接口的集合类型。 -
在Java 8之前，这是对集合进行排序的主要方式。
-
-
List的sort方法：-
是一个实例方法，直接定义在
List接口中。 -
需要在列表对象上调用，不需要显式传入列表本身。
-
是Java 8引入的新特性，利用了默认方法（default method）的特性。
-
提供了更简洁的语法，尤其是在Lambda表达式的支持下，代码更加简洁。
-
4. 关于arr.sort(new newComparator());的写法
你的代码中提到的arr.sort(new newComparator());存在一些问题：
-
如果
arr是一个数组，而不是一个List，那么它没有sort方法。数组的排序应该使用Arrays.sort方法。 -
如果
arr是一个List，那么new newComparator()的写法是不正确的。应该传入一个实现了Comparator接口的对象。
正确的写法应该是：
java复制
arr.sort(new Comparator<PersonOverride>() {
@Override
public int compare(PersonOverride p1, PersonOverride p2) {
return Integer.compare(p1.age, p2.age); // 按年龄排序
}
});或者，如果你使用的是Java 8及以上版本，可以使用Lambda表达式：
java复制
arr.sort((p1, p2) -> Integer.compare(p1.age, p2.age));总结
-
Collections.sort：适用于所有List类型的集合，需要显式传入List对象。 -
List的sort方法：是Java 8引入的新特性，直接在List对象上调用，语法更简洁。 -
如果你使用的是数组（而不是
List），应该使用Arrays.sort方法来排序。
compareTo 方法
-
定义：
compareTo是Comparable接口的方法。 -
参数：它只有一个参数，通常是同一个类的实例。这个方法用于比较当前对象（
this）与传入的对象（参数）。 -
目的：它用于定义对象的自然排序规则，即对象如何基于其属性值进行排序。
-
返回值：返回一个整数，表示当前对象和参数对象之间的排序关系。
-
负整数：如果当前对象小于参数对象。
-
零：如果当前对象等于参数对象。
-
正整数：如果当前对象大于参数对象。
-
compare 方法
-
定义：
compare是Comparator接口的方法。 -
参数：它有两个参数，通常是任意类型的两个对象。这两个对象可以是相同类的对象，也可以是不同类型的对象，只要
Comparator能够理解如何比较它们。 -
目的：它提供了一种灵活的方式来定义对象之间的比较规则，这些规则不必与对象的自然排序相关。
-
返回值：同样返回一个整数，表示两个对象之间的排序关系。
-
负整数：如果第一个参数小于第二个参数。
-
零：如果两个参数相等。
-
正整数：如果第一个参数大于第二个参数。
-
comparable---compareTo
comparetor--compare
-
import java.util.*; public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); ArrayList<Staff> arr = new ArrayList<>(); arr.add(new Staff(1,500,400,"职工1","female")); arr.add(new Staff(2,400,600,"职工2","female")); arr.add(new Staff(3,600,300,"职工3","male")); arr.add(new Staff(4,800,200,"职工4","female")); arr.add(new Staff(5,500,700,"职工5","male")); Collections.sort(arr);//类中重新定义了排序方法 System.out.println("编号,团险,个险,姓名,性别"); for(Staff i : arr) { System.out.println(i.toString()); } arr.sort(new newComparator());//()中的是排序的实现方法 System.out.println("编号,团险,个险,姓名,性别"); for(Staff i : arr) { System.out.println(i.toString()); } } } class Staff implements Comparable<Staff> {//<Staff>表示该类（在这个例子中是 Staff 类）将提供用于比较自身类型对象的逻辑。 // 这种泛型用法是为了指定 compareTo 方法将操作的对象类型。 int id; int tx; int gx; String name; String gender; Staff(int id, int tx, int gx, String name, String gender) { this.id = id; this.tx = tx; this.gx = gx; this.name = name; this.gender = gender; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getId() { return id; } public int getGx() { return gx; } public int getTx() { return tx; } public String getGender() { return gender; } @Override public String toString() { return getId()+","+getTx()+","+getGx()+","+getName()+","+getGender(); } @Override public int compareTo(Staff other){//处理多个 int num=this.tx-other.tx+this.gx-other.gx; if(num>0){ return 1; }else if(num<0){ return -1; } return num; } } class newComparator implements Comparator<Staff>{//处理两个 public int compare(Staff o1, Staff o2){ if(o1.tx<o2.tx){ return -1; } else if(o1.tx>o2.tx){ return 1; } return 0; } }
7-10 构造方法
import java.util.Scanner;
public class Main {
public Main(){
System.out.println("构造方法一被调用了");
}
public Main(int x){
this();
System.out.println("构造方法二被调用了");
}
public Main(boolean b){
this(1);
System.out.println("构造方法三被调用了");
}
public static void main(String[] args) {
new Main(true);
}
}把Main看成自己定义的一个类 然后在主函数里调用 因为有this的缘故所以会不断调用上一层
7-11 构造方法
public class Main {
public static void main(String[] args) {
RR rr = new RR(true);
}
}
class RR{
public RR(){
System.out.print("8");
}
public RR(int x){
this();
System.out.print(".");
}
public RR(boolean b){
this(1);
System.out.print("00");
}
}7-13 定义类
7-14 定义类2
7-15 计算年龄
7-16 re程序改错题3
// public class Main {
// public static void main(String[] args) {
// Person[] p = new Person[3];
// p[1]=new Person("lisi",20);
// p[0]=new Person("zhangsan",18);
// p[2]=new Person("wangwu",22);
// for (int i = 0; i < p.length; i++) {
// System.out.println(p[i]);
// }
// }
// }
// class Person {
// private String name;
// private int age;
// public Person(String name, int age) {
// super();
// this.name = name;
// this.age = age;
// }
// public String toString(){
// return name+" "+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;
// }
// }
import java.util.*;
public class Main {
public static void main(String[] args) {
Person[] p = new Person[3];
// 第一种：使用无参构造器初始化并设置属性
p[0] = new Person(); // 确保 Person 类有无参构造器
p[0].setName("zhangsan");
p[0].setAge(18);
// 第二种：使用有参构造器初始化
p[1] = new Person("lisi", 20);
// 第三种：初始化后直接访问成员变量
p[2] = new Person(); // 初始化对象
p[2].name = "wangwu"; // 直接访问成员变量（不推荐，但可以工作）
p[2].age = 22;
for (int i = 0; i < p.length; i++) {
System.out.println(p[i]);
}
}
}
class Person {
String name; // 包级私有访问权限
int age; // 包级私有访问权限
Person() {} // 无参构造器
public Person(String name, int age) {
super();
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 name +" "+ age;
}
}7-17 程序填空题1
import java.util.ArrayList;
public class Main{
private ArrayList slist = new ArrayList();
public void addStudent(Student s){
this.slist.add(s);
}
public void showStudent(){
for(Object s:slist){//在这里进行了转化
System.out.println(s);
}
}
public static void main(String[] args) {
Main t = new Main();
t.addStudent(new Student("2016001","rose",18));
t.addStudent(new Student("2016002","hunifu",19));
t.addStudent(new Student("2016003","britsh",20));
t.addStudent(new Student("2016004","sunni",17));
t.showStudent();
}
}
class Student {
String stuNo;
String name;
int age;
public Student(String stuNo,String name,int age){
this.stuNo = stuNo;
this.name = name;
this.age = age;
}
public String toString(){
return stuNo+" "+name+" "+age;
}
}有类型不匹配的情况用object就解决啦
7-21 通过键盘输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。
import java.util.*;
public class Main {
public static void main(String[] args) {
int zm=0,sz=0,kg=0,qt=0;
Scanner sc=new Scanner(System.in);
String str=sc.nextLine();
for(int i=0;i<str.length();i++){
char n=str.charAt(i);
if(n>='0'&&n<='9'){
sz++;
}else if(n>='a'&&n<='z' || n>='A' && n<='Z'){
zm++;
}else if(n==' '){
kg++;
}else{
qt++;
}
}
System.out.println("字母个数："+zm);
System.out.println("数字个数："+sz);
System.out.println("空格个数："+kg);
System.out.println("其他字符个数："+qt);
}
}7-22 数组元素交换
import java.util.ArrayList;
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String []str=input.nextLine().split(" ");
int [] arr=new int[str.length];
for(int i=0;i<str.length;i++){
arr[i]=Integer.parseInt(str[i]);
}
int maxindex=0;
int minindex=0;
for(int i=0;i<arr.length;i++){
if(arr[i]>arr[maxindex]){
maxindex=i;
}
if(arr[i]<arr[minindex]){
minindex=i;
}
}
for(Integer i:arr){
System.out.println(i);
}
swap(arr,maxindex,0);
swap(arr,minindex,arr.length-1);
for(Integer i:arr){
System.out.println(i);
}
}
static void swap(int []a,int index,int numindex){
int temp=a[index];
a[index]=a[numindex];
a[numindex]=temp;
}
}
7-26 正方形类
这个就只有用set是可以设置条件的一个知识点
import java.util.Scanner;
public class Main {
public static void main(String args[]) {
square sq = new square();
System.out.println("s1:edge="+sq.getEdge());
System.out.println("s1:area="+sq.getArea());
Scanner input = new Scanner(System.in);
int m = input.nextInt();
square sq1=new square(m);
System.out.println("s2:edge="+sq1.getEdge());
System.out.println("s2:area="+sq1.getArea());
}
}
class square{
private int edge;
public square() {
this.edge=2;
System.out.println("this is constructor method");
}
public square(int n) {
this.edge=n>0?n:1;
System.out.println("this is constructor method");
}
public void setEdge(int edge) {
this.edge =(edge<=0?1:edge);
}
public int getEdge() {
return edge;
}
public int getArea()
{
return edge*edge;
}
}7-28 点
import java.awt.*;
import java.util.Objects;
import java.util.Scanner;
class Main{
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
Point p1 = new Point(sc.nextInt(),sc.nextInt());
Point p2 = new Point(sc.nextInt(),sc.nextInt());
System.out.println(p1.toString());
int c=p1.compareTo(p2);
if(c>=0){
System.out.println("true");
}else{
System.out.println("false");
}
System.out.println(p1.distance(p2));
}
}
class Point implements Comparable<Point>{
int x;
int y;
public Point(int x,int y){
this.x=x;
this.y=y;
}
public Point(){}
public void setY(int y) {
this.y = y;
}
public void setX(int x) {
this.x = x;
}
public int getX() {
return x;
}
public int getY() {
return y;
}
@Override
public String toString() {
return "Point [" +
"x=" + x +
", y=" + y +
']';
}
@Override
public boolean equals(Object o) {
if (o == null || getClass() != o.getClass()) return false;
Point point = (Point) o;
return x == point.x && y == point.y;
}
@Override
public int hashCode() {
return super.hashCode();
}
@Override
public int compareTo(Point o) {
if(this.x>o.x){
return 1;
}else if(this.x<o.x){
return -1;
}else{
if(this.y>o.y){
return 1;
}
else if(this.y<o.y){
return -1;
}
}
return 0;
}
int distance(Point p2){
return (int)(Math.sqrt((this.x-p2.x)*(this.x-p2.x)+(this.y-p2.y)*(this.y-p2.y)));
}
}
**re7-44 两点成线
Line 包裹着point所以也一直存储着中间输入的信息
import java.util.Scanner;
class Line{
private Point p1;
private Point p2;
Line(){}
public Line(Point p1,Point p2) {
this.p1 = p1;
this.p2 = p2;
}
public double getLength(){
return p1.distance(p2);
}
public Point getP1() {
return p1;
}
public void setP1(Point p1) {
this.p1 = p1;
}
public Point getP2() {
return p2;
}
public void setP2(Point p2) {
this.p2 = p2;
}
@Override
public String toString() {
return "Line [p1=" + p1 + ", p2=" + p2 + "]";
}
}
class Point {
private int x, y;// x,y为点的坐标
//求两点之间的距离
public double distance(Point p1) {
return Math.sqrt((p1.x -this.x)*(p1.x -this.x)+(p1.y-this.y)*(p1.y-this.y));
}
public Point(int x, int y) {
super();
this.x = x;
this.y = y;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
public Point() {
super();
x = y =0;
}
@Override
public String toString() {
return "Point [x=" + x + ", y=" + y + "]";
}
}
public class Main {
public static void main(String[] args) {
Scanner sc= new Scanner(System.in);
int n = sc.nextInt();
Line []line = new Line[n];
for(int i=0;i<n;i++){
Point p1 = new Point(sc.nextInt(),sc.nextInt());
Point p2 = new Point(sc.nextInt(),sc.nextInt());
line[i]=new Line(p1,p2);
}
for(int i = 0;i<n;i++){
System.out.println(line[i].toString());
System.out.printf("此线段的长度为：%.1f\n",line[i].getLength());
}
}
}import java.util.*;
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
ArrayList<Line> lines = new ArrayList<>();
for (int i = 0; i < n; i++) {
Point p1=new Point(sc.nextInt(),sc.nextInt());
Point p2=new Point(sc.nextInt(),sc.nextInt());
lines.add(new Line(p1,p2));
}
for (Line line : lines) {
System.out.println(line);
System.out.printf("此线段的长度为：%.1f\n",line.getLength());
}
}
}
class Point {
private int x, y;// x,y为点的坐标
//求两点之间的距离
public double distance(Point p1) {
return Math.sqrt((p1.x -this.x)*(p1.x -this.x)+(p1.y-this.y)*(p1.y-this.y));
}
public Point(int x, int y) {
super();
this.x = x;
this.y = y;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
public Point() {
super();
x = y =0;
}
@Override
public String toString() {
return "Point [x=" + x + ", y=" + y + "]";
}
}
class Line{
Point p1, p2;
public Line(Point p1, Point p2) {
this.p1 = p1;
this.p2 = p2;
}
public Point getP1() {
return p1;
}
public void setP1(Point p1) {
this.p1 = p1;
}
public void setP2(Point p2) {
this.p2 = p2;
}
public Point getP2() {
return p2;
}
double getLength(){
return p1.distance(p2);
}
@Override
public String toString() {
return "Line [p1=" + p1 + ", p2=" + p2 + "]";
}
}7-45 查询某人 懒得写了明天写第五章有一样的题目
7-46 时间类 直接输出就可以了
五
7-1 jmu-Java-04面向对象进阶--02-接口-Comparator
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int n = input.nextInt();
PersonSortable2 []persons = new PersonSortable2[n];
for(int i = 0; i < n; i++){
persons[i]=new PersonSortable2(input.next(),input.nextInt());
}
Arrays.sort(persons,new NameComparator());
System.out.println("NameComparator:sort");
for(PersonSortable2 person:persons){
System.out.println(person);
}
Arrays.sort(persons,new AgeComparator());
System.out.println("AgeComparator:sort");
for(PersonSortable2 person:persons){
System.out.println(person);
}
System.out.println(Arrays.toString(NameComparator.class.getInterfaces()));
System.out.println(Arrays.toString(AgeComparator.class.getInterfaces()));
}
}
class PersonSortable2{
private String name;
private int age;
PersonSortable2(String name, int age){
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return
name +
"-" + age ;
}
}
class NameComparator implements Comparator<PersonSortable2>{
@Override
public int compare(PersonSortable2 o1, PersonSortable2 o2) {
// if (o1.getName().compareToIgnoreCase(o2.getName()) == 0){
// return 0;
// }
// if (o1.getName().compareToIgnoreCase(o2.getName()) == -1){
// return -1;
// }
// return 1;compareTo比较时区分大小写 compareToIgnoreCase不区分
return o1.getName().compareTo(o2.getName());
}
}
class AgeComparator implements Comparator<PersonSortable2>{
@Override
public int compare(PersonSortable2 o1, PersonSortable2 o2) {
if(o1.getAge() > o2.getAge()){
return 1;
}
else if(o1.getAge() < o2.getAge()){
return -1;
}
return 0;
}
}Collections.sort(persons,new AgeComparator());和Arrays.sort(persons,new AgeComparator());
这两行代码都用于对名为 persons 的列表进行排序，但它们使用了不同的方法来实现排序，并且适用于不同类型的 persons 集合。让我们逐一了解这两种方法：
1. Collections.sort(persons, new AgeComparator());
这行代码使用 Collections.sort() 方法对实现了 List 接口的集合（如 ArrayList）进行排序。Collections.sort() 是一个静态方法，它接收两个参数：
-
第一个参数是
persons，这是一个List集合。 -
第二个参数是
new AgeComparator()，这是一个Comparator实例，用于定义排序规则。
AgeComparator 是一个实现了 Comparator 接口的类，它定义了如何比较两个对象。在这个例子中，AgeComparator 可能定义了基于年龄的比较规则。
java复制
class AgeComparator implements Comparator<Staff> {
public int compare(Staff o1, Staff o2) {
return Integer.compare(o1.getAge(), o2.getAge());
}
}2. Arrays.sort(persons, new AgeComparator());
这行代码使用 Arrays.sort() 方法对数组进行排序。Arrays.sort() 也是一个静态方法，它同样接收两个参数：
-
第一个参数是
persons，这是一个数组。 -
第二个参数是
new AgeComparator()，这是一个Comparator实例，用于定义排序规则。
然而，需要注意的是，Arrays.sort() 方法的第二个参数实际上是一个 Comparator 接口的实现，但这个方法本身并不接受 Comparator 作为参数。实际上，Arrays.sort() 方法只接受一个数组作为参数，并直接对其进行排序。如果你想根据某个特定的规则对数组进行排序，你需要使用 Arrays.sort() 方法的重载版本，如下所示：
java复制
class AgeComparator implements Comparator<Staff> {
public int compare(Staff o1, Staff o2) {
return Integer.compare(o1.getAge(), o2.getAge());
}
}
// 假设 persons 是一个 Staff 类型的数组
Staff[] persons = new Staff[5];
// 初始化 persons 数组...
// 使用 Arrays.sort() 进行排序
Arrays.sort(persons, new Comparator<Staff>() {
public int compare(Staff o1, Staff o2) {
return Integer.compare(o1.getAge(), o2.getAge());
}
});在这个例子中，我们创建了一个匿名内部类实现了 Comparator 接口，并将其传递给 Arrays.sort() 方法。
总结
-
Collections.sort()用于对List集合进行排序。 -
Arrays.sort()用于对数组进行排序，但不接受Comparator作为参数。如果你需要根据特定规则对数组排序，你需要使用Arrays.sort()方法的重载版本。
7-2 jmu-Java-04面向对象进阶-03-接口-自定义接口ArrayIntegerStack
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int n = input.nextInt();
ArrayIntegerStack stack = new ArrayIntegerStack(n);
int m=input.nextInt();
for(int i=0;i<m;i++){
System.out.println(stack.push(input.nextInt()));
}
System.out.println(stack.peek() + "," + stack.empty() + "," + stack.size());
System.out.println(stack.toString());
int x=input.nextInt();
for(int i=0;i<x;i++){
System.out.println(stack.pop());
}
System.out.println(stack.peek() + "," + stack.empty() + "," + stack.size());
System.out.println(stack.toString());
}
}
interface IntegerStack{
public Integer push(Integer item);
//如果item为null，则不入栈直接返回null。如果栈满，也返回null。如果插入成功，返回item。
public Integer pop(); //出栈，如果为空，则返回null。出栈时只移动栈顶指针，相应位置不置为null
public Integer peek(); //获得栈顶元素，如果为空，则返回null.
public boolean empty(); //如果为空返回true
public int size(); //返回栈中元素个数
}
class ArrayIntegerStack implements IntegerStack{
//int []A; int和Integer是有区别的 Integer可以储存null
Integer []A;
int max;
static int size=0;
public ArrayIntegerStack(int n){
// 局部变量 vs 实例变量：
//局部变量：在方法内部定义的变量，作用域仅限于该方法。在构造函数中，Integer[] A是一个局部变量，它只在构造函数内部有效。
//实例变量：在类中定义的变量，作用域是整个类。this.A指的是当前对象的实例变量A。
// Integer []A=new Integer[n];//在这里建立数组模拟 但这种写法是错误的 只能改变局部的数值
this.A=new Integer[n];//但这样就改变了实例变量
this.max=n;//max赋值
}
public Integer push(Integer item){
if(item==null || size==max){
return null;
}//输入的数值==null或者已经达到最大size
A[size++]=item;
return item;
}
public Integer pop(){
if(size==0){
return null;
}
size--;
return A[size];
}
public Integer peek(){
if(size==0){
return null;
}
return A[size-1];
}
public boolean empty(){
if(size==0){
return true;
}
return false;
}
public int size(){
return size;
}
@Override
public String toString() {
return Arrays.toString(A);
}
}***7-4 re找到共同的选修课
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int n = input.nextInt();
input.nextLine();
StringBuilder str = new StringBuilder();
for(int i = 0; i < n; i++){
str.append(input.nextLine().split(":")[1]).append(" ");//牢记 这句话的意识是取：后的内容并添加" "
}
String []arr=str.toString().split(" ");
int flag=0;
for (int i = 0; i < arr.length; i++) {
int count = 1;//从1开始 因为arr[i]也算一个
for (int j = i + 1; j < arr.length; j++) {
if (arr[i].equals(arr[j])) {
count++;
}
}
if (count == n ) {
System.out.println(arr[i]);
flag = 1;
}
}
if (flag == 0){
System.out.println("none");
}
}
}str.append(input.nextLine().split(":")[1]).append(" ");//牢记 这句话的意识是取：后的内容并添加" "
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int n = input.nextInt();
input.nextLine();
StringBuilder str = new StringBuilder();
for (int i = 0; i < n; i++) {
str.append(input.nextLine().split(":")[1]).append(" ");
}
String []arr = str.toString().split(" ");
HashMap<String, Integer> map = new HashMap<>();
for (String string : arr) {
map.put(string,map.getOrDefault(string,0)+1);
}
int f=0;
for (Map.Entry<String, Integer> et : map.entrySet()) {
if(et.getValue()>1){
System.out.println(et.getKey());
f=1;
}
}
if(f==0){
System.out.println("none");
}
}
}
7-5 re编程题：选修课成绩统计问题
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String []data=input.nextLine().split(",");
for(int i=0;i<data.length;i++){
String []score=data[i].split(" ");
int sum=0;
String name="";
for(int j=0;j<score.length;j++){
name=score[0];
switch (score[j]){
case "A":{sum+=5;}break;
case "B":{sum+=4;}break;
case "C":{sum+=3;}break;
case "D":{sum+=2;}break;
case "E":{sum+=1;}break;
}
}
if(i==data.length-1){
System.out.print(name+" "+sum);
}else{
System.out.print(name+" "+sum+",");
}
}
}
}思路：懒得写了
7-12 re集体评分
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int[] grade = new int[5];
for(int i=0; i<grade.length; i++){
grade[i] = in.nextInt();
}
RR rr = new RT(grade);
double dd = rr.mark();
System.out.printf("%.2f",dd);
}
}
abstract class RR{
int[] grade;
public RR(int[] grade){
this.grade = grade;
}
public abstract double mark();
}
class RT extends RR{
// int[] grade;子类 RT 中定义了自己的成员变量 grade，
// 这会隐藏父类 RR 中的成员变量 grade。因此，
// 即使你调用了 super(grade);，父类的成员变量 grade 也不会被正确初始化，
// 而子类中的 grade 也不会被正确赋值。
RT(int[] grade){
super(grade);
}//子类的构造方法必须显式或隐式地调用父类的构造方法。如果父类的构造方法需要参数，子类的构造方法必须显式地调用它。
//如果你直接写 this.grade = grade;，而没有调用父类的构造方法，编译器会报错，因为父类的构造方法需要参数。
public double mark(){
return (grade[1]+grade[2]+grade[3])/3;
}
}
7-13 集体评分2
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int[] grade = new int[5];
for(int i=0; i<grade.length; i++){
grade[i] = in.nextInt();
}
RR rr = new RT(grade);
double dd = rr.mark();
System.out.printf("%.2f",dd);
}
}
interface RR{
double mark();
}
class RT implements RR{
int[] grade;
public RT(int[] grade){
this.grade = grade;
}
public double mark(){
return (double)(grade[1]+grade[2]+grade[3])/3.0;
}
}*7-14 re程序改错题2
public class Main {
public static void main(String[] args) {
Animal animal = new Dog();
animal.shout();
animal.run();
}
}
class Animal {
void shout() {
System.out.println("animal shout！");
}
void run() {
System.out.println("animal run");
}
}
class Dog extends Animal {
void shout() {
super.shout();//调用了父类就会先跑到父类实现 然后再回来 不调用就不会
System.out.println("wangwang……");
}
void run() {
System.out.println("Dog is running");
}
}这个不是正确答案看看就可以了
public class Main {
public static void main(String[] args) {
// Animal animal = new Dog();//引用类型是Animal 如果是Dog的话就不会报错
//方法的解析和调用行为确实依赖于两个关键因素：引用类型 和 实际对象类型。这两个因素在多态中起着不同的作用。
Dog animal = new Dog();
animal.shout();
animal.run();//即使 animal 实际上是一个 Dog 对象，但它的引用类型是 Animal。
// 在 Java 中，方法的解析是基于引用类型，而不是实际对象的类型。
// 因此，编译器只会检查 Animal 类中是否存在 run 方法，而不会检查实际对象的类型。
}
}
class Animal {
void run() {
// System.out.println("Dog is running");这一整个run都是后面添加的
}
void shout() {
System.out.println("animal shout！");
}
}
class Dog extends Animal {
void shout() {
super.shout();
System.out.println("wangwang……");
}
void run() {
System.out.println("Dog is running");
}
}在 Java 中，方法的解析和调用行为确实依赖于两个关键因素：引用类型 和 实际对象类型。这两个因素在多态中起着不同的作用。
引用类型和实际对象类型
-
引用类型：
-
引用类型决定了编译时的方法解析。编译器会检查引用类型中是否存在该方法。
-
如果引用类型中没有该方法，即使实际对象中有该方法，编译器也会报错。
-
-
实际对象类型：
-
实际对象类型决定了运行时的方法调用。运行时，JVM 会根据实际对象的类型来调用相应的方法。
-
如果方法是虚方法（非
final和非static方法），JVM 会动态绑定到实际对象的方法。
-
编译时检查
-
animal的引用类型是Animal。 -
Animal类中定义了shout方法，因此animal.shout()可以通过编译。 -
Animal类中没有定义run方法，因此animal.run()无法通过编译。
运行时行为
-
实际上，
animal指向的是一个Dog对象。 -
如果
run方法在Animal类中定义，运行时会调用Dog类中重写的run方法（如果有的话）。 -
但由于
run方法没有在Animal类中定义，编译器在编译阶段就会报错，根本不会到达运行时。
总结：所以是检查是从引用开始检查 但是实际使用的话是从dog的类使用
*7-15 程序填空题3
public class Main {
public static void main(String[] args) {
Son son = new Son();
son.method();
}
}
class Parent {
Parent() {
System.out.println("Parent's Constructor without parameter");
}
Parent(boolean b) {
System.out.println("Parent's Constructor with a boolean parameter");
}
public void method() {
System.out.println("Parent's method()");
}
}
class Son extends Parent {
Son() {
super(true);
}
public void method() {
System.out.println("Son's Constructor without parameter\n" +
"Son's method()");
super.method();//在构造方法中，super()或this()必须作为构造方法的第一条语句，以确保父类构造方法在子类构造方法之前执行。
//在普通方法中，super.method()的调用位置没有限制，可以放在方法体的任何位置。
}
}7-19 re设计圆和圆柱体挑个时间写吧 有点累了
7-21 re设计一个Shape及其子类Oval
import java.util.Comparator;
import java.util.*;
public class Main{
public static void main(String args[]) {
Scanner input = new Scanner(System.in);
int a=input.nextInt();
int b=input.nextInt();
Oval oval = new Oval(a, b);
System.out.println("The area of "+oval.toString()+" is "+oval.area());
System.out.println("The perimeterof "+oval.toString()+" is "+oval.perimeter());
}
}
abstract class Shape{
double Pi=3.1415926;
abstract double area();
abstract double perimeter();
}
class Oval extends Shape{
double PI=3.1415926;//也可以不要这个 如果不要的话下面的PI要改成super.PI
private double a,b;
Oval(double a,double b){
this.a=a;
this.b=b;
}
Oval(){
this.a=0;
this.b=0;
}
double area(){
return a*b*PI;
}
double perimeter(){
return 2*Pi*Math.sqrt(((a*a)+(b*b))/2);
}
public double getA() {
return a;
}
public double getB() {
return b;
}
@Override
public String toString() {
return "Oval(a:"+getA()+",b:"+getB()+")";
}
}
class ShapeTest{
}抽象类的核心规则
-
- 不能直接实例化：
- 抽象类本身不能被直接实例化，即不能使用
new关键字创建抽象类的对象。 - 例如：
Shape shape = new Shape();是非法的，因为Shape是抽象类。
- 抽象类本身不能被直接实例化，即不能使用
- 可以作为引用类型：
- 抽象类可以作为其他类的父类，也可以作为引用类型指向其子类的实例。
- 例如：
Shape shape = new Oval(a, b);是合法的，因为Oval是Shape的子类。
- 不能直接实例化：
7-27 re jmu-Java-05集合(泛型)-10-GeneralStack 这个懒得写
1：用sum求和时因为stack.pop也会改变stack.size 所以一开始就要用一个变量来获取size
2：重点 要额外关注car 题中第二个测试点 在pop>push的情况下 int和double类型都会返回null sum不做添加 但car类型比较不一样
Car 的处理逻辑：（car不是求和 而是输出剩余的name 先new一个car对象这里假设是（car1）来存储每次的pop 再输出car1.getName 如果此时是null的话就导致异常）
-
在处理
Car类型时，你需要从栈中取出Car对象，并调用其getName方法来获取name属性。如果栈为空，pop方法会返回null，直接调用getName方法会导致NullPointerException。因此，你需要显式地检查栈是否为空，以避免这种异常。
import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
while (true) {
String str = input.next();
if (str.equals("quit")) {
break;
}else{
int m=input.nextInt();
int n=input.nextInt();
ArrayListGeneralStack stack=new ArrayListGeneralStack();
if(str.equals("Integer")){
System.out.println("Integer Test");
for(int i=0;i<m;i++){
System.out.println("push:"+stack.push(input.nextInt()));
}
for(int i=0;i<n;i++){
System.out.println("pop:"+stack.pop());
}
System.out.println(stack.toString());
int sum=0;
int size=stack.size();
for(int i=0;i<size;i++){
sum+=(int)stack.pop();
}
System.out.println("sum="+sum);
}else if(str.equals("Double")){
System.out.println("Double Test");
for(int i=0;i<m;i++){
System.out.println("push:"+stack.push(input.nextDouble()));
}
for(int i=0;i<n;i++){
System.out.println("pop:"+stack.pop());
}
System.out.println(stack.toString());
double sum=0;
int size=stack.size();
for(int i=0;i< size;i++){
sum+=(double)stack.pop();
}
System.out.println("sum="+sum);
}else if(str.equals("Car")){
System.out.println("Car Test");
for(int i=0;i<m;i++){
Car car=new Car(input.nextInt(),input.next());
System.out.println("push:"+stack.push(car));
}
for(int i=0;i<n;i++){
System.out.println("pop:"+stack.pop());
}
System.out.println(stack.toString());
if(stack.size()>0){
int size=stack.size();
for(int i=0;i<size;i++){
Car car2=(Car) stack.pop();
System.out.println(car2.getName());
}}
}
}
System.out.println("interface GeneralStack");
}
}
}
interface GeneralStack{
Object push(Object item); //如item为null，则不入栈直接返回null。
Object pop(); //出栈，如为栈为空，则返回null。
Object peek(); //获得栈顶元素，如为空，则返回null.
public boolean empty();//如为空返回true
public int size(); //返回栈中元素数量
}
class ArrayListGeneralStack implements GeneralStack{
ArrayList<Object> items=new ArrayList<>();
public Object push(Object item){
if(item==null){
return null;
}
items.add(item);
return item;
}
public Object pop(){
if(items.size()==0){
return null;
}else{
return items.remove(items.size()-1);
}
}
public Object peek(){
// if(items==null){//null 表示变量没有指向任何对象。 没有初始化
if(items.size()==0){//集合已经被初始化，但其中没有元素。
return null;
}
return items.get(items.size()-1);
}
public boolean empty(){
return items.isEmpty();
}
public int size(){
return items.size();
}
public String toString(){
return items.toString();
}
}
class Car{
private int id;
private String name;
public Car() {
}
public Car(int id, String name) {
this.id = id;
this.name = name;
}
/**
* 获取
* @return id
*/
public int getId() {
return id;
}
/**
* 设置
* @param id
*/
public void setId(int id) {
this.id = id;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
public String toString() {
return "Car [id=" + id + ", name=" + name + "]";
}
}import java.util.*;
interface GeneralStack{
public Object push(Object item);
public Object pop();
public Object peek();
public boolean empty();
public int size();
}
class ArrayListGeneralStack implements GeneralStack{
ArrayList list = new ArrayList();
//重写接口的方法
//Object 是 Java 中的一个预定义类，它是所有类的父类。
//使用 Object 类作为参数类型意味着这个方法可以接受任何类型的对象作为输入。
@Override
//如item为null，则不入栈直接返回null。
public Object push(Object item){
if(item==null){
return null;
}else{
list.add(item);
return item;//入栈的同时作为输出结果
}
}
@Override
//出栈，如为栈为空，则返回null。
public Object pop(){
if(list.size()==0){
return null;
}else{
return list.remove(list.size()-1);
}
}
@Override
//获得栈顶元素，如为空，则返回null.
public Object peek(){
if(list.size()==0){
return null;
}else{
return list.get(list.size()-1);
}
}
@Override
//如为空返回true
public boolean empty(){
if(list.size()==0){
return true;
}else{
return false;
}
}
@Override
//返回栈中元素数量
public int size(){
return list.size();
}
@Override
public String toString(){
return list.toString();
}
}
class Car{
private int id;
private String name;
public int getId(){
return id;
}
public String getName(){
return name;
}
public void setName(String name){
this.name=name;
}
public void setId(int id){
this.id=id;
}
Car(int id,String name){
this.id=id;
this.name=name;
}
public String toString(){
return "Car [id="+id+", name="+name+"]";
}
}
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
while (true){
String s=sc.nextLine();
if (s.equals("Double")){
System.out.println("Double Test");
int count=sc.nextInt();
int pop_time=sc.nextInt();//出栈次数
ArrayListGeneralStack arrayListGeneralStack = new ArrayListGeneralStack();
for (int i=0;i<count;i++){
System.out.println("push:"+arrayListGeneralStack.push(sc.nextDouble()));
}
for (int i=0;i<pop_time;i++){
System.out.println("pop:"+arrayListGeneralStack.pop());
}
System.out.println(arrayListGeneralStack.toString());
double sum=0;
int size=arrayListGeneralStack.size();
for (int i=0;i<size;i++){
sum+=(double)arrayListGeneralStack.pop();
}
System.out.println("sum="+sum);
System.out.println("interface GeneralStack");
}else if (s.equals("Integer")){
System.out.println("Integer Test");
int count=sc.nextInt();
int pop_time=sc.nextInt();
ArrayListGeneralStack arrayListGeneralStack = new ArrayListGeneralStack();
for (int i=0;i<count;i++){
System.out.println("push:"+arrayListGeneralStack.push(sc.nextInt()));
}
for (int i=0;i<pop_time;i++){
System.out.println("pop:"+arrayListGeneralStack.pop());
}
System.out.println(arrayListGeneralStack.toString());
int sum=0;
int size=arrayListGeneralStack.size();
for (int i=0;i<size;i++){
sum+=(int)arrayListGeneralStack.pop();
}
System.out.println("sum="+sum);
System.out.println("interface GeneralStack");
}else if (s.equals("Car")){
System.out.println("Car Test");
int count=sc.nextInt();
int pop_time=sc.nextInt();
ArrayListGeneralStack arrayListGeneralStack = new ArrayListGeneralStack();
for (int i=0;i<count;i++){
int id=sc.nextInt();
String name=sc.next();
Car car = new Car(id,name);
System.out.println("push:"+arrayListGeneralStack.push(car));
}
for (int i=0;i<pop_time;i++){
System.out.println("pop:"+arrayListGeneralStack.pop());
}
System.out.println(arrayListGeneralStack.toString());
if (arrayListGeneralStack.size()>0){
int size=arrayListGeneralStack.size();
for (int i=0;i<size;i++){
Car car=(Car) arrayListGeneralStack.pop();
System.out.println(car.getName());
}
}
System.out.println("interface GeneralStack");
}else if (s.equals("quit")){
break;
}
}
}
}六 re ctrl+alt+t
***re7-1 jmu-Java-06异常-01-常见异常
// import java.util.*;
// //TIP To <b>Run</b> code, press <shortcut actionId="Run"/> or
// // click the <icon src="AllIcons.Actions.Execute"/> icon in the gutter.
// public class Main {
// public static void main(String[] args) {
// Scanner sc = new Scanner(System.in);
// int arr[]=new int[5];
// while (true)
// {
// String str = sc.next();
// try {
// if ("arr".equals(str)) {
// int index=sc.nextInt();
// int num=arr[index];
// } else if ("null".equals(str)) {
// throw new NullPointerException();
// } else if ("cast".equals(str)) {
// Object obj=new String("abc");
// Integer num=(Integer)obj;//为什么错误？讲解在csdn 类型转换
// } else if ("num".equals(str)) {
// String str2=sc.next();
// Integer num=Integer.parseInt(str2);//这里为什么异常？当试图将一个字符串解析为数字，
// // 但字符串的格式不符合数字的格式要求时异常。如果输入的是数值就可以 但题中输入的是字母
// }
// else {
// break;
// }
// }catch (Exception e) {
// System.out.println(e);
// }
// }
// }
// }
import java.util.Comparator;
import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int arr[]=new int[5];
while(input.hasNext()){
String str = input.next();
try {
if (str.equals("arr")) {
int n = input.nextInt();
int num=arr[n];
} else if (str.equals("null")) {
// throw NullPointerException;这个写法错误//在 Java 中，当你想要手动抛出一个异常时，
// 必须使用 new 关键字来创建一个异常对象。这是因为异常本质上是一个对象，
// 而 throw 语句需要抛出一个具体的对象实例，而不是类本身。
throw new NullPointerException();
} else if (str.equals("cast")) {//cast用obj做中介
Object a="abc";
Integer b=(Integer)a;
}
else if (str.equals("num")) {
String a=input.next();
int num=Integer.parseInt(a);
}else{
break;
}
}catch (Exception e){
System.out.println(e);
}
}
}
}**7-2 jmu-Java-06异常-02-使用异常机制处理异常输入
import java.util.*;
//TIP To <b>Run</b> code, press <shortcut actionId="Run"/> or
// click the <icon src="AllIcons.Actions.Execute"/> icon in the gutter.
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int arr[]=new int[n];
int index=0;
for (int i = 0; i < n; ) {
try {
String str=sc.next();
arr[i] = Integer.parseInt(str);//捕捉到错误就直接去catch了
i++;//输入正确才会增加
//nteger.parseInt() 是一个标准的方法，用于将字符串解析为整数。
// 如果输入的内容是有效的整数格式（如 "123"），解析会成功；
// 如果输入的内容不是整数格式（如 "abc" 或 "123.45"），解析会失败并抛出 NumberFormatException。
}catch (NumberFormatException e) {
System.out.println(e);
}
}
System.out.println(Arrays.toString(arr));
}
}**7-3 rejmu-Java-06异常-03-throw与throws
//findMax 方法被声明为可能会抛出异常（通过 throws 关键字）。 //调用 findMax 方法时，必须处理这些可能的异常。如果没有正确处理这些异常，编译器会报错。
1. throw
- 用途：用于在代码中显式地抛出一个异常对象。
- 用法：通常用于在检测到错误条件时，主动抛出异常以中断程序流程。
- 示例：
java复制代码public static void validateAge(int age) {if (age < 0) {throw new IllegalArgumentException("年龄不能为负数");}}- 在这个方法中，如果
age小于0，会抛出IllegalArgumentException异常。
- 在这个方法中，如果
2. throws
- 用途：用于在方法声明中声明该方法可能抛出的异常类型。
- 用法：表示该方法不处理这些异常，而是将异常传递给调用者处理。
- 示例：
java复制代码public static void readFile(String path) throws IOException {// 读取文件内容，可能抛出IOException}
import java.util.Comparator;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int n = input.nextInt();
double []arr = new double[n];
for (int i = 0; i < n; i++) {
arr[i] = input.nextDouble();
}
// while (input.hasNext()){// 按行读取 这个方法行不通 因为最后一行有end 而end在题目中是不被读取的
while (input.hasNextInt()){//或者input.hasNextDouble()也可以 作用是持续读取直到遇到非数字
try{
int begin=input.nextInt();
int end=input.nextInt();
ArrayUtils ar=new ArrayUtils();
System.out.println(ar.findMax(arr,begin,end));
}catch(IllegalArgumentException e){
System.out.println(e);
}
}
try {
System.out.println(ArrayUtils.class.getDeclaredMethod("findMax", double[].class,int.class,int.class));
} catch (Exception e1) {
}
}
}
class ArrayUtils{
public static double findMax(double[] arr,int begin, int end) throws IllegalArgumentException{
if(begin>=end){
throw new IllegalArgumentException("begin:"+begin+" >= end:"+end);
}
else if(begin<0){
throw new IllegalArgumentException("begin:"+begin+" < 0");
}else if(end>arr.length){
throw new IllegalArgumentException("end:"+end+" > arr.length");
}
double max=arr[begin];
for(int i=begin;i<end;i++){
if(arr[i]>max){
max=arr[i];
}
}
return max;
}
}
在 Java 中，是否需要使用 new 关键字来创建对象，取决于你想要使用的功能是类的静态成员还是实例成员。以下是详细的解释：
1. 静态成员（Static Members）
静态成员属于类本身，而不是类的某个具体实例。静态成员包括静态方法和静态变量。你可以直接通过类名来访问静态成员，而不需要创建类的实例。
示例：静态方法
java复制
class ArrayUtils {
public static double findMax(double[] arr, int begin, int end) {
// 方法实现
}
}调用静态方法时，不需要创建类的实例：
java复制
double max = ArrayUtils.findMax(arr, begin, end);示例：静态变量
java复制
class Constants {
public static final double PI = 3.14159;
}访问静态变量时，也不需要创建类的实例：
java复制
double pi = Constants.PI;2. 实例成员（Instance Members）
实例成员属于类的某个具体实例，而不是类本身。实例成员包括实例方法和实例变量。要访问实例成员，必须先创建类的实例。
示例：实例方法
java复制
class Calculator {
public double add(double a, double b) {
return a + b;
}
}调用实例方法时，需要先创建类的实例：
java复制
Calculator calc = new Calculator(); // 创建实例
double result = calc.add(2.5, 3.5); // 通过实例调用方法示例：实例变量
java复制
class Person {
private String name;
public Person(String name) {
this.name = name;
}
public String getName() {
return name;
}
}访问实例变量时，也需要先创建类的实例：
java复制
Person person = new Person("Alice"); // 创建实例
String name = person.getName(); // 通过实例访问变量3. 为什么有时候需要 new 一个
-
访问实例成员：当你需要调用实例方法或访问实例变量时，必须先创建类的实例。这是因为实例成员是属于某个具体对象的，而不是类本身。
-
动态分配内存：
new关键字用于在堆内存中动态分配内存，并初始化对象。每次调用new都会创建一个新的对象实例。
4. 总结
-
静态成员：属于类本身，可以通过类名直接访问，不需要创建实例。
-
实例成员：属于类的某个具体实例，必须先创建类的实例，然后通过实例访问。
****7-4 jmu-Java-06异常-04-自定义异常(综合)
import java.util.NoSuchElementException;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (true) {
String str = sc.nextLine();
try {
if (str.equals("new")) {
String [] arr = sc.nextLine().split(" ");
if(arr.length==2){
Student s = new Student();
s.setName(arr[0]);
s.addScore(Integer.parseInt(arr[1]));
System.out.println(s);
}else{
System.out.println("java.util.NoSuchElementException");
}
}else{
break;
}
}
catch (Exception e) {
System.out.println(e);
}
}
System.out.println("scanner closed");
}
}
class IllegalScoreException extends Exception {
public IllegalScoreException () {
}
public IllegalScoreException (String message) {
super(message);
}
}
class IllegalNameException extends RuntimeException {
public IllegalNameException () {
}
public IllegalNameException (String message) {
super(message);
}
}
class Student {
private String name;
private int score;
public Student() {
}
public Student(String name, int score) {
this.name = name;
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {//而这个不需要抛出
this.name = name;
if(this.name.charAt(0)>='0' && this.name.charAt(0)<='9') {
throw new IllegalNameException("the first char of name must not be digit, name="+name);
}
this.name = name;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public int addScore (int score)throws IllegalScoreException {//为什么这个需要在签名里声明呢？因为这个是checked exception
this.score+=score;
if(score<0 || score>100){
throw new IllegalScoreException("score out of range, score="+score);
}
return score;
}
public String toString() {
return "Student [name=" + name + ", score=" + score + "]";
}
} import java.util.Comparator;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(sc.hasNextLine()) {
String s = sc.nextLine();
if(s.equals("new")) {
String[] words = sc.nextLine().split(" ");
if(words.length == 2) {
Student stu = new Student();
stu.setName(words[0]);
stu.setScore(Integer.parseInt(words[1]));
if(stu.getMis()!=true){
System.out.println(stu.toString());
}
}
else {
System.out.println("java.util.NoSuchElementException");
}
}else{
break;
}
}
sc.close();
System.out.println("scanner closed");
}
}
class IllegalScoreException extends Exception {
public IllegalScoreException(String message) {
super(message);
}
}
class IllegalNameException extends Exception {
public IllegalNameException(String message) {
super(message);
}
}
class Student {
private String name;
private int score;
private static boolean mis=false;
Student() {}
public Student(String name, int score) {
this.name = name;
this.score = score;
}
public boolean getMis() {
return mis;
}
public String getName() {
return name;
}
public int getScore() {
return score;
}
public void setName(String name) {
// throw new IllegalNameException(name);要配合try{}catch使用
try {
if(name.charAt(0)>='0' &&name.charAt(0)<='9') {
mis=true;
throw new IllegalNameException("IllegalNameException: the first char of name must not be digit, name="+name);
}else{
this.name = name;
mis=false;
}
}catch(IllegalNameException e) {
System.out.println(e.getMessage());
}
}
public void setScore(int score) {
if (mis==true) {
return;
}try {
if (score < 0 || score > 100) {
mis=true;
throw new IllegalScoreException("IllegalScoreException: score out of range, score=" + score);
}else{
this.score = score;
mis=false;
}
} catch (IllegalScoreException e) {
System.out.println(e.getMessage());
}
}
public int addScore(int score){
return 0;
}
@Override
public String toString() {
return "Student [name=" + name + ", score=" + score + ']';
}
}
**re7-5 天不假年
哈哈哈哈哈哈哈我发现就是System.err.println打出来的是红色的 改成System.out.println这题第二个测试点就对了
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner in = new Scanner(System.in);
int age;
age = in.nextInt();
Person p = new Person(age);
age = in.nextInt();
try{
p.setAge(age);
}catch(AgeException e){
System.out.println("B");//就在这System.err.println是错的
return;
}
System.out.println("A");
}
}
class Person{
int age;
public Person(int age){
this.age = age;
}
public void setAge(int age) throws AgeException {
if(this.age <=age){
this.age = age;
}else{
throw new AgeException();
}
}
}
class AgeException extends Exception{
AgeException(){
}
}import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner in = new Scanner(System.in);
int age;
age = in.nextInt();
Person p = new Person(age);
age = in.nextInt();
try{
p.setAge(age);
}catch(AgeException e){//如果捕获异常了
System.out.println("B");
return;
}
System.out.println("A");
}
}
class Person{
int age;
public Person(int age){
this.age = age;
}
public void setAge(int age) throws AgeException {
if(this.age <=age){
this.age = age;
}else{
throw new AgeException();
}
}
}
class AgeException extends Exception{
Ag
}7-6 成绩录入时的及格与不及格人数统计
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int score=0;
int pass=0;
int nopass=0;
for(int i = 0; i < n; ){
try{
score = in.nextInt();
if(score < 0 || score > 100){
throw new IllegalArgumentException();
}
if(score >= 60){
pass++;
}else {
nopass++;
}
i++;
}catch(Exception e){
System.out.println(score+"invalid!");
}
}
System.out.println(pass);
System.out.println(nopass);
}
}
**7-7 较为复杂情况下的求和
// import java.util.Scanner;
// public class Main {
// public static void main(String[] args) {
// Scanner input = new Scanner(System.in);
// String str = input.nextLine();
// String []arr=str.split(" ");
// int sum=0;
// for(String s:arr){
// try {
// sum += Integer.parseInt(s);
// }catch(NumberFormatException e) {
// continue;
// }
// }
// System.out.println(sum);
// }
// }
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner in = new Scanner(System.in);
Scanner input = new Scanner(System.in);
Scanner input2 = new Scanner(System.in);
String []arr=input.nextLine().split(" ");
int sum=0;
for (int i = 0; i < arr.length; i++) {
try {
sum += Integer.parseInt(arr[i]);
}catch (Exception e){
// continue; 因为有i++ 不需要这个
}
}
System.out.println(sum);
}
}7-8 re **InputMismatchException异常
// import java.util.*;
// public class Main {
// public static void main(String[] args) {
// Scanner scanner = new Scanner(System.in);
// while (scanner.hasNext()) {
// int sum = 0;
// try {
// int num =scanner.nextInt();
// int num2 = scanner.nextInt();
// sum = num + num2;
// // } catch (InputMismatchException e) {
// // System.out.println("Incorrect input: two integers are required");
// // continue;
// // InputMismatchException 和 NumberFormatException 的区别：
// // InputMismatchException 是 Scanner 类中特有的异常，通常在使用 Scanner 的方法（如 nextInt()、nextDouble()）时抛出，表示输入的格式与预期不符。
// // NumberFormatException 是在尝试将字符串解析为数字（如使用 Integer.parseInt() 或 Double.parseDouble()）时抛出的异常。
// }catch (InputMismatchException e){
// System.out.println("Incorrect input: two integer is required");
// scanner.nextLine();//一定要清空缓冲区 否则一直读入错误输入
// continue;
// }
// System.out.println("sum = "+sum);
// }
// }
// }
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner input = new Scanner(System.in);
while(input.hasNext()) {
int sum = 0;
try {
sum += input.nextInt() + input.nextInt();
}catch(Exception e) {
System.out.println("Incorrect input: two integer is required");
input.nextLine();
continue;
}
System.out.println("sum = "+sum);
}
}
}
7-9 设计一个能处理异常的Loan类
// import java.util.Date;
// import java.util.*;
// public class Main {
// public static void main(String[] args) {
// Scanner input = new Scanner(System.in);
// while (input.hasNext()) {
// double AIR = input.nextDouble();
// int NOY = input.nextInt();
// double LA = input.nextDouble();
// try {
// Loan m = new Loan(AIR, NOY, LA);
// if (AIR<=0)throw new IllegalArgumentException("Annual interest rate must be positive");
// else if (NOY<=0)throw new IllegalArgumentException("Number of years must be positive");
// else if (LA<=0)throw new IllegalArgumentException("Loan amount must be positive");
// System.out.printf("%.3f\n",m.getTotalPayment());
// } catch (Exception ex) {
// System.out.println(ex);
// }
// }
// }
// }
// class Loan{
// double annualInterestRate=2.5;
// int numberOfYears=1;
// double loanAmount=100;
// Date loanDate;
// Loan(){}
// Loan(double annualInterestRate, int numberOfYears, double loanAmount) {
// this.annualInterestRate=annualInterestRate;
// this.numberOfYears=numberOfYears;
// this.loanAmount=loanAmount;
// }
// public Date getLoanDate() {
// return loanDate;
// }
// public void setLoanDate(Date loanDate) {
// this.loanDate = loanDate;
// }
// public double getAnnualInterestRate() {
// return annualInterestRate;
// }
// public void setAnnualInterestRate(double annualInterestRate) {
// this.annualInterestRate = annualInterestRate;
// }
// public int getNumberOfYears() {
// return numberOfYears;
// }
// public void setNumberOfYears(int numberOfYears) {
// this.numberOfYears = numberOfYears;
// }
// public double getLoanAmount() {
// return loanAmount;
// }
// public void setLoanAmount(double loanAmount) {
// this.loanAmount = loanAmount;
// }
// public double getMonthlyPayment(){
// double monthRate=annualInterestRate/1200;//注意月利率=年利率/1200;
// return loanAmount*monthRate/(1-(1/Math.pow(1+monthRate,getNumberOfYears()*12)));
// }
// public double getTotalPayment(){
// return getMonthlyPayment()*12*getNumberOfYears();
// }
// }
import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
while (input.hasNext()) {
double AIR = input.nextDouble();
int NOY = input.nextInt();
double LA = input.nextDouble();
try {
Loan m = new Loan(AIR, NOY, LA);
if (AIR<=0)throw new IllegalArgumentException("Annual interest rate must be positive");
else if (NOY<=0)throw new IllegalArgumentException("Number of years must be positive");
else if (LA<=0)throw new IllegalArgumentException("Loan amount must be positive");
System.out.printf("%.3f\n",m.getTotalPayment());
} catch (Exception ex) {
System.out.println(ex);
}
}
}
}
class Loan {
double annualInterestRate=2.5;
int numberOfYears =1;
double loanAmount=100;
Date loanDate=new Date();
Loan(double annualInterestRate, int numberOfYears, double loanAmount) {
this.annualInterestRate=annualInterestRate;
this.numberOfYears=numberOfYears;
this.loanAmount=loanAmount;
this.loanDate=new Date();
}
Loan() {}
public double getAnnualInterestRate() {
return annualInterestRate;
}
public Date getLoanDate() {
return loanDate;
}
public double getLoanAmount() {
return loanAmount;
}
public int getNumberOfYears() {
return numberOfYears;
}
public void setAnnualInterestRate(double annualInterestRate) {
this.annualInterestRate = annualInterestRate;
}
public void setLoanAmount(double loanAmount) {
this.loanAmount = loanAmount;
}
public void setLoanDate(Date loanDate) {
this.loanDate = loanDate;
}
public void setNumberOfYears(int numberOfYears) {
this.numberOfYears = numberOfYears;
}
public double getMonthlyPayment(){
double yll=annualInterestRate/12/100;
return (loanAmount*yll)/(1-(1/Math.pow(1+yll,numberOfYears*12)));
}
public double getTotalPayment(){
return getMonthlyPayment()*12*getNumberOfYears();
}
}7-10 设计一个Tiangle异常类
// import java.util.Date;
// import java.util.*;
// public class Main {
// public static void main(String[] args) {
// Scanner input = new Scanner(System.in);
// double s1 = input.nextDouble();
// double s2 = input.nextDouble();
// double s3 = input.nextDouble();
// try {
// Triangle t = new Triangle(s1,s2,s3);
// System.out.println(t);
// }
// catch (IllegalTriangleException ex) {
// System.out.println("Invalid: "+s1+","+s2+","+s3);
// }
// }
// }
// //class IllegalTriangleException extends Exception{//不能及作为普通类又作为异常类 我黑化了
// // double side1;
// // double side2;
// // double side3;
// // public Triangle(double side1, double side2, double side3) throws IllegalTriangleException {
// // this.side1 = side1;
// // this.side2 = side2;
// // this.side3 = side3;
// // if(side1+side2<=side3 || side2+side3<=side1 || side3+side1<=side2) {
// // throw new IllegalTriangleException();
// // }
// // }
// //
// // @Override
// // public String toString() {
// // return "Triangle [side1=" + side1 + ", side2=" + side2 + ", side3=" + side3 + "]";
// // }
// //}
// class IllegalTriangleException extends Exception{
// IllegalTriangleException(){
// // super("Invalid triangle");
// // super 传递了什么？
// //super("Invalid triangle") 传递了一个字符串 "Invalid triangle"，
// // 这个字符串会被存储为异常的详细消息。
// // 当你调用异常的 getMessage() 方法时，它会返回这个字符串。
// }
// }
// class Triangle {
// private double side1;
// private double side2;
// private double side3;
// // 构造方法
// public Triangle(double side1, double side2, double side3) throws IllegalTriangleException {
// this.side1 = side1;
// this.side2 = side2;
// this.side3 = side3;
// if (side1 + side2 <= side3 || side2 + side3 <= side1 || side3 + side1 <= side2) {
// throw new IllegalTriangleException();
// }
// }
// // Getter 方法
// public double getSide1() {
// return side1;
// }
// public double getSide2() {
// return side2;
// }
// public double getSide3() {
// return side3;
// }
// // 重写 toString 方法
// @Override
// public String toString() {
// return "Triangle [side1=" + side1 + ", side2=" + side2 + ", side3=" + side3 + "]";
// }
// }
import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
double s1 = input.nextDouble();
double s2 = input.nextDouble();
double s3 = input.nextDouble();
try {
Triangle t = new Triangle(s1,s2,s3);
System.out.println(t);
}
catch (IllegalTriangleException ex) {
System.out.println(ex.getMessage());
}
}
}
class IllegalTriangleException extends Exception{
IllegalTriangleException(String message){
super(message);
}
}
class Triangle{
double s1;
double s2;
double s3;
Triangle(double s1,double s2,double s3) throws IllegalTriangleException{
this.s1=s1;
this.s2=s2;
this.s3=s3;
if(s1+s2<=s3||s1+s3<=s2||s2+s3<=s1){
throw new IllegalTriangleException("Invalid: "+s1+","+s2+","+s3);
}
}
@Override
public String toString() {
return "Triangle [" +
"side1=" + s1 +
", side2=" + s2 +
", side3=" + s3 +
']';
}
}
七
**7-1 jmu-Java-02基本语法-08-ArrayList入门
import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
ArrayList<String> strList=new ArrayList<>();
while(true){
String str=input.next();
if(str.equals("!!end!!")){
break;
}
strList.add(str);
}
strList.add(0, "begin"); // 在开头添加 "begin"
strList.add("end"); // 在末尾添加 "end"
System.out.println(strList);//3
String str=input.next();
System.out.println(strList.contains(str));//是否包含 返回bool值 5
System.out.println(strList.indexOf(str));//用来查看strlist中str的位置 前往后 5
System.out.println(strList.lastIndexOf(str));//用来查看strlist中str的位置 后往前 6
System.out.println(strList.remove(0)); System.out.println(strList);//7
String str2=input.next();//8
strList.set(1,str2); System.out.println(strList);//9,10
String str3=input.next();//11
ArrayList<String> strList1=new ArrayList<>();
for(String s: strList){//12
if(s.contains(str3)){
strList1.add(s);
}
}
System.out.println(strList1);//12
// strList.remove(strList.indexOf(str));
strList.remove(str3);
System.out.println(strList);
strList.clear();
System.out.println(strList+","+strList.size()+","+strList.isEmpty());
}
}
代码中有几个要记的函数 还有ArrayList是没有addfirst什么的函数的
而LinkedList 类提供了 addFirst 和 addLast 方法
**7-6 office文档页码打印
**7-8 sdust-Java-字符串集合求并集
import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
HashSet<String> list1=new HashSet<>();
HashSet<String> list2=new HashSet<>();
String []str=input.nextLine().split(" ");
for(int i=0;i<str.length;i++){
if(list1.size()<5){
list1.add(str[i]);
}else if(list2.size()<5){
list2.add(str[i]);
}
}
TreeSet<String> list=new TreeSet<>(list1);
list.addAll(list1);
list.addAll(list2);
for(String s:list){
System.out.println(s);
}
}
}
7-11 有重复的数据
import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int n = input.nextInt();
HashSet<Integer> set = new HashSet<>();
while (n-- > 0) {
int count=set.size();
set.add(input.nextInt());
if(set.size()!=(count+1)){
System.out.println("YES");
return;
}
}
System.out.println("NO");
}
}
7-24 数组元素的删除
方法1（推荐思密达
import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int n = input.nextInt();
ArrayList<Integer> list = new ArrayList<>();
for(int i = 0; i < n; i++){
list.add(input.nextInt());
}
int m = input.nextInt();
for(int i = 0; i < m; i++){
list.remove(input.nextInt()-1);
}
int flag=0;
for (Integer i : list) {
if(flag==0){
System.out.print(i);
flag=1;
}else{
System.out.print(" "+i);
}
}
}
}方法2
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int []arr = new int[n];
int count=0;
for(int a0 = 0; a0 < n; a0++){
arr[a0] = sc.nextInt();
}
int k = sc.nextInt();
count=k;
while(k-- > 0){
int m = sc.nextInt();
//java有特定的函数吗？ 没有的话只能循环类似插入排序
for(int i = m-1; i < arr.length-1; i++){
arr[i]=arr[i+1];
}
}
for(int i =0; i < arr.length-count; i++){
if(i<arr.length-count-1)System.out.print(arr[i]+" ");
else System.out.print(arr[i]);
}
}
}7-25 re打台球
import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int []arr = new int[7];
for(int i=0;i<7;i++){
arr[i] = input.nextInt();
}
int score=0;
if(arr[0]>0){
while(arr[0]>0){
arr[0]--;
score++;
for(int j=6;j>=0;j--){
if(arr[j]>0){
arr[j]--;
arr[j]++;
score+=j+1;
break;
}
}
}
}
for(int j=1;j<7;j++){
score+=arr[j]*(j+1);
}
System.out.println(score);
}
}
思路 1，有红打红 且打最大分的球x1 打完直接break 一直循环到没有红 这个时候彩球打完一个放回一个
2，循环从大到小看那个彩球>0 如果是的话就打 score+=arr[i]*(i+1)
7-26 re有重复的数据I
代码解释
-
InputStreamReader isr = new InputStreamReader(System.in);-
System.in是键盘输入。 -
InputStreamReader把键盘输入从“字节流”变成“字符流”，方便处理文字。
-
-
BufferedReader br = new BufferedReader(isr);-
BufferedReader是一个“升级版”的字符流。 -
它可以让读取文字更高效，还能按行读取文字。
-
-
isr是输入，br是升级版-
isr是基本的字符输入。 -
br是在isr的基础上升级的，功能更强大。
-
-
BufferedReader是一个字符流，它的主要功能是高效地读取文本数据，而它的方法主要围绕读取字符、字符串或行展开。以下是一些常见的BufferedReader方法： -
readLine()-
读取一行文本，返回一个
String类型。
-
-
read()-
读取单个字符，返回一个
int类型的字符编码（ASCII 或 Unicode）。
-
import java.io.*;
import java.util.*;
public class Main{
public static void main(String[] args) throws IOException {
InputStreamReader isr=new InputStreamReader(System.in);//照搬Scaner 只是改成了InputStreamReader而已
BufferedReader br=new BufferedReader(isr);
HashSet<String> set=new HashSet<>();
int n= Integer.parseInt(br.readLine());//这里如果上面没有添加throws IOException的话就会报错 而且输入的类型是String 必须转换成int类型
String str=br.readLine();
String []arr=str.split(" ");
for (int i = 0; i < n; i++) {
set.add(arr[i]);
}
if(set.size()<n){
System.out.println("YES");
}else{
System.out.println("NO");
}
}
}7-27 re御膳房
第一段代码（嵌套循环）
-
条件：
count >= n / 2 + 1 -
解释：统计从当前天开始，后续有多少天是相同的早餐内容。如果从某一天开始，后续有超过一半的天数是相同的早餐内容，那么无法调整成相邻两天不重复。
第二段代码（HashMap）
-
条件：
count > n / 2 + 1 -
解释：统计某种早餐内容在整个数组中的总出现次数。如果某种早餐内容的总出现次数超过总天数的一半加一，那么无法调整成相邻两天不重复。
import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int n = input.nextInt();
int []arr=new int[n];
for(int i = 0; i < n; i++){
arr[i]=input.nextInt();
}
for(int i = 0; i < n; i++){
int count=0;
for(int j = i+1; j < n; j++){
if(arr[i]==arr[j]){
count++;
}
}
if(count>=n/2+1){//这里的条件包括arr[i]本身
System.out.println("NO");
return;
}
}
System.out.println("YES");
}
}import java.io.*;
import java.util.*;
public class Main{
public static void main(String[] args) throws IOException {
Scanner input = new Scanner(System.in);
int n = input.nextInt();
if(n<=1){
System.out.println("YES");
return;
}
HashMap<Integer,Integer> map = new HashMap<>();
for (int i = 0; i < n; i++) {
int num = input.nextInt();
int count=map.getOrDefault(num,0)+1;
map.put(num,count);
if(count>n/2+1){
System.out.println("NO");
return;
}
}
System.out.println("YES");
}
}
**7-29 程序填空题4
import java.util.*;
public class Main {
public static void main(String[] args) {
TreeSet<String> ts = new TreeSet<>();
ts.add("cab");
ts.add("bac");
ts.add("bca");
ts.add("123");
ts.add("abc");
ts.add("acb");
ts.add("cba");
ts.add("cab");
Iterator<String> it = ts.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
}
7-36 re找出最长的单词
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String []str = input.nextLine().split(" ");
Arrays.sort(str, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return -(o1.length() - o2.length());
}
});
System.out.println(str[0]);
}
}import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String []arr=input.nextLine().split(" ");
int count=0;
String a="";
for(int i=0;i<arr.length;i++){
if(arr[i].length()>count){
count=arr[i].length();
a=arr[i];
}
}
System.out.println(a);
}
}7-37 re找到出勤最多的人
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String []str = input.nextLine().split(" ");
HashMap<String,Integer> map = new HashMap<>();
int count=0;int maxcount=0;
for (String s : str) {
count=map.getOrDefault(s,0)+1;
map.put(s,count);
if(count>maxcount){
maxcount=count;
}
}
for (Map.Entry<String, Integer> stringIntegerEntry : map.entrySet()) {
if(stringIntegerEntry.getValue()==maxcount){
System.out.println(stringIntegerEntry.getKey());
}
}
}
}import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String []arr=input.nextLine().split(" ");
Map<String,Integer> map=new HashMap<>();
List<String> list=new ArrayList<>();
int count=0;
int max=0;
for(String s:arr){
count=map.getOrDefault(s,0)+1;
map.put(s,count);//更新之后还要记得赋值
if(count>max){
max=count;
list.clear();
list.add(s);
}else if(count==max){
list.add(s);
}
}
System.out.println(list.get(0));
}
}7-38 删除序列的最大和最小值问题
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String []arr=input.nextLine().split(" ");
List<Integer> list=new ArrayList<>();
for(int i=0;i<arr.length;i++){
list.add(Integer.parseInt(arr[i]));
}
Collections.sort(list);
for(int i=1;i<list.size()-1;i++){
System.out.print(list.get(i));
if(i<list.size()-1-1)
{
System.out.print(" ");
}
}
}
}
**7-41 re约瑟夫环问题
// import java.util.*;
// public class Main {
// public static void main(String[] args) {
// Scanner input = new Scanner(System.in);
// int m = input.nextInt();
// input.nextLine();
// String []str=input.nextLine().split(",");
// ArrayList<String> list = new ArrayList<>(Arrays.asList(str));//asList是什么
// StringBuilder str2 = new StringBuilder();
// int index=0;
// while(list.isEmpty()==false){
// index=(index+m-1)%list.size();
// //index + m - 1：计算从当前起始位置 index 开始，报数到第 m 个人的索引位置。因为索引从 0 开始，所以需要减去 1。
// //% list.size()：对计算结果取模，确保索引位置在列表的范围内。这是因为报数是循环进行的，当报数超过列表末尾时，需要从头开始。
// if(str2.length()>0){
// str2.append(",");
// }
// str2.append(list.remove(index));
// }
// System.out.println(str2.toString());
// }
// }
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int n = input.nextInt();
input.nextLine();
String []s = input.nextLine().split(",");
List<String> list = new ArrayList<>();
StringBuilder str = new StringBuilder();
for(int i=0;i<s.length;i++)
{
list.add(s[i]);
}
int index=0;
while (list.isEmpty()==false)
{
index=(index+n-1)%list.size();
if(str.length()>0)//这边“，”最后一个不用管 因为那个时候已经要退出循环了 管第一个以后的数值就可以
{
str.append(",");
}
str.append(list.remove(index));
}
System.out.println(str.toString());
}
}
待写 re7-42 学术会议地点统计问题
有只输出一个教授的测试点 判断逗号输出方式很重要
package org.example;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
TreeMap<String,Integer> z = new TreeMap<>();
TreeMap<String,Integer> w = new TreeMap<>();
for (int i = 0; i < 2; i++) {
String s = sc.nextLine();
String[] ss = s.split(":");
if(ss[0].equals("z")) {
String []arr=ss[1].split(",");
for (String string : arr) {
String [] ss2 = string.split("\\s+");
z.put(ss2[0],z.getOrDefault(ss2[0],0)+Integer.parseInt(ss2[1]));
}
}else if(ss[0].equals("w")) {
String []arr=ss[1].split(",");
for (String string : arr) {
String [] ss2 = string.split(" ");
w.put(ss2[0],w.getOrDefault(ss2[0],0)+Integer.parseInt(ss2[1]));
}
}
}
// int flag=0;
// for (String s : z.keySet()) {
// if(w.containsKey(s)){
// if(w.get(s)>z.get(s)){
// System.out.print("w:"+s+" "+w.get(s));
// }else {
// System.out.print("z:"+s+" "+z.get(s));
// }
// if(flag==0){
// System.out.print(",");
// }
// flag=1;
// }
// }错误写法 在只输出一个的时候多输出了逗号
int flag=0;
for (String s : z.keySet()) {
if(w.containsKey(s)){
if(flag!=0){
System.out.print(",");
}
flag=1;
if(w.get(s)>z.get(s)){
System.out.print("w:"+s+" "+w.get(s));
}else {
System.out.print("z:"+s+" "+z.get(s));
}
}
}//正确写法 在输出第一个之后若还有输出则输出逗号
if(flag==0){
System.out.print("none");
}
}
}
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
TreeMap<String,Integer> z=new TreeMap<>();
TreeMap<String,Integer> w=new TreeMap<>();
for (int i = 0; i < 2; i++) {
String str=sc.nextLine();
String[] arr = str.split(":");
if(arr[0].equals("z")){
String[] brr=arr[1].split(",");
for (String s : brr) {
String[] brr2=s.split("\\s+");
z.put(brr2[0],z.getOrDefault(brr2[0],0)+Integer.parseInt(brr2[1]));
}
}else{
String[] brr=arr[1].split(",");
for (String s : brr) {
String[] brr2 = s.split(" ");
w.put(brr2[0],w.getOrDefault(brr2[0],0)+Integer.parseInt(brr2[1]));
}
}
}
int flag=0;
for (String s : z.keySet()) {
if(w.containsKey(s)){
if(flag != 0){
System.out.print(",");
}
flag=1;
if(w.get(s)>z.get(s)){
System.out.print("w:"+s+" "+w.get(s));
}else{
System.out.print("z:"+s+" "+z.get(s));
}
}
}
if(flag==0){
System.out.println("none");
}
}
}stream方式:之后看吧
// import java.util.*;
// import java.util.stream.Collectors;
// public class Main {
// public static void main(String[] args) {
// Scanner sc = new Scanner(System.in);
// String zData = sc.nextLine().split(":")[1]; // 获取z的数据部分
// String wData = sc.nextLine().split(":")[1]; // 获取w的数据部分
// // 解析数据为Map<城市, 总天数>
// Map<String, Integer> zMap = parseData(zData);
// Map<String, Integer> wMap = parseData(wData);
// // 获取共同城市并按字母排序
// List<String> commonCities = zMap.keySet().stream()
// .filter(wMap::containsKey)
// .sorted()
// .toList();
// if (commonCities.isEmpty()) {
// System.out.println("none");
// } else {
// // 生成结果列表
// List<String> result = commonCities.stream()
// .map(city -> {
// int zDays = zMap.get(city);
// int wDays = wMap.get(city);
// return zDays > wDays
// ? "z:" + city + " " + zDays
// : "w:" + city + " " + wDays;
// })
// .collect(Collectors.toList());
// // 输出结果
// System.out.println(String.join(",", result));
// }
// }
// // 解析单行数据为Map
// private static Map<String, Integer> parseData(String data) {
// return Arrays.stream(data.split(","))
// .map(s -> s.split(" "))
// .collect(Collectors.toMap(
// arr -> arr[0],
// arr -> Integer.parseInt(arr[1]),
// Integer::sum
// ));
// }
// }re7-49 数组乱炖
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int n = input.nextInt();
int []arr = new int[n];
int []brr = new int[n];
for(int i=0;i<n;i++){
arr[i]=input.nextInt();
}
System.out.println(Arrays.toString(arr));
brr=Arrays.copyOf(arr,n);
System.out.println(Arrays.toString(brr));
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
//
int m= Arrays.binarySearch(arr,input.nextInt());//全是9的情况需要使用二分查找
if(m>-1) System.out.println(m);
//如果找到了 key，返回 key 在数组中的索引（从0开始）。
//如果没有找到 key，返回一个负数。
else System.out.println("no");
if(n>=2)
{
arr[0]=9;
arr[1]=9;
}
System.out.println(Arrays.toString(arr));
boolean boo=Arrays.equals(arr,brr);
if(boo==true){
System.out.println("yes");
}else {
System.out.println("no");
}
}
}re7-56 list re存储动物对象
import java.util.*;
public class Main {
public static void main(String[] args) {
// Animal list=new Animal();这种写法是错误 抽象类不能被实例化 必须通过子类来实例化对象
Scanner input = new Scanner(System.in);
int n = input.nextInt();
// Animal []list=new Animal[n];
input.nextLine();
ArrayList<Animal> list = new ArrayList<>();
while (n-- > 0) {
int type = input.nextInt();
input.nextLine();
if(type==1){
String name = input.next();
String age = input.next();
String leg=input.next();
Dog dog = new Dog(name,age,leg);
list.add(dog);
}else{
String name = input.next();
String age = input.next();
Bird bird = new Bird(name,age);
list.add(bird);
}
}
System.out.printf("[");
for (int i = 0; i < list.size(); i++)
if(i==0) {
System.out.printf(list.get(i).toString());
}else
{
System.out.printf(", "+list.get(i).toString());
}
int flag=0;
System.out.println("]");
String str = input.next();
for(Animal animal : list){
if(animal.getName().equals(str)){
System.out.println(animal.classs());
System.out.printf(animal.toString());
flag=1;
return;
}
}
if(flag==0){
System.out.printf("no this one");
}
}
}
abstract class Animal {
private String name;
private String age;
Animal(String name, String age) {
this.name = name;
this.age = age;
}
Animal() {}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
public String classs(){
return "Animal";
}
@Override
public String toString() {
return
" name=" + name +
", age=" + age ;
}
}
class Dog extends Animal {
private String leg;
Dog(){
}
Dog(String leg) {
this.leg = leg;
}
Dog(String name, String age, String leg){
super(name, age);
this.leg = leg;
}
public String getLeg() {
return leg;
}
public void setLeg(String leg) {
this.leg = leg;
}
public String classs(){
return "Dog";
}
@Override
public String toString() {
return "Dog[" +
"leg=" + leg +","+super.toString()+
']';
}
}
class Bird extends Animal {
Bird(){
}
Bird(String name, String age){
super(name, age);
}
public String classs(){
return "Bird";
}
@Override
public String toString() {
return "Bird[name=" + super.getName() + ", age=" + super.getAge()+ "]";
}
}7-55 查询某人
import java.io.Console;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int n = input.nextInt();
Person []per=new Person[n];
for(int i=0;i<n;i++){
per[i]=new Person();
per[i].setName(input.next());
per[i].setAge(input.nextInt());
System.out.println(per[i].toString());
}
String s=input.next();
int flag=0;
for(int i=0;i<n;i++){
if(per[i].name.equals(s)){
flag=1;
System.out.println("查询结果：");
System.out.println(per[i].toString());
break;
}
}
if(flag==0){
System.out.println("not found");
}
}
}
class Person{
String name;
int age;
public Person(String name,int age){
this.age=age;
this.name=name;
}
Person(){
this.name="none";
this.age=1;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
扫一扫
5604
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
