Java习题

1.题目

使用Java的输入、输出流将一个文本文件的内容按行读出，每读出一行就顺序添加行号，并写入到另一个文件中。

代码及详细注释

import java.io.*; // 导入Java I/O库中的所有类

public class E { // 定义一个公共类E
    public static void main(String args[]) { // 主方法，程序的入口
        File file = new File("E.java"); // 创建一个File对象，表示要读取的文件"E.java"
        File tempFile = new File("temp.txt"); // 创建一个File对象，表示要写入的文件"temp.txt"
        
        try { // 开始一个try块，用于捕获和处理可能的IO异常
            FileReader inOne = new FileReader(file); // 创建FileReader对象，读取"E.java"文件内容
            BufferedReader inTwo = new BufferedReader(inOne); // 用BufferedReader包装FileReader，提供缓冲功能，提高读取效率
            FileWriter tofile = new FileWriter(tempFile); // 创建FileWriter对象，用于将内容写入"temp.txt"文件
            BufferedWriter out = new BufferedWriter(tofile); // 用BufferedWriter包装FileWriter，提供缓冲功能，提高写入效率
            
            String s = null; // 定义一个字符串变量s，初始化为null，用于存储每行读取的数据
            int i = 0; // 定义一个整数变量i，初始化为0，用于记录行号
            
            s = inTwo.readLine(); // 读取文件的第一行，并将其存储到字符串变量s中
            while (s != null) { // 当读取的行不为null时，进入循环
                i++; // 增加行号计数器
                out.write(i + " " + s); // 将当前行号和读取的内容写入到"temp.txt"文件中
                out.newLine(); // 写入一个新行符
                s = inTwo.readLine(); // 读取文件的下一行
            }
            
            // 关闭所有流，释放资源
            inOne.close(); // 关闭FileReader流
            inTwo.close(); // 关闭BufferedReader流
            out.flush(); // 刷新BufferedWriter流，确保所有缓冲数据都被写入
            out.close(); // 关闭BufferedWriter流
            tofile.close(); // 关闭FileWriter流
        } catch (IOException e) { // 捕获和处理IO异常
            e.printStackTrace(); // 打印异常信息到标准错误输出
        }
    }
}

代码执行过程

1. 文件对象创建：

   • File file = new File("E.java");：表示要读取的原始文件。
   • File tempFile = new File("temp.txt");：表示要写入的新文件。

2. 文件流初始化：

   • FileReader 和 BufferedReader 用于从 E.java 文件中按行读取文本。
   • FileWriter 和 BufferedWriter 用于将文本写入 temp.txt 文件，并为每一行添加行号。

3. 读取与写入：

   • 循环读取 E.java 文件的每一行，将行号与文本内容拼接后写入 temp.txt。

4. 流的关闭：

   • 在操作完成后，关闭所有打开的流以释放资源，并刷新 BufferedWriter 确保所有数据写入文件。

5. 异常处理：

   • 使用 try-catch 捕获 IOException 并打印异常堆栈跟踪。
     以下是图片中的Java代码题目及详细注释：

2.题目

计算8 + 88 + 888 + …前10项之和

编写应用程序，使用 for 循环语句计算 8 + 88 + 888 + ... 前10项之和。

代码及详细注释

public class Main { // 定义公共类 Main
    public static void main(String args[]) { // 主方法，程序的入口
        int m = 8, i = 1; // 定义整数变量m为8，i为1
        long item = 8; // 定义长整型变量item为8，用于表示每项的值
        long sum = 0; // 定义长整型变量sum为0，用于累加前10项的和

        // for循环，i从1循环到10，每次循环执行一次
        for (i = 1, sum = 0, item = m; i <= 10; i++) {
            sum = sum + item; // 将当前项的值加到sum中
            item = item * 10 + m; // 计算下一项的值，每次循环item变成之前的值乘以10再加上m
        }

        System.out.println(sum); // 输出前10项的总和
    }
}

代码执行过程

