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

вопрос создан в Wed, Jan 3, 2018 12:00 AM

В 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]
    
1772
  1. Что вы хотите, чтобы представление было для объектов, отличных от строк? Результат вызова toString? В кавычках или нет?
    2009-01-03 20: 41: 29Z
  2. Да, объекты будут представлены их методом toString () и без кавычек (только что отредактировал пример вывода).
    2009-01-03 20: 42: 45Z
  3. На практике тесно связано с stackoverflow.com/questions/29140402/…
    2016-01-24 18: 02: 46Z
  4. Этот странный вывод не обязательно является местом в памяти. Это hashCode() в шестнадцатеричном формате. См. Object#toString() . . /DIV>
    2016-11-10 21: 22: 40Z
  5. Для печати одномерного или многомерного массива в java8 проверьте stackoverflow.com/questions/409784/…
    2016-11-16 01: 28: 38Z
  6. 30 ответов                              30                         

    Начиная с 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 ]
      
    2369
    2019-02-08 20: 00: 52Z
    1. Что, если у нас есть массив строк, и мы хотим простой вывод; как: String[] array = {"John", "Mahta", "Sara"}, и мы хотим этот вывод без скобок и запятых: John Mahta Sara?
      2015-08-29 02: 34: 41Z
    2. @ Hengameh: Есть несколько других способов сделать это, но мой любимый это один: javahotchocolate.com/notes/java.html#arrays-tostring .
      2015-08-29 06: 16: 05Z
    3. FYI, Arrays.deepToString() принимает только Object [] (или массив классов, которые расширяют Object, например Integer, например, не будет работать с типом 0600001 типа 03000011), так как он не будет работать с типом 0600001110011, если он не будет работать с типом 0600001. Но int [] прекрасно работает для примитивных массивов.
      2015-12-11 23: 25: 12Z
    4. @ Hengameh Для этого есть метод. Arrays.toString(<int array>) напечатает System.out.println(String.join(" ", new String[]{"John", "Mahta", "Sara"})).
      2017-03-13 14: 15: 53Z
    5. @ dorukayhan На самом деле вы можете опустить явное создание экземпляра массива здесь: John Mahta Sara для метода String.join(" ", "John", "Mahta", "Sara")62 принимает массив в качестве параметра vararg .
      2018-08-18 08: 12: 13Z

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

    .join(...)

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

    System.out.println(Arrays.toString(array));
    
        
    335
    2009-02-13 22: 50: 47Z
    1. Что, если у нас есть массив строк, и мы хотим простой вывод; как:
      System.out.println(Arrays.deepToString(array));
      
      , и мы хотим этот вывод без скобок и запятых: String[] array = {"John", "Mahta", "Sara"}?
      2015-08-29 02: 35: 20Z
    2. @ Hengameh Просто сохраните Arrays.toString (array) в строковую переменную, а затем удалите фигурные скобки методом замены Java
      2015-10-21 22: 09: 20Z
    3. @ В настоящее время Hengameh с Java 8: John Mahta Sara. doc
      2016-03-04 23: 14: 07Z

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

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

    Arrays.toString( myarray )     
    100
    2010-11-29 14: 05: 59Z
    1. Что, если у нас есть массив строк, и мы хотим простой вывод; как:
      import java.util.Arrays;
      .
      .
      .
      System.out.println( Arrays.toString( myarray ) );
      
      , и мы хотим этот вывод без скобок и запятых: String[] array = {"John", "Mahta", "Sara"}?
      2015-08-29 02: 35: 32Z
    2. @ Hengameh Я думаю, что это другая тема. После этого вы можете манипулировать этой строкой с помощью общих строковых операций ... Как Arrays.toString (myarray) .replace ("[", "(") и т. Д.
      2016-01-14 10: 42: 15Z

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

    John Mahta Sara     
    81
    2016-03-27 20: 22: 16Z
    1. Или меньшебезумный,
      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
      */
      
      2014-05-22 22: 01: 51Z
    2. Это неуклюже. Это должно быть Arrays.stream(strArray).forEach(System.out::println);, которое является ссылкой на метод Java 8. Ваш код создает ненужную лямбду.
      2014-09-20 09: 11: 49Z
    3. Просто пропустите System.out::println и выполните Arrays.asList
      2016-03-04 23: 16: 07Z
    4. @ AlexisC. Потому что его также можно использовать с другими объектами, кроме массивов.
      2016-03-27 20: 27: 10Z
    5. @ YassinHajaj Оба. Например, если вы хотите иметь поток диапазона над массивом, идиоматический способ с использованием Arrays.stream(strArray).forEach(System.out::println) должен был бы сделать Stream.of. Текущая реализация не возвращает поток SIZED, тогда как .skip(n).limit(m) делает, что приводит к лучшей производительности разделения, если вы хотите выполнять операции параллельно , Кроме того, если у вас есть Arrays.stream(T[], int, int), вы можете случайно использовать int[], который вернет Stream.of с одним элементом, а Stream<int[]> предоставит вам Arrays.stream напрямую.
      2016-03-27 20: 41: 00Z

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

    IntStream

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

        
    40
    2009-01-03 21: 44: 05Z
    1. К сожалению, это работает только с массивами объектов, а не с массивами примитивов.
      2009-01-03 21: 57: 57Z

    Начиная с Java 8, можно также использовать метод

    System.out.println(Arrays.asList(array));
    
    , предоставляемый String class для распечатки элементов массива без скобок, разделенных выбранным разделителем (который является пробелом для пример, показанный ниже): join()

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

        
    37
    2015-12-23 18: 51: 48Z

    Arrays.toString

    В качестве прямого ответа решение, предоставленное несколькими, включая @Esko , с использованием

    String[] greeting = {"Hey", "there", "amigo!"};
    String delimiter = " ";
    String.join(delimiter, greeting) 
    
    и Arrays.toString являются просто лучшими. р>

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

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

    String.join     
    31
    2018-11-13 18: 05: 53Z

    До Java 8

    Мы могли бы использовать

    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);
    
    для печати одномерного массива и Arrays.toString(array) для многомерных массивов.

    Java 8

    Теперь у нас есть опция Arrays.deepToString(array) и Stream для печати массива.

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

    lambda

    Вывод:

      

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

    Печать многомерного массива На всякий случай, если мы хотим напечатать многомерный массив, мы можем использовать

    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);
    }
    
    как: 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[]> сопоставляет каждый элемент потока с содержимым сопоставленного потока, полученного путем применения предоставленной функции сопоставления к каждому элементу <.>

    Вывод:

      

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

        
    29
    2018-11-14 06: 09: 18Z
    1. Что, если у нас есть массив строк, и мы хотим простой вывод; как: flatMapToInt(), и мы хотим этот вывод без скобок и запятых: String[] array = {"John", "Mahta", "Sara"}?
      2015-08-29 02: 33: 51Z

    John Mahta Sara печатает только в одну строку.

    Arrays.deepToString(arr)

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

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

    Похоже, что метод

    System.out.println(Arrays.deepToString(table).replaceAll("],", "]," + System.getProperty("line.separator")));
    
    должен принимать строку-разделитель, но, к сожалению, это не так.     
    28
    2015-05-14 23: 40: 47Z
    1. Возможно, используйте System.getProperty ("line.separator"); вместо \r \n, так что это верно и для не Windows.
      2013-12-21 22: 01: 31Z
    2. теперь вы можете использовать System.lineSeparator ()
      2017-04-07 17: 20: 34Z
    Arrays.deepToString(arr)     
    19
    2014-10-29 10: 24: 51Z
    1. Таким образом, вы получите пустой пробел;)
      2014-09-21 09: 23: 15Z
    2. @ matthiad .. эта строка не будет заканчиваться пустым пространством System.out.println (n + (someArray.length == n)? "": "")
      2015-06-01 12: 29: 18Z
    3. Наихудший способ сделать это.
      2015-07-08 12: 56: 07Z
    4. Это так неэффективно, но хорошо для начинающих.
      2018-04-08 23: 23: 12Z
    5. @ MuhammadSuleman Это не работает, потому что это цикл для каждого.
      for(int n: someArray) {
          System.out.println(n+" ");
      }
      
      - это фактическое значение из массива, а не индекса. Для регулаr для цикла, это также будет n, потому что он прерывается, когда (someArray.length - 1) == i равен длине массива.
      2018-08-06 22: 02: 18Z

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

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

      i
      

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

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

      toString()
      

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

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

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

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

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

        
    16
    2016-11-15 17: 05: 20Z

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

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

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

        
    12
    2013-12-27 23: 31: 15Z
    1. Он выводит "1, 2, 3, 4, 5" в качестве вывода, он также печатает запятую после последнего элемента.
      2014-03-10 11: 32: 27Z
    2. Как решить проблему отсутствия запятой после последнего элемента?
      2014-06-16 01: 48: 30Z
    3. Вы можете заменить код в цикле на
      for (int i = 0; i < intArray.length; i++) {
         System.out.print(intArray[i] + ", ");
      }
      
      2014-07-16 17: 39: 36Z
    4. Вы также можете использовать System.out.print(intArray[i]); if(i != intArray.length - 1) System.out.print(", "); для объединения этих двух строк.
      2016-01-11 18: 55: 21Z
    5. Вы можете использовать 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».
      2016-12-27 23: 00: 23Z

    Я наткнулся на этот пост в ванили #Java недавно. Не очень удобно писать System.out.print(i + (i < intArray.length - 1 ? ", " : ""));, а затем постоянно импортировать Arrays.toString(arr);.

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

    Печать массива напрямую дает внутреннее представление и hashCode. Теперь все классы имеют java.util.Arrays; в качестве родительского типа. Итак, почему бы не взломать Object? Без модификации класс Object выглядит следующим образом:

    Object.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/p:target/classes начиная с Java 5, deepToString(..) можно легко изменить на toString(..), чтобы добавить поддержку массивов, содержащих другие массивы.

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

        
    7
    2016-03-11 11: 50: 38Z
    1. вы хотите выполнить эти условия PrintWriter для каждого объекта?
      2016-08-10 11: 48: 25Z
    2. + 1 только для идеи, но, основываясь на предыдущем комментарии, можем ли мы модифицировать реализации массива напрямую, а не в зависимости от общего родителя if? Можем ли мы развить эту идею дальше? Не то чтобы я думал, что изменение поведения по умолчанию объектов java.lang. * - это то, что я бы рекомендовал ...
      2017-09-11 15: 52: 57Z

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

    Object

    Это будет работать, если

    System.out.println(Arrays.asList(array));
    
    содержит объекты. Если Array содержит типы примитивов, вы можете использовать классы-обертки, вместо этого сохраняя примитив непосредственно как ..

    Пример:

    Array

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

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

    Обновление:

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

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

    Integer[] a = new Integer[]{1,2,3,4,5};
    
        
    7
    2016-05-13 11: 52: 23Z
    1. Преобразование массива в список просто для печатных целей не кажется очень изобретательным решением; и учитывая, что тот же класс имеет
      public void printArray(int [] a){
              //write printing code
      } 
      
      , это побеждает меня, почему кто-то когда-либо делал бы это.
      2016-05-13 11: 35: 36Z

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

    1. поток: toString(..)
    2. ссылка на метод: Arrays.stream(intArray).forEach

      ::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);
    
        
    7
    2016-09-27 09: 46: 23Z
    1. Это напечатает каждый элемент массива в отдельной строке, чтобы он не соответствовал требованиям.
      2016-06-29 15: 51: 11Z
    2. если вы хотите напечатать все элементы в массиве в одной строке, просто используйте 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));
      2016-06-29 20: 56: 46Z

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

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

    печатает

    char A[] = {'a', 'b', 'c'}; 
    
    System.out.println(A); // no other arguments
    
        
    5
    2014-04-29 07: 34: 31Z

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

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

    abc
    

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

    ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
    System.out.println(ow.writeValueAsString(anyArray));
    
        
    5
    2014-11-12 13: 38: 24Z
    1. Это то, что я делаю. Благодаря этому вы можете печатать произвольно сложные структуры, если они кодируются в JSON. Я всегда стараюсь использовать "довольно". Ваш второй пример делает это? Я думаю, вам нужно выбрать «симпатичный» вариант, чтобы получить это.
      2019-02-10 02: 43: 20Z

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

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

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

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

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

        
    4
    2015-02-21 07: 12: 25Z

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

    1
    2
    3
    

    Вывод:

    String[] items = {"item 1", "item 2", "item 3"};
    
    for(int i = 0; i < items.length; i++) {
    
        System.out.println(items[i]);
    
    }
    
        
    4
    2016-07-20 23: 55: 49Z

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

    item 1
    item 2
    item 3
    
        
    4
    2018-05-08 12: 43: 03Z
     // 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);
         }
    
        
    3
    2015-04-05 20: 30: 48Z

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

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

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

    String[] strArray = new String[] { "John", "Mary", "Bob" };
    String arrayAsCSV = StringUtils.join(strArray, " , ");
    System.out.printf("[%s]", arrayAsCSV);
    //output: [John , Mary , Bob]
    
        
    3
    2015-08-08 20: 18: 14Z

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

    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.3.2</version>
    
        
    3
    2018-03-11 19: 23: 36Z
    1. @ firephil System.out.println (a [i]); используется с обычным циклом for, где создается индекс «i» и выводится значение для каждого индекса. Я использовал «для каждого» цикла. Попробуйте, надеюсь, вы поймете мою точку зрения.
      2016-12-25 21: 22: 43Z
    2. Да, это самый короткий способ печати массива
      2018-08-04 16: 20: 25Z

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

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

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

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

    String s = new String(bytes, StandardChars.ISO_8559);
    System.out.println(s);
    // to reverse
    byte[] bytes2 = s.getBytes(StandardChars.ISO_8559);
    

    или если вы хотите распечатать его как шестнадцатеричный.

    String s = new String(bytes, StandardChars.UTF_8);
    System.out.println(s);
    // to reverse
    byte[] bytes2 = s.getBytes(StandardChars.UTF_8);
    

    или если вы хотите распечатать его как base64.

    String s = DatatypeConverter.printHexBinary(bytes);
    System.out.println(s);
    // to reverse
    byte[] bytes2 = DatatypeConverter.parseHexBinary(s);
    

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

    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]);
    
        
    2
    2018-06-22 19: 26: 51Z
    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.
    
    // array of primitives:
    int[] intArray = new int[] {1, 2, 3, 4, 5};
    
    System.out.println(Arrays.toString(intArray));
    
    output: [1, 2, 3, 4, 5]
    
        
    1
    2018-03-16 01: 44: 40Z

    В Java 8:

    // array of object references:
    String[] strArray = new String[] {"John", "Mary", "Bob"};
    
    System.out.println(Arrays.toString(strArray));
    
    output: [John, Mary, Bob]
    
        
    0
    2018-05-08 20: 05: 49Z

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

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

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

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

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

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

    class demo{
          public static void main(String a[]){
    
               int[] number={1,2,3,4,5};
    
               System.out.print(number);
          }
    }
    

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

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

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

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

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

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

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

        
    0
    2018-07-01 15: 45: 41Z
    1. int array [] = {1, 2, 3, 4, 5}; for (int i: array) System.out.println (i);
      2018-08-04 16: 22: 44Z
    2. попробуйте это, я думаю, что это самый короткий способ напечатать массив
      2018-08-04 16: 23: 15Z

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

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

    выход: р>

    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);
    
        
    0
    2018-12-10 07: 57: 58Z
    1. Это лучше, чем принятый ответ, поскольку дает больший контроль над разделителем, префиксом и суффиксом. Однако я бы удалил лишние
      [7,3,5,1,3]
      
      в окончательном toString() и использовал бы его в System.out.println() вместо добавления пустой строки. Это решение также работает для массивов не примитивных типов.
      2018-12-14 14: 42: 08Z
    2. Мой плохой, joiner.add(element.toString()) внутри element.toString() только для непримитивных типов. Вам все еще нужно использовать joiner.add() - подобные конструкции для примитивных типов. Лично я использовал цикл foreach Integer.toString(element) вместо потоков, но это дело вкуса.
      2018-12-14 15: 02: 50Z

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

    for (int element : array) joiner.add(Integer.toString(element)); р> 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);
    
        
    0
    2019-01-01 23: 34: 11Z

    Если вы хотите распечатать, оцените содержимое массива так, как вы можете использовать

    {1,2,3,4,5}
    {John,Mary,Bob}
    
    Arrays.toString     
    - 1
    2018-07-06 12: 29: 41Z
    jshell> String[] names = {"ram","shyam"};
    names ==> String[2] { "ram", "shyam" }
    
    jshell> Arrays.toString(names);
    $2 ==> "[ram, shyam]"
    
    jshell> 
    
источник размещен Вот