Jaki jest najprostszy sposób na wydrukowanie tablicy Java?

Zawsze najpierw sprawdź standardowe biblioteki.

import java.util.Arrays;

Następnie spróbuj:

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

Lub jeśli tablica zawiera inne tablice jako elementy:

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

Miło to wiedzieć, jednak jeśli chodzi o "zawsze najpierw sprawdź standardowe biblioteki", nigdy nie natknąłbym się na sztuczkę Arrays.toString( myarray )

-- ponieważ koncentrowałem się na rodzaju myarray, aby zobaczyć, jak to zrobić. Nie chciaĹ 'em musiaĹ' em przechodziÄ ‡ przez to: chciaĹ 'em Ĺ' atwego wywoĹ 'ania, aby wyszĺ' o podobnie do tego, co widze w Debuggerze Eclipse i myarray.toString () po prostu tego nie robił.

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

W JDK1. 8 możesz użyć operacji agregacyjnych i wyrażenia lambda:

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

Począwszy od Javy 8, można również skorzystać z metody join() dostarczonej przez klasę String, Aby wydrukować elementy tablicy, bez nawiasów i oddzielone wybranym ogranicznikiem (który jest znakiem spacji dla przykładu pokazanego poniżej):

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

Wyjście będzie "Hey there amigo!".

Jeśli używasz Javy 1.4, możesz zamiast tego zrobić:

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

(oczywiście działa to również w 1.5+.)

Przed Java 8

Mogliśmy użyć Arrays.toString(array) do drukowania tablicy jednowymiarowej i {[3] } do tablic wielowymiarowych.

Java 8

Teraz mamy opcję Stream i lambda, aby wydrukować tablicę.

Drukowanie tablicy jednowymiarowej:

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

Wyjście to:

[1, 2, 3, 4, 5]
[John, Mary, Bob]
1
2
3
4
5
John
Mary
Bob

Drukowanie wielowymiarowej tablicy Na wypadek, gdybyśmy chcieli wydrukować tablicę wielowymiarową możemy użyć Arrays.deepToString(array) jako:

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

Teraz należy obserwować, że metoda Arrays.stream(T[]), która w przypadku int[] zwraca nam Stream<int[]>, a następnie metoda flatMapToInt() mapuje każdy element strumienia z zawartością zmapowanego strumienia wytworzonego przez zastosowanie dostarczonej funkcji mapowania do każdego elementu.

Wyjście to:

