Java嵌套循环中结构化数据收集与处理实践-java教程-PHP中文网

Java嵌套循环中结构化数据收集与处理实践

在java嵌套循环中处理多组相关数据（如学生姓名及其各项成绩）时，直接使用分散的数组难以进行有效的关联和计算。本教程将介绍如何通过面向对象的方法，定义自定义类来封装相关数据，从而实现更清晰的数据收集、存储与后续处理，提升代码的可维护性和功能性，并提供数据类型转换和计算的实践示例。

引言：嵌套循环中的数据收集挑战

在处理需要从用户输入中收集多组相关数据的场景时，例如收集多个学生的姓名、多次测验成绩、期中和期末成绩，我们常常会遇到使用嵌套循环的情况。然而，如果仅仅使用独立的数组来存储这些数据，例如一个数组存姓名，另一个数组存测验成绩，当数据量增大或需要进行复杂计算时，将很难将特定的成绩与对应的学生关联起来，从而导致数据管理混乱，计算困难。

原始代码示例中，虽然成功收集了所有输入，但由于quiz、midterm和myfinal数组在每次外层循环（学生循环）中都被重新创建，这意味着每次循环结束后，前一个学生的成绩数据就会丢失，只有names数组的数据被保留。这使得对单个学生的所有成绩进行加总、平均等操作变得不可能。

// 原始代码片段的问题所在
// String[] quiz = new String[2]; // 在每次学生循环中重新创建
// for (...) { ... quiz[qznumber] = input.next(); }
// ...
// 这些数组的数据在下一次学生循环开始时会被覆盖或丢失

登录后复制

为了解决这一问题，我们需要一种更结构化的方式来存储数据，确保每个学生的所有相关信息都被作为一个整体进行管理。

解决方案：使用面向对象方法封装数据

Java作为一种面向对象的语言，其核心思想就是将相关的数据和操作封装在一个对象中。对于学生及其成绩的场景，最自然的方法就是创建一个Student类来表示一个学生实体。

立即学习“Java免费学习笔记（深入）”；

1. 定义 Student 类

Student类应该包含一个学生的所有属性，例如姓名、测验成绩数组、期中成绩数组和期末成绩数组。为了方便后续的数值计算，我们建议将成绩存储为整数类型（int[]）或浮点数类型（double[]），而不是字符串（String[]）。

集简云

软件集成平台，快速建立企业自动化与智能化

查看详情

public class Student {
    private String name;
    private int[] quizzes;
    private int[] midterms;
    private int[] finals;

    // 构造方法
    public Student(String name, int numQuizzes, int numMidterms, int numFinals) {
        this.name = name;
        this.quizzes = new int[numQuizzes];
        this.midterms = new int[numMidterms];
        this.finals = new int[numFinals];
    }

    // Getter 方法 (用于获取属性值)
    public String getName() {
        return name;
    }

    public int[] getQuizzes() {
        return quizzes;
    }

    public int[] getMidterms() {
        return midterms;
    }

    public int[] getFinals() {
        return finals;
    }

    // Setter 方法 (用于设置属性值，如果需要的话)
    public void setQuizMark(int index, int mark) {
        if (index >= 0 && index < quizzes.length) {
            quizzes[index] = mark;
        } else {
            System.err.println("Error: Quiz index out of bounds.");
        }
    }

    public void setMidtermMark(int index, int mark) {
        if (index >= 0 && index < midterms.length) {
            midterms[index] = mark;
        } else {
            System.err.println("Error: Midterm index out of bounds.");
        }
    }

    public void setFinalMark(int index, int mark) {
        if (index >= 0 && index < finals.length) {
            finals[index] = mark;
        } else {
            System.err.println("Error: Final index out of bounds.");
        }
    }

    // 示例：计算学生总分的方法
    public int calculateTotalScore() {
        int total = 0;
        for (int score : quizzes) {
            total += score;
        }
        for (int score : midterms) {
            total += score;
        }
        for (int score : finals) {
            total += score;
        }
        return total;
    }

