Який найпростіший спосіб друкувати Java-масив?

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

Оскільки 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 ]

Завжди спочатку перевіряйте стандартні бібліотеки.

import java.util.Arrays;

Потім спробуйте:

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

або якщо ваш масив містить інші масиви як елементи:

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

Це приємно знати, однак, щоби "завжди спочатку перевірити стандартні бібліотеки", я ніколи не натрапляв на хитрість Arrays.toString( 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 8, можна також скористатися join()методом, передбаченим класом String, для друку елементів масиву без дужок і розділених роздільником для вибору (що є символом пробілу для прикладу, показаного нижче):

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

Вихід буде "Ей, там amigo!".

Якщо ви використовуєте Java 1.4, ви можете:

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

(Звичайно, це працює і в 1,5+).

Arrays.toString

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

Java 8 - Stream.collect (приєднання ()), Stream.forEach

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

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

Arrays.deepToString(arr) друкує лише на одній лінії.

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

Щоб насправді отримати таблицю для друку у вигляді двовимірної таблиці, мені довелося це зробити:

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

Здається, що Arrays.deepToString(arr)метод повинен приймати роздільний рядок, але, на жаль, це не так.

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

Різні способи друкувати масиви на 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] [[П'ятий, Шостий], [Сьомий, Восьмий]]

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

На мою думку, використання регулярних для циклу - це найпростіший спосіб друку масиву. Тут ви маєте зразок коду на основі вашого intArray

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

Це дає вихід як ваш 1, 2, 3, 4, 5

Я нещодавно натрапив на цю посаду у ванільній #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для таких випадків.

Він повинен працювати завжди в будь-якій версії 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
} 

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

Є ще один спосіб, якщо ваш масив має тип char []:

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

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

відбитки

abc

Щоб додати до всіх відповідей, друк об'єкта у вигляді рядка JSON також є варіантом.

Використання Джексона:

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

Використання Gson:

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

Ви можете провести цикл через масив, роздруковуючи кожен елемент під час циклу. Наприклад:

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

Існує наступний спосіб друкувати масив

 // 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 x[] = {1,2,3};
    String printableText = Arrays.toString(x).replaceAll("[\\[\\]]", "").replaceAll(", ", "\n");
    System.out.println(printableText);

Він надрукує

1
2
3

У цьому підході не потрібні петлі, і це найкраще лише для невеликих масивів

Для кожного циклу також можна використовувати для друку елементів масиву:

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

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

Використання методів 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>

Це позначено як дублікат для друку байта [] . Примітка: для байтового масиву є додаткові методи, які можуть бути доречними.

Ви можете роздрукувати його як String, якщо він містить символи 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.

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

якщо у вас 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]

У java 8:

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

Якщо ви використовуєте бібліотеку 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}

// Якщо ви друкуєте адресу елемента масиву на консолі в java.

      int myArrayElement[] = {1,2,3,4,5,6,7,8,9,10};
       Log.i("MyTag",myIntegerNumbers + "");

Існує кілька способів друкувати елементи масиву. По-перше, я поясню це, що таке масив? .. Масив - це проста структура даних для зберігання даних. Коли ви визначаєте масив, виділіть набір допоміжних блоків пам'яті в оперативній пам'яті. Ці блоки пам'яті приймаються одним блоком.

Гаразд, я створу такий масив,

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

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

           System.out.print(number);
      }
}

Тепер подивіться на вихід,

Ви можете бачити невідомий рядок, надрукований. Як я вже згадував, адреса пам'яті, масив (числовий масив) якої оголошено, друкується. Якщо ви хочете відобразити елементи в масиві, ви можете використовувати "for loop", наприклад, цей ..

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 елементи. Дякую!