Какой самый простой способ напечатать массив Java?

В Java массивы не переопределяют toString(), поэтому, если вы попытаетесь вывести один из них напрямую, вы получите className + ‘@’ + шестнадцатиричный hashCode массива, как определено в Object.toString():

int[] intArray = new int[] {1, 2, 3, 4, 5};
System.out.println(intArray); // Выводит что-то вроде '[I@3343c8b3'

Но, как правило, мы на самом деле хотели бы получить что-то похожее на [1, 2, 3, 4, 5]. Каков самый простой способ сделать это? Вот некоторые примеры входных данных и выходных данных:

// Массив примитивов:
int[] intArray = new int[] {1, 2, 3, 4, 5};
// Вывод: [1, 2, 3, 4, 5]

// Массив ссылок на объекты:
String[] strArray = new String[] {"John", "Mary", "Bob"};
// Вывод: [John, Mary, Bob]

С Java 5 вы можете использовать Arrays.toString(arr) или Arrays.deepToString(arr) для массивов внутри массивов. Обратите внимание, что версия Object[] вызывает .toString() для каждого объекта в массиве. Вывод даже оформлен точно так, как вы хотите.

Примеры:

• Простой массив:

  String[] array = new String[] {"John", "Mary", "Bob"};
  System.out.println(Arrays.toString(array));
  

  Вывод:

  [John, Mary, Bob]
  

• Вложенный массив:

  String[][] deepArray = new String[][] {{"John", "Mary"}, {"Alice", "Bob"}};
  // Выводит нежелательный результат:
  System.out.println(Arrays.toString(deepArray));
  // Выводит ожидаемый результат:
  System.out.println(Arrays.deepToString(deepArray));
  

  Вывод:

  [[Ljava.lang.String;@106d69c, [Ljava.lang.String;@52e922]
  [[John, Mary], [Alice, Bob]]
  

• double массив:

  double[] doubleArray = { 7.0, 9.0, 5.0, 1.0, 3.0 };
  System.out.println(Arrays.toString(doubleArray));
  

  Вывод:

  [7.0, 9.0, 5.0, 1.0, 3.0 ]
  

• int массив:

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

  Вывод:

  [7, 9, 5, 1, 3 ]
  

Всегда сначала проверяйте стандартные библиотеки.

import java.util.Arrays;

Затем попробуйте:

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

или если ваш массив содержит другие массивы в качестве элементов:

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

Это полезно знать, однако, в отношении “всегда проверять стандартные библиотеки сначала” я никогда бы не натолкнулся на трюк Arrays.toString(myarray)

— поскольку я сосредоточился на типе myarray, чтобы выяснить, как это сделать. Я не хотел бы проходить через это: я хотел простую функцию, чтобы это выглядело похоже на то, что я вижу в отладчике Eclipse, а myarray.toString() просто не давал этого.

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

В JDK1.8 вы можете использовать агрегатные операции и лямбда-выражения:

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);

/* вывод:
John
Mary
Bob
*/

Arrays.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));

// Эти варианты не одинаковы, так как каждый элемент выводится на новой строке:
IntStream.of(ints).forEach(System.out::println);
Stream.of(strs).forEach(System.out::println);
Stream.of(days).forEach(System.out::println);

Начиная с Java 8, можно также воспользоваться методом join(), предоставляемым классом String, чтобы распечатать элементы массива без скобок и разделить их выбранным разделителем (который является пробелом в примере ниже):

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

Вывод будет “Hey there amigo!”.

До Java 8

Мы могли использовать Arrays.toString(array) для вывода одномерного массива и Arrays.deepToString(array) для многомерных массивов.

Java 8

Теперь у нас есть возможность Stream и lambda для вывода массива.

Вывод одномерного массива:

public static void main(String[] args) {
    int[] intArray = new int[] {1, 2, 3, 4, 5};
    String[] strArray = new String[] {"John", "Mary", "Bob"};

    //До Java 8
    System.out.println(Arrays.toString(intArray));
    System.out.println(Arrays.toString(strArray));

    // В Java 8 у нас есть лямбда-выражения
    Arrays.stream(intArray).forEach(System.out::println);
    Arrays.stream(strArray).forEach(System.out::println);
}

Вывод:

[1, 2, 3, 4, 5]
[John, Mary, Bob]
1
2
3
4
5
John
Mary
Bob

Вывод многомерного массива
Если мы захотим вывести многомерный массив, мы можем использовать Arrays.deepToString(array) следующим образом:

public static void main(String[] args) {
    int[][] int2DArray = new int[][] { {11, 12}, { 21, 22}, {31, 32, 33} };
    String[][] str2DArray = new String[][]{ {"John", "Bravo"} , {"Mary", "Lee"}, {"Bob", "Johnson"} };

    //До Java 8
    System.out.println(Arrays.deepToString(int2DArray));
    System.out.println(Arrays.deepToString(str2DArray));

    // В Java 8 у нас есть лямбда-выражения
    Arrays.stream(int2DArray).flatMapToInt(x -> Arrays.stream(x)).forEach(System.out::println);
    Arrays.stream(str2DArray).flatMap(x -> Arrays.stream(x)).forEach(System.out::println);
} 

