जावा सरणी को प्रिंट करने का सबसे सरल तरीका क्या है?

1943

जावा में, सरणियाँ ओवरराइड नहीं होती हैं 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 arrays printing

— एलेक्स स्पर्लिंग
स्रोत

8

आप स्ट्रिंग के अलावा अन्य वस्तुओं के लिए प्रतिनिधित्व क्या चाहते हैं? कॉल करने का परिणाम उद्धरण में या नहीं?

— जॉन स्कीट

3

हाँ वस्तुओं का प्रतिनिधित्व उनके toString () पद्धति और उद्धरण के बिना किया जाएगा (बस उदाहरण आउटपुट संपादित किया गया)।

— एलेक्स स्पर्लिंग

2

व्यवहार में, stackoverflow.com/questions/29140402/…

— Raedwald

1

यह अजीब आउटपुट स्मृति स्थान जरूरी नहीं है। यह hashCode()हेक्साडेसिमल में है। देख लो Object#toString()।

— 4castle

1

Java8 में एकल आयामी या बहुआयामी सरणी प्रिंट करने के लिए stackoverflow.com/questions/409784/…

— akhil_mittal

2600

Java 5 के बाद से आप arrays के भीतर 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 ]

— RAnders00
स्रोत

3

क्या होगा अगर हमारे पास स्ट्रिंग्स की एक सरणी है, और सरल आउटपुट चाहते हैं; जैसे: String[] array = {"John", "Mahta", "Sara"}और हम ब्रैकेट और कॉमा के बिना यह आउटपुट चाहते हैं John Mahta Sara:?

— हेंगामेह

3

@ हेन्गमेह: ऐसा करने के कई अन्य तरीके हैं, लेकिन मेरा पसंदीदा यह है: javahotchinery.com/notes/java.html#arrays-tostring ।

— रोस बेटमैन

5

