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

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

Примеры:

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

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

Вывод:

    [Джон, Мэри, Боб]

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

    String[][] deepArray = new String[][] {{"John", "Mary"}, {"Alice", "Bob"}};
    System.out.println(Arrays.toString(deepArray));
    //output: [[Ljava.lang.String;@106d69c, [Ljava.lang.String;@52e922]].
    System.out.println(Arrays.deepToString(deepArray));

Вывод:

    [[Джон, Мэри], [Алиса, Боб]]

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

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

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

/* output:
John
Mary
Bob
*/

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

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

(Конечно, это работает и в версии 1.5+).

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

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

Выход будет "Привет Амиго!&и".

Массивы.метод toString

В качестве прямого ответа, решение, предоставляемые несколькими, в том числе @Eskoиспользуя Arrays.toString и Arrays.deepToString методы, просто лучший.

В Java 8 - Трансляцию.собирать(соединять()), трансляция.еогеасп

Ниже я попробую перечислить некоторые из других методов, предложенных, пытаясь хоть немного улучшить, с наиболее заметным дополнением является использование Stream.collect оператор, помощью joining коллекционер, чтобы имитировать то, что в эту строку.присоединяйтесь делает.

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

До Java 8

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

В Java 8

Теперь у нас есть возможность "поток" и "лямбда", чтобы распечатать массив.

Печати одномерного массива:

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

    //Prior to Java 8
    System.out.println(Arrays.toString(intArray));
    System.out.println(Arrays.toString(strArray));

    // In Java 8 we have lambda expressions
    Arrays.stream(intArray).forEach(System.out::println);
    Arrays.stream(strArray).forEach(System.out::println);
}

Вывод:

[1, 2, 3, 4, 5] [Джон, Мэри, Боб] 1 2 3 4 5 Джон Мэри Боб

Печать многомерного массива Только в случае, если мы хотим напечатать многомерного массива можно использовать массивы.deepToString(массив)` как:

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"} };

    //Prior to Java 8
    System.out.println(Arrays.deepToString(int2DArray));
    System.out.println(Arrays.deepToString(str2DArray));

    // In Java 8 we have lambda expressions
    Arrays.stream(int2DArray).flatMapToInt(x -> Arrays.stream(x)).forEach(System.out::println);
    Arrays.stream(str2DArray).flatMap(x -> Arrays.stream(x)).forEach(System.out::println);
} 

Теперь наблюдение заключается в том, что массивы метод.трансляция(Т []), которые в случае типаint[]возвращает нас трансляция И Л;int [] и GT;, а затем метод flatMapToInt() сопоставляет каждому элементу потока с содержанием сетевого потока, произведенного, применяя при условии сопоставления функции к каждому элементу.

Вывод:

[[11, 12], [21, 22], [31, 32, 33]] [[Джон, Браво], [Мэри, Ли], [Боб, Джонсон]] 11 12 21 22 31 32 33 Джон Браво Мэри Ли Боб Джонсон

`Массивы.deepToString только принты(Арр) на одной линии.

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

На самом деле сделать таблицу для печати как двумерная таблица, я должен был сделать это:

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

Похоже, что массивы.deepToString(Арр) метод должен принимать строку, разделитель, но, к сожалению, это не'т.

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

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

Список<строка> Список = новый ArrayList и Л;строка> В(); список.добавить("Один и"); список.добавить("от двух" - а); список.добавить("на три"); список.добавить("от четырех" - а); // Печать списка в консоли Системы.из.код println(список);

выход: [один, два, три, четыре]

2. Используя метод toString()

Массив string [] = новая строка[] { "Один и", "от двух" В, С "Три", "от четырех" и }; Системы.из.код println(массивов.метод toString(массив));

выход: [один, два, три, четыре]

3. Печать массив массивов

Строка[] arr1 = новая строка [] {с "пятой" В, С "шестой" и }; Строка[] arr2 = новая строка [] {с "Седьмой" В, С "восьмеркой" и }; Строка[][] arrayOfArray = новая строка[][] { arr1, arr2 }; Системы.из.метод println(arrayOfArray); Системы.из.код println(массивов.метод toString(arrayOfArray)); Системы.из.код println(массивов.deepToString(arrayOfArray));

выход: [[Ljava.яз.Строка;@1ad086a [[Ljava.яз.Строка;@10385c1, [Ljava.яз.Строка;@42719c] [[пятый, шестой], [седьмой, восьмой]]

Ресурс: Доступ К Массиву

С помощью регулярных по петля-это самый простой способ печати массива на мой взгляд. Здесь у вас есть пример кода, на основе вашего класса intarray

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

Это дает выход как ваша 1, 2, 3, 4, 5

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

1. стрим: массивы.поток(intarray с).команда foreach
2. контрольный метод: ::код println

тип int[] intarray с = новый инт[] {1, 2, 3, 4, 5}; Массивы.поток(intarray с).(по каждому элементу системы.из::код 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));

Она всегда должна работать в зависимости от версии JDK версии, которую вы используете:

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

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

Пример:

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

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

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

Обновление :

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

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

public void printArray(int [] a){
        //write printing code
} 

Я наткнулся на этот пост в Ваниль #Ява в последнее время. Это's не очень удобно писать массивы.метод toString(Арр);, затем импортироватьЯва.утиль.Массивов;` все время.

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

Печать массива напрямую дает внутреннее представление и хэш-код. Сейчас все классы имеют "объект" в качестве родительского типа. Так почему бы не взломать объекта.метод toString()`? Без изменений, объект класса выглядит так:

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/п:направления/классы.

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

Я нашел, что это очень полезный Хак, и было бы здорово, если Java может просто добавить это. Я понимаю, что потенциальных проблем с имея очень большие массивы со строковыми представлениями может быть проблематичным. Может быть, передать что-то типа системы.из ОРиздания` к подобным неожиданностям.

Там's один дополнительный способ, если Ваш массив имеет тип char[]:

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

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

печать

abc

Вы могли бы перебрать массив, печать каждого элемента, как цикл. Например:

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

Чтобы добавить в ответы на все вопросы, печать объекта в строку JSON тоже вариант.

Используя Джексон:

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

Используя Дсын:

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

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

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

Для каждой петли также может быть использован для печатать элементы массива:

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