Java数组打印与排序：避免“垃圾值”和实现高效算法

本教程旨在解决java数组在打印时出现内存地址而非实际内容的问题，并纠正常见的排序算法误区。我们将深入探讨`system.out.println()`对数组对象的影响，提供正确的数组内容打印方法，并详细介绍如何实现一个稳定可靠的排序算法（如选择排序），同时强调代码中职责分离的重要性，以编写出更清晰、更易维护的java程序。

在Java编程中，初学者常会遇到两个与数组操作相关的问题：一是尝试打印数组时得到类似[I@5caf905d的输出，而非数组元素；二是实现的排序算法未能完全正确地对数组进行排序。本文将针对这两个核心问题提供详细的解析和解决方案。

理解Java数组的默认打印行为

当我们在Java中直接使用System.out.println()方法打印一个数组对象时，例如System.out.println(myArr);，实际上是调用了该数组对象的toString()方法。对于原始数组类型（如int[], double[]等），其默认的toString()方法并不会遍历并打印数组的每个元素，而是输出其类型签名和内存地址的哈希码。[I@5caf905d中的[I表示这是一个int类型的数组，而5caf905d则是该对象内存地址的哈希码。

要正确地打印数组的所有元素，我们需要采用以下两种常用方法：

方法一：使用Arrays.toString()方法

Java标准库中的java.util.Arrays类提供了一个非常方便的静态方法toString(array)，它可以将任何类型的数组转换为一个包含所有元素的可读字符串。

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

示例代码：

import java.util.Arrays; // 导入Arrays类

public class ArrayPrinter {
    public static void main(String[] args) {
        int[] numbers = {10, 4, 39, 12, 2};
        System.out.println(Arrays.toString(numbers)); // 输出: [10, 4, 39, 12, 2]
    }
}

方法二：手动遍历数组

通过循环遍历数组的每一个元素并逐一打印，可以实现更灵活的输出格式控制。

示例代码：

public class ManualArrayPrinter {
    public static void main(String[] args) {
        int[] numbers = {10, 4, 39, 12, 2};
        System.out.print("[");
        for (int i = 0; i < numbers.length; i++) {
            System.out.print(numbers[i]);
            if (i < numbers.length - 1) {
                System.out.print(", ");
            }
        }
        System.out.println("]"); // 输出: [10, 4, 39, 12, 2]
    }
}

实现健壮的数组排序算法

原始代码中的sortArray函数仅进行了一次遍历，并在相邻元素之间进行了一次比较和可能的交换。这实际上是冒泡排序的一个单趟操作，不足以完成整个数组的排序。一个完整的排序算法需要多趟操作才能确保所有元素都处于正确的位置。

BiLin AI

免费的多语言AI搜索引擎

下载

这里我们以选择排序（Selection Sort）为例，演示如何实现一个将数组按降序排列的算法。选择排序的基本思想是：在未排序部分中找到最大（或最小）的元素，然后将其放到已排序部分的末尾（或开头）。

选择排序（降序）实现

public class ArraySorter {

    /**
     * 对整型数组进行降序选择排序。
     * @param arr 待排序的整型数组。
     */
    public static void selectionSortDesc(int[] arr) {
        // 外层循环控制已排序部分的边界
        for (int i = 0; i < arr.length - 1; i++) {
            // k 用于记录当前未排序部分中最大元素的索引
            int maxIndex = i; 

            // 内层循环在未排序部分中查找最大元素
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[maxIndex] < arr[j]) {
                    maxIndex = j; // 找到更大的元素，更新maxIndex
                }
            }

            // 如果最大元素不在当前位置i，则进行交换
            if (maxIndex != i) {
                swap(arr, i, maxIndex);
            }
        }
    }

    /**
     * 辅助方法：交换数组中两个指定位置的元素。
     * @param arr 目标数组。
     * @param i 第一个元素的索引。
     * @param j 第二个元素的索引。
     */
    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    public static void main(String[] args) {
        int[] myArr = {10, 4, 39, 12, 2};
        System.out.println("原始数组: " + java.util.Arrays.toString(myArr));

        selectionSortDesc(myArr);

        System.out.println("降序排序后的数组: " + java.util.Arrays.toString(myArr)); // 输出: [39, 12, 10, 4, 2]
    }
}

使用Arrays.sort()进行排序

对于更简单的排序需求，Java提供了内置的Arrays.sort()方法。它可以对基本类型数组进行升序排序，也可以对对象数组使用自定义的Comparator进行排序。

示例代码（降序排序）：

import java.util.Arrays;
import java.util.Collections; // 导入Collections类

public class BuiltInSorter {
    public static void main(String[] args) {
        Integer[] myArr = {10, 4, 39, 12, 2}; // 注意：需要使用包装类Integer[]
        System.out.println("原始数组: " + Arrays.toString(myArr));

        // 使用Collections.reverseOrder()实现降序排序
        Arrays.sort(myArr, Collections.reverseOrder()); 

        System.out.println("降序排序后的数组 (使用Arrays.sort): " + Arrays.toString(myArr)); // 输出: [39, 12, 10, 4, 2]
    }
}

注意事项： Arrays.sort()直接作用于基本类型数组时是升序的。如果需要对基本类型数组进行降序排序，通常的做法是先升序排序，然后反转数组，或者将其转换为包装类数组再使用Collections.reverseOrder()。

职责分离：排序与打印

一个良好的编程实践是遵循“单一职责原则”，即将不同的功能模块分离开来。排序算法的职责是修改数组的顺序，而打印数组的职责是显示数组的内容。将这两个操作混合在一个方法中会降低代码的可读性和可维护性。

优化后的主程序结构：

import java.util.Scanner;
import java.util.Arrays; // 导入Arrays类

public class LabProgramRefactored {

    /**
     * 对整型数组进行降序选择排序。
     * @param arr 待排序的整型数组。
     */
    public static void selectionSortDesc(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int maxIndex = i; 
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[maxIndex] < arr[j]) {
                    maxIndex = j; 
                }
            }
            if (maxIndex != i) {
                swap(arr, i, maxIndex);
            }
        }
    }

    /**
     * 辅助方法：交换数组中两个指定位置的元素。
     */
    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    public static void main(String[] args) {
        Scanner scnr = new Scanner(System.in);
        int[] myArr;
        int arrSize;

        // 读取数组大小
        arrSize = scnr.nextInt();
        myArr = new int[arrSize];

        // 读取数组元素
        for (int i = 0; i < arrSize; i++) {
            myArr[i] = scnr.nextInt();
        }

        // 关闭Scanner
        scnr.close();

        // 打印原始数组（可选）
        System.out.println("输入数组: " + Arrays.toString(myArr));

        // 调用排序函数
        selectionSortDesc(myArr);  

        // 打印排序后的数组
        System.out.println("排序后的数组 (降序): " + Arrays.toString(myArr));
    }
}

总结

通过本文的讲解，我们解决了Java数组打印和排序的常见问题。核心要点包括：

1. 正确打印数组： 使用Arrays.toString()或手动遍历来获取数组元素的字符串表示，而不是直接打印数组对象。
2. 实现有效排序： 采用如选择排序、冒泡排序等完整的排序算法，或者利用Arrays.sort()等内置方法，确保数组能够被正确地排列。
3. 职责分离： 将排序逻辑和打印逻辑封装在不同的方法中，提高代码的模块化和可维护性。

遵循这些最佳实践，将有助于您编写出更健壮、更易于理解和调试的Java代码。