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




arrays printing (22)

जावा में, सरणी 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]

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

  1. सरल तरीका

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

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

  1. toString() का उपयोग करना toString()

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

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

  1. 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; @ 4271 9सी] [[पांचवां, छठा], [सातवां, आठवां]]

संसाधन: एक ऐरे का उपयोग करें


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

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

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

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

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

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

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

प्रिंट

abc

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

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

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

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

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


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

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

आप Arrays.toString() उपयोग कर सकते हैं

String[] array = { "a", "b", "c" };  
System.out.println(Arrays.toString(array));

जावा 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 ]

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>

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

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

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

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

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

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

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

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

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

यह हमेशा जो भी जेडीके संस्करण आप उपयोग करते हैं उसे हमेशा काम करना चाहिए:

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
} 

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

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

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

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


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

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

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

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

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

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

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

(यह निश्चित रूप से 1.5+ में भी काम करता है।)


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

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

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

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

1
2
3

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


मैं हाल ही में वेनिला # जावा में इस पोस्ट में आया था। यह बहुत सुविधाजनक लेखन 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 तरह कुछ पास करें।


// 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(element-> System.out.println(element));




printing