Java程序设计2023-第二次上机练习

sylviiiiiia

已于 2023-10-04 21:26:23 修改

阅读量403

点赞数 1

分类专栏： pta题库 java 文章标签： java 开发语言

于 2023-10-03 23:39:40 首次发布

本文链接：https://blog.csdn.net/sylviiiiiia/article/details/133343178

版权

pta题库同时被 2 个专栏收录

24 篇文章 2 订阅

订阅专栏

java

19 篇文章 0 订阅

订阅专栏

仅供参考，请勿CTRL+CV提交OJ

7-1伪随机数

在java.util这个包里面提供了一个Random的类，我们可以新建一个Random的对象来产生随机数，他可以产生随机整数、随机float、随机double，随机long。Random的对象有两种构建方式：带种子和不带种子。不带种子的方式将会返回随机的数字，每次运行结果不一样。无论程序运行多少次，带种子方式构建的Random对象会返回一样的结果。

请编写程序，使用第一种方式构建Random对象，并完成下面输入输出要求。

输入格式:

在一行中输入3个不超过10000的正整数n,m,k。

输出格式:

在一行中输出以k为种子建立的Random对象产生的第n个0到m-1之间的伪随机数。

输入样例:

10 100 1000

输出样例:

import java.util.*;
public class Main{
    public static void main(String args[]){
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int m=in.nextInt();
        int k=in.nextInt();
        Random r = new Random(k);
        int x;
        for(int i=0;i<n;i++){
            x=r.nextInt(m);
            if(i==n-1)System.out.println(x);
        }
    }
}

7-2jmu-Java-03面向对象基础-01-构造方法与toString

定义一个有关人的Person类，内含属性：
String name、int age、boolean gender、int id，所有的变量必须为私有(private)。
注意：属性顺序请严格按照上述顺序依次出现。
1.编写无参构造函数：
打印"This is constructor"。
将name,age,gender,id按照name,age,gender,id格式输出
2.编写有参构造函数
依次对name,age,gender赋值。
3.覆盖toString函数：
按照格式：类名 [name=, age=, gender=, id=]输出。建议使用Eclipse自动生成.
4.对每个属性生成setter/getter方法
5.main方法中
首先从屏幕读取n，代表要创建的对象个数。
然后输入n行name age gender , 调用上面2编写的有参构造函数新建对象。
然后将刚才创建的所有对象逆序输出。
接下来使用无参构造函数新建一个Person对象，并直接打印该对象。
输入样例:

3
a 11 false
b 12 true
c 10 false

输出样例:

Person [name=c, age=10, gender=false, id=0]
Person [name=b, age=12, gender=true, id=0]
Person [name=a, age=11, gender=false, id=0]
This is constructor
null,0,false,0
Person [name=null, age=0, gender=false, id=0]

import java.util.*;
class Person{
    private String name;
    private int age;
    private boolean gender;
    private int id;
    public Person(){
        System.out.println("This is constructor");
        System.out.printf("%s,%d,%b,%d\n",name,age,gender,id);
    }
    public Person(String nm,int ag,boolean sex){
        name=nm;
        age=ag;
        gender=sex;
    }
    public String toString(){
        return "Person [name="+name+", age="+age+", gender="+gender+", id="+id+"]";
    }
}
public class Main{
    public static void main(String args[]){
        Scanner in=new Scanner(System.in);
        String s=in.nextLine();
        int n=Integer.parseInt(s);
        Person []ps=new Person[n+1];
        for(int i=0;i<n;i++){
            s=in.nextLine();
            String []str=s.split("\\s+");
            ps[i]=new Person(str[0],Integer.parseInt(str[1]),Boolean.parseBoolean(str[2]));
        }
        for(int i=n-1;i>=0;i--){
            System.out.println(ps[i].toString());
        }
        ps[n]=new Person();
        System.out.println(ps[n].toString());
    }
}

7-3jmu-Java-03面向对象基础-02-构造方法与初始化块