1. 变量初始化：

   • m = 8：每一项的基数。
   • i = 1：循环控制变量。
   • item = 8：每一项的初始值为8。
   • sum = 0：用于累加前10项的和。

2. 循环计算：

   • for (i = 1, sum = 0, item = m; i <= 10; i++)：循环从1开始到10结束，每次循环：
     • sum = sum + item;：将当前项的值累加到 sum 中。
     • item = item * 10 + m;：计算下一项的值（例如：8、88、888…）。

3. 输出结果：

   • System.out.println(sum);：输出前10项的总和。

这段代码利用了 for 循环来依次生成每一项的值，并将其累加到 sum 中，最终输出前10项的总和。
以下是图片中的Java代码题目及详细注释：

3.题目

计算数的和以及平均值

第3章中例子9的程序允许用户在键盘依次输入若干个数字（每输入一个数字都需要按回车键确认），程序将计算出这些数的和以及平均值。请在第3章的例子9中增加断言语句，当用户输入的数字大于100或小于0时，程序立刻终止执行，并提示这是一个非法的成绩数据。

输出样例：

3个数的和为21.000000
3个数的平均值是7.000000

代码及详细注释

import java.util.*; // 导入Java实用工具包中的所有类

public class Main { // 定义公共类Main
    public static void main(String args[]) { // 主方法，程序的入口
        Scanner reader = new Scanner(System.in); // 创建Scanner对象，从标准输入流读取用户输入
        double sum = 0; // 定义双精度变量sum，初始化为0，用于存储输入数字的累加和
        int m = 0; // 定义整数变量m，初始化为0，用于记录输入数字的个数
        
        // 使用while循环读取用户输入的双精度数字，直到输入流中没有更多的数字
        while (reader.hasNextDouble()) {
            double x = reader.nextDouble(); // 读取用户输入的下一个双精度数字
            assert x <= 100 && x >= 0 : "数据不合理"; // 断言输入的数字在0到100之间，若不满足则抛出异常并终止程序
            m = m + 1; // 数字个数计数器增加1
            sum = sum + x; // 将输入的数字累加到sum中
        }
        
        // 使用printf方法格式化输出结果
        System.out.printf("%d个数的和为%f\n", m, sum); // 输出输入数字的总和
        System.out.printf("%d个数的平均值是%f\n", m, sum / m); // 输出输入数字的平均值
    }
}

代码执行过程

1. 初始化变量：

   • Scanner reader = new Scanner(System.in);：创建 Scanner 对象，用于从标准输入读取用户输入。
   • double sum = 0;：初始化 sum 变量，用于累加用户输入的数字之和。
   • int m = 0;：初始化 m 变量，用于记录输入数字的个数。

2. 输入处理和断言：

   • while (reader.hasNextDouble())：循环读取用户输入的数字，直到输入流中没有更多数字。
   • double x = reader.nextDouble();：读取下一个双精度数字。
   • assert x <= 100 && x >= 0 : "数据不合理";：断言输入数字在 0 到 100 之间，若不满足则输出 数据不合理 并终止程序。

3. 累加和计算：

   • m = m + 1;：增加计数器 m，表示输入的数字个数。
   • sum = sum + x;：累加输入的数字到 sum 中。

4. 输出结果：

   • System.out.printf("%d个数的和为%f\n", m, sum);：输出输入数字的总和。
   • System.out.printf("%d个数的平均值是%f\n", m, sum / m);：输出输入数字的平均值。

这段代码通过 while 循环从标准输入读取双精度数字，使用断言检查输入数字的范围，并计算总和和平均值。在完成所有输入后，使用 printf 格式化输出总和和平均值。
以下是图片中的Java代码题目及详细注释：

4.题目

public char charAt(int index)方法

String类的 public char charAt(int index) 方法可以得到当前字符串 index 位置上的一个字符。编写程序使用该方法得到一个字符串中的第一个和最后一个字符。

例如测试的字符串为：ABCDabcd

代码及详细注释

