Java方法调用：理解程序执行流程与常见陷阱

import java.util.Arrays;

public class MethodExecutionDemo {

    public static void main(String[] args) {
        // 创建数组
        double[] list = new double[10];       
        // 生成10个1-100之间的随机数
        for(int i = 0; i < list.length; i++) {
          list[i] = (int)(Math.random()* 100 + 1);
        }
        System.out.println("The unsorted list is: " + Arrays.toString(list));     

        // 查找最大数
        double max = -1;
        for (int i = 0; i < list.length; i++) {
            if (list[i] > max) max = list[i];
        }
        System.out.println("The largest value is " + max);

        // 此处缺少对 bubbleSort 方法的调用
    }

    // bubbleSort 方法的定义，但尚未被调用
    public static double[] bubbleSort(double[] list) {
        // ... 排序逻辑 ...
        return list;
    }
}

import java.util.Arrays;

public class MethodExecutionDemo {

    public static void main(String[] args) {
        // 创建数组并填充随机数 (与之前相同)
        double[] list = new double[10];       
        for(int i = 0; i < list.length; i++) {
          list[i] = (int)(Math.random()* 100 + 1);
        }
        System.out.println("The unsorted list is: " + Arrays.toString(list));     

        // 查找最大数 (与之前相同)
        double max = -1;
        for (int i = 0; i < list.length; i++) {
            if (list[i] > max) max = list[i];
        }
        System.out.println("The largest value is " + max);

        // 显式调用 bubbleSort 方法
        double[] sortedList = bubbleSort(list); // 调用排序方法
        System.out.println("The sorted list is: " + Arrays.toString(sortedList)); // 打印排序后的列表
    }

    // bubbleSort 方法的定义
    public static double[] bubbleSort(double[] list) {
        double temp;
        for (int i = list.length - 1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                if (list[j] > list[j + 1]) {
                    temp = list[j];
                    list[j] = list[j + 1];
                    list[j + 1] = temp;
                }
            }
        }
        return list; // 返回排序后的数组
    }
}

// 原始 bubbleSort 方法中的问题代码片段
if (list[j] > list[j + 1]) {
    temp = list[j];
    list[j] = list[j + 1];
    list[j + 1] = temp;  
    // 问题所在：在内部循环中进行递归调用和打印
    System.out.println("The sorted list is: " + bubbleSort(list) + " "); 
}

import java.util.Arrays; // 导入 Arrays 工具类，用于方便地打印数组

public class CorrectMethodExecutionDemo {

    public static void main(String[] args) {
        // 1. 初始化数组并填充随机数
        double[] list = new double[10];       
        for(int i = 0; i < list.length; i++) {
          list[i] = (int)(Math.random()* 100 + 1); // 生成1到100之间的随机整数
        }
        System.out.println("原始列表: " + Arrays.toString(list));     

        // 2. 查找最大值 (此部分代码功能不变)
        double max = -1;
        for (int i = 0; i < list.length; i++) {
            if (list[i] > max) max = list[i];
        }
        System.out.println("最大值是: " + max);

        // 3. 显式调用 bubbleSort 方法，并接收其返回的排序结果
        // 注意：bubbleSort 方法会直接修改传入的数组，但为了代码清晰，
        // 仍然建议接收其返回值。
        double[] sortedList = bubbleSort(list); 

        // 4. 打印排序后的列表
        System.out.println("排序后的列表: " + Arrays.toString(sortedList)); 
    }

    /**
     * 对给定的双精度浮点数数组执行冒泡排序。
     * 该方法会直接修改传入的数组，并返回排序后的数组引用。
     *
     * @param list 待排序的双精度浮点数数组。
     * @return 排序后的数组。
     */
    public static double[] bubbleSort(double[] list) {
        double temp; // 用于交换元素的临时变量
        boolean swapped; // 标志位，用于优化：如果一轮没有发生交换，则表示数组已排序

        // 外层循环控制排序的轮数
        for (int i = list.length - 1; i > 0; i--) {
            swapped = false; // 每轮开始前重置交换标志
            // 内层循环遍历未排序部分，将最大元素“冒泡”到正确位置
            for (int j = 0; j < i; j++) {
                // 如果当前元素大于下一个元素，则进行交换
                if (list[j] > list[j + 1]) {
                    temp = list[j];
                    list[j] = list[j + 1];
                    list[j + 1] = temp;
                    swapped = true; // 发生交换，设置标志
                }
            }
            // 如果一轮下来没有发生任何交换，说明数组已经有序，可以提前结束排序
            if (!swapped) {
                break; 
            }
        }
        return list; // 返回排序后的数组
    }
}