1.定义一个Person类
属性：String name, boolean gender, int age, int id ,所有的变量必须为私有(private)。
无参构造函数:Person(), 功能：打印This is constructor 。
有参构造函数:Person(name, gender, age) ，功能：给属性赋值。
建议：使用Eclipse自动生成toString方法
2.定义类的初始化块
为Person类加入初始化块，在初始化块中对id属性赋值，并且要保证每次的值比上次创建的对象的值+1。然后在下一行打印This is initialization block, id is … 其中…是id的值。
提示：可为Person类定义一个static属性来记录所创建的对象个数。
3.编写静态初始化块
打印This is static initialization block
4.编写main方法
首先输入n，代表要创建的对象数量。
然后从控制台分别读取n行的name age gender, 并调用有参构造函数Person(name, age, gender)新建对象。
将创建好的n个对象逆序输出(即输出toString()方法)。
使用无参构造函数新建一个Person对象，然后直接打印该对象。
思考
初始化类与对象有几种方法，构造函数、初始化块、静态初始化块。这三种方法执行的先后顺序是什么？各执行几次。

输入样例:

3
a 11 false
b 12 true
c 10 false

输出样例:

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]

import java.util.*;
class Person{
    private String name;
    private int age;
    private boolean gender;
    private int id;
    static int cnt;
    public Person(){
        System.out.println("This is constructor");
    }
    public Person(String nm,int ag,boolean sex){
        name=nm;
        age=ag;
        gender=sex;
    }
    public String toString(){
        return "Person [name="+name+", age="+age+", gender="+gender+", id="+id+"]";
    }
    static{
        System.out.println("This is static initialization block");
        cnt=0;
    }
    {    
        id=cnt;
        cnt++;
        System.out.printf("This is initialization block, id is %d\n",id);
    }
    public String prt(){
        return name+","+age+","+gender+","+id;
    }
}
public class Main{
    public static void main(String args[]){
        Scanner in=new Scanner(System.in);
        String s=in.nextLine();
        int n=Integer.parseInt(s);
        Person []ps=new Person[n+1];
        for(int i=0;i<n;i++){
            s=in.nextLine();
            String []str=s.split("\\s+");
            ps[i]=new Person(str[0],Integer.parseInt(str[1]),Boolean.parseBoolean(str[2]));
        }
        for(int i=n-1;i>=0;i--){
            System.out.println(ps[i].toString());
        }
        ps[n]=new Person();
        System.out.println(ps[n].prt());
        System.out.println(ps[n].toString());
    }
}

7-4复数类的定义

编写一个复数类，可以进行复数加法和减法运算。编写一个包含main方法的类测试该复数类。要求该复数类至少包含一个无参的构造方法和一个带参的构造方法；数据成员包括复数的实部和虚部，为double类型；包括两个方法，分别实现复数的加法和减法运算。
输入格式:
输入两个复数。输入为两行，每一行为一个复数的实部和虚部，用空格隔开。
输出格式:
输出复数加法和减法结果。输出为4行，第一行和第二行输出两个复数，第三行为两个复数的加法运算结果，第四行为减法运算结果。
输入样例:
在这里给出两组输入。例如：

1 2
3 4

-1 2
1 2

输出样例:
在这里给出相应的输出。例如：

1.0+2.0i
3.0+4.0i
4.0+6.0i
-2.0-2.0i

-1.0+2.0i
1.0+2.0i
4.0i
-2.0

import java.util.*;
class Complex{
    private double real,image;
    public Complex(){
        real=0;image=0;
    }
    public Complex(double r,double i){
        real=r;
        image=i;
    }
    public void setRealPart(double r){
        real=r;
    }
    public void setImaginaryPart(double i){
        image=i;
    }
    public double getReal(){
        return real;
    }
    public double getImage(){
        return image;
    }
    public String toString(){ //注意此处
        if(real!=0){
            if(image>0)return real+"+"+image+"i";
            else if(image==0)return real+"";
            else return real+""+image+"i";
        }else{
            if(image==0)return "0";
            else return image+"i";
        }
    }
    public Complex add(Complex b){
        Complex res=new Complex(this.real+b.getReal(),this.image+b.getImage());
        return res;
    }
    public Complex sub(Complex b){
        Complex res=new Complex(this.real-b.getReal(),this.image-b.getImage());
        return res;
    }
}
public class Main{
    public static void main(String [] args){
        Complex a=new Complex();
        Complex b=new Complex();
        Scanner in=new Scanner(System.in);
        a.setRealPart(in.nextDouble());
        a.setImaginaryPart(in.nextDouble());
        b.setRealPart(in.nextDouble());
        b.setImaginaryPart(in.nextDouble());
        System.out.println(a);
        System.out.println(b);
        System.out.println(a.add(b));
        System.out.println(a.sub(b));      
    }
}