public class Main { // 定义公共类 Main
    public static void main(String args[]) { // 主方法，程序的入口
        String s = "ABCDabcd"; // 定义字符串变量s并初始化为"ABCDabcd"
        
        // 使用charAt方法获取字符串s的第一个字符
        char cStart = s.charAt(0); // 通过索引0获取字符串的第一个字符，并存储到字符变量cStart中
        
        // 使用charAt方法获取字符串s的最后一个字符
        char cEnd = s.charAt(s.length() - 1); // 通过索引s.length() - 1获取字符串的最后一个字符，并存储到字符变量cEnd中
        
        // 输出第一个字符和最后一个字符
        System.out.println(cStart); // 打印第一个字符cStart
        System.out.println(cEnd); // 打印最后一个字符cEnd
    }
}

代码执行过程

1. 字符串初始化：

   • String s = "ABCDabcd";：定义并初始化字符串 s。

2. 获取字符：

   • char cStart = s.charAt(0);：使用 charAt 方法获取字符串 s 的第一个字符，即索引位置为 0 的字符 'A'，并将其存储在 cStart 中。
   • char cEnd = s.charAt(s.length() - 1);：使用 charAt 方法获取字符串 s 的最后一个字符，即索引位置为 s.length() - 1 的字符 'd'，并将其存储在 cEnd 中。

3. 输出结果：

   • System.out.println(cStart);：打印 cStart 的值，即字符串的第一个字符 'A'。
   • System.out.println(cEnd);：打印 cEnd 的值，即字符串的最后一个字符 'd'。

这段代码通过 charAt 方法获取字符串中指定索引位置的字符，并分别获取字符串的第一个和最后一个字符进行输出。

以下是图片中的Java代码题目及详细注释：

5.题目

public String toUpperCase()方法

字符串调用 public String toUpperCase() 方法返回一个字符串，该字符串把当前字符串中的小写字母变成大写字母；
字符串调用 public String toLowerCase() 方法返回一个字符串，该字符串把当前字符串中的大写字母变成小写字母。
String 类的 public String concat(String str) 方法返回一个字符串，该字符串是把调用该方法的字符串与参数指定的字符串连接。编写一个程序，练习使用这3个方法。

测试字符串为：“ABCDabcd”

代码及详细注释

public class Main { // 定义公共类 Main
    public static void main(String args[]) { // 主方法，程序的入口
        String s1, s2, t1 = "ABCDabcd"; // 定义字符串s1, s2，初始化t1为"ABCDabcd"
        
        // 使用toUpperCase方法将t1转换为大写，并赋值给s1
        s1 = t1.toUpperCase(); // 调用toUpperCase方法，将字符串t1转换为大写并赋值给s1
        
        // 使用toLowerCase方法将t1转换为小写，并赋值给s2
        s2 = t1.toLowerCase(); // 调用toLowerCase方法，将字符串t1转换为小写并赋值给s2
        
        // 输出转换后的大写字符串s1
        System.out.println(s1); // 打印大写的字符串s1，即"ABCDABCD"
        
        // 输出转换后的小写字符串s2
        System.out.println(s2); // 打印小写的字符串s2，即"abcdabcd"
        
        // 使用concat方法将s1和s2连接，并赋值给s3
        String s3 = s1.concat(s2); // 调用concat方法，将字符串s1与s2连接，结果赋值给s3
        
        // 输出连接后的字符串s3
        System.out.println(s3); // 打印连接后的字符串s3，即"ABCDABCDabcdabcd"
    }
}

代码执行过程

1. 字符串初始化：

   • String s1, s2, t1 = "ABCDabcd";：定义字符串 s1、s2，并初始化字符串 t1 为 "ABCDabcd"。

2. 字符串转换：

   • s1 = t1.toUpperCase();：将字符串 t1 中的所有小写字母转换为大写，结果为 "ABCDABCD"，并将其赋值给 s1。
   • s2 = t1.toLowerCase();：将字符串 t1 中的所有大写字母转换为小写，结果为 "abcdabcd"，并将其赋值给 s2。