    // 示例：打印学生信息的方法
    public void printStudentDetails() {
        System.out.println("学生姓名: " + name);
        System.out.print("  测验成绩: ");
        for (int i = 0; i < quizzes.length; i++) {
            System.out.print(quizzes[i] + (i < quizzes.length - 1 ? ", " : ""));
        }
        System.out.println();

        System.out.print("  期中成绩: ");
        for (int i = 0; i < midterms.length; i++) {
            System.out.print(midterms[i] + (i < midterms.length - 1 ? ", " : ""));
        }
        System.out.println();

        System.out.print("  期末成绩: ");
        for (int i = 0; i < finals.length; i++) {
            System.out.print(finals[i] + (i < finals.length - 1 ? ", " : ""));
        }
        System.out.println();
        System.out.println("  总分: " + calculateTotalScore());
    }
}

登录后复制

在上述Student类中：

我们定义了私有属性name, quizzes, midterms, finals，以实现封装。
提供了一个构造方法，用于在创建Student对象时初始化其姓名和成绩数组的大小。
提供了getter方法来访问属性值。
提供了setter方法来设置特定索引的成绩，并包含基本的边界检查。
添加了calculateTotalScore()方法，可以直接计算该学生的总分。
添加了printStudentDetails()方法，方便打印学生的所有信息。

2. 实现数据收集与存储

现在，我们可以在主方法中利用Student类来收集和存储数据。我们需要一个Student对象的数组（或者更灵活的ArrayList<Student>)来存储所有学生的信息。

import java.util.ArrayList;
import java.util.InputMismatchException;
import java.util.List;
import java.util.Scanner;

public class StudentGradesApp {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        List<Student> students = new ArrayList<>(); // 使用ArrayList存储Student对象

        System.out.println("您要输入多少名学生的信息？");
        int numberOfStudents = 0;
        try {
            numberOfStudents = input.nextInt();
        } catch (InputMismatchException e) {
            System.err.println("输入无效，请输入一个整数。");
            input.close();
            return;
        }
        input.nextLine(); // 消耗掉nextInt()留下的换行符

        // 定义每种成绩的数量
        final int NUM_QUIZZES = 2;
        final int NUM_MIDTERMS = 1;
        final int NUM_FINALS = 1;

        for (int stNumber = 0; stNumber < numberOfStudents; stNumber++) {
            System.out.println("\n请输入第 " + (stNumber + 1) + " 名学生的信息：");
            System.out.print("  请输入学生姓名: ");
            String studentName = input.nextLine();

            // 创建一个新的Student对象
            Student currentStudent = new Student(studentName, NUM_QUIZZES, NUM_MIDTERMS, NUM_FINALS);

            // 收集测验成绩
            for (int qzNumber = 0; qzNumber < NUM_QUIZZES; qzNumber++) {
                System.out.print("  请输入测验 " + (qzNumber + 1) + " 成绩: ");
                try {
                    int mark = Integer.parseInt(input.nextLine());
                    currentStudent.setQuizMark(qzNumber, mark);
                } catch (NumberFormatException e) {
                    System.err.println("无效的成绩输入，请确保输入整数。该成绩将记为0。");
                    currentStudent.setQuizMark(qzNumber, 0); // 错误处理，记为0
                }
            }

            // 收集期中成绩
            for (int mtNumber = 0; mtNumber < NUM_MIDTERMS; mtNumber++) {
                System.out.print("  请输入期中 " + (mtNumber + 1) + " 成绩: ");
                try {
                    int mark = Integer.parseInt(input.nextLine());
                    currentStudent.setMidtermMark(mtNumber, mark);
                } catch (NumberFormatException e) {
                    System.err.println("无效的成绩输入，请确保输入整数。该成绩将记为0。");
                    currentStudent.setMidtermMark(mtNumber, 0);
                }
            }

            // 收集期末成绩
            for (int fnNumber = 0; fnNumber < NUM_FINALS; fnNumber++) {
                System.out.print("  请输入期末 " + (fnNumber + 1) + " 成绩: ");
                try {
                    int mark = Integer.parseInt(input.nextLine());
                    currentStudent.setFinalMark(fnNumber, mark);
                } catch (NumberFormatException e) {
                    System.err.println("无效的成绩输入，请确保输入整数。该成绩将记为0。");
                    currentStudent.setFinalMark(fnNumber, 0);
                }
            }
            students.add(currentStudent); // 将完整的学生对象添加到列表中
        }

        input.close();

        System.out.println("\n--- 所有学生的成绩报告 ---");
        for (Student student : students) {
            student.printStudentDetails(); // 调用Student对象的方法打印详细信息
            System.out.println("-------------------------");
        }

        // 示例：计算所有学生的平均总分
        if (!students.isEmpty()) {
            int totalAllStudentsScore = 0;
            for (Student student : students) {
                totalAllStudentsScore += student.calculateTotalScore();
            }
            double averageTotalScore = (double) totalAllStudentsScore / students.size();
            System.out.printf("\n所有学生的平均总分: %.2f\n", averageTotalScore);
        }
    }
}

登录后复制

在修改后的主方法中：

我们使用 ArrayList<Student> 来动态存储Student对象，避免了固定大小数组的限制。
每次外层循环，都会创建一个新的Student对象，并使用用户输入的数据填充其属性。
Integer.parseInt(input.nextLine()) 用于将用户输入的字符串转换为整数。务必注意nextInt()后需要input.nextLine()来消耗掉换行符，否则后续的nextLine()会直接读取到空字符串。
增加了try-catch块来处理NumberFormatException，以防用户输入非数字字符，提高了程序的健壮性。
所有数据收集完成后，可以轻松遍历students列表，对每个学生对象进行操作，例如调用printStudentDetails()或calculateTotalScore()方法。

数据处理与计算

一旦数据被封装在Student对象中并存储在ArrayList里，后续的数据处理和计算就变得非常直观。

访问特定学生的成绩：

Student firstStudent = students.get(0);
System.out.println("第一个学生的姓名: " + firstStudent.getName());
System.out.println("第一个学生的第一个测验成绩: " + firstStudent.getQuizzes()[0]);

登录后复制

计算某个学生的总分：

for (Student student : students) {
    System.out.println(student.getName() + " 的总分为: " + student.calculateTotalScore());
}

登录后复制

进行更复杂的统计： 例如计算班级平均分、找出最高分学生等。

// 找出总分最高的学生
Student topStudent = null;
int maxScore = -1;
for (Student student : students) {
    int currentScore = student.calculateTotalScore();
    if (currentScore > maxScore) {
        maxScore = currentScore;
        topStudent = student;
    }
}
if (topStudent != null) {
    System.out.println("\n总分最高的学生是: " + topStudent.getName() + ", 总分: " + maxScore);
}

登录后复制

进一步优化与注意事项

数据类型选择： 对于成绩，如果可能存在小数，应使用double或float类型。如果总是整数，int即可。
错误处理： 除了NumberFormatException，实际应用中可能还需要处理其他输入错误，例如负数成绩、超出合理范围的成绩等。
动态数组ArrayList： 当学生数量不确定时，ArrayList比固定大小的数组更灵活。
封装性： Student类中的属性应尽可能设为private，并通过public的getter和setter方法来访问和修改，以更好地控制数据。
模块化： 可以将数据收集、处理和报告生成等逻辑进一步分解到不同的方法或类中，提高代码的可读性和可维护性。
用户体验： 提供清晰的提示信息，并在用户输入错误时给出友好的反馈。

总结

通过引入自定义类（如Student类）来封装相关数据，我们能够有效地解决在嵌套循环中处理多组关联数据时遇到的挑战。这种面向对象的方法不仅使得数据结构更加清晰、易于理解，而且极大地简化了后续的数据访问、处理和计算操作，从而提高了代码的健壮性、可维护性和扩展性。在Java开发中，当面对复杂的数据结构时，优先考虑使用对象来建模真实世界的实体，是构建高质量应用程序的关键实践。

以上就是Java嵌套循环中结构化数据收集与处理实践的详细内容，更多请关注php中文网其它相关文章！