Bir Java dizisini yazdırmanın en basit yolu nedir?

Java'da, diziler geçersiz kılmaz toString(), bu nedenle doğrudan bir tane yazdırmaya çalışırsanız , dizinin className+ '@' + hex'ini hashCodeşu şekilde tanımlanır Object.toString():

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

Ama genellikle, daha çok benzer bir şey isterdik [1, 2, 3, 4, 5]. Bunu yapmanın en basit yolu nedir? Aşağıda bazı örnek giriş ve çıkışlar verilmiştir:

// 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'ten beri Arrays.toString(arr)veya Arrays.deepToString(arr)diziler içindeki diziler için kullanabilirsiniz . Object[]Sürümün .toString()dizideki her nesneyi çağırdığını unutmayın . Çıktı, tam olarak istediğiniz şekilde dekore edilmiştir.

Örnekler:

• Basit Dizi:

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

  Çıktı:

  [John, Mary, Bob]

• İç İçe Dizi:

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

  Çıktı:

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

• double Dizi:

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

  Çıktı:

  [7.0, 9.0, 5.0, 1.0, 3.0 ]

• int Dizi:

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

  Çıktı:

  [7, 9, 5, 1, 3 ]

Her zaman önce standart kitaplıkları kontrol edin.

import java.util.Arrays;

O zaman dene:

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

veya diziniz öğe olarak başka diziler içeriyorsa:

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

Bunu bilmek güzel, ama "her zaman önce standart kütüphaneleri kontrol edin" Arrays.toString( myarray )

--Bunu nasıl yapacağımı görmek için myarray türüne yoğunlaştığımdan beri. Bu şeyi yinelemek zorunda kalmadım: Eclipse hata ayıklayıcısında ve myarray.toString () 'de gördüklerime benzer hale getirmek için kolay bir çağrı yapmak istedim.

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

JDK1.8'de toplu işlemleri ve lambda ifadesini kullanabilirsiniz:

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 ile başlayarak join(), dizgi öğelerini köşeli parantez olmadan yazdırmak ve bir seçim sınırlayıcısıyla (aşağıda gösterilen örnek için alan karakteri olan) ayrılmış String sınıfı tarafından sağlanan yöntemden de yararlanılabilir :

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

Çıktı "Hey amigo!" Olacaktır.

Java 1.4 kullanıyorsanız bunun yerine şunları yapabilirsiniz:

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

(Bu elbette 1.5+ de çalışıyor.)

Arrays.toString

Doğrudan bir cevap olarak, @Esko dahil olmak üzere birçok kişi tarafındanArrays.toString ve Arrays.deepToStringyöntemlerini kullanarak sağlanan çözüm basitçe en iyisidir.

Java 8 - Stream.collect (birleştirme ()), Stream.forEach

Aşağıda, diğer önemli yöntemleri listelemeye çalışıyorum, biraz geliştirmeye çalışıyorum, en dikkat çekici ek, Stream.collectoperatörün kullanımı, a'nın ne yaptığını taklit etmek için a kullanarak .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'den önce

Biz kullanmış olabilir Arrays.toString(array)tek boyutlu dizi ve yazdırmak için Arrays.deepToString(array)çok boyutlu diziler için.

Java 8

Şimdi diziyi yazdırma Streamve lambdayazdırma seçeneğimiz var .

Tek Boyutlu Dizi Yazdırma:

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

Çıktı:

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

Çok Boyutlu Dizi Yazdırma Çok boyutlu dizi yazdırmak istiyorsak şu şekilde kullanabiliriz 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);
} 

Şimdi gözlemlenmesi gereken nokta Arrays.stream(T[]), int[]bize geri dönmesi Stream<int[]>ve ardından yöntemin, flatMapToInt()her bir öğeyi, sağlanan eşleme işlevinin her bir öğeye uygulanmasıyla üretilen eşlenen bir akışın içeriğiyle eşleştirdiği yöntemin olmasıdır .

Çıktı:

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

Arrays.deepToString(arr) yalnızca bir satıra yazdırır.

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

Aslında iki boyutlu bir tablo olarak yazdırmak için bir tablo almak için, bunu yapmak zorunda kaldı:

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

Arrays.deepToString(arr)Yöntemin ayırıcı bir dize alması gerektiği anlaşılıyor , ancak ne yazık ki almıyor.

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

Java'da Dizileri Yazdırmanın Farklı Yolları:

1. Basit yol

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

Çıktı: [Bir, İki, Üç, Dört]

2. kullanma toString()

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

Çıktı: [Bir, İki, Üç, Dört]

3. Dizilerin Baskı Dizisi

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