Теперь важно отметить, что метод Arrays.stream(T[]), который в случае int[] возвращает Stream<int[]>, а затем метод flatMapToInt() отображает каждый элемент потока в содержимое отображаемого потока, создаваемого применением предоставленной функции отображения к каждому элементу.

Вывод:

[[11, 12], [21, 22], [31, 32, 33]]
[[John, Bravo], [Mary, Lee], [Bob, Johnson]]
11
12
21
22
31
32
33
John
Bravo
Mary
Lee
Bob
Johnson

Если вы используете Java 1.4, вы можете сделать следующее:

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

(Это также работает в версиях 1.5 и выше, конечно.)

Arrays.deepToString(arr) выводит только в одну строку.

int[][] table = new int[2][2];

Чтобы действительно вывести таблицу в виде двумерной таблицы, мне пришлось сделать следующее:

System.out.println(Arrays.deepToString(table).replaceAll("],", "]," + System.getProperty("line.separator")));

Кажется, метод Arrays.deepToString(arr) должен принимать строку-разделитель, но, к сожалению, этого не происходит.

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

Разные способы вывести массивы в Java:

1. Простой способ

   List<String> list = new ArrayList<String>();
   list.add("Один");
   list.add("Два");
   list.add("Три");
   list.add("Четыре");
   // Вывод списка в консоль
   System.out.println(list);
   

Вывод:
[Один, Два, Три, Четыре]

2. Используя toString()

   String[] array = new String[] { "Один", "Два", "Три", "Четыре" };
   System.out.println(Arrays.toString(array));
   

Вывод: [Один, Два, Три, Четыре]

3. Вывод массива массивов

   String[] arr1 = new String[] { "Пятый", "Шестой" };
   String[] arr2 = new String[] { "Седьмой", "Восьмой" };
   String[][] arrayOfArray = new String[][] { arr1, arr2 };
   System.out.println(arrayOfArray);
   System.out.println(Arrays.toString(arrayOfArray));
   System.out.println(Arrays.deepToString(arrayOfArray));
   