FYI करें, Arrays.deepToString()केवल एक Object [](या वर्गों की एक सरणी है कि विस्तार Object, जैसे Integer, तो यह प्रकार की एक आदिम सरणी पर काम नहीं करेगा स्वीकार करता है int []। लेकिन Arrays.toString(<int array>)आदिम सरणियों के लिए ठीक काम करता है।

— मार्कस

4

@ हेंगमेह एक विधि है जो इसके लिए समर्पित है। System.out.println(String.join(" ", new String[]{"John", "Mahta", "Sara"}))छप जाएगा John Mahta Sara।

— user8397947

2

@dorukayhan वास्तव में आप स्पष्ट रूप से यहाँ सरणी instantiating छोड़ सकते हैं: String.join(" ", "John", "Mahta", "Sara")के लिए .join(...)विधि एक के रूप में सरणी लेता vararg पैरामीटर।

— Amadán

354

हमेशा मानक पुस्तकालयों को पहले जांचें।

import java.util.Arrays;

फिर कोशिश करो:

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

या यदि आपके सरणी में तत्व के रूप में अन्य सरणियाँ हैं:

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

— लिम्बिक सिस्टम
स्रोत

क्या होगा अगर हमारे पास स्ट्रिंग्स की एक सरणी है, और सरल आउटपुट चाहते हैं; जैसे: String[] array = {"John", "Mahta", "Sara"}और हम ब्रैकेट और कॉमा के बिना यह आउटपुट चाहते हैं John Mahta Sara:?

— हेंगामेह

1

@Hengameh एक स्ट्रिंग चर के लिए Arrays.toString (सरणी) को स्टोर करें और फिर जावा की जगह विधि द्वारा ब्रेसिज़ निकालें

— नावेद अहमद

12

@Hengameh आजकल जावा 8 के साथ String.join(" ", Arrays.asList(array)):। डॉक्टर

— जस्टिन

106

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

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

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

— रस बेटमैन
स्रोत

क्या होगा अगर हमारे पास स्ट्रिंग्स की एक सरणी है, और सरल आउटपुट चाहते हैं; जैसे: String[] array = {"John", "Mahta", "Sara"}और हम ब्रैकेट और कॉमा के बिना यह आउटपुट चाहते हैं John Mahta Sara:?

— हेंगामेह

3

@ हेन्गमेह मुझे लगता है कि यह एक और विषय है। आप बाद में इस स्ट्रिंग को आम स्ट्रिंग ऑपरेशन के साथ जोड़ सकते हैं ... जैसे Arrays.toString (myarray) .replace ("[", "("), और इसी तरह।

— OddDev

91

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

— एरिक बेकर
स्रोत

50

या कम बोझिल,Arrays.stream(strArray).forEach(System.out::println);

— एलेक्सिस सी।

9

यह अनाड़ी है। यह होना चाहिए System.out::printlnजो एक जावा 8 विधि संदर्भ है। आप एक अनावश्यक लैम्बडा का निर्माण करते हैं।

— बोरिस द स्पाइडर

2

बस छोड़ दो Arrays.asListऔर करोArrays.stream(strArray).forEach(System.out::println)

— जस्टिन

1

@AlexisC। क्योंकि इसका उपयोग सरणियों के अलावा अन्य वस्तुओं के साथ भी किया जा सकता है।

— यासिन हज्ज

1

@ यिसनहज दोनों। उदाहरण के लिए यदि आप सरणी में एक रेंज स्ट्रीम रखना चाहते हैं तो मुहावरेदार तरीका उपयोग Stream.ofकरना होगा .skip(n).limit(m)। Arrays.stream(T[], int, int)यदि आप समानांतर में संचालन करना चाहते हैं, तो वर्तमान कार्यान्वयन एक SIZED स्ट्रीम नहीं लौटाता है, जो बेहतर विभाजन प्रदर्शन करता है। यदि आपके पास एक भी है int[], तो आप गलती से उपयोग कर सकते हैं Stream.ofजो Stream<int[]>एक ही तत्व के साथ वापस आ जाएगा , जबकि Arrays.streamआपको IntStreamसीधे देगा।

— एलेक्सिस सी।

41

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

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

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

— laylaylom
स्रोत

40

यदि आप जावा 1.4 का उपयोग कर रहे हैं, तो आप इसके बजाय कर सकते हैं:

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

(यह 1.5+ में भी काम करता है, बिल्कुल।)

— रॉस
स्रोत

38

दुर्भाग्य से यह केवल वस्तुओं के सरणियों के साथ काम करता है, न कि आदिमों के सरणियों के साथ।

— एलेक्स स्पर्लिंग

34

Arrays.toString

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

जावा 8 - Stream.collect (ज्वाइनिंग ()), Stream.forEach

नीचे मैं सुझाए गए कुछ अन्य तरीकों को सूचीबद्ध करने का प्रयास करता हूं, जिनमें थोड़ा सुधार करने का प्रयास किया जाता है, सबसे उल्लेखनीय इसके अलावा Stream.collectऑपरेटर का उपयोग करने के लिए , ए का उपयोग करके , जो कर रहा है उसकी नकल करना है।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);

— योयो
स्रोत

33

जावा 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
जॉन
ब्रावो
मैरी
ली
बॉब
जॉनसन

— akhil_mittal
स्रोत

क्या होगा अगर हमारे पास स्ट्रिंग्स की एक सरणी है, और सरल आउटपुट चाहते हैं; जैसे: String[] array = {"John", "Mahta", "Sara"}और हम ब्रैकेट और कॉमा के बिना यह आउटपुट चाहते हैं John Mahta Sara:?

— हेंगामेह

28

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

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

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

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

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

— Rhyous
स्रोत

3

शायद System.getProperty ("line.separator") का उपयोग करें; इसके बजाय \ r \ n के बजाय यह गैर-विंडोज के लिए भी सही है।

— स्कूटर

अब आप System.lineSeparator ()

— Novaterata

20

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

— somedude
स्रोत

6

इस तरह आप एक खाली जगह के साथ समाप्त होते हैं;)

— मथायस

1

@ मैथियाड .. यह रेखा रिक्त स्थान System.out.println (n + (someArray.length == n) के साथ समाप्त होने से बच जाएगी; "": "");

— मुहम्मद सुलेमान

3

इसे करने का सबसे खराब तरीका है।

— NameNotFoundException