Çıktı: [[Ljava.lang.String; @ 1ad086a [[Ljava.lang.String; @ 10385c1, [Ljava.lang.String; @ 42719c] [[Beşinci, Altıncı], [Yedinci, Sekizinci]]

Kaynak: Bir Diziye Erişim

Bence düzenli baskı için döngü kullanmak en basit yöntemdir. Burada intArray'ınıza dayalı bir örnek kod var

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

Sizinki gibi çıktı verir 1, 2, 3, 4, 5

Geçenlerde Vanilla #Java'da bu yazıyla karşılaştım . Çok uygun bir yazı değil Arrays.toString(arr);, her zaman içe aktarıyor java.util.Arrays;.

Lütfen bunun hiçbir şekilde kalıcı bir düzeltme olmadığını unutmayın. Hata ayıklamayı basitleştiren bir kesmek.

Bir diziyi doğrudan yazdırmak dahili temsili ve hashCode'u verir. Şimdi, tüm sınıflar Objectüst öğe tipine sahiptir. Peki, neden hacklemiyorsun Object.toString()? Değişiklik yapılmadan Object sınıfı şuna benzer:

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

Bu şu şekilde değiştirilirse:

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

Bu modded sınıf, komut satırına aşağıdakiler eklenerek sınıf yoluna eklenebilir: -Xbootclasspath/p:target/classes .

Şimdi, kullanılabilirliği ile deepToString(..)Java 5 beri toString(..)kolaylıkla değiştirilebilirdeepToString(..) , diğer dizileri içeren diziler için destek eklemek .

Bunu oldukça kullanışlı bir kesmek olarak buldum ve Java bunu ekleyebilirse harika olurdu. Dize gösterimleri sorunlu olabileceğinden çok büyük dizilere sahip olma ile ilgili olası sorunları anlıyorum. Belki de bu tür olasılıklar için a System.outveya a gibi bir şey PrintWritergeçirin.

Hangi JDK sürümünü kullanırsanız kullanın her zaman çalışmalıdır:

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

ArrayNesneleri içeriyorsa çalışır . Eğer Arrayilk türleri içeren, bunun yerine direkt olarak ilkel depolama sarma sınıfları kullanabilir ..

Misal:

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

Şununla değiştir:

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

Güncelleme :

Evet ! bir dizinin bir nesne dizisine VEYA Nesnenin dizisini kullanmak için dönüştürülmesinin maliyetli olduğunu ve yürütmeyi yavaşlatabileceği belirtilmelidir. otomatik boks adı verilen java'nın doğası gereği olur.

Bu yüzden sadece baskı amaçlı, kullanılmamalıdır. Bir diziyi parametre olarak alan ve istenen biçimi şu şekilde basan bir işlev yapabiliriz:

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

Java 8'de bu kolaydır. iki anahtar kelime var

1. Akış: Arrays.stream(intArray).forEach

2. yöntem referansı: ::println

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

Dizideki tüm öğeleri aynı satırda yazdırmak istiyorsanız print, printlnie yerine kullanın.

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

Yöntem referansı olmayan başka bir yol sadece şunu kullanın:

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

Diziniz char [] türünde ise başka bir yol daha vardır:

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

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

baskılar

abc

Tüm cevaplara eklemek için, nesneyi JSON dizesi olarak yazdırmak da bir seçenektir.

Jackson'ı kullanma:

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

Gson'u kullanma:

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

Döngü boyunca her öğeyi yazdırarak dizi arasında döngü yapabilirsiniz. Örneğin:

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

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

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

}

Çıktı:

item 1
item 2
item 3

Dizi yazdırmak için aşağıdaki yol var

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

Denediğim basitleştirilmiş bir kısayol şudur:

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

Yazdırılacak

1
2
3

Bu yaklaşımda döngülere gerek yoktur ve sadece küçük diziler için en iyisidir

Her döngü için dizi öğelerini yazdırmak için de kullanılabilir:

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 (*) yöntemlerini kullanmak bir seçenek olabilir
Örneğin:

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

Aşağıdaki bağımlılığı kullandım

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

Bu bir bayt [] yazdırmak için bir kopya olarak işaretlenmiştir . Not: bayt dizisi için uygun olabilecek ek yöntemler vardır.

ISO-8859-1 karakterleri içeriyorsa bir String olarak yazdırabilirsiniz.

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

veya UTF-8 dizesi içeriyorsa

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

veya onaltılık olarak yazdırmak istiyorsanız.

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

veya base64 olarak yazdırmak istiyorsanız.

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

veya bir dizi işaretli bayt değeri yazdırmak istiyorsanız

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

veya işaretsiz bayt değerleri dizisi yazdırmak istiyorsanız

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 çalıştırıyorsanız.

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

çıktı:

[7,3,5,1,3]

Java 8'de:

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

Commons.Lang kütüphanesini kullanıyorsanız şunları yapabiliriz:

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

Çıktı:

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

// Java'daki konsoldaki dizi öğesinin adresini yazdırırsanız.

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

Bir dizi elemanını yazdırmanın birkaç yolu vardır.Önce, bir dizi nedir açıklayacağım? .. Dizi veri depolamak için basit bir veri yapısıdır .. Bir dizi tanımladığınızda, Yardımcı bellek blokları kümesi tahsis edin Bu bellek blokları bir birim alınır ..

Tamam, böyle bir dizi oluşturacağım,

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

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

           System.out.print(number);
      }
}

Şimdi çıktıya bakın,

Bilmediğiniz bilinmeyen bir dize görebilirsiniz .. Daha önce de belirttiğim gibi, dizisi (sayı dizisi) bildirilen bellek adresi yazdırılır. Dizideki öğeleri görüntülemek istiyorsanız, bunun için "for loop" kullanabilirsiniz.

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

Şimdi çıktıya bakın,

Tamam, bir boyut dizisinin öğeleri başarıyla yazdırıldı ... Şimdi iki boyut dizisini dikkate alacağım ... İki boyut dizisini "sayı2" olarak ilan edeceğim ve öğeleri "Arrays.deepToString ()" anahtar sözcüğünü kullanarak yazdıracağım. 'Java.util.Arrays' kitaplığını içe aktarmanız gerekir.

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

çıktıyı düşünün,

Aynı zamanda, döngüler için iki kullanarak, 2D elemanlar yazdırılabilir .. Teşekkür ederim!