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

В Java массивы не переопределяют toString(), поэтому, если вы попытаетесь напечатать один непосредственно, вы получите className + '@' + гекс hashCode массива, так как определяется Object.toString():

int[] intArray = new int[] {1, 2, 3, 4, 5};
System.out.println(intArray);     // prints something like '[[email protected]'

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

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

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

Ответ 1

Начиная с 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));
//output: [[Ljava.lang.String;@106d69c, [Ljava.lang.String;@52e922]
System.out.println(Arrays.deepToString(deepArray));

Выход:

[[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` Array:

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

Выход:

[7, 9, 5, 1, 3 ]

Ответ 2

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

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

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

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

Ответ 3

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

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

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

Ответ 4

В 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
*/

Ответ 5

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

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

(Это тоже работает в 1.5+, конечно.)

Ответ 6

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

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

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

Ответ 7

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

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

Ответ 8

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

    //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
Джон
Мэри
боб

Печать многомерного массива На всякий случай, когда мы хотим печатать многомерный массив, мы можем использовать 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"} };

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

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

Выход:

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

Ответ 9

Arrays.deepToString(arr) печатает только одну строку.

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

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

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

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

Ответ 10

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

Ответ 11

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

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

List<String> list = new ArrayList<String>();
list.add("One");
list.add("Two");
list.add("Three");
list.add("Four");
// Print the list in console
System.out.println(list);

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

Использование toString()

String[] array = new String[] { "One", "Two", "Three", "Four" };
System.out.println(Arrays.toString(array));

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

Массив массивов массивов

String[] arr1 = new String[] { "Fifth", "Sixth" };
String[] arr2 = new String[] { "Seventh", "Eight" };
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] [[Пятый, шестой], [Седьмой, восьмой]]

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

Ответ 12

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

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

Он дает результат как ваш 1, 2, 3, 4, 5

Ответ 13

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

Обратите внимание, что это не постоянное исправление любыми способами. Просто взломать, что упростит отладку.

Печать массива напрямую дает внутреннее представление и хэш-код. Теперь все классы имеют 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 для таких событий.

Ответ 14

Он всегда должен работать в зависимости от используемой вами версии 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};

Обновление:

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

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

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

Ответ 15

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

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

ссылка на метод: ::println

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

Если вы хотите напечатать все элементы в массиве в одной строке, просто используйте print вместо println i.e.

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

Ответ 16

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

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

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

печатает

abc

Ответ 17

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

Использование Джексона:

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

Использование Gson:

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

Ответ 18

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

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

Ответ 19

Есть следующий способ печати массива

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

Ответ 20

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

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

Он напечатает

1
2
3

В этом подходе нет циклов, и это лучше всего для небольших массивов

Ответ 21

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

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

Ответ 22

public class printer {

    public static void main(String[] args) {
        String a[] = new String[4];
        Scanner sc = new Scanner(System.in);
        System.out.println("enter the data");
        for (int i = 0; i < 4; i++) {
            a[i] = sc.nextLine();
        }
        System.out.println("the entered data is");
        for (String i : a) {
            System.out.println(i);
        }
      }
    }

Ответ 23

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

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

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

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

Ответ 24

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

Вы можете распечатать его как строку, если она содержит символы 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.

Ответ 25

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

Ответ 26

если вы используете 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]

Ответ 27

В java 8:

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

Ответ 28

Существует несколько способов печати элементов массива. Прежде всего, я объясню, что такое массив?.. Массив - это простая структура данных для хранения данных. Когда вы определяете массив, выделите набор блоков вспомогательной памяти в ОЗУ. Эти блоки памяти принимаются на единицу.

Хорошо, я создам такой массив,

class demo{
      public static void main(String a[]){

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

           System.out.print(number);
      }
}

Теперь посмотрим на результат,

Вы можете увидеть неизвестную строку, напечатанную... Как я уже упоминал ранее, адрес памяти, чей массив (числовой массив) объявлен, печатается. Если вы хотите отображать элементы в массиве, вы можете использовать "для цикла", как это.

class demo{
      public static void main(String a[]){

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

           int i;

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

Теперь посмотрим на результат,

Хорошо, успешно напечатанные элементы одного массива измерений. Теперь я рассмотрю два массива измерений. Я объявлю два массива измерений как "число2" и распечатаю элементы с помощью ключевого слова "Arrays.deepToString()". Прежде чем использовать это Вам нужно будет импортировать библиотеку java.util.Arrays.

 import java.util.Arrays;

 class demo{
      public static void main(String a[]){

           int[][] number2={{1,2},{3,4},{5,6}};'

           System.out.print(Arrays.deepToString(number2));
      }
}

рассмотрим выход,

В то же время, используя два для циклов, 2D-элементы могут быть напечатаны.. Спасибо!

Ответ 29

Если вы используете библиотеку Commons.Lang, мы можем сделать:

ArrayUtils.toString(array)

int[] intArray = new int[] {1, 2, 3, 4, 5};
String[] strArray = new String[] {"John", "Mary", "Bob"};
ArrayUtils.toString(intArray);
ArrayUtils.toString(strArray);

Выход:

{1,2,3,4,5}
{John,Mary,Bob}

Ответ 30

toString - это способ преобразования массива в строку.

Также вы можете использовать:

for (int i = 0; i < myArray.length; i++){
System.out.println(myArray[i] + " ");
}

Этот цикл for позволит вам распечатать каждое значение вашего массива по порядку.

Ответ 1

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

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

double массив:

int Array:

Ответ 2

Ответ 3

Ответ 4

Ответ 5

Ответ 6

Ответ 7

Arrays.toString

Java 8 - Stream.collect(joining()), Stream.forEach

Ответ 8

До Java 8

Java 8

Ответ 9

Ответ 10

Ответ 11

Ответ 12

Ответ 13

Ответ 14

Ответ 15

Ответ 16

Ответ 17

Ответ 18

Ответ 19

Ответ 20

Ответ 21

Ответ 22

Ответ 23

Ответ 24

Ответ 25

Ответ 26

Ответ 27

Ответ 28

Ответ 29

Ответ 30

`double` массив:

`int` Array: