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

Начиная с 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));

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

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

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

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

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

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

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

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

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

Чтобы действительно распечатать таблицу как двухмерную, мне пришлось сделать следующее:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

отпечатки

abc

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

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

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

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

1
2
3

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

До 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]
[John, Mary, Bob]
1
2
3
4
5
John
Mary
Bob

Печать многомерного массива На всякий случай, если мы хотим напечатать многомерный массив, мы можем использовать 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]]
[[John, Bravo], [Mary, Lee], [Bob, Johnson]]
11
12
21
22
31
32
33
John
Bravo
Mary
Lee
Bob
Johnson

Использование методов 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>

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

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

Результатом будет «Привет, амиго!».

Arrays.toString

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

Java 8 - Stream.collect (объединение ()), Stream.forEach

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

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

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

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

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

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

Output: [One, Two, Three, Four]

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

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

Output: [One, Two, Three, Four]

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

Output: [[Ljava.lang.String;@1ad086a [[Ljava.lang.String;@10385c1, [Ljava.lang.String;@42719c] [[Fifth, Sixth], [Seventh, Eighth]]

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

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

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

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

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

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

В java 8:

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

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

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

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

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

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

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

           System.out.print(number);
      }
}

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

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

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-элементы .. Спасибо!

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

Если использовать Библиотека 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}

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

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

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

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

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

` Результатом будет "Привет, амиго!"

Вот возможная функция печати:

  public static void printArray (int [] array){
        System.out.print("{ ");
        for (int i = 0; i < array.length; i++){
            System.out.print("[" + array[i] + "] ");
        }
        System.out.print("}");
    }

Например, если main такой

public static void main (String [] args){
    int [] array = {1, 2, 3, 4};
    printArray(array);
}

вывод будет {[1] [2] [3] [4]}

Если вы используете Java 11

import java.util.Arrays;
public class HelloWorld{

     public static void main(String []args){
        String[] array = { "John", "Mahta", "Sara" };
       System.out.println(Arrays.toString(array).replace(",", "").replace("[", "").replace("]", ""));
     }
}

Выход :

John Mahta Sara