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

Question

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

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

Но обычно нам бы хотелось чего-то большего, чем [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]

Answer 1

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

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

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

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

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

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

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

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

   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] [[Пятая, шестая], [Седьмая, восьмая]]

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

Answer 2

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

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

выдает вывод как твой 1, 2, 3, 4, 5

Answer 3

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

Answer 4

Он всегда должен работать независимо от того, какую версию 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){
        //write printing code
} 

Answer 5

Я недавно наткнулся на этот пост в 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 для таких случаев.

Answer 6

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

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

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

отпечатки

abc

Answer 7

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

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

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

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

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

Answer 8

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

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

Answer 9

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

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

Будет напечатано

1
2
3

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

Answer 10

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

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