这被标记为用于打印字节[]的副本。注意：对于字节数组，可能有其他合适的方法。
如果它包含iso-8859-1字符，则可以将其打印为字符串。

String s = new String(bytes, StandardChars.ISO_8559);
System.out.println(s);
// to reverse
byte[] bytes2 = s.getBytes(StandardChars.ISO_8559);

或者如果它包含utf-8字符串

String s = new String(bytes, StandardChars.UTF_8);
System.out.println(s);
// to reverse
byte[] bytes2 = s.getBytes(StandardChars.UTF_8);

或者如果你想把它打印成十六进制。

String s = DatatypeConverter.printHexBinary(bytes);
System.out.println(s);
// to reverse
byte[] bytes2 = DatatypeConverter.parseHexBinary(s);

或者如果你想把它打印成base64。

String s = DatatypeConverter.printBase64Binary(bytes);
System.out.println(s);
// to reverse
byte[] bytes2 = DatatypeConverter.parseBase64Binary(s);

或者如果要打印有符号字节值的数组

String s = Arrays.toString(bytes);
System.out.println(s);
// to reverse
String[] split = s.substring(1, s.length() - 1).split(", ");
byte[] bytes2 = new byte[split.length];
for (int i = 0; i < bytes2.length; i++)
    bytes2[i] = Byte.parseByte(split[i]);

或者如果要打印一个无符号字节值数组

String s = Arrays.toString(
               IntStream.range(0, bytes.length).map(i -> bytes[i] & 0xFF).toArray());
System.out.println(s);
// to reverse
String[] split = s.substring(1, s.length() - 1).split(", ");
byte[] bytes2 = new byte[split.length];
for (int i = 0; i < bytes2.length; i++)
    bytes2[i] = (byte) Integer.parseInt(split[i]); // might need a range check.

我尝试过的一个简化的快捷方式是：

int x[] = {1,2,3};
    String printableText = Arrays.toString(x).replaceAll("[\\[\\]]", "").replaceAll(", ", "\n");
    System.out.println(printableText);

它会打印出来

1
2
3

这种方法不需要循环，最好只用于小型阵列

如果您使用的是java 1.4，则可以执行以下操作：

System.out.println(Arrays.asList(array));

（当然，这也适用于1.5以上版本。）

您可以在数组中循环，在循环时打印出每个项。例如：

String[] items = {"item 1", "item 2", "item 3"};

for(int i = 0; i < items.length; i++) {

    System.out.println(items[i]);

}

输出：

item 1
item 2
item 3

数组.tostring

作为一个直接的答案，包括@esko在内的几个公司提供的解决方案 Arrays.toString 以及 Arrays.deepToString 方法，简直就是最好的。

java 8-stream.collect（joining（）），stream.foreach

下面我试着列出一些建议的其他方法，试图稍加改进，最值得注意的是使用 Stream.collect 运算符，使用
joining Collector ，来模仿 String.join 他在做什么。

int[] ints = new int[] {1, 2, 3, 4, 5};
System.out.println(IntStream.of(ints).mapToObj(Integer::toString).collect(Collectors.joining(", ")));
System.out.println(IntStream.of(ints).boxed().map(Object::toString).collect(Collectors.joining(", ")));
System.out.println(Arrays.toString(ints));

String[] strs = new String[] {"John", "Mary", "Bob"};
System.out.println(Stream.of(strs).collect(Collectors.joining(", ")));
System.out.println(String.join(", ", strs));
System.out.println(Arrays.toString(strs));

DayOfWeek [] days = { FRIDAY, MONDAY, TUESDAY };
System.out.println(Stream.of(days).map(Object::toString).collect(Collectors.joining(", ")));
System.out.println(Arrays.toString(days));

// These options are not the same as each item is printed on a new line:
IntStream.of(ints).forEach(System.out::println);
Stream.of(strs).forEach(System.out::println);
Stream.of(days).forEach(System.out::println);

for each循环还可以用于打印数组的元素：

int array[] = {1, 2, 3, 4, 5};
for (int i:array)
    System.out.println(i);

// array of primitives:
int[] intArray = new int[] {1, 2, 3, 4, 5};

System.out.println(Arrays.toString(intArray));

output: [1, 2, 3, 4, 5]

// array of object references:
String[] strArray = new String[] {"John", "Mary", "Bob"};

System.out.println(Arrays.toString(strArray));

output: [John, Mary, Bob]

在jdk1.8中，可以使用聚合操作和lambda表达式：

String[] strArray = new String[] {"John", "Mary", "Bob"};

// #1
Arrays.asList(strArray).stream().forEach(s -> System.out.println(s));

// #2
Stream.of(strArray).forEach(System.out::println);

// #3
Arrays.stream(strArray).forEach(System.out::println);

/* output:
John
Mary
Bob

* /

在Java8中，这很简单。有两个关键字
流： Arrays.stream(intArray).forEach 方法参考： ::println ```
int[] intArray = new int[] {1, 2, 3, 4, 5};
Arrays.stream(intArray).forEach(System.out::println);

如果要在同一行中打印数组中的所有元素，则只需使用 `print` 而不是 `println` 即

int[] intArray = new int[] {1, 2, 3, 4, 5};
Arrays.stream(intArray).forEach(System.out::print);

另一种没有方法参考的方法只是使用：

int[] intArray = new int[] {1, 2, 3, 4, 5};
System.out.println(Arrays.toString(intArray));

如果数组是char[]类型，还有一种方法：

char A[] = {'a', 'b', 'c'}; 

System.out.println(A); // no other arguments

印刷品

abc

不过，知道这一点很好，至于“总是先检查标准库”，我从来没有偶然发现 Arrays.toString( myarray ) --因为我专注于myarray的类型，所以我想看看如何做到这一点。我不想遍历这个东西：我想要一个简单的调用，使它与我在eclipse调试器和myarray中看到的类似，而tostring（）没有做到这一点。

import java.util.Arrays;
.
.
.
System.out.println( Arrays.toString( myarray ) );

for(int n: someArray) {
    System.out.println(n+" ");
}

如果您运行的是jdk8。

public static void print(int[] array) {
    StringJoiner joiner = new StringJoiner(",", "[", "]");
    Arrays.stream(array).forEach(element -> joiner.add(element + ""));
    System.out.println(joiner.toString());
}

int[] array = new int[]{7, 3, 5, 1, 3};
print(array);

输出：

[7,3,5,1,3]

这里有一个可能的打印功能：

public static void printArray (int [] array){
        System.out.print("{ ");
        for (int i = 0; i < array.length; i++){
            System.out.print("[" + array[i] + "] ");
        }
        System.out.print("}");
    }

例如，如果main是这样的

public static void main (String [] args){
    int [] array = {1, 2, 3, 4};
    printArray(array);
}

输出将是{[1][2][3][4]}

在jdk1.8中，可以使用聚合操作和lambda表达式：

String[] strArray = new String[] {"John", "Mary", "Bob"};

// #1
Arrays.asList(strArray).stream().forEach(s -> System.out.println(s));

// #2
Stream.of(strArray).forEach(System.out::println);

 // #3
 Arrays.stream(strArray).forEach(System.out::println);

/* output:
John
Mary
Bob

* /

另外，从Java8开始，还可以利用string类提供的join（）方法打印出数组元素，不使用括号，并用所选的分隔符（下面示例中的空格字符）分隔

string[] greeting = {"Hey", "there", "amigo!"};
String delimiter = " ";
String.join(delimiter, greeting)

`输出将是“嘿，朋友！”