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

1946

В 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]
Алекс Сперлинг
источник
8
Что вы хотите, чтобы представление было для объектов, кроме строк? Результат вызова toString? В кавычках или нет?
Джон Скит
3
Да, объекты будут представлены их методом toString () и без кавычек (только что отредактировал пример вывода).
Алекс Сперлинг
2
На практике тесно связан со stackoverflow.com/questions/29140402/…
Raedwald
1
Этот странный вывод не обязательно является местом в памяти. Это hashCode()в шестнадцатеричном. См Object#toString().
4касл
1
Для печати одномерного или многомерного массива в java8 проверке stackoverflow.com/questions/409784/...
akhil_mittal

Ответы:

2606

Начиная с 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 Массив:

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

    Вывод:

    [7, 9, 5, 1, 3 ]
RAnders00
источник
3
Что, если у нас есть массив строк, и мы хотим простой вывод; как: String[] array = {"John", "Mahta", "Sara"}, и мы хотим , чтобы этот выход без кронштейна и запятых: John Mahta Sara?
Хенгаме
3
@Hengameh: Есть несколько других способов сделать это, но мой любимый это один: javahotchocolate.com/notes/java.html#arrays-tostring .
Расс Бейтман
5
К вашему сведению, Arrays.deepToString()допускается только расширение Object [](или массив классов, которые расширяются Object, например Integer, поэтому он не будет работать с примитивным массивом типа int []. Но Arrays.toString(<int array>)отлично работает для примитивных массивов.
Marcus
4
@Hengameh Есть метод, посвященный этому. System.out.println(String.join(" ", new String[]{"John", "Mahta", "Sara"}))напечатает John Mahta Sara.
user8397947
2
@dorukayhan На самом деле вы можете пропустить явно инстанцирование массива здесь: String.join(" ", "John", "Mahta", "Sara")для .join(...)метод принимают массив в качестве vararg параметра.
Амадан
354

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

import java.util.Arrays;

Тогда попробуйте:

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

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

System.out.println(Arrays.deepToString(array));
Лимбическая система
источник
Что, если у нас есть массив строк, и мы хотим простой вывод; как: String[] array = {"John", "Mahta", "Sara"}, и мы хотим , чтобы этот выход без кронштейна и запятых: John Mahta Sara?
Хенгаме
1
@Hengameh Просто сохраните Arrays.toString (массив) в строковую переменную, а затем удалите фигурные скобки методом замены Java
Naveed Ahmad
12
@Hengameh В настоящее время с Java 8: String.join(" ", Arrays.asList(array)). Док
Джастин,
106

Это приятно знать, однако, что «сначала всегда проверяйте стандартные библиотеки», я бы никогда не наткнулся на хитрость Arrays.toString( myarray )

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

import java.util.Arrays;
.
.
.
System.out.println( Arrays.toString( myarray ) );
Расс Бейтман
источник
Что, если у нас есть массив строк, и мы хотим простой вывод; как: String[] array = {"John", "Mahta", "Sara"}, и мы хотим , чтобы этот выход без кронштейна и запятых: John Mahta Sara?
Хенгаме
3
@Hengameh Я думаю, это другая тема. После этого вы можете манипулировать этой строкой с помощью общих строковых операций ... Как Arrays.toString (myarray) .replace ("[", "(") и т. Д.
OddDev
91

В 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
*/
Эрик Бейкер
источник
50
Или менее громоздким,Arrays.stream(strArray).forEach(System.out::println);
Алексис С.
9
Это неуклюже Это должна быть System.out::printlnссылка на метод Java 8. Ваш код выдает ненужную лямбду.
Борис Паук
2
Просто пропустите Arrays.asListи сделайтеArrays.stream(strArray).forEach(System.out::println)
Джастин
1
@AlexisC. Потому что он также может быть использован с другими объектами, кроме массивов.
Яссин Хаджадж
1
@YassinHajaj Оба. Например , если вы хотите иметь поток диапазона по массиву идиоматического пути , используя Stream.ofбуду делать .skip(n).limit(m). Текущая реализация не возвращает поток SIZED, в то время как Arrays.stream(T[], int, int)делает, что приводит к лучшему разделению производительности, если вы хотите выполнять операции параллельно. Также, если у вас есть int[], вы можете случайно использовать, Stream.ofкоторый будет возвращать Stream<int[]>с одним элементом, а Arrays.streamдаст вам IntStreamнапрямую.
Алексис С.
41

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

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

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

laylaylom
источник
40

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

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

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

Росс
источник
38
К сожалению, это работает только с массивами объектов, а не с массивами примитивов.
Алекс Сперлинг
34

Arrays.toString

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

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

Ниже я попытаюсь перечислить некоторые из других предложенных методов, пытаясь немного улучшить их, при этом наиболее заметным дополнением является использование Stream.collectоператора, использующего , для имитации того, что делает.joining CollectorString.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);
Йоу йоу
источник
33

