java - जावा सरणी मुद्रित करने का सबसे आसान तरीका क्या है?




arrays printing (18)

Arrays.toString

सीधा जवाब के रूप में, Arrays.toString और Arrays.deepToString विधियों का उपयोग करके @Esko सहित कई द्वारा प्रदान किया गया समाधान , बस सबसे अच्छा है।

जावा 8 - Stream.collect (शामिल ()), Stream.forEach

नीचे मैं Stream.collect क्या कर रहा है, String.join नकल करने के लिए, joining Collector का उपयोग करके Stream.collect ऑपरेटर के उपयोग के सबसे उल्लेखनीय जोड़े के साथ, कुछ सुधारने का प्रयास करने के लिए सुझाए गए कुछ अन्य तरीकों को सूचीबद्ध करने का प्रयास करें।

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

जावा में, सरणी toString() ओवरराइड नहीं करते हैं, इसलिए यदि आप सीधे प्रिंट करने का प्रयास करते हैं, तो आपको ऑब्जेक्ट. Object.toString() द्वारा परिभाषित सरणी के हैशकोड के वर्गनाम + @ + हेक्स प्राप्त होता है:

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

लेकिन आम तौर पर हम वास्तव में कुछ और चाहते हैं [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]

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>

आप सरणी के माध्यम से लूप कर सकते हैं, प्रत्येक आइटम को प्रिंट करते हुए, जैसे आप लूप करते हैं। उदाहरण के लिए:

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

एक सरणी मुद्रित करने का सबसे आसान तरीका एक लूप का उपयोग करना है:

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

जावा 8 में यह आसान है। दो कीवर्ड हैं

  1. धारा: Arrays.stream(intArray).forEach
  2. विधि संदर्भ: ::println

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

यदि आप एक ही पंक्ति में सरणी में सभी तत्वों को मुद्रित करना चाहते हैं, तो केवल println यानी के बजाय print उपयोग करें

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

जावा 8 में:

Arrays.stream(myArray).forEach(element-> System.out.println(element));

जावा 8 से शुरू join() , स्ट्रिंग क्लास द्वारा प्रदान की गई join() विधि का लाभ भी ले सकता है ताकि ब्रैकेट के बिना सरणी तत्वों को मुद्रित किया जा सके और पसंद के डिलीमीटर द्वारा अलग किया जा सके (जो नीचे दिखाए गए उदाहरण के लिए स्पेस कैरेक्टर है) :

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

आउटपुट होगा "अरे वहाँ amigo!"।


जेडीके 1.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
*/

मैं हाल ही में वेनिला # जावा में इस पोस्ट में आया था। यह बहुत सुविधाजनक लेखन Arrays.toString(arr); , फिर java.util.Arrays; आयात 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

अब, जावा 5 के बाद deepToString(..) की उपलब्धता के साथ, toString(..) को अन्य सरणी वाले सरणी के लिए समर्थन जोड़ने के लिए आसानी से deepToString(..) बदला जा सकता है।

मैंने इसे काफी उपयोगी हैक पाया और यह बहुत अच्छा होगा अगर जावा बस इसे जोड़ सके। स्ट्रिंग प्रस्तुतियां समस्याग्रस्त हो सकती हैं क्योंकि मैं बहुत बड़े सरणी रखने के साथ संभावित मुद्दों को समझता हूं। शायद ऐसी PrintWriter लिए System.out या PrintWriter तरह कुछ पास करें।


मैंने कोशिश की एक सरल शॉर्टकट यह है:

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

यह प्रिंट करेगा

1
2
3

इस दृष्टिकोण में कोई लूप आवश्यक नहीं है और यह केवल छोटे सरणी के लिए सबसे अच्छा है


यदि आपकी सरणी प्रकार char [] है तो एक अतिरिक्त तरीका है:

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

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

प्रिंट

abc

यह जानना अच्छा है, हालांकि, "हमेशा मानक पुस्तकालयों की जांच करें" के रूप में मैं कभी भी Arrays.toString( myarray ) की चाल पर ठोकर नहीं Arrays.toString( myarray )

- क्योंकि मैं यह कैसे करना है यह देखने के लिए मायारे के प्रकार पर ध्यान केंद्रित कर रहा था। मैं इस चीज़ के माध्यम से पुन: प्रयास नहीं करना चाहता था: मैं ग्रहण डीबगर और myarray.toString () में जो कुछ भी देखता हूं उसके समान बाहर आने के लिए एक आसान कॉल चाहता था, बस यह नहीं कर रहा था।

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

लूप के लिए नियमित रूप से उपयोग करना मेरी राय में मुद्रण सरणी का सबसे आसान तरीका है। यहां आपके intArray के आधार पर नमूना कोड है

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

यह आउटपुट आपके 1, 2, 3, 4, 5 के रूप में देता है


सभी उत्तरों को जोड़ने के लिए, ऑब्जेक्ट को JSON स्ट्रिंग के रूप में प्रिंट करना भी एक विकल्प है।

जैक्सन का प्रयोग करना:

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

जीसन का प्रयोग करना:

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

Arrays.deepToString(arr) केवल एक पंक्ति पर प्रिंट करता है।

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

वास्तव में एक दो आयामी तालिका के रूप में मुद्रित करने के लिए एक टेबल प्राप्त करने के लिए, मुझे यह करना था:

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

ऐसा लगता है जैसे Arrays.deepToString(arr) विधि को विभाजक स्ट्रिंग लेनी चाहिए, लेकिन दुर्भाग्यवश यह नहीं है।


ऐरे प्रिंट करने के लिए निम्नलिखित तरीके हैं

 // 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(Integer lists : arrayInt){
         System.out.println(lists);
     }

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

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






printing