下面我将分情况详细介绍几种最常用和最实用的方法。

获取数组的默认字符串表示（最简单）

如果你只是想快速调试或打印数组,查看它包含哪些元素，最简单的方法是直接使用 Arrays.toString()。

核心方法：java.util.Arrays.toString()

这个方法会返回一个字符串,格式为 [元素1, 元素2, 元素3, ...]，它适用于所有基本类型数组（如 int[], double[]）和对象数组（如 String[], Object[]）。

示例代码

import java.util.Arrays;
public class ArrayToStringExample {
    public static void main(String[] args) {
        // 1. 基本类型数组 (int)
        int[] intArray = {1, 2, 3, 4, 5};
        System.out.println("int[] 数组: " + Arrays.toString(intArray));
        // 输出: int[] 数组: [1, 2, 3, 4, 5]
        // 2. 对象数组 (String)
        String[] stringArray = {"apple", "banana", "cherry"};
        System.out.println("String[] 数组: " + Arrays.toString(stringArray));
        // 输出: String[] 数组: [apple, banana, cherry]
        // 3. 二维数组
        int[][] twoDArray = {{1, 2}, {3, 4}};
        System.out.println("int[][] 数组: " + Arrays.toString(twoDArray));
        // 输出: int[][] 数组: [[I@15db9742, [I@6d06d69c] 
        // 注意：对于多维数组，直接 toString() 只会打印出内存地址，这不是我们想要的。
        // 正确的做法是使用 Arrays.deepToString()
        System.out.println("int[][] 数组 (使用 deepToString): " + Arrays.deepToString(twoDArray));
        // 输出: int[][] 数组 (使用 deepToString): [[1, 2], [3, 4]]
    }
}

• 一维数组：使用 Arrays.toString()。
• 多维数组：使用 Arrays.deepToString()，它会递归地处理所有层级的数组。

自定义分隔符拼接字符串（最常用）

在实际开发中,我们经常需要将数组元素拼接成一个由特定分隔符（如逗号、竖线 ）连接的字符串，"1,2,3,4,5" 或 "apple|banana|cherry"。

方法 1：使用 String.join() (Java 8+ 推荐方法)

这是最简洁、最现代的方法，但它主要用于 CharSequence 数组，String[]。

import java.util.Arrays;
public class StringJoinExample {
    public static void main(String[] args) {
        String[] fruits = {"apple", "banana", "cherry"};
        // 使用逗号作为分隔符
        String result1 = String.join(",", fruits);
        System.out.println("使用 String.join: " + result1);
        // 输出: 使用 String.join: apple,banana,cherry
        // 使用竖线作为分隔符
        String result2 = String.join("|", fruits);
        System.out.println("使用 String.join: " + result2);
        // 输出: 使用 String.join: apple|banana|cherry
    }
}

注意： String.join() 不能直接用于基本类型数组（如 int[]），你需要先将基本类型数组转换为 String[]。

import java.util.Arrays;
import java.util.stream.Collectors;
public class StringJoinWithPrimitiveArray {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40};
        // 方法1：使用 Arrays.stream 和 mapToObj
        String result1 = Arrays.stream(numbers)
                              .mapToObj(String::valueOf) // 将 int 转为 String
                              .collect(Collectors.joining(","));
        System.out.println("基本类型数组转字符串 (stream): " + result1);
        // 输出: 基本类型数组转字符串 (stream): 10,20,30,40
        // 方法2：先转成 String[] 再用 String.join
        String[] stringNumbers = Arrays.stream(numbers).mapToObj(String::valueOf).toArray(String[]::new);
        String result2 = String.join("-", stringNumbers);
        System.out.println("基本类型数组转字符串 (先转数组): " + result2);
        // 输出: 基本类型数组转字符串 (先转数组): 10-20-30-40
    }
}

方法 2：使用 StringBuilder (手动拼接，灵活高效)

这是在 Java 8 之前最经典、最高效的方法，尤其适用于基本类型数组和复杂的拼接逻辑。

import java.util.Arrays;
public class StringBuilderExample {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < numbers.length; i++) {
            sb.append(numbers[i]);
            // 如果不是最后一个元素，则添加分隔符
            if (i < numbers.length - 1) {
                sb.append(",");
            }
        }
        String result = sb.toString();
        System.out.println("使用 StringBuilder: " + result);
        // 输出: 使用 StringBuilder: 1,2,3,4,5
    }
}

处理对象数组，自定义对象的字符串表示

如果你的数组元素是自定义的 Java 对象，直接 toString() 可能会输出你不想要的内存地址（如 com.example.MyObject@15db9742）。

这时,你需要：

1. 重写 对象的 toString() 方法。
2. 然后使用前面提到的任何一种方法来转换数组。

示例代码

import java.util.Arrays;
// 1. 定义一个自定义类
class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // 2. 重写 toString() 方法
    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}
public class ObjectArrayToString {
    public static void main(String[] args) {
        Person[] people = {
            new Person("Alice", 30),
            new Person("Bob", 25),
            new Person("Charlie", 35)
        };
        // 现在使用 Arrays.toString() 会调用我们重写的 toString() 方法
        System.out.println("对象数组: " + Arrays.toString(people));
        // 输出: 对象数组: [Person{name='Alice', age=30}, Person{name='Bob', age=25}, Person{name='Charlie', age=35}]
        // 使用 String.join 拼接
        String joinedResult = String.join(" | ", people);
        System.out.println("拼接后的对象数组: " + joinedResult);
        // 输出: 拼接后的对象数组: Person{name='Alice', age=30} | Person{name='Bob', age=25} | Person{name='Charlie', age=35}
    }
}

总结与选择指南

根据你的具体场景和使用的 Java 版本，选择最适合你的方法即可，对于现代 Java 开发，String.join() 和 Stream API 通常是首选。