@MuhammadSuleman यह काम नहीं करता है, क्योंकि यह प्रत्येक के लिए एक लूप है। nसूचकांक से वास्तविक मूल्य है, न कि सूचकांक से। लूप के लिए एक नियमित रूप से, यह भी होगा (someArray.length - 1) == i, क्योंकि यह iसरणी की लंबाई के बराबर होने पर टूट जाता है।

— रेडियोडफ

17

जावा में एरर प्रिंट करने के विभिन्न तरीके:

सरल तरीका

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

आउटपुट: [एक, दो, तीन, चार]

मुद्रण Arrays के सरणी

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] [पांचवां, छठा], [सातवां, आठवां]]]

संसाधन: एक ऐरे तक पहुँचें

— Affy
स्रोत

13

लूप के लिए नियमित उपयोग करना मेरी राय में प्रिंटिंग एरे का सबसे सरल तरीका है। यहां आपके पास एक नमूना कोड है जो आपके इंट्रे पर आधारित है

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

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

— Andrew_Dublin
स्रोत

4

यह "1, 2, 3, 4, 5" प्रिंट करता है, आउटपुट के रूप में, यह अंतिम तत्व के बाद भी कॉमा प्रिंट करता है।

— icza

अंतिम तत्व के बाद अल्पविराम न होने का क्या उपाय है?

— मोना जलाल

3

आप लूप के भीतर कोड को बदल सकते हैंSystem.out.print(intArray[i]); if(i != intArray.length - 1) System.out.print(", ");

— नेपॉक्सक्स

2

आप System.out.print(i + (i < intArray.length - 1 ? ", " : ""));उन दो लाइनों को संयोजित करने के लिए भी उपयोग कर सकते हैं ।

— निक Suwyn

आप एक StringBuilder का उपयोग कर सकते हैं और अनुगामी अल्पविराम को काट सकते हैं। int [] intArray = new int [] {१, २, ३, ४, ५}; अंतिम StringBuilder sb = नया StringBuilder (); for (int i: intArray) {sb.append (intArray [i])। परिशिष्ट (","); } अगर (sb.length ()> 0) {sb.setLength (sb.length () - 1); } System.out.println (sb.toString ()); यह "1, 2, 3, 4, 5" आउटपुट करता है।

— रिक राइकर

8

मैं हाल ही में वेनिला # जावा में इस पद पर आया था । यह बहुत सुविधाजनक लेखन नहीं है 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());
}

इस modded वर्ग को केवल कमांड लाइन में निम्न जोड़कर वर्ग पथ में जोड़ा जा सकता है -Xbootclasspath/p:target/classes:।

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

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

— देबोसमित रे
स्रोत

2

आप ifहर वस्तु पर इन शर्तों को निष्पादित करना चाहते हैं ?

— sidgate

+1 केवल विचार के लिए, लेकिन पिछली टिप्पणी के आधार पर, क्या हम Objectसामान्य अभिभावकों पर निर्भर होने के बजाय सीधे सरणी कार्यान्वयन को मॉडिफाई कर सकते हैं ? क्या हम उस विचार को आगे बढ़ा सकते हैं? ऐसा नहीं है कि मुझे लगता है कि java.lang के डिफ़ॉल्ट व्यवहार को संशोधित करना। * वस्तुएं कुछ ऐसा है जो मैं प्रोत्साहित करूंगा ...

— YoYo

8

यह हमेशा काम करना चाहिए जो भी 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};

अपडेट करें :

हाँ ! यह उल्लेख किया जाना चाहिए कि किसी सरणी को ऑब्जेक्ट सरणी में बदलना या ऑब्जेक्ट के सरणी का उपयोग करना महंगा है और निष्पादन को धीमा कर सकता है। यह जावा की प्रकृति से होता है जिसे ऑटोबॉक्सिंग कहा जाता है।

तो केवल मुद्रण उद्देश्य के लिए, इसका उपयोग नहीं किया जाना चाहिए। हम एक फंक्शन बना सकते हैं जो एक अरैमीटर को पैरामीटर के रूप में लेता है और वांछित फॉर्मेट को प्रिंट करता है

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

— ग्रीश कुमार
स्रोत

1

मुद्रण उद्देश्यों के लिए एक सूची में एक सरणी को परिवर्तित करना एक बहुत ही संसाधनपूर्ण निर्णय की तरह नहीं लगता है; और यह देखते हुए कि एक ही वर्ग के पास है toString(..), यह मुझे हरा देता है कि कोई ऐसा क्यों करेगा।

— देबोसमित रे

8

जावा 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));

— suatCoskun
स्रोत

1

यह सरणी के प्रत्येक तत्व को एक अलग लाइन पर प्रिंट करेगा ताकि यह आवश्यकताओं को पूरा न करे।

— एलेक्स स्परलिंग

अगर आप एक ही पंक्ति में सरणी में सभी तत्वों को प्रिंट करना चाहते हैं, तो बस प्रिंटलाइन के बजाय प्रिंट का उपयोग करें अर्थात int [] intArray = new int [] {1, 2, 3, 4, 5}; Arrays.stream (intArray) .forEach (System.out :: प्रिंट); एंटेरवे बिना मेथेरेफेरेंस के केवल int [] intArray = new int [] {1, 2, 3, 4, 5} का उपयोग करते हैं; Println (Arrays.toString (intArray));

— suatCoskun 20

6

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

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

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

प्रिंट

abc

— इधर-उधर भटकना
स्रोत

5

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

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

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

Gson का उपयोग करना:

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

— जीन लॉगरट
स्रोत

मैं यह करता हूं। इसके साथ, आप मनमाने ढंग से जटिल संरचनाओं को प्रिंट कर सकते हैं जब तक कि वे JSON के लिए एनोडेबल हों। मैं हमेशा "सुंदर" का उपयोग करना सुनिश्चित करता हूं। क्या आपका दूसरा उदाहरण ऐसा है? मुझे लगता है कि आपको इसे प्राप्त करने के लिए एक "सुंदर" विकल्प को गुदगुदी करने की आवश्यकता होगी।

— स्टीव

5

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

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

— डायलन ब्लैक
स्रोत

5

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

— रवि पटेल
स्रोत

4

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

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

यह छपेगा

1
2
3

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

— मोहम्मद इदरीस
स्रोत

4

प्रत्येक लूप का उपयोग सरणी के तत्वों को प्रिंट करने के लिए भी किया जा सकता है:

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

— hasham.98
स्रोत

@firephil System.out.println ([i]); लूप के लिए साधारण के साथ प्रयोग किया जाता है, जहां सूचकांक "i" बनाया जाता है और हर सूचकांक पर मूल्य मुद्रित होता है। मैंने "प्रत्येक" लूप के लिए उपयोग किया है। इसे आजमाएँ, आशा है कि आपको मेरी बात अच्छी लगेगी।

— हैशम .8

हाँ, यह सरणी प्रिंट करने का सबसे छोटा तरीका है

— मंजीत तेशरा

3

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

— SamTebbs33
स्रोत

3

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>

— हािम रमन
स्रोत

कोड की दो पंक्तियों में किए जाने वाले कुछ तुच्छ होने के कारण एक निर्भरता जोड़ना एक चिल्ला चिल्लाहट है।

— jurez

commons-lang3 एक बहुत ही चिनार निर्भरता है, और ध्यान दें कि इस उत्तर में ज्यादातर लोग जावा 8 का इस्तेमाल नहीं करते थे

— हैम रमन

2

यह बाइट छापने के लिए एक डुप्लिकेट के रूप में चिह्नित है [] । नोट: एक बाइट सरणी के लिए अतिरिक्त तरीके हैं जो उपयुक्त हो सकते हैं।

आप इसे स्ट्रिंग के रूप में प्रिंट कर सकते हैं यदि इसमें 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);

या यदि आप चाहते हैं कि इसे बेस 64 के रूप में प्रिंट करें।

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.

— पीटर लॉरी
स्रोत

1

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

— fjnk
स्रोत

1

अगर आप 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);

उत्पादन:

[7,3,5,1,3]

— shellhub
स्रोत

