ما هي أبسط طريقة لطباعة مجموعة جافا؟

https://stackoverflow.com/questions/409784

03-07-2019
|

سؤال

في 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 ]

نصائح أخرى

وتأكد دائما من المكتبات القياسية لأول مرة. جرب:

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

وأو إذا كان لديك مجموعة تحتوي صفائف أخرى كعناصر:

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

وهذا هو الجميل أن نعرف، ولكن، كما ل"دائما التحقق من المكتبات القياسية لأول مرة" والا ما كنت قد عثر عليها خدعة Arrays.toString( myarray )

و- منذ أن تم التركيز على نوع myarray لمعرفة كيفية القيام بذلك. لم أكن أريد أن يكون للتكرار خلال الشيء: كنت أريد مكالمة سهلة لجعله يخرج على غرار ما أرى في المصحح الكسوف و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
*/

إذا كنت تستخدم جافا 1.4، بدلا من ذلك يمكنك القيام به:

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

(وهذا يعمل في 1.5+ جدا، بالطبع).

وبدءا جافا 8، يمكن للمرء أيضا الاستفادة من طريقة join() التي تقدمها في فئة سلسلة للطباعة عناصر المصفوفة، دون الأقواس، ومفصولة محدد من خيار (وهو حرف مسافة ل هو مبين أدناه على سبيل المثال):

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

والناتج سيكون "يا هناك أميغو!".

Arrays.toString

وأما إجابة مباشرة، <وأ href = "https://www.google.com/search؟client=safari&rls=en&q=html+jump+to+anchor&ie=UTF-8&oe=UTF-8" يختلط = " نوفولو noreferrer "> الحل تقدمها عدة، بما في ذلكEsko ، وذلك باستخدام في Arrays.toString و <لأ href =" https://docs.oracle.com/javase/7/docs/api/java /util/Arrays.html#deepToString٪28java.lang.Object[]٪29 "يختلط =" نوفولو noreferrer "> طرق Arrays.deepToString، هو ببساطة أفضل.

جافا 8 - Stream.collect (الانضمام ())، Stream.forEach

وفيما يلي أحاول سرد بعض الطرق الأخرى المقترحة، في محاولة لتحسين قليلا، مع إضافة أبرزها استخدام في مشغل Stream.collect ، وذلك باستخدام <لأ href =" HTTPS: // docs.oracle.com/javase/8/docs/api/java/util/stream/Collectors.html#joining-java.lang.CharSequence- "يختلط =" نوفولو noreferrer "> joining Collector، لتقليد ما و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);

قبل جافا 8

كان من الممكن أن نستخدم Arrays.toString(array) لطباعة مجموعة ذات بعد واحد و Arrays.deepToString(array) للمصفوفات متعددة الأبعاد.

جافا 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+" ");
}

طرق مختلفة لطباعة المصفوفات في جافا:

طريقة بسيطة

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

انتاج:[واحد إثنان ثلاثة أربعة]

استخدام toString()

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

انتاج:[واحد إثنان ثلاثة أربعة]

طباعة مصفوفة من المصفوفات

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] [[الخامس ، السادس] ، [السابع ، الثامن]]]]

الموارد: الوصول إلى صفيف

باستخدام العادية ل Loop هي أبسط طريقة لطباعة المصفوفة في رأيي.هنا لديك نموذج للتعليمة البرمجية يعتمد على intArray الخاص بك

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

يمنح الإخراج كأسلوب لك 1 ، 2 ، 3 ، 4 ، 5

جئت عبر هذا المنصب في فانيليا #جافا حديثاً.إنها ليست كتابة مريحة للغاية Arrays.toString(arr);, ، ثم الاستيراد java.util.Arrays; طوال الوقت.

يرجى ملاحظة أن هذا ليس حلاً دائمًا بأي وسيلة.مجرد اختراق يمكن أن يجعل تصحيح الأخطاء أسهل.

