java选做实验4常用集合类使用

(1). 编写Java应用程序，根据用户输入的5个时间（每行一个时间），计算相邻两个时间之间的间隔，共4个结果。注：用户输入的时间格式为“××××年××月××日××时××分××秒”，输出的时间格式为“××日××时××分××秒”。在报告中附上程序截图、完整的运行结果截图和简要文字说明。

该题计算时间和输出时间时，主要用到Date类和日期格式化类SimpleDateFormat。输入时按中文字符串输入，所以处理时也要用到Scanner字符串解析器

源代码如下：

main类中输入字符串处理部分：

主要就是用times来接收输入的时间，date来存储格式化后的日期，将每个日期按字符串输入后用useDelimiter来分割字符串中的数字。最后对times进行格式化作为最后结果输出。

随后抛出异常方法来对赋值，最后在自定义的countTimeDifferent方法里对时间以及时间差进行输出：

countTimeDifferent方法：主要是对传进来的两个时间做比较之后，得到时间差（单位是毫秒）的绝对值通过手动计算年月日时分秒

（其实本来是将long 类型的different作为参数定义了一个Date对象，然后用Date里面的getYear进行输出，但是结果有误改不对就这样了）

package first;
import java.text.ParseException;
import java.util.Date;
import java.text.SimpleDateFormat;
import java.util.*;
public class first {
 
    static void countTimeDifferent(Date[]date, int num, String []times){
                long []time=new long [num];
                for(int i=0;i
                    time[i]=date[i].getTime();//time接收date表示的时间化为毫秒后的long型数据
                for(int i=0;i1;i++){//num个时间那么就有num-1个时间差
                    if(time[i]>time[i+1]){
                        System.out.print(times[i]+"到"+times[i+1]+"的时间间隔是：");
                    }
                    else{
                        System.out.print(times[i+1]+"到"+times[i]+"的时间间隔是：");
                    }
                    long different=Math.abs(time[i]-time[i+1]);
                    different/=1000;//将时间差化为秒数
                    long year,month,day,hour,minute,second;
                    year=different/(60*60*24*365);//得到相差的年数
                    different-=year*(60*60*24*365);
                    month=different/(60*60*24*30);//得到相差的月数
                    different-=month*(60*60*24*30);
                    day=different/(60*60*24);//得到相差的天数
                    different-=day*(60*60*24);
                    hour=different/(60*60);//得到相差的小时数
                    different-=hour*(60*60);
                    minute=different/60;//得到相差的分钟数
                    different-=minute*60;
                    second=different;//秒数
                    System.out.print(year+"年"+month+"月"+day+"日");
                    System.out.println(hour+"时"+minute+"分"+second+"秒");
                }
    }
        public static void main(String []args){
                System.out.print("请输入要计算的时间差个数:");
                Scanner scanner=new Scanner(System.in);
                int num=scanner.nextInt();
                Date []date=new Date[num];//date用来存储日期
                String []times=new String[num];//times用来存储以string接收的日期
                for(int i=0;i
                    String s1=scanner.next();
                    Scanner input=new Scanner(s1);
                    input.useDelimiter("[^0123456789]+");//除数字外的字符全为分隔符
                    int []time=new int[6];//分别存储年、月、日、时、分、秒6位数字
                    int count=0;//下标变量
                    while(input.hasNext()){
                        try{
                                time[count++]=input.nextInt();
                        }
                        catch(InputMismatchException in){
                                input.next();
                        }
                    }
                    times[i]=time[0]+"年"+time[1]+"月"+time[2]+"日"+time[3]+"时"+time[4]+"分"+time[5]+"秒";//分辨输出
                    SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日HH时mm分ss秒");//格式化
                    try{
                        Date da=sdf.parse(times[i]);
                        long long_num=da.getTime();//将输入的时间化为long类型存储
                        date[i]=new Date(long_num);//给日期初始化
                    }
                    catch(ParseException pa){//出现转化异常
                        pa.printStackTrace();
                    }
                    input.close();
                }
            countTimeDifferent(date,num,times);
            scanner.close();
        }
}
 

最后就是为了验证我的程序，我测试了7个时间两两各差1个单位的时间（而不是5个）

7
2022年11月18日12分12时23秒
2023年11月18日12分12时23秒
2023年12月18日12分12时23秒
2023年12月19日12分12时23秒
2023年12月19日11分12时23秒
2023年12月19日11分13时23秒
2023年12月19日11分13时24秒

(2). 编写Java应用程序，实现稀疏矩阵的加法和乘法运算，其中稀疏矩阵是指矩阵中的大部分元素的值为0。用户在命令行输入矩阵时矩阵的大小可能有错，因此需要使用异常处理。在报告中附上程序截图、完整的运行结果截图和简要文字说明。

首先我想到的是直接写了一个Matrix类来对矩阵进行定义，其中Matrix里面的分别有：

成员变量：行row、列column、矩阵元素数组matrix[][]：

    private int column;//列数
    private int row;//行数
    private int [][]matrix;//矩阵数组

无参构造以及行和列为参数有参构造（矩阵在这步首先是初始化没有具体赋值）：

    public Matrix(){
        column=0;
        row=0;
    }
    public Matrix(int r,int c) {
        row = r;
        column = c;
        matrix = new int[row][column];
    }

对矩阵元素具体赋值的setMatrix方法：

一开始是用C++里面两个for循环逐一赋值的，但是后来突然想起java可以直接一句完事，所以这里有点单调qaq

    public void setMatrix(int [][]m){
        matrix=m;
    }

矩阵输出方法（方便后面四次输出：矩阵1、矩阵2、它们的和以及乘积）：

