Java题目-数组计算-中位数- 圆类的构造-时间计算-学生类设计
第一题：数组计算
题目描述：
编写Java程序，计算两个整型数组的和、差、乘积、商的整数部分及大小关系。定义如下：
和：两个数组对应元素的和，若元素缺失，则补0；
差：第一个数组和第二个数组对应元素的差，若元素缺失，则补0；
乘积：两个数组对应元素的积，若元素缺失，则计0；
除：第一个数组元素除以第二个数组元素，所得到的商的整数部分，分母为0时，计为0；
大小关系：统计两个数组中对应元素的大小关系，认为大于对方数组元素的个数多与小于对方数组元素个数的那个数组更大，若元素缺失，则补0。1表示大于，-1表示小于，0表示等于。
输入
第一个数组：长度n和n个整数；
第二个数组：长度m和m个整数
输出
两个数组的和、差、乘积、除、大小关系（每一行行末无空格）
样例输入
3 1 2 3 4 1 2 3 4
样例输出
2 4 6 4 0 0 0 -4 1 4 9 0 1 1 1 0 -1
答案代码
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int n1 = input.nextInt();
int[] arry1 = new int[n1];
for (int i = 0; i < arry1.length; i++) {
arry1[i] = input.nextInt();
}
int n2 = input.nextInt();
int[] arry2 = new int[n2];
for (int i = 0; i < arry2.length; i++) {
arry2[i] = input.nextInt();
}
add(arry1, arry2);
sub(arry1, arry2);
mul(arry1, arry2);
division(arry1, arry2);
compare(arry1, arry2);
}
public static void add(int[] arry1, int[] arry2) {
int max = Math.max(arry1.length, arry2.length);
for (int i = 0; i < max; i++) {
int n = arry1.length > i ? arry1[i] : 0;
int m = arry2.length > i ? arry2[i] : 0;
System.out.print(n + m);
if(i != max -1) {
System.out.print(" ");
}
}
System.out.println();
}
public static void sub(int[] arry1, int[] arry2) {
int max = Math.max(arry1.length, arry2.length);
for (int i = 0; i < max; i++) {
int n = arry1.length > i ? arry1[i] : 0;
int m = arry2.length > i ? arry2[i] : 0;
System.out.print(n - m);
if(i != max -1) {
System.out.print(" ");
}
}
System.out.println();
}
public static void mul(int[] arry1, int[] arry2) {
int max = Math.max(arry1.length, arry2.length);
for (int i = 0; i < max; i++) {
int n = arry1.length > i ? arry1[i] : 0;
int m = arry2.length > i ? arry2[i] : 0;
System.out.print(n * m);
if(i != max -1) {
System.out.print(" ");
}
}
System.out.println();
}
public static void division(int[] arry1, int[] arry2) {
int max = Math.max(arry1.length, arry2.length);
for (int i = 0; i < max; i++) {
int n = arry1.length > i ? arry1[i] : 0;
int m = arry2.length > i ? arry2[i] : 0;
if(n*m != 0) {
System.out.print(n / m);
}else {
System.out.print(0);
}
if(i != max -1) {
System.out.print(" ");
}
}
System.out.println();
}
public static void compare(int[] arry1, int[] arry2) {
int max = Math.max(arry1.length, arry2.length);
int mark1 = 0;
int mark2 = 0;
for (int i = 0; i < max; i++) {
int n = arry1.length > i ? arry1[i] : 0;
int m = arry2.length > i ? arry2[i] : 0;
if(n > m) {
mark1 += 1;
}else if(n mark2) {
System.out.println(1);
}else if(mark1 < mark2) {
System.out.println(-1);
}else {
System.out.println(0);
}
}
} 答案代码介绍
有一个名为Main的类，包含了以下几个方法：
1. main方法：包含了程序的入口点，通过Scanner类获取用户输入的两个整数数组，然后调用其他方法进行加法、减法、乘法、除法和比较操作。
2. add方法：接受两个整型数组作为参数，将这两个数组对应位置的元素相加，并输出结果。
3. sub方法：接受两个整型数组作为参数，将第一个数组的元素减去第二个数组的元素，并输出结果。
4. mul方法：接受两个整型数组作为参数，将这两个数组对应位置的元素相乘，并输出结果。
5. division方法：接受两个整型数组作为参数，将第一个数组的元素除以第二个数组的元素，并输出结果。如果除数为0，则输出0。
6. compare方法：接受两个整型数组作为参数，比较这两个数组对应位置的元素大小，输出比较结果。如果第一个数组中的元素大于第二个数组中的元素，则输出1；如果小于，则输出-1；如果相等，则输出0。
这些方法实现了对两个整型数组进行加减乘除和比较的操作，并根据不同的需求输出相应的结果。
第二题：中位数
题目描述
编写Java程序输入n个整数，以及一个整数x，计算这n个整数的中位数并输出。然后将x插入到数组的相应位置，使数组按升序排列。中位数定义：对元素按降序排列，若n是奇数，取(n+1)/2位置的值，否则，取n/2和（n/2+1）的平均值(舍去小数取整）。
输入
n和n个整数，整数x
输出
中位数，插入x后的数组元素
样例输入 Copy
5 1 2 3 4 5 4
样例输出 Copy
3 1 2 3 4 4 5
答案代码
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int n = input.nextInt();
int[] arry = new int[n];
for (int i = 0; i < arry.length; i++) {
arry[i] = input.nextInt();
}
int x = input.nextInt();
Arrays.sort(arry);
int med = median(arry);
System.out.print(med);
int[] arryb = addArry(arry, x);
for (int i = 0; i < arryb.length; i++) {
System.out.print(" " + arryb[i]);
}
}
public static int median(int[] arry) {
int med;
if(arry.length%2 == 0) {
med = (arry[arry.length/2] + arry[arry.length/2-1])/2;
}else {
med = arry[arry.length/2];
}
return med;
}
public static int[] addArry(int[] arry, int n) {
int[] arryb = new int[arry.length+1];
int i;
for (i = 0; i < arry.length; i++) {
arryb[i] = arry[i];
}
arryb[i] = n;
Arrays.sort(arryb);
return arryb;
}
}代码分析
有一个名为Main的类，包含了以下几个方法：
1. main方法：程序的入口点，通过Scanner类获取用户输入的整数数组和一个整数，然后对输入的数组进行排序，并计算其中位数（如果数组长度为偶数，取中间两个数的平均值，如果为奇数，取中间数）。接着调用addArry方法将输入的整数加入到数组中，并对新数组进行排序，最后输出中位数和新数组。
2. median方法：接受一个整型数组作为参数，计算数组的中位数并返回。如果数组长度为偶数，则取中间两个数的平均值，如果为奇数，则取中间数。
3. addArry方法：接受一个整型数组和一个整数作为参数，在数组的末尾添加这个整数，并返回新的整型数组。添加完整数后，对新数组进行排序。
这些方法实现了对输入的整型数组进行排序、计算中位数，并实现了向数组中添加元素并排序的操作。最终输出了计算得到的中位数和添加完整数后的新数组。
第三题：圆类的构造
题目描述
编写一个圆类Circle，该类拥有：
①一个成员变量
radius（私有，浮点型）； // 存放圆的半径；
②两个构造方法
Circle( ) // 将半径设为0
Circle(double r ) //创建Circle对象时将半径初始化为r
③ 三个成员方法
void setRadius(double r) //设置圆的半径
double getArea( ) //获取圆的面积
double getPerimeter( ) //获取圆的周长
void show( ) //将圆的半径、周长、面积输出到屏幕，值保留小数点后两位
④ 在main方法中定义一个Circle类的对象，输入圆的半径，输出当前圆的半径、周长与面积值；再将圆的半径增加10，输出修改后圆的半径、周长与面积值。
说明：圆周率的值为Math.PI
输入
圆的半径
输出
圆的半径、周长、面积，
再将圆的半径增加10，修改后圆的半径、周长与面积。
数值保留小数点后两位
样例输入 Copy
1
样例输出 Copy
1.00,6.28,3.14 11.00,69.12,380.13
答案代码
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
Cricle cricleOne = new Cricle();
double r = input.nextDouble();
cricleOne.setRadius(r);
cricleOne.show();
Cricle cricleTow = new Cricle(r+10);
cricleTow.show();
}
}
class Cricle{
private double radius;
Cricle(){
};
Cricle(double radius){
this.radius = radius;
}
void setRadius(double r) {
radius = r;
}
double getRadius() {
return radius;
}
double getArea() {
double area = Math.PI*radius*radius;
return area;
}
double getPerimeter() {
double perimeter = 2*Math.PI*radius;
return perimeter;
}
void show() {
System.out.printf("%.2f,", radius);
System.out.printf("%.2f,",getPerimeter());
System.out.printf("%.2f\n",getArea());
}
}代码分析
这段代码包含了一个名为Main的类和一个名为Circle的类。Main类的main方法用于接收用户输入的半径值，创建一个Circle对象，设置该对象的半径，然后调用show方法展示圆的半径、周长和面积。接着，创建另一个Circle对象，其半径比第一个Circle对象的半径大10，同样调用show方法展示信息。
Circle类包含了以下几个属性和方法：
1. radius：表示圆的半径，为私有属性。
2. Circle()：无参构造方法。
3. Circle(double radius)：带参构造方法，接受一个半径值。
4. setRadius(double r)：设置圆的半径。
5. getRadius()：获取圆的半径。
6. getArea()：计算并返回圆的面积。
7. getPerimeter()：计算并返回圆的周长。
8. show()：展示圆的半径、周长和面积。
第四题：时间计算
题目描述
定义一个时间类MyTime，实现时间（小时、分钟、秒）的输入、输出、相关计算、比较等功能。时间的计算包括但不限于：
时间相加：从t1时刻经过t2时间后得到的新时间；
时间相减：t1时刻的t2时间之前的时间，这也是一个新时间；（例如：10时34分之前50分钟的时间是什么）
两个MyTime时间对象之间的间距：运算结果单位为秒。
输出：格式为“时:分:秒”
定义主类MyTimeTest（OJ上提交时修改为Main），按照输入的时、分、秒分别创建两个时间类的对象t1与t2，输入m分或m时或m秒，输出t1+m、t1-m与t2-t1的运算结果。
说明1：两个字符串s1与s2比较是否相同，使用的是s1.equals(s2)，若内容相同则返回true，否则返回false。
说明2：字符串s获取子串，String r=s.substring(begin,end)，例如，s串为”123s“，则String s1=s.substring(s.length()-1); String s2=s.substring(0, s.length()-1); ，经过处理后，s1为”s”，s2为”123”。
说明3：将字符串s，s为”123”转换为整数123的方法是：int n=Integer.parseInt(s);
说明4：注意时、分、秒的取值范围
说明5：最后一行输入，小时用h表示、分钟用m表示、秒用s表示。
输入
三行，两组时间，一个时间间隔
输出
三行，计算后的两组时间，时间间隔
样例输入 Copy
16 25 35 13 20 30 80s
样例输出 Copy
16:26:55 16:24:15 -11105s
答案代码
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int[] timeNum = new int[6];
for (int i = 0; i < timeNum.length; i++) {
timeNum[i] = input.nextInt();
}
MyTime timeOne = new MyTime(timeNum[0], timeNum[1], timeNum[2]);
MyTime timeTow = new MyTime(timeNum[3], timeNum[4], timeNum[5]);
String time = input.next();
String string1 = time.substring(time.length() - 1);
String string2 = time.substring(0, time.length() - 1);
int n = Integer.parseInt(string2);
int second = nSecond(n, string1);
timeOne.addTime(second);
timeOne.subTime(second);
timeOne.timeSub(timeTow);
}
public static int nSecond(int x, String s) {
int second = 0;
switch (s) {
case "s":
second = x;
break;
case "m":
second = x * 60;
break;
case "h":
second = x * 60 * 60;
break;
}
return second;
}
}
class MyTime {
int hour;
int minute;
int second;
MyTime(int hour, int minute, int second) {
this.hour = hour;
this.minute = minute;
this.second = second;
}
MyTime() {
}
void subTime(int m) {
int[] timeNum = new int[3];
timeNum[0] = m % 60;
timeNum[1] = (m - timeNum[0]) / 60 % 60;
timeNum[2] = (m - timeNum[0]) / 60 / 60;
int[] time = new int[3];
time[0] = second - timeNum[0];
if (time[0] < 0) {
time[0] = time[0] + 60;
time[1] = -1;
}
time[1] = minute - timeNum[1] + time[1];
if (time[1] < 0) {
time[1] = time[1] + 60;
time[2] = -1;
}
time[2] = hour - timeNum[2] + time[2];
while(true) {
if(time[2]<0) {
time[2]+=24;
}else {
break;
}
}
System.out.print(time[2]+":");
System.out.print(time[1]+":");
System.out.println(time[0]);
}
void addTime(int m) {
int[] timeNum = new int[3];
timeNum[0] = m % 60;
timeNum[1] = (m - timeNum[0]) / 60 % 60;
timeNum[2] = (m - timeNum[0]) / 60 / 60;
int[] time = new int[3];
time[0] = timeNum[0] + second;
if (time[0] > 60) {
time[0] = time[0] - 60;
time[1] = 1;
}
time[1] = timeNum[1] + minute + time[1];
if (time[1] >= 60) {
time[1] = time[1] - 60;
time[2] = 1;
}
time[2] = timeNum[2] + hour + time[2];
System.out.print(time[2]%24+":");
System.out.print(time[1]+":");
System.out.println(time[0]);
}
void timeSub(MyTime time) {
int secondOne = hour * 60 * 60 + minute * 60 + second;
int secondTow = time.hour * 60 * 60 + time.minute * 60 + time.second;
int s = secondOne - secondTow;
System.out.println(-1 * s + "s");
}
}代码分析
这段代码包含了一个Main类和一个名为MyTime的子类。Main类的main方法用于接收用户输入的时间数据，创建两个MyTime对象，计算时间的加减与差，并输出结果。
MyTime类用于表示时间，包含以下方法和属性：
1. hour：小时，为整型。
2. minute：分钟，为整型。
3. second：秒，为整型。
4. MyTime(int hour, int minute, int second)：带参构造方法，初始化时间对象。
5. MyTime()：无参构造方法。
6. subTime(int m)：减去指定的时间秒数m，并输出结果。
7. addTime(int m)：增加指定的时间秒数m，并输出结果。
8. timeSub(MyTime time)：计算该时间与另一个时间对象的差，并输出结果。
9. nSecond(int x, String s)：静态方法，根据时间单位s、m、h，将数值x转换为秒数。
第五题：学生类设计
题目描述
编写一个Java应用程序。设计一个学生类Students，包括属性有：学号，姓名，性别，专业，三门课程成绩（计算机，数学，英语）；包括方法有：求成绩总分，成绩平均分，各个属性的赋值方法，各个属性值的获取方法等等。
编写一个主类StudentsDemo.java，利用Students类输入5名同学的所有信息，按以下要求依次输出相关信息：
（1）输入一个学生的学号或者姓名，输出该学生的所有信息。
（2）数学课程（输入的第2门课程）最高分同学学号、姓名和课程分数
（3）总分最高与最低同学学号、姓名和课程分数
（4）有没有这样的学生存在：总分大于所有学生的平均成绩，但是至少有一门课不及格（低于60分）。若有，按行输出这些学生的全部信息；若没有，输出NOT EXIST。
分析：对于以上每个要求，编写相应的成员方法（函数）实现对应的功能，在测试类（StudentsDemo）中，调用这些方法实现相应功能。
输入
5行，5名学生信息
输出
5行，学生的相关信息
样例输入 Copy
001 aa male math 80 85 78 002 bb female math 78 78 80 003 cc female math 95 95 98 004 dd male cs 89 92 95 005 ee female cs 89 92 95 aa
样例输出 Copy
001,aa,male,math,80.0,85.0,78.0 003,cc,95.0,95.0,98.0 003,cc,95.0,95.0,98.0 002,bb,78.0,78.0,80.0 NOT EXIST
答案代码
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
Students[] std = new Students[5];
for (int i = 0; i < std.length; i++) {
std[i]= new Students();
std[i].setStuID(input.next());
std[i].setName(input.next());
std[i].setSex(input.next());
std[i].setSubject(input.next());
std[i].setComputer(input.nextDouble());
std[i].setMath(input.nextDouble());
std[i].setEnglish(input.nextDouble());
std[i].setScore();
}
String s = input.next();
StudentsDemo demo = new StudentsDemo(std);
demo.searchStdByNameOrId(s);
demo.mathMax();
demo.SumMaxMin();
demo.nbStd();
}
}
class StudentsDemo{
private Students[] std;
StudentsDemo(Students[] std){
this.std = std;
}
void searchStdByNameOrId(String s) {
for (int i = 0; i < std.length; i++) {
if(std[i].getName().equals(s)||std[i].getStuID().equals(s)) {
System.out.println(std[i].getStuID()+","+std[i].getName()+","+std[i].getSex()+","+std[i].getSubject()+","+std[i].getComputer()+","+std[i].getMath()+","+std[i].getEnglish());
}
}
}
void mathMax(){
double max = std[0].getMath();
int mark = 0;
int i;
for (i = 1; i < std.length; i++) {
if(std[i].getMath()>max) {
max = std[i].getMath();
mark = i;
}
}
i = mark;
System.out.println(std[i].getStuID()+","+std[i].getName()+","+std[i].getComputer()+","+std[i].getMath()+","+std[i].getEnglish());
}
void SumMaxMin(){
double max = std[0].getScore();
double min = std[0].getScore();
int mark1 = 0;
int mark2 = 0;
for (int i = 1; i < std.length; i++) {
if(maxstd[i].getScore()) {
min=std[i].getScore();
mark2 = i;
}
}
System.out.println(std[mark1].getStuID()+","+std[mark1].getName()+","+std[mark1].getComputer()+","+std[mark1].getMath()+","+std[mark1].getEnglish());
System.out.println(std[mark2].getStuID()+","+std[mark2].getName()+","+std[mark2].getComputer()+","+std[mark2].getMath()+","+std[mark2].getEnglish());
}
void nbStd() {
double allScore = 0;
for (int i = 0; i < std.length; i++) {
allScore += std[i].getScore();
}
double avgScore = allScore/5;
int mark = 0;
for (int i = 0; i < std.length; i++) {
if(std[i].getScore()>=avgScore && (std[i].getComputer()<60||std[i].getMath()<60||std[i].getEnglish()<60)) {
System.out.println(std[i].getStuID()+","+std[i].getName()+","+std[i].getSex()+","+std[i].getSubject()+","+std[i].getComputer()+","+std[i].getMath()+","+std[i].getEnglish());
mark = 1;
}
}
if(mark == 0) {
System.out.println("NOT EXIST");
}
}
}
class Students{
private String stuID;
private String name;
private String sex;
private String subject;
private double computer;
private double math;
private double English;
private double score;
public Students(String stuID, String name, String sex, String subject, double computer, double math, double english,
double score) {
super();
this.stuID = stuID;
this.name = name;
this.sex = sex;
this.subject = subject;
this.computer = computer;
this.math = math;
English = english;
this.score = score;
}
public Students() {
super();
}
public String getStuID() {
return stuID;
}
public void setStuID(String stuID) {
this.stuID = stuID;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getSubject() {
return subject;
}
public void setSubject(String subject) {
this.subject = subject;
}
public double getComputer() {
return computer;
}
public void setComputer(double computer) {
this.computer = computer;
}
public double getMath() {
return math;
}
public void setMath(double math) {
this.math = math;
}
public double getEnglish() {
return English;
}
public void setEnglish(double english) {
English = english;
}
public double getScore() {
return score;
}
public void setScore() {
this.score = this.math+this.computer+this.English;
}
} 代码分析
一个名为Main的主类和两个其他类：Students和StudentsDemo。Main类的主要任务是创建学生对象数组，接收用户输入学生信息，并调用StudentsDemo类的方法来处理学生数据。
Students类用于表示学生对象，包含学生的学号、姓名、性别、科目成绩等属性，并提供了相应的set和get方法。
StudentsDemo类包含了对学生数组的操作方法，如按姓名或学号查找学生信息、找出数学成绩最高的学生、找出总分最高和最低的学生、以及找出总分高于平均分且存在科目成绩低于60分的学生。这些方法用于对学生数据进行处理和筛选，并输出相应的结果。
这个程序实现了学生数据的录入和分析功能，可以帮助用户查找出符合条件的学生信息，并输出相应的结果。