Java创建random.txt存500个随机整数并运行通用算法，解决编译失败

一、常见命令行编译报错排查 #

• 类名与文件名不匹配：Java要求public修饰的类名必须与.java文件名完全一致，比如定义了public class Common_Algo，对应文件名必须是Common_Algo.java，否则编译器会直接抛出类定义找不到的错误
• 必要导入缺失：使用文件读写、随机数生成、控制台输入功能时，未导入对应的JDK类，比如缺少java.io.*、java.util.Scanner、java.util.Random的导入语句，会触发“找不到符号”的编译错误
• 语法格式不规范：语句末尾漏写分号、switch分支缺少break导致逻辑穿透、数组访问下标越界、字符串转义错误（比如Windows路径书写时单反斜杠会被识别为转义字符，需要写成双反斜杠）
• 运行环境配置错误：未配置JDK环境变量，导致命令行无法识别javac、java命令

二、符合要求的程序实现 #

程序拆分为两个独立文件，完全满足封装、菜单交互、文件读写的要求：

1. 公共算法类 Common_Algo.java #

该类内部封装长度为500的整型数组实例变量，所有数组操作方法均在类内部实现，不对外暴露数组修改权限

import java.util.Arrays;

// 公共算法类
public class Common_Algo {
    // 固定长度500的整型数组作为类实例变量
    private final int[] arr = new int[500];

    // 构造方法：用读取的源数组数据填充内部数组
    public Common_Algo(int[] sourceData) {
        // 校验源数据长度匹配，避免越界
        if (sourceData.length != 500) {
            throw new IllegalArgumentException("源数据长度必须为500");
        }
        System.arraycopy(sourceData, 0, this.arr, 0, 500);
    }

    // 方法1：输出所有数组值
    public void printAllElements() {
        System.out.println("数组所有元素：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
            // 每10个元素换一行，避免打印过长
            if ((i + 1) % 10 == 0) System.out.println();
        }
        System.out.println();
    }

    // 方法2：输出总和与平均值
    public void printSumAndAvg() {
        int sum = 0;
        for (int num : arr) sum += num;
        double avg = (double) sum / arr.length;
        System.out.printf("数组总和：%d，平均值：%.2f%n", sum, avg);
    }

    // 方法3：输出所有奇数
    public void printOddNumbers() {
        System.out.println("数组中的所有奇数：");
        int count = 0;
        for (int num : arr) {
            if (num % 2 != 0) {
                System.out.print(num + "\t");
                count++;
                if (count % 10 == 0) System.out.println();
            }
        }
        System.out.println();
    }

    // 方法4：输出所有偶数
    public void printEvenNumbers() {
        System.out.println("数组中的所有偶数：");
        int count = 0;
        for (int num : arr) {
            if (num % 2 == 0) {
                System.out.print(num + "\t");
                count++;
                if (count % 10 == 0) System.out.println();
            }
        }
        System.out.println();
    }

    // 方法5：输出数组中间值（500个元素取第250、251位的均值）
    public void printMiddleValue() {
        // 下标从0开始，500个元素的中间位置为索引249、250
        int mid1 = arr[249];
        int mid2 = arr[250];
        double midAvg = (mid1 + mid2) / 2.0;
        System.out.printf("数组中间两个值为%d、%d，中间值均值为%.2f%n", mid1, mid2, midAvg);
    }

    // 方法6：输出首元素
    public void printFirstElement() {
        System.out.println("数组首元素：" + arr[0]);
    }

    // 方法7：输出末元素
    public void printLastElement() {
        System.out.println("数组末元素：" + arr[arr.length - 1]);
    }

    // 方法8：搜索指定值，返回出现的位置
    public void searchValue(int target) {
        System.out.println("搜索值" + target + "的结果：");
        boolean found = false;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == target) {
                System.out.printf("值出现位置为索引%d（第%d个元素）%n", i, i + 1);
                found = true;
            }
        }
        if (!found) {
            System.out.println("数组中不存在该值");
        }
    }

    // 方法9：输出排序后的数组（不修改原数组结构）
    public void printSortedArray() {
        // 拷贝原数组到临时变量，避免排序破坏原数组顺序
        int[] sortedArr = Arrays.copyOf(arr, arr.length);
        Arrays.sort(sortedArr);
        System.out.println("升序排序后的数组：");
        for (int i = 0; i < sortedArr.length; i++) {
            System.out.print(sortedArr[i] + "\t");
            if ((i + 1) % 10 == 0) System.out.println();
        }
        System.out.println();
    }

    // 方法10：输出最高值及其所在位置
    public void printMaxValueWithIndex() {
        int max = arr[0];
        int index = 0;
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
                index = i;
            }
        }
        System.out.printf("数组最高值为%d，所在位置为索引%d（第%d个元素）%n", max, index, index + 1);
    }

    // 方法11：输出最低值及其所在位置
    public void printMinValueWithIndex() {
        int min = arr[0];
        int index = 0;
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < min) {
                min = arr[i];
                index = i;
            }
        }
        System.out.printf("数组最低值为%d，所在位置为索引%d（第%d个元素）%n", min, index, index + 1);
    }
}