7-5jmu-Java-01入门-开根号

使用逐步逼近法对给定数值x求开根号。

逐步逼近法说明：从0开始逐步累加步长值。

步长=0.0001，epsilon(误差)=0.0001

循环继续的条件：

平方值<x 且 |x-平方值| > epsilon

###说明与参考

数值输出保留6位小数，使用System.out.printf(“%.6f\n”)
求平方，参考Math.pow函数。
输入值<0时，返回Double.NaN
输入格式:
任意数值

输出格式:
对每一组输入，在一行中输出其开根号。保留6位小数

输入样例:

输出样例:

import java.util.*;
public class Main{
    public static void main(String args[]){
        Scanner in =new Scanner(System.in);
        String str;
        double step=0.0001,epsilon=0.0001;
        while(true){
            if((str=in.nextLine()).equals(""))break;
            double x=Double.parseDouble(str);
            if(x<0)System.out.println(Double.NaN);
            else{
                double now=0;
                while(now*now<x&&Math.abs(x-now*now)>epsilon){
                    now+=step;
                }
                System.out.printf("%.6f\n",now);
            }
        }
    }
}

7-6jmu-Java-01入门-取数字浮点数

本题目要求读入若干以回车结束的字符串表示的整数或者浮点数，然后将每个数中的所有数字全部加总求和。

输入格式:
每行一个整数或者浮点数。保证在浮点数范围内。

输出格式:
整数或者浮点数中的数字之和。题目保证和在整型范围内。

输入样例:

-123.01
234

输出样例:

7
9

import java.util.*;
import java.io.*;
public class Main{
    public static void main(String args[]){
        Scanner in=new Scanner(System.in);
        String s;
        while(true){
            try{
                s=in.nextLine();
                int res=0;
                for(int i=0;i<s.length();i++){
                    try{
                        int tmp=Integer.parseInt(s.substring(i,i+1));
                        res+=tmp;
                    }catch(Exception e){
                        continue;
                    }
                }
                System.out.println(res);
            }catch(Exception e){
                break;
            }
        }
    }
}

7-7日期类设计

参考题目3和日期相关的程序，设计一个类DateUtil，该类有三个私有属性year、month、day（均为整型数），其中，year∈[1820,2020] ,month∈[1,12] ,day∈[1,31] , 除了创建该类的构造方法、属性的getter及setter方法外，需要编写如下方法：略
应用程序共测试三个功能：
求下n天
求前n天
求两个日期相差的天数
注意：严禁使用Java中提供的任何与日期相关的类与方法，并提交完整源码，包括主类及方法（已提供，不需修改）
程序主方法如下：略
输入格式:
有三种输入方式（以输入的第一个数字划分[1,3]）：
1 year month day n //测试输入日期的下n天
2 year month day n //测试输入日期的前n天
3 year1 month1 day1 year2 month2 day2 //测试两个日期之间相差的天数
输出格式:
当输入有误时，输出格式如下：
Wrong Format
当第一个数字为1且输入均有效，输出格式如下：
year1-month1-day1 next n days is:year2-month2-day2
当第一个数字为2且输入均有效，输出格式如下：
year1-month1-day1 previous n days is:year2-month2-day2
当第一个数字为3且输入均有效，输出格式如下：
The days between year1-month1-day1 and year2-month2-day2 are:值
输入样例1:
在这里给出一组输入。例如：

3 2014 2 14 2020 6 14

输出样例1:
在这里给出相应的输出。例如：

The days between 2014-2-14 and 2020-6-14 are:2312

输入样例2:
在这里给出一组输入。例如：

2 1834 2 17 7821