До 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
Джон
Браво
Мэри
Ли
Боб
Джонсон

akhil_mittal
источник
Что, если у нас есть массив строк, и мы хотим простой вывод; как: String[] array = {"John", "Mahta", "Sara"}, и мы хотим , чтобы этот выход без кронштейна и запятых: John Mahta Sara?
Хенгаме
28

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

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

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

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

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

Rhyous
источник
3
Может быть, использовать System.getProperty ("line.separator"); вместо \ r \ n, так что это правильно и для не-Windows.
Скутер
Вы можете использовать System.lineSeparator () сейчас
Novaterata
20
for(int n: someArray) {
    System.out.println(n+" ");
}
somedude
источник
6
Таким образом, вы получите пустое место;)
Маттиас
1
@ matthiad .. эта строка не будет содержать пустое пространство System.out.println (n + (someArray.length == n)? "": "");
Мухаммед Сулеман
3
Худший способ сделать это.
NameNotFoundException
@MuhammadSuleman Это не работает, потому что это цикл для каждого. nфактическое значение из массива, а не индекс. Для обычного цикла for это также произойдет (someArray.length - 1) == i, потому что он прерывается, когда iравен длине массива.
Radiodef
17

Различные способы печати массивов в 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);

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

  1. С помощью toString()

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

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

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

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

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

AFFY
источник
13

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

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

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

Andrew_Dublin
источник
4
Он выводит «1, 2, 3, 4, 5» в качестве вывода, он также печатает запятую после последнего элемента.
icza
Как решить проблему отсутствия запятой после последнего элемента?
Мона Джалал
3
Вы можете заменить код внутри цикла наSystem.out.print(intArray[i]); if(i != intArray.length - 1) System.out.print(", ");
Nepoxx
2
Вы также можете использовать System.out.print(i + (i < intArray.length - 1 ? ", " : ""));для объединения этих двух линий.
Ник Сувин
Вы можете использовать StringBuilder и усечь завершающую запятую. int [] intArray = new int [] {1, 2, 3, 4, 5}; final StringBuilder sb = new StringBuilder (); for (int i: intArray) {sb.append (intArray [i]). append (","); } if (sb.length ()> 0) {sb.setLength (sb.length () - 1); } System.out.println (sb.toString ()); Это выводит «1, 2, 3, 4, 5».
Рик Райкер,
8

Я недавно наткнулся на этот пост в 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());
}

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

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

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

Дебосмит Рэй
источник
2
Вы хотите выполнить эти ifусловия на каждом объекте?
Сидгейт
+1 только для идеи, но, основываясь на предыдущем комментарии, можем ли мы модифицировать реализации массива напрямую, а не в зависимости от Objectобщего родителя? Можем ли мы развить эту идею дальше? Не то чтобы я думал, что изменение поведения объектов java.lang. * По умолчанию - это то, что я бы рекомендовал ...
YoYo
8

Он всегда должен работать независимо от того, какую версию 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
} 
Греш Кумар
источник
1
Преобразование массива в список просто для печатных целей не кажется очень изобретательным решением; и учитывая, что у того же класса есть toString(..), это побеждает меня, почему кто-то когда-либо делал это
Debosmit Ray
8