[[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

Tablice.toString

Jako bezpośrednią odpowiedź, Rozwiązanie dostarczone przez kilka, w tym @Esko , przy użyciu Arrays.toString oraz Arrays.deepToString metody, jest po prostu najlepszy.

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

Poniżej staram się wymienić niektóre z innych proponowanych metod, próbując poprawić trochę, z najbardziej zauważalnym dodatkiem jest użycie Stream.collect operator, za pomocą joining Collector, aby naśladować to, co String.join jest robiąc.

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.deepToString(arr) tylko odciski na jednej linii.

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

Aby uzyskać tabelę do wydruku jako dwuwymiarową tabelę, musiałem to zrobić:

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

Wydaje się, że metoda Arrays.deepToString(arr) powinna przyjmować ciąg znaków separatora, ale niestety tak nie jest.

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

Różne sposoby drukowania tablic w Javie:

1. Prosty Sposób

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

Wyjście: [Raz, Dwa, Trzy, Cztery]

1. Za pomocą toString()

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

Wyjście: [Jeden, Dwa, Trzy, Cztery]

1. Drukowanie tablicy tablic

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

Wyjście: [[Ljava.lang.String;@1ad086a [[Ljava.lang.String;@10385c1, [Ljava.lang.String;@42719c] [[piąty, Szósty], [Siódmy, Ósmy]]

Resource: Access An Array

Użycie zwykłej dla pętli jest moim zdaniem najprostszym sposobem drukowania tablicy. Tutaj masz przykładowy kod oparty na twoim intArray

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

Daje wyjście jako Twoje 1, 2, 3, 4, 5

Powinno zawsze działać niezależnie od używanej wersji JDK:

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

Zadziała, jeśli Array zawiera obiekty. Jeśli Array zawiera typy prymitywne, możesz użyć klas wrappera przechowujących ten typ bezpośrednio jako..

Przykład:

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

Zastąp go przez:

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

Update:

Więc tylko do celów drukowania, nie powinny być używane. możemy wykonać funkcję, która przyjmuje tablicę jako parametr i wypisuje żądany format jako

public void printArray(int [] a){
        //write printing code
} 

[[12]}ostatnio natknąłem się na ten post w Vanilla #Java. Nie jest to zbyt wygodne pisanie Arrays.toString(arr);, a następnie importowanie java.util.Arrays; przez cały czas.

Należy pamiętać, że nie jest to stałe rozwiązanie w żaden sposób. Tylko hack, który może uprościć debugowanie.

Drukowanie tablicy bezpośrednio daje wewnętrzną reprezentację i hashCode. Teraz wszystkie klasy mają Object jako typ rodzica. Dlaczego więc nie zhakować Object.toString()? Bez modyfikacji Klasa obiektu wygląda następująco to:

public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

Co jeśli to zostanie zmienione na:

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

Ta zmodyfikowana klasa może być po prostu dodana do ścieżki klasy, dodając do wiersza poleceń: -Xbootclasspath/p:target/classes.

Teraz, przy dostępności deepToString(..) od wersji Java 5, toString(..) można łatwo zmienić na deepToString(..), aby dodać obsługę tablic zawierających inne tablice.

Uznałem to za bardzo przydatny hack i byłoby świetnie, gdyby Java mogła po prostu dodać to. Rozumiem potencjalne problemy z posiadaniem bardzo dużych tablice, ponieważ reprezentacje łańcuchów mogą być problematyczne. Może przekazać coś w rodzaju System.out lub PrintWriter dla takich ewentualności.

W Javie 8 jest to proste. istnieją dwa słowa kluczowe

1. strumień: Arrays.stream(intArray).forEach

2. Odniesienie do metody: ::println

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

Jeśli chcesz wydrukować wszystkie elementy w tablicy w tej samej linii, po prostu użyj print zamiast println tj.

int[] intArray = new int[] {1, 2, 3, 4, 5};
Arrays.stream(intArray).forEach(System.out::print);

Inny sposób bez odniesienia do metody po prostu użyj:

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

Istnieje jeden dodatkowy sposób, jeśli tablica jest typu char []:

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

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

Druki

abc

Istnieje następujący sposób drukowania tablicy

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

Aby dodać do wszystkich odpowiedzi, można również wydrukować obiekt jako łańcuch JSON.

Użycie:

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

Using Gson:

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

Możesz zapętlić tablicę, wypisując każdy element podczas zapętlania. Na przykład:

String[] items = {"item 1", "item 2", "item 3"};

for(int i = 0; i < items.length; i++) {

    System.out.println(items[i]);

}

Wyjście:

item 1
item 2
item 3

Uproszczony skrót, który próbowałem jest taki:

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

Wydrukuje

1
2
3

Nie wymaga pętli w tym podejściu i najlepiej jest tylko dla małych tablic

Korzystanie z org.Apacz.commons.lang3.StringUtils.metody join (*) mogą być opcją
Na przykład:

String[] strArray = new String[] { "John", "Mary", "Bob" };
String arrayAsCSV = StringUtils.join(strArray, " , ");
System.out.printf("[%s]", arrayAsCSV);
//output: [John , Mary , Bob]

Użyłem następującej zależności

<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.3.2</version>

For-każda pętla może być również użyta do wypisania elementów tablicy:

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

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

Jest to oznaczone jako duplikat dla drukowania bajtu [] . Notatka: dla tablicy bajtów istnieją dodatkowe metody, które mogą być odpowiednie.

Można go wydrukować jako ciąg znaków, jeśli zawiera znaki ISO-8859-1.

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

Lub jeśli zawiera łańcuch UTF-8

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

Lub jeśli chcesz wydrukować go jako szesnastkowy.

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

Lub jeśli chcesz wydrukować go jako base64.

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

Lub jeśli chcesz wydrukować tablicę z podpisanymi wartościami bajtów

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

Lub jeśli chcesz wydrukować tablica wartości bajtów niepodpisanych

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.

Jeśli używasz 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);

Wyjście:

[7,3,5,1,3]

W Javie 8:

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

Jeśli używasz Commons.Biblioteka Lang , możemy zrobić:

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

Wyjście:

{1,2,3,4,5}
{John,Mary,Bob}

W JDK1. 8 możesz użyć operacji agregacyjnych i wyrażenia lambda:

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

Również, począwszy od Javy 8, można skorzystać z metody join() dostarczonej przez klasę String, aby wydrukować elementy tablicy, bez nawiasów i oddzielone wybranym ogranicznikiem (który jest znakiem spacji dla przykładu pokazanego poniżej)

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

` Efektem będzie utwór " Hey there amigo!"

Tutaj możliwa funkcja drukowania:

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

Na przykład, jeśli main jest taki

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

Wyjście będzie { [1] [2] [3] [4] }