输出样例2:
在这里给出相应的输出。例如：

1834-2-17 previous 7821 days is:1812-9-19

输入样例3:
在这里给出一组输入。例如：

1 1999 3 28 6543

输出样例3:
在这里给出相应的输出。例如：

1999-3-28 next 6543 days is:2017-2-24

输入样例4:
在这里给出一组输入。例如：

0 2000 5 12 30

输出样例4:
在这里给出相应的输出。例如：

Wrong Format

import java.util.*;
class DateUtil{
    private int year,month,day;
    public DateUtil(int year,int month,int day){
        this.year=year;this.month=month;this.day=day;
    }
    static int []dayOfMonth={31,28,31,30,31,30,31,31,30,31,30,31};
    public int getYear(){return year;}
    public int getMonth(){return month;}
    public int getDay(){return day;}
    public boolean checkInputValidity(){//检测输入的年、月、日是否合法
        if(year<1820||year>2020)return false;
        if(month<1||month>12)return false;
        if(day<1)return false;
        if(month==2){
            if(isLeapYear(year)&&day>29)return false;
            if(!isLeapYear(year)&&day>28)return false;
        }else{
            if(day>dayOfMonth[month-1])return false;
        }
        return true;
    }
    public boolean isLeapYear(int year){//判断year是否为闰年
        if(year%4==0){
            if(year%100==0){
                if(year%400==0)return true;
                else return false;
            }
            return true;
        }
        return false;
    }
    public DateUtil getNextNDays(int n){//取得year-month-day的下n天日期
        int day=this.day;
        int month=this.month;
        int year=this.year;
        for(int i=0;i<n;i++){
            day++;
            if(month==2){
                if((isLeapYear(year)&&day>29)||!isLeapYear(year)&&day>28){
                    day=1;month++;
                }
            }else{
                if(day>dayOfMonth[month-1]){
                    day=1;month++;
                }
            }
            if(month>12){
                month=1;year++;
            }
        }
        DateUtil res=new DateUtil(year,month,day);
        return res;
    }
    public DateUtil getPreviousNDays(int n){//取得year-month-day的前n天日期
        int day=this.day;
        int month=this.month;
        int year=this.year;
        for(int i=0;i<n;i++){
            day--;
            if(day<=0){
                month--;
                if(month<=0){
                    month=12;year--;
                }
                if(month==2){
                    if(isLeapYear(year)){
                        day=29;
                    }else{
                        day=28;
                    }
                }else{
                    day=dayOfMonth[month-1];
                }
            }
        }
        DateUtil res=new DateUtil(year,month,day);
        return res;
    }
    public boolean compareDates(DateUtil date){//比较当前日期与date的大小（先后） 当前日期>=返回真
        if(this.year>date.year)return true;
        else if(this.year<date.year)return false;
        if(this.month>date.month)return true;
        else if(this.month<date.month)return false;
        if(this.day>date.day)return true;
        else if(this.day<date.day)return false;
        return true;
    }
    public boolean equalTwoDates(DateUtil date){//判断两个日期是否相等
        if(this.year==date.year&&this.month==date.month&&this.day==date.day)return true;
        return false;
    }
    public int getDaysofDates(DateUtil date){//求当前日期与date之间相差的天数
        int res=0;
        if(this.equalTwoDates(date))return res;
        if(!this.compareDates(date)){ //当前更小 本年度剩余天数+下一年度已过天数+中间年的天数(不在同一年)
            for(int i=this.year+1;i<date.year;i++){
                if(this.isLeapYear(i))res+=366;
                else res+=365;
            }
            if(this.year!=date.year){//不在同一年
                //本年度剩余天数
                if(this.month==2){
                    if(this.isLeapYear(this.year))res+=29-this.day;
                    else res+=28-this.day;
                }else res+=dayOfMonth[this.month-1]-this.day;
                for(int i=this.month+1;i<=12;i++){
                    if(i==2){
                        if(this.isLeapYear(this.year))res+=29;
                        else res+=28;
                    }else{
                        res+=dayOfMonth[i-1];
                    }
                }
                //下一年度已过天数
                for(int i=1;i<date.month;i++){
                    if(i==2){
                        if(this.isLeapYear(this.year))res+=29;
                        else res+=28;
                    }else res+=dayOfMonth[i-1];
                }
                res+=date.day;
            }else{//在同一年
                if(this.month!=date.month){ //不在同一月
                    for(int i=this.month+1;i<date.month;i++){
                        if(i==2){
                            if(this.isLeapYear(this.year))res+=29;
                            else res+=28;
                        }else{
                            res+=dayOfMonth[i-1];
                        }
                    }
                    //本月剩余天数
                    if(this.month==2){
                        if(this.isLeapYear(this.year))res+=29-this.day;
                        else res+=28-this.day;
                    }else res+=dayOfMonth[this.month-1]-this.day;
                    //下一月已过天数
                    res+=date.day;
                }else{//在同一月
                    res+=date.day-this.day;
                }
            }

        }else{
            res=date.getDaysofDates(this);
        }
        return res;
    }
    public String showDate(){//以“year-month-day”格式返回日期值
        return year+"-"+month+"-"+day;
    }
}
public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int year = 0;
        int month = 0;
        int day = 0;
        int choice = input.nextInt();
        if (choice == 1) { // test getNextNDays method
            int m = 0;
            year = Integer.parseInt(input.next());
            month = Integer.parseInt(input.next());
            day = Integer.parseInt(input.next());
            DateUtil date = new DateUtil(year, month, day);
            if (!date.checkInputValidity()) {
                System.out.println("Wrong Format");
                System.exit(0);
            }
            m = input.nextInt();
            if (m < 0) {
                System.out.println("Wrong Format");
                System.exit(0);
            }
            System.out.print(date.getYear() + "-" + date.getMonth() + "-" + date.getDay() + " next " + m + " days is:");
            System.out.println(date.getNextNDays(m).showDate());
        } else if (choice == 2) { // test getPreviousNDays method
            int n = 0;
            year = Integer.parseInt(input.next());
            month = Integer.parseInt(input.next());
            day = Integer.parseInt(input.next());
            DateUtil date = new DateUtil(year, month, day);
            if (!date.checkInputValidity()) {
                System.out.println("Wrong Format");
                System.exit(0);
            }
            n = input.nextInt();
            if (n < 0) {
                System.out.println("Wrong Format");
                System.exit(0);
            }
            System.out.print(
                    date.getYear() + "-" + date.getMonth() + "-" + date.getDay() + " previous " + n + " days is:");
            System.out.println(date.getPreviousNDays(n).showDate());
        } else if (choice == 3) {    //test getDaysofDates method
            year = Integer.parseInt(input.next());
            month = Integer.parseInt(input.next());
            day = Integer.parseInt(input.next());
            int anotherYear = Integer.parseInt(input.next());
            int anotherMonth = Integer.parseInt(input.next());
            int anotherDay = Integer.parseInt(input.next());
            DateUtil fromDate = new DateUtil(year, month, day);
            DateUtil toDate = new DateUtil(anotherYear, anotherMonth, anotherDay);
            if (fromDate.checkInputValidity() && toDate.checkInputValidity()) {
                System.out.println("The days between " + fromDate.showDate() + 
                        " and " + toDate.showDate() + " are:"
                        + fromDate.getDaysofDates(toDate));
            } else {
                System.out.println("Wrong Format");
                System.exit(0);
            }
        }else{
            System.out.println("Wrong Format");
            System.exit(0);
        }        
    }
}