यह स्वीकार किए गए उत्तर से बेहतर है कि यह सीमांकक, उपसर्ग और प्रत्यय पर अधिक नियंत्रण देता है। हालाँकि, मैं toString()फ़ाइनल में फ़ालतू को हटा दूंगा System.out.println()और joiner.add(element.toString())खाली स्ट्रिंग को जोड़ने के बजाय इसका उपयोग करूँगा । यह समाधान गैर-आदिम प्रकार के सरणियों के साथ-साथ समान रूप से काम करता है।

— जॉन मैकक्लेन

मेरा बुरा, element.toString()अंदर joiner.add()केवल गैर-आदिम प्रकारों के लिए है। आपको अभी भी उपयोग करने की आवश्यकता है Integer.toString(element)- जैसे आदिम प्रकारों के लिए निर्माण। व्यक्तिगत रूप से, मैंने for (int element : array) joiner.add(Integer.toString(element));धाराओं के बजाय फ़ॉरच लूप का उपयोग किया , लेकिन यह स्वाद का मामला है।

— जॉन मैकक्लेन

0

जावा 8 में:

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

— मेहदी
स्रोत

0

यदि 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}

— प्रदीप कार्की
स्रोत

0

// यदि आप जावा में कंसोल पर एरे तत्व के पते को प्रिंट करते हैं।

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

— तेजवीर सिंह
स्रोत

इस सवाल का जवाब नहीं लगता है।

— उपयोगकर्ता

-1

सरणी तत्वों को मुद्रित करने के कई तरीके हैं। सभी में से, मैं समझाता हूं कि, एक सरणी क्या है? .. सरणी डेटा संग्रहीत करने के लिए एक सरल डेटा संरचना है। जब आप किसी सरणी को परिभाषित करते हैं, तो सहायक मेमोरी ब्लॉकों का आवंटन सेट करें। RAM में। मेमोरी ब्लॉक्स को एक यूनिट लिया जाता है।

ठीक है, मैं इस तरह से एक सरणी बनाऊंगा,

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

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

           System.out.print(number);
      }
}

अब आउटपुट को देखें,

आप एक अज्ञात स्ट्रिंग मुद्रित देख सकते हैं..जिससे मैंने पहले उल्लेख किया था, स्मृति पता जिसका ऐरे (संख्या सरणी) घोषित किया गया है। यदि आप एरे में तत्वों को प्रदर्शित करना चाहते हैं, तो आप "लूप के लिए" का उपयोग कर सकते हैं, जैसे ..

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

अब आउटपुट को देखें,

ठीक है, एक आयाम सरणी के सफलतापूर्वक मुद्रित तत्व..अब मैं दो आयाम सरणी पर विचार करने जा रहा हूं..मैं दो आयाम सरणी को "संख्या 2" घोषित करूंगा और "Arrays.deepToString ()" keyword.Be का उपयोग करके तत्वों को प्रिंट करूंगा। आपको '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));
      }
}

उत्पादन पर विचार करें,

उसी समय, दो छोरों के लिए, 2 डी तत्वों का उपयोग करके मुद्रित किया जा सकता है..धन्यवाद!

— GT_hash
स्रोत

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

— मंजीत तेशरा

मुझे लगता है कि यह सरणी प्रिंट करने का सबसे छोटा तरीका है

— मंजीत तेशरा

"स्मृति पता जिसका ऐरे (संख्या सरणी) घोषित किया गया है" यह बिल्कुल सही नहीं है, इसका सिस्टम हैश कोड ऑफ ऑब्जेक्ट है, और यह मेमोरी एड्रेस सहित कई चीजों पर आधारित हो सकता है, लेकिन यह बाद में बदल सकता है और हैश कोड नहीं होगा परिवर्तन। और वर्तमान में इसकी ज्यादातर एक यादृच्छिक संख्या है। gotofinal.dev/java/2017/10/08/java-default-hashcode.html

— GotoFinal

जावा सरणी को प्रिंट करने का सबसे सरल तरीका क्या है?

सरल ऐरे:

नेस्टेड ऐरे:

double सरणी:

int सरणी:

Arrays.toString

जावा 8 - Stream.collect (ज्वाइनिंग ()), Stream.forEach

जावा 8 से पहले

जावा 8

`double` सरणी:

`int` सरणी: