Wat is de eenvoudigste manier om een ​​Java-array af te drukken?

In Java overschrijven arrays toString() niet, dus als u er een rechtstreeks probeert af te drukken, krijgt u de className + ‘@’ + de hex van de hashCode van de array, zoals gedefinieerd door Object.toString():

int[] intArray = new int[] {1, 2, 3, 4, 5};
System.out.println(intArray);     // prints something like '[I@3343c8b3'

Maar meestal willen we eigenlijk meer zoals [1, 2, 3, 4, 5]. Wat is de eenvoudigste manier om dat te doen? Hier zijn enkele voorbeelden van in- en uitgangen:

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

Antwoord 1, autoriteit 100%

Sinds Java 5 kunt u Arrays.toString(arr) of Arrays.deepToString(arr) voor arrays binnen arrays. Merk op dat de Object[]-versie .toString() aanroept voor elk object in de array. De uitvoer is zelfs gedecoreerd op de exacte manier die u vraagt.

Voorbeelden:

• Eenvoudige matrix:

  String[] array = new String[] {"John", "Mary", "Bob"};
  System.out.println(Arrays.toString(array));
  

  Uitvoer:

  [John, Mary, Bob]
  

• Geneste array:

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

  Uitvoer:

  [[John, Mary], [Alice, Bob]]
  

• double Array:

  double[] doubleArray = { 7.0, 9.0, 5.0, 1.0, 3.0 };
  System.out.println(Arrays.toString(doubleArray));
  

  Uitvoer:

  [7.0, 9.0, 5.0, 1.0, 3.0 ]
  

• int Array:

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

  Uitvoer:

  [7, 9, 5, 1, 3 ]
  

Antwoord 2, autoriteit 14%

Controleer altijd eerst de standaardbibliotheken.

import java.util.Arrays;

Probeer dan:

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

of als uw array andere arrays als elementen bevat:

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

Antwoord 3, autoriteit 4%

Dit is echter leuk om te weten, want voor “controleer altijd eerst de standaardbibliotheken” zou ik nooit de truc van Arrays.toString( myarray )

zijn tegengekomen

–omdat ik me concentreerde op het type myarray om te zien hoe ik dit moest doen. Ik wilde het ding niet herhalen: ik wilde een eenvoudige aanroep om het eruit te laten zien zoals ik zie in de Eclipse-debugger en myarray.toString() deed het gewoon niet.

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

Antwoord 4, autoriteit 3%

In JDK1.8 kunt u aggregatiebewerkingen en een lambda-expressie gebruiken:

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

Antwoord 5, autoriteit 2%

Vanaf Java 8 kan men ook profiteren van de join()-methode die wordt geboden door de String class om array-elementen af ​​te drukken, zonder de haakjes, en gescheiden door een scheidingsteken naar keuze (dit is het spatieteken voor het onderstaande voorbeeld):

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

De uitvoer is “Hey there amigo!”.

Antwoord 6

Vóór Java 8

We hadden Arrays.toString(array) kunnen gebruiken om eendimensionale array af te drukken en Arrays.deepToString(array) voor multidimensionale arrays.

Java 8

Nu hebben we de optie Stream en lambda om de array af te drukken.

Eendimensionale matrix afdrukken:

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

De uitvoer is:

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

Multidimensionale array afdrukken
Voor het geval we een multidimensionale array willen afdrukken, kunnen we Arrays.deepToString(array) gebruiken als:

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

Het punt om te observeren is dat de methode Arrays.stream(T[]), die in het geval van int[] ons Stream<int[]> en vervolgens methode flatMapToInt() wijst elk element van de stream toe aan de inhoud van een toegewezen stream die is geproduceerd door de meegeleverde mapping-functie op elk element toe te passen.

De uitvoer is:

[[11, 12], [21, 22], [31, 32, 33]]
[[John, Bravo], [Mary, Lee], [Bob, Johnson]]
11
12
21
22
31
32
33
John
Bravo
Maria
Lee
Bob
Johnson

Antwoord 7

Als u Java 1.4 gebruikt, kunt u in plaats daarvan het volgende doen:

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

(Dit werkt natuurlijk ook in 1.5+.)

Antwoord 8

Arrays.toString

Als direct antwoord, de oplossing van verschillende, waaronder @Esko, met behulp van de Arrays.toString en Arrays.deepToString methoden, is gewoon de beste.

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

Hieronder probeer ik enkele van de andere voorgestelde methoden op te sommen, in een poging een beetje te verbeteren, met als meest opvallende toevoeging het gebruik van de Stream.collect operator, met behulp van een joining Collector, om na te bootsen wat de String.join doet.

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

Antwoord 9

Arrays.deepToString(arr) drukt alleen op één regel af.

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

Om een ​​tabel daadwerkelijk als een tweedimensionale tabel af te drukken, moest ik dit doen:

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

Het lijkt erop dat de methode Arrays.deepToString(arr) een scheidingsteken moet hebben, maar dat is helaas niet het geval.

Antwoord 10

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

Antwoord 11

Verschillende manieren om arrays af te drukken in Java:

1. Eenvoudige manier

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

Uitvoer:
[Een, twee, drie, vier]

2. Gebruik toString()

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

Uitvoer: [Een, Twee, Drie, Vier]

3. Een reeks arrays afdrukken

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

Uitvoer: [[Ljava.lang.String;@1ad086a [[Ljava.lang.String;@10385c1,
[Ljava.lang.String;@42719c] [[Vijfde, Zesde], [Zevende, Achtste]]

Bron: Toegang Een array

Antwoord 12

Het gebruik van een gewone for loop is naar mijn mening de eenvoudigste manier om arrays af te drukken.
Hier heb je een voorbeeldcode op basis van je intArray

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

Het geeft output als de jouwe
1, 2, 3, 4, 5

Antwoord 13

Het zou altijd moeten werken, welke JDK-versie je ook gebruikt:

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

Het werkt als de Array Objecten bevat. Als de Array primitieve typen bevat, kunt u wrapper-klassen gebruiken in plaats van de primitieve direct op te slaan als..

Voorbeeld:

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

Vervang het door:

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

Bijwerken:

Ja! dit moet worden vermeld dat het converteren van een array naar een objectarray OF om de array van het object te gebruiken duur is en de uitvoering kan vertragen. het gebeurt door de aard van java, autoboxing genaamd.

Dus alleen voor afdrukdoeleinden, het mag niet worden gebruikt. we kunnen een functie maken die een array als parameter neemt en het gewenste formaat afdrukt als

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

Antwoord 14

Ik kwam dit bericht tegen in Vanilla #Java recentelijk. Het is niet erg handig om Arrays.toString(arr); te schrijven en vervolgens de hele tijd java.util.Arrays; te importeren.

Let op, dit is op geen enkele manier een permanente oplossing. Gewoon een hack die foutopsporing eenvoudiger kan maken.

Het rechtstreeks afdrukken van een array geeft de interne representatie en de hashCode. Nu hebben alle klassen Object als oudertype. Dus waarom zou u de Object.toString() niet hacken? Zonder aanpassingen ziet de klasse Object er als volgt uit:

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

Wat als dit wordt gewijzigd in:

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

Deze gemodificeerde klasse kan eenvoudig aan het klassenpad worden toegevoegd door het volgende aan de opdrachtregel toe te voegen: -Xbootclasspath/p:target/classes.

Met de beschikbaarheid van deepToString(..) sinds Java 5, kan de toString(..) eenvoudig worden gewijzigd in deepToString(..) om ondersteuning toe te voegen voor arrays die andere arrays bevatten.

Ik vond dit een heel nuttige hack en het zou geweldig zijn als Java dit gewoon zou kunnen toevoegen. Ik begrijp mogelijke problemen met het hebben van zeer grote arrays, omdat de tekenreeksrepresentaties problematisch kunnen zijn. Geef misschien iets door als een System.outof een PrintWriter voor dergelijke gevallen.

Antwoord 15

In Java 8 is het eenvoudig. er zijn twee trefwoorden

1. stream: Arrays.stream(intArray).forEach
2. methode referentie: ::println

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

Als je alle elementen in de array op dezelfde regel wilt afdrukken, gebruik dan gewoon print in plaats van println, d.w.z.

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

Een andere manier zonder methodeverwijzing, gebruik gewoon:

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

Antwoord 16

Er zijn de volgende manieren om array af te drukken

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

Antwoord 17

Er is nog een andere manier als je array van het type char[] is:

char A[] = {'a', 'b', 'c'}; 
System.out.println(A); // no other arguments

afdrukken

abc

Antwoord 18

U kunt door de array lopen en elk item afdrukken terwijl u doorloopt. Bijvoorbeeld:

String[] items = {"item 1", "item 2", "item 3"};
for(int i = 0; i < items.length; i++) {
    System.out.println(items[i]);
}

Uitvoer:

item 1
item 2
item 3

Antwoord 19

Een vereenvoudigde snelkoppeling die ik heb geprobeerd is deze:

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

Het wordt afgedrukt

1
2
3

Er zijn geen lussen vereist in deze benadering en het is alleen het beste voor kleine arrays

Antwoord 20

Het gebruik van org.apache.commons.lang3.StringUtils.join(*)-methoden kan een optie zijn
Bijvoorbeeld:

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

Ik heb de volgende afhankelijkheid gebruikt

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

Antwoord 21

For-each loop kan ook worden gebruikt om elementen van array af te drukken:

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

Antwoord 22

Om aan alle antwoorden toe te voegen, is het ook een optie om het object af te drukken als een JSON-string.

Jackson gebruiken:

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

Gson gebruiken:

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

Antwoord 23

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

Antwoord 24

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

Antwoord 25

Dit is gemarkeerd als een duplicaat voor het afdrukken van een byte[]. Opmerking: voor een bytearray zijn er aanvullende methoden die geschikt kunnen zijn.

Je kunt het als een tekenreeks afdrukken als het ISO-8859-1-tekens bevat.

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

of als het een UTF-8-tekenreeks bevat

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

of als u het als hexadecimaal wilt afdrukken.

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

of als je het wilt afdrukken als base64.

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

of als u een reeks ondertekende bytewaarden wilt afdrukken

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

of als u een reeks niet-ondertekende bytewaarden wilt afdrukken

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.

Antwoord 26

als je jdk 8 gebruikt.

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

uitvoer:

[7,3,5,1,3]

Antwoord 27

In JDK1.8 kunt u aggregatiebewerkingen en een lambda-expressie gebruiken:

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

Ook, te beginnen met Java 8, zou men ook gebruik kunnen maken van de methode join() die door de klasse String wordt geleverd om array-elementen af ​​te drukken, zonder de haakjes, en gescheiden door een scheidingsteken naar keuze (dit is het spatieteken voor het onderstaande voorbeeld)

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

`
De output is “Hey there amigo!”

Antwoord 28

Hier een mogelijke afdrukfunctie:

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

Als hoofd bijvoorbeeld zo is

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

de uitvoer is { [1] [2] [3] [4] }

Antwoord 29

In Java 8 :

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

Antwoord 30

Als we Commons.Lang-bibliotheek gebruiken, kunnen we het volgende doen:

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

Uitvoer:

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