طباعة مصفوفة تعطي مباشرة التمثيل الداخلي ورمز التجزئة.الآن، جميع الطبقات لديها Object كنوع الوالدين.فلماذا لا تخترق Object.toString()؟بدون تعديل، تبدو فئة الكائن كما يلي:

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

تحديث :

نعم !تجدر الإشارة إلى أن تحويل مصفوفة إلى مصفوفة كائن أو استخدام مصفوفة الكائن أمر مكلف وقد يؤدي إلى إبطاء التنفيذ.يحدث ذلك بطبيعة جافا التي تسمى autoboxing.

لذلك فقط لغرض الطباعة، لا ينبغي استخدامه.يمكننا إنشاء دالة تأخذ مصفوفة كمعلمة وتطبع التنسيق المطلوب كـ

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

في جافا 8 الأمر سهل.هناك نوعان من الكلمات الرئيسية

تدفق: Arrays.stream(intArray).forEach

مرجع الطريقة: ::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));

وهناك طريقة واحدة إضافية إذا مجموعة الخاص بك هو من نوع شار []:

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

واختصار مبسط حاولت هو:

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

ووسوف طباعة

1
2
3

ولا الحلقات المطلوبة في هذا النهج وأنه من الأفضل للصفائف صغيرة فقط

هل يمكن أن يتكرر خلال مجموعة، طبع كل بند، كما كنت حلقة. على سبيل المثال:

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

هناك الطريقة التالية لطباعة Array

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

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>

ل-كل حلقة ويمكن أيضا أن تستخدم لطباعة عناصر مجموعة:

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

ويتميز هذا على أنه مكرر ل الطباعة ل [] بايت . ملاحظة: لمجموعة بايت هناك طرق إضافية قد يكون مناسبا

ويمكنك طباعة على أنها سلسلة إذا كان يحتوي على أحرف 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]

في جافا 8:

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

وهناك عدة طرق لطباعة مجموعة elements.First قبل كل شيء، سوف أشرح ذلك، ما هو مصفوفة؟ .. صفيف هو بنية بيانات بسيطة لتخزين data..When تقوم بتعريف صفيف، تخصيص مجموعة من تؤخذ كتل الذاكرة الإضافية في كتل الذاكرة RAM.Those وحدة واحدة ..

وطيب، وأنا إنشاء مجموعة من هذا القبيل،

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

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

           System.out.print(number);
      }
}

والآن ننظر في الإخراج،

ويمكنك أن ترى printed..As سلسلة المجهول ذكرت من قبل، عنوان الذاكرة الذي الصفيف (عدد مجموعة) أعلن هو printed.If كنت ترغب في عرض العناصر في المصفوفة، يمكنك استخدام "عن حلقة"، مثل هذا ..

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

والآن ننظر في الإخراج،

وطيب، وعناصر المطبوعة بنجاح من بعد واحد array..Now وانا ذاهب للنظر بعدين array..I'll إعلان اثنين من مجموعة البعد باسم "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));
      }
}

والنظر في الإخراج،

وفي الوقت نفسه، عن طريق اثنين من أجل الحلقات، وعناصر 2D يمكن printed..Thank لك!

وإذا كنت تقوم بتشغيل جدك 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}

إذا كنت ترغب في طباعة، وتقييم المحتوى صفيف مثل التي يمكنك استخدامها Arrays.toString

jshell> String[] names = {"ram","shyam"};
names ==> String[2] { "ram", "shyam" }

jshell> Arrays.toString(names);
$2 ==> "[ram, shyam]"

jshell>

مرخصة بموجب: CC-BY-SA مع الإسناد

لا تنتمي إلى StackOverflow

ما هي أبسط طريقة لطباعة مجموعة جافا؟

صفيف بسيط:

صفيف متداخل:

double مجموعة مصفوفة:

int مجموعة مصفوفة:

Arrays.toString

جافا 8 - Stream.collect (الانضمام ())، Stream.forEach

قبل جافا 8

جافا 8

`double` مجموعة مصفوفة:

`int` مجموعة مصفوفة: