jmu-Java-PTA题解 (面向对象进阶-04-嵌套类-静态嵌套类) 网安2312陈卓

问题要求

定义类ArrayUtils，在该类内部创建一个静态嵌套类PairResult，该嵌套类包含：
属性: private double min与private double max，用于存放最小值最大值
方法：toString方法，格式见下面的输出样例。

为ArrayUtils类创建一个静态方法PairResult findMinMax(double[] values)，对传递进来的数组找到其中的最大值和最小值并返回PairResult对象。

main方法说明

1. 输入n，创建大小为n的double型数组
2. 依次输入n个double型数值放入数组
3. 调用findMinMax方法得到结果，并输出。
4. 最后使用System.out.println(ArrayUtils.PairResult.class)打印标识信息

输入格式:

第一行输入一个整数 n，表示数组的大小。
接下来的 n 行，每行输入一个 double 类型的数值。

输出格式:

第一行输出 PairResult 对象的字符串表示，格式为 PairResult [min=最小值, max=最大值]。
第二行输出 ArrayUtils.PairResult 类的标识信息。

输入样例:

5
0 -1 1 1.1 1.1

输出样例:

PairResult [min=-1.0, max=1.1]
\\这里打印标识

关键点

• 静态嵌套类的定义：需要在 ArrayUtils 类内部正确定义 PairResult 静态嵌套类，并实现其属性和方法。
• 数组最值查找：在 findMinMax 方法中，要准确找出数组中的最大值和最小值。
• 输入输出处理：在 main 方法中，需要正确读取用户输入，并将结果按要求输出。

解题步骤

第一步：定义 ArrayUtils 类和 PairResult 静态嵌套类

在 ArrayUtils 类内部定义 PairResult 静态嵌套类，包含 min 和 max 两个私有属性，以及 toString 方法。

static class PairResult {
    private double min;
    private double max;

    public PairResult(double min, double max) {
        this.min = min;
        this.max = max;
    }

    public String toString() {
        return "PairResult [min=" + min + ", max=" + max + "]";
    }
}

第二步：实现 findMinMax 方法

在 ArrayUtils 类中实现 findMinMax 方法，该方法接收一个 double 类型的数组，通过遍历数组找出其中的最大值和最小值，最后返回一个 PairResult 对象。

public static PairResult findMinMax(double[] values) {
    double min = values[0], max = values[0];
    for (int i = 1; i < values.length; i++) {
        if (values[i] < min) {
            min = values[i];
        }
        if (values[i] > max) {
            max = values[i];
        }
    }
    PairResult result = new PairResult(min, max);
    return result;
}

第三步：实现 main 方法

在 main 方法中，首先读取用户输入的整数 n，创建一个大小为 n 的 double 类型数组，然后依次读取 n 个 double 类型的数值存入数组。接着调用 findMinMax 方法得到包含最小值和最大值的 PairResult 对象，并将其输出。最后打印 ArrayUtils.PairResult 类的标识信息。

public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    int n = in.nextInt();
    double[] array = new double[n];
    for (int i = 0; i < n; i++) {
        array[i] = in.nextDouble();
    }
    ArrayUtils.PairResult result = ArrayUtils.findMinMax(array);
    System.out.println(result.toString());
    System.out.println(ArrayUtils.PairResult.class);
}

逻辑流程图：

整体代码

import java.util.Scanner;
class ArrayUtils{
    static class PairResult{
        private double min;
        private double max;

        public PairResult(double min, double max){
            this.min = min;
            this.max = max;
        }

        public String toString(){
            return "PairResult [min="+min+", max="+max+"]";
        }
    }

    public static PairResult findMinMax(double[] values){
        double min = values[0], max = values[0];
        for(int i=1; i<values.length; i++){
            if(values[i]<min){
                min = values[i];
            }
            if(values[i]>max){
                max = values[i];
            }
        }
        PairResult e = new PairResult(min,max);
        return e;
    }
}

public class Main{
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        double[] e = new double[n];
        for(int i=0; i<n; i++){
            e[i] = in.nextDouble();
        }
        ArrayUtils s = new ArrayUtils();
        ArrayUtils.PairResult x = ArrayUtils.findMinMax(e);
        System.out.println(x.toString());
        System.out.println(ArrayUtils.PairResult.class);
    }
}

思考：在解决这个查找数组最小值和最大值的问题时，首先使用静态嵌套类 PairResult 来封装最小值和最大值，将相关数据和行为封装在一起，不仅使代码结构更加清晰，也方便了后续对结果的操作和处理，findMinMax 方法采用遍历数组的方式，逐个比较元素来确定最大值和最小值，其时间复杂度为 O(n)，在一般情况下，这是较为高效的实现方式。然而，当处理大规模数据时，这种顺序遍历的方式可能会在性能上有所瓶颈。此时，可以考虑使用并行计算，利用多核处理器的优势，将数组分割成多个子数组，并行地计算每个子数组的最值，最后再汇总得到整个数组的最值，以此来提升处理效率。此外，对于 PairResult 类，除了现有的 toString 方法，还可以根据实际需求添加更多的方法，如获取最小值和最大值的独立访问方法等，进一步丰富该类的功能。