7-8jmu-Java-03面向对象基础-03-形状

定义长方形类与圆形类Circle
长方形类-类名：Rectangle，private属性：int width,length
圆形类-类名：Circle，private属性:int radius
编写构造函数：
带参构造函数:Rectangle(width, length),Circle(radius)
编写方法：
public int getPerimeter()，求周长。
public int getArea()，求面积。
toString方法，使用Eclipse自动生成。
注意：
计算圆形的面积与周长，使用Math.PI。
求周长和面积时，应先计算出其值(带小数位)，然后强制转换为int再返回。
main方法
输入2行长与宽，创建两个Rectangle对象放入相应的数组。
输入2行半径，创建两个Circle对象放入相应的数组。
输出1：上面2个数组中的所有对象的周长加总。
输出2：上面2个数组中的所有对象的面积加总。
最后需使用Arrays.deepToString分别输出上面建立的Rectangle数组与Circle数组
思考：如果初次做该题会发现代码冗余严重。使用继承、多态思想可以大幅简化上述代码。

输入样例:

输出样例:

69
170
[Rectangle [width=1, length=2], Rectangle [width=3, length=4]]
[Circle [radius=7], Circle [radius=1]]

import java.util.*;
class Rectangle{
    private int width,length;
    public Rectangle(int width,int length){
        this.width=width;
        this.length=length;
    }
    public int getPerimeter(){
        return (width+length)*2;
    }
    public int getArea(){
        return width*length;
    }
    public String toString(){
        return "Rectangle [width="+width+", length="+length+"]";
    }
}
class Circle{
    private int radius;
    public Circle(int radius){
        this.radius=radius;
    }
    public int getPerimeter(){
        double res=2*Math.PI*radius;
        return (int)res;
    }
    public int getArea(){
        double res=Math.PI*radius*radius;
        return (int)res;
    }
    public String toString(){
        return "Circle [radius="+radius+"]";
    }
}
public class Main{
    public static void main(String args[]){
        Scanner in = new Scanner(System.in);
        Rectangle []rect=new Rectangle[2];
        Circle [] cir=new Circle[2];
        int x,y;
        for(int i=0;i<2;i++){
            x=in.nextInt();y=in.nextInt();
            rect[i]=new Rectangle(x,y);
        }
        for(int i=0;i<2;i++){
            x=in.nextInt();
           cir[i]=new Circle(x);
        }
        int psum=rect[0].getPerimeter()+rect[1].getPerimeter();
        psum+=cir[0].getPerimeter()+cir[1].getPerimeter();
        int asum=rect[0].getArea()+rect[1].getArea();
        asum+=cir[0].getArea()+cir[1].getArea();
        System.out.println(psum);
        System.out.println(asum);
        System.out.println(Arrays.toString(rect));
        System.out.println(Arrays.deepToString(cir));
    }
}