В 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вместо printlnie

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));
suatCoskun
источник
1
Это напечатает каждый элемент массива в отдельной строке, чтобы он не соответствовал требованиям.
Алекс Спёрлинг
если вы хотите напечатать все элементы в массиве в одной строке, просто используйте print вместо println, т.е. int [] intArray = new int [] {1, 2, 3, 4, 5}; Arrays.stream (INTArray) .forEach (System.out :: печать); в противном случае без ссылки на метод просто используйте int [] intArray = new int [] {1, 2, 3, 4, 5}; System.out.println (Arrays.toString (INTArray));
suatCoskun
6

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

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

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

печать

abc
странствовать
источник
5

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

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

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

Используя Gson:

Gson gson = new Gson();
System.out.println(gson.toJson(anyArray));
Жан Ложар
источник
Это то, что я делаю. Благодаря этому вы можете печатать произвольно сложные структуры, если они кодируются в JSON. Я всегда стараюсь использовать "довольно". Ваш второй пример делает это? Я думаю, вам нужно щекотать «красивый» вариант, чтобы получить это.
Стив
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
Дилан Блэк
источник
5

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

 // 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);
     }
Рави Патель
источник
4

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

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

Будет печатать

1
2
3

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

Мохамед Идрис
источник
4

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

int array[] = {1, 2, 3, 4, 5};
for (int i:array)
    System.out.println(i);
hasham.98
источник
@firephil System.out.println (a [i]); используется с обычным циклом for, где создается индекс «i» и выводится значение для каждого индекса. Я использовал «для каждого» цикла. Попробуйте, надеюсь, вы поймете мою точку зрения.
hasham.98 25.12.16
Да, это самый короткий способ печати массива
Манджита Тешара
3
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);
        }
      }
    }
SamTebbs33
источник
3

Можно использовать методы 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>
Хаим Раман
источник
Добавление зависимости из-за чего-то тривиального, что должно быть сделано в две строки кода, является кричащим антипаттерном.
Jurez
commons-lang3 очень зависима от тополя, и обратите внимание, что этот ответ был, где большинство людей не использовали java 8
Хаим Раман
2

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

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

если вы используете 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]
shellhub
источник
Это лучше, чем принятый ответ, поскольку дает больший контроль над разделителем, префиксом и суффиксом. Тем не менее, я бы удалил лишнее toString()в финале System.out.println()и использовал его joiner.add(element.toString())вместо добавления пустой строки. Это решение работает и для массивов непримитивных типов, равномерно.
Джон Макклейн
Мое плохое, element.toString()внутри только joiner.add()для непримитивных типов. Вам все еще нужно использовать Integer.toString(element)подобные конструкции для примитивных типов. Лично я использовал цикл foreach for (int element : array) joiner.add(Integer.toString(element));вместо потоков, но это дело вкуса.
Джон Макклейн
0

В Ява 8:

Arrays.stream(myArray).forEach(System.out::println);
Мехди
источник
0

Если вы используете библиотеку 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}
Прадип Карки
источник
0

// Если вы печатаете адрес элемента массива на консоли в Java.

      int myArrayElement[] = {1,2,3,4,5,6,7,8,9,10};
       Log.i("MyTag",myIntegerNumbers + "");
TEJVEER SINGH
источник
Это не похоже на ответ на вопрос.
пользователь
-1

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

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

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]+"  ");
           }
      }
}

Теперь посмотрим на вывод,

введите описание изображения здесь

Хорошо, успешно напечатаны элементы одного размерного массива. Теперь я собираюсь рассмотреть двухмерный массив. Я объявлю двухмерный массив как «number2» и напечатаю элементы, используя ключевое слово «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));
      }
}

рассмотреть выход,

введите описание изображения здесь

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

GT_hash
источник
int array [] = {1, 2, 3, 4, 5}; for (int i: array) System.out.println (i);
Манджита Тешара
попробуйте это, я думаю, что это самый короткий способ напечатать массив
Манджита Тешара
"адрес памяти, чей массив (объявленный массив) напечатан" Это совсем не так, его системный хеш-код объекта, и это может основываться на многих вещах, включая адрес памяти, но это может измениться позже, и хеш-код не будет изменение. И в настоящее время это в основном случайное число. gotofinal.dev/java/2017/10/08/java-default-hashcode.html
GotoFinal