2. 主程序类 Main.java #

主方法完全独立于Common_Algo类，负责全流程控制：生成随机数、写入/读取random.txt、展示交互菜单、调用算法类方法

import java.io.*;
import java.util.Random;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        final String FILE_PATH = "random.txt";
        int[] dataArr = new int[500];

        // 第一步：检查random.txt是否存在，不存在则生成500个1-1000的随机数并写入
        File randomFile = new File(FILE_PATH);
        if (!randomFile.exists()) {
            System.out.println("检测到random.txt不存在，正在生成随机数文件...");
            Random random = new Random();
            for (int i = 0; i < 500; i++) {
                // 生成1-1000的随机整数
                dataArr[i] = random.nextInt(1000) + 1;
            }
            // 写入文件
            try (BufferedWriter writer = new BufferedWriter(new FileWriter(FILE_PATH))) {
                for (int num : dataArr) {
                    writer.write(num + " ");
                }
                System.out.println("random.txt生成完成");
            } catch (IOException e) {
                System.out.println("文件写入失败：" + e.getMessage());
                return;
            }
        } else {
            // 第二步：从已存在的random.txt读取500个整数
            System.out.println("检测到random.txt存在，正在读取文件数据...");
            try (BufferedReader reader = new BufferedReader(new FileReader(FILE_PATH))) {
                String content = reader.readLine();
                String[] numStrs = content.split(" ");
                for (int i = 0; i < 500; i++) {
                    dataArr[i] = Integer.parseInt(numStrs[i]);
                }
            } catch (IOException | NumberFormatException e) {
                System.out.println("文件读取失败，请检查random.txt内容是否合法：" + e.getMessage());
                return;
            }
        }

        // 实例化Common_Algo对象，通过构造方法传入读取的数组
        Common_Algo algo = new Common_Algo(dataArr);
        Scanner scanner = new Scanner(System.in);

        // 第三步：循环展示交互菜单，用switch实现分支逻辑
        while (true) {
            System.out.println("\n===== 程序功能菜单 =====");
            System.out.println("1. 输出所有数组值");
            System.out.println("2. 输出数组总和与平均值");
            System.out.println("3. 输出所有奇数");
            System.out.println("4. 输出所有偶数");
            System.out.println("5. 输出数组中间值");
            System.out.println("6. 输出数组首元素");
            System.out.println("7. 输出数组末元素");
            System.out.println("8. 输入值搜索");
            System.out.println("9. 输出排序后的数组");
            System.out.println("10. 输出最高值及其位置");
            System.out.println("11. 输出最低值及其位置");
            System.out.println("12. 退出程序");
            System.out.print("请输入选项编号：");

            int option = scanner.nextInt();
            switch (option) {
                case 1:
                    algo.printAllElements();
                    break;
                case 2:
                    algo.printSumAndAvg();
                    break;
                case 3:
                    algo.printOddNumbers();
                    break;
                case 4:
                    algo.printEvenNumbers();
                    break;
                case 5:
                    algo.printMiddleValue();
                    break;
                case 6:
                    algo.printFirstElement();
                    break;
                case 7:
                    algo.printLastElement();
                    break;
                case 8:
                    System.out.print("请输入要搜索的整数：");
                    int target = scanner.nextInt();
                    algo.searchValue(target);
                    break;
                case 9:
                    algo.printSortedArray();
                    break;
                case 10:
                    algo.printMaxValueWithIndex();
                    break;
                case 11:
                    algo.printMinValueWithIndex();
                    break;
                case 12:
                    System.out.println("程序退出");
                    scanner.close();
                    return;
                default:
                    System.out.println("输入的选项无效，请重新输入");
            }
        }
    }
}

三、命令行编译与运行步骤 #

• 把上面两个代码内容分别保存为Common_Algo.java和Main.java，放在同一个文件夹下
• 打开命令提示符，切换到该文件夹路径，执行编译命令：javac Common_Algo.java Main.java
• 编译完成后执行运行命令：java Main，程序会自动在运行目录生成random.txt文件并启动菜单交互

内容的提问来源于stack exchange，提问作者Rebel