7-9jmu-Java-02基本语法-01-综合小测验

运行程序后可以输入4个选项，分别为：fib,sort,search,getBirthDate

fib:根据输入n，打印斐波那契数列。比如输入：3，输出：1 1 2

sort:输入一串数字，然后进行排序并输出，注意数组元素输出的格式为使用[ ]包括。提示：可直接使用函数Arrays相关方法处理输出。

search:如果找到返回所找到的位置，如果没找到，返回-1。提示：可以先对数组排序，然后使用Arrays相关函数进行查找。

getBirthDate:输入n个身份证，然后把输入的n个身份号的年月日抽取出来，按年-月-日格式输出。

当输入不是这几个字符串(fib,sort,search,getBirthDate)的时候，显示exit并退出程序。

注意：在处理输入的时候，尽量只使用Scanner的nextLine()方法接收输入，不要将nextLine()与其它next方法混用，否则可能会出现行尾回车换行未处理影响下次输入的情况。

参考：jdk文档的Arrays，String

输入格式:

fib
3
sort
-1 10 3 2 5
search
-1
search
0
getBirthDate
1
330226196605054190
e

输出格式:

1 1 2
[-1, 2, 3, 5, 10]
0
-1
1966-05-05
exit

import java.util.*;
import java.io.*;
public class Main{
    public static void main(String args[]){
        Scanner in = new Scanner(System.in);
        String str;
        int []fibb=new int[201];
        fibb[0]=1;fibb[1]=1;
        for(int i=2;i<201;i++){
            fibb[i]=fibb[i-1]+fibb[i-2];
        }
        int []arr=new int[200];
        int arrLen=0;
        while(true){
            str=in.nextLine();
            if(str.equals("fib")){
                str=in.nextLine();
                int x=Integer.parseInt(str);
                System.out.printf("%d",fibb[0]);
                for(int i=1;i<x;i++){
                    System.out.printf(" %d",fibb[i]);
                }
                System.out.println();
            }else if(str.equals("sort")){
                str=in.nextLine();
                String []strSplit=str.split("\\s+");
                arrLen=strSplit.length;
                for(int i=0;i<arrLen;i++){
                    arr[i]=Integer.parseInt(strSplit[i]);
                }
                Arrays.sort(arr,0,arrLen);
                System.out.printf("[%d",arr[0]);
                for(int i=1;i<arrLen;i++){
                    System.out.printf(", %d",arr[i]);
                }
                System.out.println("]");
            }else if(str.equals("search")){
                str=in.nextLine();
                int x=Integer.parseInt(str);
                boolean f=false;
                for(int i=0;i<arrLen;i++){
                    if(x==arr[i]){
                        System.out.println(i);
                        f=true;
                        break;
                    }
                }
                if(f==false)System.out.println(-1);
            }else if(str.equals("getBirthDate")){
                str=in.nextLine();
                int n=Integer.parseInt(str);
                String []id=new String[n];
                for(int i=0;i<n;i++){
                    id[i]=in.nextLine();
                }
                for(int i=0;i<n;i++){
                    String tmp=id[i].substring(6,10)+"-"+id[i].substring(10,12)+"-"+id[i].substring(12,14);
                    System.out.println(tmp);
                }
            }else{
                System.out.println("exit");
                break;
            }
        }
    }
}