Вывод: [[Ljava.lang.String;@1ad086a [[Ljava.lang.String;@10385c1,
[Ljava.lang.String;@42719c] [[Пятый, Шестой], [Седьмой, Восьмой]]

Ресурс: Доступ к массиву

Использование обычного for цикла – самый простой способ вывода массива, на мой взгляд.
Вот пример кода на основе вашего intArray

for (int i = 0; i < intArray.length; i++) {
   System.out.print(intArray[i] + ", ");
}

Это даст вывод как у вас
1, 2, 3, 4, 5

Это должно всегда работать, независимо от версии JDK:

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

Это будет работать, если Array содержит объекты. Если Array содержит примитивные типы, вы можете использовать обертки вместо хранения примитива напрямую как..

Пример:

int[] a = new int[]{1,2,3,4,5};

Замените его на:

Integer[] a = new Integer[]{1,2,3,4,5};

Обновление :

Да! это стоит упомянуть, что преобразование массива в массив объектов ИЛИ использование массива объектов дорого и может замедлить выполнение. это происходит по природе Java, называемому автопакетом.

Так что только для целей вывода это не должно использоваться. Мы можем сделать функцию, которая принимает массив в качестве параметра и выводит нужный формат как

public void printArray(int [] a){
        //напишите код для вывода
} 

Я наткнулся на этот пост в Vanilla #Java недавно. Не очень удобно все время писать Arrays.toString(arr);, затем импортируя java.util.Arrays;.

Обратите внимание, что это ни в коем случае не является постоянным решением. Просто хак, который может сделать отладку проще.

Вывод массива напрямую дает внутреннее представление и hashCode. Теперь все классы имеют Object в качестве родительского типа. Так почему бы не взломать Object.toString()? Без изменения класс Object выглядит так:

public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

Что если это изменить на:

public String toString() {
    if (this instanceof boolean[])
        return Arrays.toString((boolean[]) this);
    if (this instanceof byte[])
        return Arrays.toString((byte[]) this);
    if (this instanceof short[])
        return Arrays.toString((short[]) this);
    if (this instanceof char[])
        return Arrays.toString((char[]) this);
    if (this instanceof int[])
        return Arrays.toString((int[]) this);
    if (this instanceof long[])
        return Arrays.toString((long[]) this);
    if (this instanceof float[])
        return Arrays.toString((float[]) this);
    if (this instanceof double[])
        return Arrays.toString((double[]) this);
    if (this instanceof Object[])
        return Arrays.deepToString((Object[]) this);
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

Этот модифицированный класс можно просто добавить в путь классов, добавив следующее в командную строку: -Xbootclasspath/p:target/classes.

Теперь, с доступностью deepToString(..) с Java 5, toString(..) можно легко изменить на deepToString(..), чтобы добавить поддержку массивов, содержащих другие массивы.

Я нашел это довольно полезным хаком, и было бы здорово, если бы Java могла просто добавить это. Я понимаю потенциальные проблемы с очень большими массивами, так как строковые представления могут быть проблематичными. Возможно, передать что-то вроде System.out или PrintWriter для таких случаев.

В Java 8 это просто. есть два ключевых слова

1. поток: Arrays.stream(intArray).forEach

2. ссылка на метод: ::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));

Вы можете пройтись по массиву, выводя каждый элемент по мере прохода. Например:

String[] items = {"элемент 1", "элемент 2", "элемент 3"};

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

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

}

Вывод:

элемент 1
элемент 2
элемент 3

• Это очень простой способ вывести массив без использования циклов в JAVA.

  -> Для простого массива:

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

  Вывод :

        [1, 2, 3, 4, 5, 6]
  

  -> Этот 2D массив не может быть выведен с помощью Arrays.toString()

   int[][] array = new int[][]{{1, 2, 3, 4, 5, 6, 7}, {8, 9, 10, 11, 12,13,14}};
   System.out.println(Arrays.deepToString(array));
  

  Вывод:

     [[1, 2, 3, 4, 5, 6, 7], [8, 9, 10, 11, 12, 13, 14]]
  

Существуют следующие способы вывода массива

 // 1) toString()  
    int[] arrayInt = new int[] {10, 20, 30, 40, 50};  
    System.out.println(Arrays.toString(arrayInt));

// 2 for loop()
    for (int number : arrayInt) {
        System.out.println(number);
    }

// 3 for each()
    for(int x: arrayInt){
         System.out.println(x);
     }

Существует еще один способ, если ваш массив имеет тип char[]:

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

System.out.println(A); // без других аргументов

выводит

abc

Упрощенный сокращенный способ, который я пробовал, такой:

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

Это выведет

1
2
3

Циклы не требуются в этом подходе, и это лучше всего подходит для малых массивов

Использование методов org.apache.commons.lang3.StringUtils.join(*) может быть вариантом
Например:

String[] strArray = new String[] { "John", "Mary", "Bob" };
String arrayAsCSV = StringUtils.join(strArray, " , ");
System.out.printf("[%s]", arrayAsCSV);
//вывод: [John , Mary , Bob]

Я использовал следующую зависимость

<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.3.2</version>

Цикл for-each также можно использовать для вывода элементов массива:

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

В дополнение ко всем ответам, вывод объекта в виде JSON строки также является вариантом.

Используя Jackson:

ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
System.out.println(ow.writeValueAsString(anyArray));

Используя Gson:

Gson gson = new Gson();
System.out.println(gson.toJson(anyArray));

// массив примитивов:
int[] intArray = new int[] {1, 2, 3, 4, 5};

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

вывод: [1, 2, 3, 4, 5]

// массив ссылок на объекты:
String[] strArray = new String[] {"John", "Mary", "Bob"};

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

вывод: [John, Mary, Bob]

Вот возможная функция для вывода:

  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] }

public class printer {

    public static void main(String[] args) {
        String a[] = new String[4];
        Scanner sc = new Scanner(System.in);
        System.out.println("введите данные");
        for (int i = 0; i < 4; i++) {
            a[i] = sc.nextLine();
        }
        System.out.println("введенные данные:");
        for (String i : a) {
            System.out.println(i);
        }
      }
    }

Это помечено как дубликат для вывод byte[]. Обратите внимание: для массива байтов есть дополнительные методы, которые могут быть подходящими.

Вы можете вывести его как строку, если она содержит символы ISO-8859-1.

String s = new String(bytes, StandardChars.ISO_8559);
System.out.println(s);
// чтобы обратить
byte[] bytes2 = s.getBytes(StandardChars.ISO_8559);

или если это содержит строку UTF-8

String s = new String(bytes, StandardChars.UTF_8);
System.out.println(s);
// чтобы обратить
byte[] bytes2 = s.getBytes(StandardChars.UTF_8);

или если вы хотите вывести его в шестнадцатиричном виде.

String s = DatatypeConverter.printHexBinary(bytes);
System.out.println(s);
// чтобы обратить
byte[] bytes2 = DatatypeConverter.parseHexBinary(s);

или если вы хотите вывести его в base64.

String s = DatatypeConverter.printBase64Binary(bytes);
System.out.println(s);
// чтобы обратить
byte[] bytes2 = DatatypeConverter.parseBase64Binary(s);

или если вы хотите вывести массив значений байтов с знаком

String s = Arrays.toString(bytes);
System.out.println(s);
// чтобы обратить
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);
// чтобы обратить
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]); // может потребоваться проверка диапазона.

если вы используете jdk 8.

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]

Если вы используете Java 11

import java.util.Arrays;
public class HelloWorld{

     public static void main(String []args){
        String[] array = { "John", "Mahta", "Sara" };
       System.out.println(Arrays.toString(array).replace(",", "").replace("[", "").replace("]", ""));
     }
}

Вывод :

John Mahta Sara

В Java 8 :

Arrays.stream(myArray).forEach(System.out::println);