    public void print(){
        for(int i=0;i
            for(int j=0;j
                System.out.print(matrix[i][j]+" ");
            System.out.println();
        }
    }

矩阵相加方法：

在相加的方法的参数里面我传进去了一个Matrix类 matrix1作为相加的矩阵，方法内部首先判断两矩阵能否相加（默认类的matrix和传进来的matrix1的矩阵都是合法的），另外在方法内部我重新定义了一个Matrix类matrix2用来接收两矩阵相加的和，对matrix2赋值后就输出提示信息并且调用matrix2的print方法来输出相加后得到的新矩阵。

    public void add(Matrix matrix1){
        if(column!=matrix1.column||row!=matrix1.row){
            System.out.println("两矩阵不符合相加条件（行列数均相等），无法相加qwq");
        }
        else{
            Matrix matrix2=new Matrix(column,row);
            for(int i=0;i
                for(int j=0;j
                    matrix2.matrix[i][j]=this.matrix[i][j]+matrix1.matrix[i][j];
            System.out.println("两矩阵相加的结果为：");
            matrix2.print();
        }
    }

矩阵相乘方法：

2和相加的方法类似，在相乘的方法的参数里面我传进去了一个Matrix类 matrix1作为相加的矩阵，方法内部首先判断两矩阵能否相乘（同样默认类的matrix和传进来的matrix1的矩阵都是合法的），另外在方法内部重新定义了一个Matrix类matrix2用来接收两矩阵相乘的积，对matrix2赋值后就输出提示信息并且调用matrix2的print方法来输出相加后得到的新矩阵。

    public void multiply(Matrix matrix1){
        if(column!=matrix1.row){//首先判断矩阵是否满足相乘的条件
            System.out.println("两矩阵不符合相乘条件（左矩阵的列数与右矩阵的行数的相等），无法相乘qwq");
        }
        else{
            Matrix matrix2=new Matrix(row,matrix1.column);
            for(int i=0;i//套用公式子求矩乘积
                for(int j=0;j
                    for(int k=0;k
                        matrix2.matrix[i][j]+=matrix[i][k]*matrix1.matrix[k][j];
            System.out.println("两矩阵相乘的结果为：");
           matrix2.print();
        }
    }

2、main里面：

      要对两个矩阵进行初始化这步不难只是对矩阵进异常处理一开始有点不知所措，最后我想到的还是对输入的矩阵进行输入规范化来做的（矩阵元素当做一行来输入）。

        随后输出输入提示信息，并且输入第一个矩阵的行列：

            int column1,column2,row1,row2;
            Scanner scanner=new Scanner(System.in);
            System.out.print("请分别输入第一个矩阵的行数和列数");
            row1=scanner.nextInt();
            column1=scanner.nextInt();

    然后我定义了一个string来接收矩阵（我的想法是将矩阵作为一行用Scanner的nextLine方法输入），注意nextLine会把之前输入的换行符输入，所以我先让s=scanner的nextLine来去掉上一行的换行符，然后在输出输入提示信息之后再读入有矩阵元素的一行，然后定义一个Scanner类实例input（s为参数），随后以数字外的字符作为分隔符。

            String s=scanner.nextLine();//“吃掉”末尾的换行符
            System.out.println("请输入第一个矩阵");
            s=scanner.nextLine();
            Scanner input=new Scanner(s);
            input.useDelimiter("[^1234567890]+");//数字外都是分隔符
            int [][]matrix=new int[row1][column1];//数组初始化

对matrix初始化大小后利用异常处理对matrix赋值，如图的try里面的语句，如果矩阵输入有异常（越界），那么catch里面的语句就会执行输出错误信息并且退出程序，无误后初始化矩阵matrix1

            try{
                for(int i=0;i
                    for(int j=0;j
                        matrix[i][j]=input.nextInt();
            }
            catch(Exception e){
                System.out.println("第一个矩阵输入有误:"+e);
                return;
            }
            Matrix matrix1=new Matrix(row1,column1);
            matrix1.setMatrix(matrix);

matrix2的初始化与matrix类似

          System.out.print("请分别输入第二个矩阵的行数和列数");
            row2=scanner.nextInt();
            column2=scanner.nextInt();
            s=scanner.nextLine();//“吃掉”末尾的换行符
            System.out.println("请输入第二个矩阵");
            s=scanner.nextLine();
            input=new Scanner(s);
            input.useDelimiter("[^1234567890]+");//数字外都是分隔符
            matrix=new int[row2][column2];
            try{
                for(int i=0;i
                    for(int j=0;j
                        matrix[i][j]=input.nextInt();
            }
            catch(Exception e){
                System.out.println("第二个矩阵输入有误:"+e);
                return;
            }
            Matrix matrix2=new Matrix(row2,column2);
            matrix2.setMatrix(matrix);

最后是输出

            Matrix matrix2=new Matrix(row2,column2);
            matrix2.setMatrix(matrix);
            System.out.println("矩阵1如下：");
            matrix1.print();
            System.out.println("矩阵2如下：");
            matrix2.print();
            System.out.println("两矩阵相加与相乘的结果分别如下：");
            matrix1.add(matrix2);
            matrix1.multiply(matrix2);

测试数据：

3 2
1 2 3 4 5 6
2 3
1 2 3 4 5 6
 
3 3
1 2 3 4 5 6
3 3
1 2 3 4 5 6
 
3 2
1 2 3 4  5 6 
2 3
1 2 3 4 5 6
 
3 3
1 2 3 4 5 6 7 8 9
3 3
1 2 3 4 5 6 7 8 9

应该的没太大问题了吧（大概）