7-10jmu-Java-02基本语法-04-动态数组

根据输入的n，打印n行乘法口诀表。
需要使用二维字符串数组存储乘法口诀表的每一项，比如存放1*1=1.
为了保证程序中使用了二维数组，需在打印完乘法口诀表后使用Arrays.deepToString打印二维数组中的内容。

提醒：格式化输出可使用String.format或者System.out.printf。
输出格式说明
每行末尾无空格。
每一项表达式之间(从第1个表达式的第1个字符算起到下一个表达式的首字符之间)，共有包含7个字符。如21=2 22=4从第1个2开始到第二项``2*2=4`首字母之间，总共有7个字符(包含空格，此例中包含2个空格)。
输入样例:

2
5

输出样例:

1*1=1
2*1=2  2*2=4
[[1*1=1], [2*1=2, 2*2=4]]
1*1=1
2*1=2  2*2=4
3*1=3  3*2=6  3*3=9
4*1=4  4*2=8  4*3=12 4*4=16
5*1=5  5*2=10 5*3=15 5*4=20 5*5=25
[[1*1=1], [2*1=2, 2*2=4], [3*1=3, 3*2=6, 3*3=9], [4*1=4, 4*2=8, 4*3=12, 4*4=16], [5*1=5, 5*2=10, 5*3=15, 5*4=20, 5*5=25]]

import java.util.*;
public class Main{
    public static void main(String args[]){
        Scanner in =new Scanner(System.in);
        while(true){ //此方法读入未知数量的键盘输入
                String str;
                if ((str = in.nextLine()).equals(""))break;
                int n=Integer.parseInt(str);
                String [][]mul=new String[n][];
                for(int i=0;i<n;i++){
                    mul[i]=new String[i+1];
                    for(int j=0;j<i+1;j++){
                        mul[i][j]=(i+1)+"*"+(j+1)+"="+(i+1)*(j+1);
                    }
                }
                for(int i=0;i<n;i++){
                    for(int j=0;j<i+1;j++){
                    //%-3d表示用空格在右侧填充
                        if(j!=i)System.out.printf("%d*%d=%-3d",i+1,j+1,(i+1)*(j+1));
                        else System.out.printf("%d*%d=%d",i+1,j+1,(i+1)*(j+1));
                    }
                    System.out.println();
                }
                System.out.println(Arrays.deepToString(mul));
        }
        
    }
}

7-11jmu-Java-02基本语法-07-大整数相加

有若干大整数，需要对其进行求和操作。

输入格式
每行输入一个字符串代表一个大整数，连续输入若干行，当某行字符为e或E时退出。

输入样例:

42846280183517070527831839425882145521227251250327
55121603546981200581762165212827652751691296897789
e

输出样例:

97967883730498271109594004638709798272918548148116

import java.util.*;
import java.math.BigInteger;
public class Main{
    public static void main(String args[]){
        Scanner in=new Scanner(System.in);
        String str;
        BigInteger res=BigInteger.valueOf(0);
        while(true){
            str=in.nextLine();
            if(str.equals("e")||str.equals("E")){
                break;
            }
            
            BigInteger a=new BigInteger(str);
            res=res.add(a);
        }
        System.out.println(res);
    }
}

7-12jmu-Java-03面向对象基础-05-覆盖

Java每个对象都继承自Object,都有equals、toString等方法。
现在需要定义PersonOverride类并覆盖其toString与equals方法。

新建PersonOverride类
a. 属性：String name、int age、boolean gender，所有的变量必须为私有(private)。
b. 有参构造方法，参数为name, age, gender
c. 无参构造方法，使用this(name, age,gender)调用有参构造方法。参数值分别为"default",1,true
d.toString()方法返回格式为：name-age-gender
e. equals方法需比较name、age、gender，这三者内容都相同，才返回true.
main方法
2.1 输入n1，使用无参构造方法创建n1个对象，放入数组persons1。
2.2 输入n2，然后指定name age gender。每创建一个对象都使用equals方法比较该对象是否已经在数组中存在，如果不存在，才将该对象放入数组persons2。
2.3 输出persons1数组中的所有对象
2.4 输出persons2数组中的所有对象
2.5 输出persons2中实际包含的对象的数量
2.5 使用System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));输出PersonOverride的所有构造方法。

提示：使用ArrayList代替数组大幅复简化代码，请尝试重构你的代码。

输入样例:

1
3
zhang 10 true
zhang 10 true
zhang 10 false

输出样例:

default-1-true
zhang-10-true
zhang-10-false
2
[public PersonOverride(), public PersonOverride(java.lang.String,int,boolean)]

import java.util.*;
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 String toString(){
        return name+"-"+age+"-"+gender;
    }
    public boolean equals(String name,int age,boolean gender){
        if(this.name.equals(name)&&this.age==age&&this.gender==gender)
            return true;
        else return false;
    }
}
public class Main{
    public static void main(String args[]){
        Scanner in=new Scanner(System.in);
        String str=in.nextLine();
        int n1=Integer.parseInt(str);
        str=in.nextLine();
        int n2=Integer.parseInt(str);
        PersonOverride []person1=new PersonOverride[n1];
        for(int i=0;i<n1;i++){
            person1[i]=new PersonOverride();
        }
        PersonOverride []person2=new PersonOverride[n2];
        int k=0;
        for(int i=0;i<n2;i++){
            str=in.nextLine();
            String []ps=str.split("\\s+");
            PersonOverride tmp=new PersonOverride(ps[0],Integer.parseInt(ps[1]),Boolean.parseBoolean(ps[2]));
            Boolean f=false;
            for(int j=0;j<k;j++){
                if(person2[j].equals(ps[0],Integer.parseInt(ps[1]),Boolean.parseBoolean(ps[2]))==true){
                    //System.out.println("find");
                    f=true;break;
                }
            }
            if(f==false){
                person2[k]=new PersonOverride(ps[0],Integer.parseInt(ps[1]),Boolean.parseBoolean(ps[2]));
                k++;
            }
        }
        for(int i=0;i<n1;i++){
            System.out.println(person1[i]);
        }
        for(int i=0;i<k;i++){
            System.out.println(person2[i]);
        }
        System.out.println(k);
        System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));
    }
}

sylviiiiiia

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Java程序设计2023-第二次上机练习

编写一个复数类，可以进行复数加法和减法运算。编写一个包含main方法的类测试该复数类。要求该复数类至少包含一个无参的构造方法和一个带参的构造方法；数据成员包括复数的实部和虚部，为double类型；包括两个方法，分别实现复数的加法和减法运算。输入格式:输入两个复数。输入为两行，每一行为一个复数的实部和虚部，用空格隔开。输出格式:输出复数加法和减法结果。输出为4行，第一行和第二行输出两个复数，第三行为两个复数的加法运算结果，第四行为减法运算结果。输入样例:在这里给出两组输入。1 2。
复制链接

扫一扫