3. 输出转换结果：

   • System.out.println(s1);：打印大写转换后的字符串 s1，即 "ABCDABCD"。
   • System.out.println(s2);：打印小写转换后的字符串 s2，即 "abcdabcd"。

4. 字符串连接：

   • String s3 = s1.concat(s2);：将字符串 s1 和 s2 连接，结果为 "ABCDABCDabcdabcd"，并将其赋值给 s3。

5. 输出连接结果：

   • System.out.println(s3);：打印连接后的字符串 s3，即 "ABCDABCDabcdabcd"。

通过使用 toUpperCase、toLowerCase 和 concat 方法，这段代码展示了如何转换字符串的大小写以及如何连接两个字符串。
以下是图片中的Java代码题目及详细注释：

6.题目

计算数的和以及平均值

第3章中例子9的程序允许用户在键盘依次输入若干个数字（每输入一个数字都需要按回车键确认），程序将计算出这些数的和以及平均值。请在第3章的例子9中增加断言语句，当用户输入的数字大于100或小于0时，程序立刻终止执行，并提示这是一个非法的成绩数据。

输出样例：

3个数的和为21.000000
3个数的平均值是7.000000

代码及详细注释

import java.util.*; // 导入Java实用工具包中的所有类

public class Main { // 定义公共类Main
    public static void main(String args[]) { // 主方法，程序的入口
        Scanner reader = new Scanner(System.in); // 创建Scanner对象，从标准输入流读取用户输入
        double sum = 0; // 定义双精度变量sum，初始化为0，用于存储输入数字的累加和
        int m = 0; // 定义整数变量m，初始化为0，用于记录输入数字的个数
        
        // 使用while循环读取用户输入的双精度数字，直到输入流中没有更多的数字
        while (reader.hasNextDouble()) {
            double x = reader.nextDouble(); // 读取用户输入的下一个双精度数字
            assert x <= 100 && x >= 0 : "数据不合理"; // 断言输入的数字在0到100之间，若不满足则抛出异常并终止程序
            m = m + 1; // 数字个数计数器增加1
            sum = sum + x; // 将输入的数字累加到sum中
        }
        
        // 使用printf方法格式化输出结果
        System.out.printf("%d个数的和为%f\n", m, sum); // 输出输入数字的总和
        System.out.printf("%d个数的平均值是%f\n", m, sum / m); // 输出输入数字的平均值
    }
}

代码执行过程

1. 导入包：

   • import java.util.*;：导入 java.util 包中的所有类，用于使用 Scanner 类进行输入操作。

2. 定义主类和主方法：

   • public class Main { ... }：定义主类 Main。
   • public static void main(String args[]) { ... }：主方法，程序的入口。

3. 创建输入对象和初始化变量：

   • Scanner reader = new Scanner(System.in);：创建 Scanner 对象，从标准输入流（键盘）读取用户输入。
   • double sum = 0;：定义双精度变量 sum，用于累加输入的数字之和。
   • int m = 0;：定义整数变量 m，用于记录输入数字的个数。

4. 读取输入并计算：

   • while (reader.hasNextDouble()) { ... }：使用 while 循环读取用户输入的双精度数字，直到输入流中没有更多的数字。
   • double x = reader.nextDouble();：读取用户输入的下一个双精度数字并赋值给 x。
   • assert x <= 100 && x >= 0 : "数据不合理";：使用断言检查输入的数字是否在 0 到 100 之间，若不满足则输出 "数据不合理" 并终止程序。
   • m = m + 1;：增加计数器 m，表示输入的数字个数。
   • sum = sum + x;：将输入的数字累加到 sum 中。

5. 输出结果：

   • System.out.printf("%d个数的和为%f\n", m, sum);：格式化输出输入数字的总和。
   • System.out.printf("%d个数的平均值是%f\n", m, sum / m);：格式化输出输入数字的平均值。

这段代码通过 Scanner 类从标准输入读取数字，使用断言确保输入数字的范围在 0 到 100 之间，累加这些数字并计算它们的平均值，最后格式化输出结果。