जावा में सूची के सभी तत्वों को कैसे प्रिंट करें?

Question

मैं सभी तत्वों को प्रिंट करने की कोशिश कर रहा हूं List, हालांकि यह Objectमूल्य के बजाय सूचक को प्रिंट कर रहा है ।

यह मेरा प्रिंटिंग कोड है ...

for(int i=0;i<list.size();i++){
    System.out.println(list.get(i));
} 

क्या कोई मेरी मदद कर सकता है क्यों यह तत्वों के मूल्य को नहीं छाप रहा है।

Comments

आपने किस प्रकार की घोषणा की List? हमें बताएं कि आपने इसे कैसे घोषित किया और इसे तुरंत बदल दिया।

— मकोतो

आपको स्टर्लिंग को कॉल करना होगा और आपको वर्ग की एक व्याख्या प्राप्त करनी होगी या सूची के प्रकार के लिए

— स्ट्रीडिंग

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

— डेव न्यूटन

ArrayList <class> सूची = new ArrayList <class> ();

— user1335361

ध्यान दें कि आप एक ही कॉम्पैक्ट सिंटैक्स का उपयोग कर सकते हैं जो एक ही चीज़ को पूरा करने के लिए उपयोग कर सकते हैं for (Object obj : list) {System.out.println(obj);}:।

— आरोह

Answer 1

सूची घटक का प्रिंट आउट प्राप्त करने के बारे में कुछ उदाहरण इस प्रकार है:

public class ListExample {

    public static void main(String[] args) {
        List<Model> models = new ArrayList<>();

        // TODO: First create your model and add to models ArrayList, to prevent NullPointerException for trying this example

        // Print the name from the list....
        for(Model model : models) {
            System.out.println(model.getName());
        }

        // Or like this...
        for(int i = 0; i < models.size(); i++) {
            System.out.println(models.get(i).getName());
        }
    }
}

class Model {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Comments

Modelप्रश्न से संबंधित कक्षा का परिचय कैसा है ?

— कार्ल रिक्टर

यह सिर्फ एक धारणा है, क्योंकि मुझे नहीं पता कि सूची के अंदर किस तरह की वस्तु है।

— Crazenezz

Answer 2

निम्नलिखित कॉम्पैक्ट है और आपके उदाहरण कोड में लूप से बचा जाता है (और आपको अच्छा कॉमा देता है):

System.out.println(Arrays.toString(list.toArray()));

हालाँकि, जैसा कि अन्य ने इंगित किया है, यदि आपके पास सूची के अंदर वस्तुओं के लिए कार्यान्वित होने योग्य समझदार () तरीके नहीं हैं, तो आपको ऑब्जेक्ट पॉइंटर्स (हैश कोड, वास्तव में) मिलेंगे। यह सच है कि वे एक सूची में हैं या नहीं।

Comments

क्या बारे में ही list.toString()।

— जसकी

बस 'list.toString ()' का उपयोग करके व्यक्तिगत तत्वों को प्रिंट नहीं किया जाएगा, जब तक कि यह सूची इंटरफ़ेस का एक कस्टम कार्यान्वयन नहीं है जो सामान्य व्यवहार (वर्ग नाम और हैश कोड को प्रिंट करने के लिए, अधिक या कम) को ओवरराइड करता है।

— होली कमिंस

यदि वे कस्टम वर्ग का उपयोग करते हैं और ओवरराइड नहीं करते हैं toString, तो आपका समाधान इसके वर्ग नाम और हैश कोड को भी प्रिंट करेगा।

— जस्की डे

यह [value1, value2, value3] के रूप में प्रिंट होता है। क्या हम बिना [] छाप सकते हैं?

— deadend

दरअसल, @ जसकी सही है - उनका जवाब बेहतर है। Arraysविधि सरणियों के लिए उपयोगी है, लेकिन अब के उपवर्गों के लिए आवश्यक नहीं है AbstractCollection।

— होली कमिंस

Answer 3

Java 8 के बाद से, सूची एक डिफ़ॉल्ट "forEach" विधि विरासत में मिली है जिसे आप विधि संदर्भ "System.out :: println" के साथ जोड़ सकते हैं।

list.forEach(System.out::println);

Comments

@ कटजा है, क्या printlnआउटपुट के लिए कुछ स्ट्रिंग को जोड़ना या रोकना संभव है ?

— गमकिंस

@gumkins, हाँ, आप कर सकते हैं। उदाहरण: Arrays.stream (नया स्ट्रिंग [] {"जॉन", "संसा", "Cerse" ")। नक्शा (s ->" हाय "+ s +"! ") ForEach (System.out - Println)। ;

— तियागो मुसी

Answer 4

System.out.println(list);//toString() is easy and good enough for debugging.

toString()की AbstractCollection स्वच्छ और ऐसा करने के लिए काफी आसान होगा । AbstractListका एक उपवर्ग है AbstractCollection, इसलिए लूप की कोई आवश्यकता नहीं है और किसी भी ऐरे () की आवश्यकता नहीं है।

इस संग्रह का एक स्ट्रिंग प्रतिनिधित्व लौटाता है। स्ट्रिंग प्रतिनिधित्व में संग्रह के तत्वों की एक सूची होती है, जिस क्रम में वे इसके पुनरावर्तक द्वारा लौटाए जाते हैं, जो चौकोर कोष्ठकों में संलग्न होते हैं ("[]")। आसन्न तत्वों को वर्णों द्वारा अलग किया जाता है "," (अल्पविराम और स्थान)। तत्वों को स्ट्रिंग में परिवर्तित किया जाता है जैसे String.valueOf (ऑब्जेक्ट)।

यदि आप अपनी सूची में किसी भी कस्टम ऑब्जेक्ट का उपयोग कर रहे हैं, तो छात्र का कहना है, आपको toString()एक सार्थक आउटपुट प्राप्त करने के लिए इसकी विधि को ओवरराइड करने की आवश्यकता है (इस पद्धति को ओवरराइड करना हमेशा अच्छा होता है)

नीचे दिए गए उदाहरण देखें:

public class TestPrintElements {

    public static void main(String[] args) {

        //Element is String, Integer,or other primitive type
        List<String> sList = new ArrayList<String>();
        sList.add("string1");
        sList.add("string2");
        System.out.println(sList);

        //Element is custom type
        Student st1=new Student(15,"Tom");
        Student st2=new Student(16,"Kate");
        List<Student> stList=new ArrayList<Student>();
        stList.add(st1);
        stList.add(st2);
        System.out.println(stList);
   }
}


public  class Student{
    private int age;
    private String name;

    public Student(int age, String name){
        this.age=age;
        this.name=name;
    }

    @Override
    public String toString(){
        return "student "+name+", age:" +age;
    }
}

उत्पादन:

[string1, string2]
[student Tom age:15, student Kate age:16]

Comments

क्योंकि यह उत्तर पूरी तरह से सही नहीं है। यह इसे साकार किए बिना बहुरूपता का उपयोग कर रहा है। यहाँ के लिए वास्तविक वंशानुगत पदानुक्रम है list: List -> Collection -> Iterable -> Object। वह वर्ग जो वास्तव में AbstractCollection से विरासत में मिला है ArrayList। इसलिए इस उदाहरण में जब toString()इसे बुलाया जाता है तो यह उस ArrayListकार्यान्वयन को पाता है जिसे परिभाषित किया गया है AbstractCollection। के लिए विरासत पदानुक्रम पर ध्यान दें ArrayList:ArrayList -> AbstractList -> AbstractCollection -> Collection -> Iterable -> Object

— anon58192932

Answer 5

जावा 8 स्ट्रीम दृष्टिकोण ...

list.stream().forEach(System.out::println);

Comments

काटजा हैन के समान जवाब

— कार्ल रिक्टर

नहीं, यह नहीं है। मेरा धारा का लाभ उठाता है ()।

— ब्राडली डी

@ ब्रैडली क्या पद्धति कॉल की एक और परत जोड़कर लाभ प्राप्त कर रहे हैं?

— लियोन

Answer 6

सूची में मौजूद वस्तुओं ने toStringस्क्रीन के लिए कुछ सार्थक प्रिंट करने के लिए उन्हें लागू किया होगा।

मतभेद देखने के लिए यहां एक त्वरित परीक्षा दी गई है:

public class Test {

    public class T1 {
        public Integer x;
    }

    public class T2 {
        public Integer x;

        @Override
        public String toString() {
            return x.toString();
        }
    }

    public void run() {
        T1 t1 = new T1();
        t1.x = 5;
        System.out.println(t1);

        T2 t2 = new T2();
        t2.x = 5;
        System.out.println(t2);

    }

    public static void main(String[] args) {        
        new Test().run();
    }
}

और जब यह निष्पादित होता है, तो स्क्रीन पर मुद्रित परिणाम निम्न हैं:

t1 = Test$T1@19821f
t2 = 5

चूंकि T1 स्ट्रोइडिंग विधि को ओवरराइड नहीं करता है, इसलिए इसका उदाहरण t1 प्रिंट करता है, जो बहुत उपयोगी नहीं है। दूसरी ओर, T2 स्ट्रीडिंग को ओवरराइड करता है, इसलिए हम नियंत्रित करते हैं कि जब यह आई / ओ में उपयोग किया जाता है तो यह क्या प्रिंट करता है, और हम स्क्रीन पर कुछ बेहतर देखते हैं।

Answer 7

इस बात पर विचार करें List<String> stringListकि जावा 8 निर्माणों का उपयोग करके कई तरीकों से किसे मुद्रित किया जा सकता है :

stringList.forEach(System.out::println);                            // 1) Iterable.forEach
stringList.stream().forEach(System.out::println);                   // 2) Stream.forEach (order maintained generally but doc does not guarantee)
stringList.stream().forEachOrdered(System.out::println);            // 3) Stream.forEachOrdered (order maintained always)
stringList.parallelStream().forEach(System.out::println);           // 4) Parallel version of Stream.forEach (order not maintained)
stringList.parallelStream().forEachOrdered(System.out::println);    // 5) Parallel version ofStream.forEachOrdered (order maintained always)

ये दृष्टिकोण एक दूसरे से अलग कैसे हैं?

पहला दृष्टिकोण ( Iterable.forEach) - संग्रह के इटेरेटर का उपयोग आम तौर पर किया जाता है और जिसे विफल-तेज़ बनाया गया है, जिसका अर्थ है कि ConcurrentModificationExceptionअगर यह संग्रह के दौरान अंतर्निहित संग्रह संरचनात्मक रूप से संशोधित किया गया है तो इसे फेंक देगा । के लिए डॉक्टर के रूप में उल्लेख किया गया है ArrayList:

एक संरचनात्मक संशोधन कोई भी ऑपरेशन है जो एक या अधिक तत्वों को जोड़ता या हटाता है, या बैकिंग सरणी को स्पष्ट रूप से आकार देता है; केवल एक तत्व का मूल्य निर्धारित करना एक संरचनात्मक संशोधन नहीं है।

तो इसका मतलब है कि ArrayList.forEachकिसी भी मुद्दे के बिना मूल्य निर्धारित करने की अनुमति है। और समवर्ती संग्रह के मामले में उदाहरण के ConcurrentLinkedQueueलिए इट्रेटर कमजोर-सुसंगत होगा जिसका अर्थ है कि पारित किए गए कार्यों forEachको ConcurrentModificationExceptionअपवाद के बिना संरचनात्मक परिवर्तन करने की अनुमति है । लेकिन यहां संशोधन उस पुनरावृत्ति में दिखाई नहीं दे सकते हैं या हो सकते हैं।

दूसरा दृष्टिकोण ( Stream.forEach) - आदेश अपरिभाषित है। यह क्रमिक धाराओं के लिए नहीं हो सकता है, लेकिन विनिर्देश इसकी गारंटी नहीं देता है। इसके अलावा कार्रवाई प्रकृति में गैर-हस्तक्षेप करने के लिए आवश्यक है। जैसा कि डॉक्टर ने उल्लेख किया है :

इस ऑपरेशन का व्यवहार स्पष्ट रूप से नॉनडेटर्मिनिस्टिक है। समानांतर स्ट्रीम पाइपलाइनों के लिए, यह ऑपरेशन स्ट्रीम के एनकाउंटर ऑर्डर का सम्मान करने की गारंटी नहीं देता है, क्योंकि ऐसा करने से समानता का लाभ मिलता है।

तीसरा दृष्टिकोण ( Stream.forEachOrdered) - कार्रवाई धारा के मुठभेड़ क्रम में की जाएगी। इसलिए जब भी आदेश के मामले forEachOrderedएक दूसरे विचार के बिना उपयोग करते हैं । जैसा कि डॉक्टर ने उल्लेख किया है :

इस धारा के प्रत्येक तत्व के लिए एक कार्रवाई करता है, तो धारा के मुठभेड़ क्रम में यदि धारा में एक मुठभेड़ आदेश है।

एक से अधिक पुनरावृत्ति जबकि सिंक्रनाइज़ संग्रह पहले दृष्टिकोण संग्रह की लॉक ले जाएगा एक बार और कॉल कार्रवाई विधि करने के लिए है, लेकिन नदियों के मामले में वे संग्रह के spliterator, जो लॉक नहीं करता है और गैर की पहले से ही स्थापित नियमों पर निर्भर करता है का उपयोग करें, वे इसे पूरे पकड़ होगा -दखल अंदाजी। मामले के संग्रह में धारा का समर्थन करते हुए पुनरावृत्ति के दौरान संशोधित किया जाता है ConcurrentModificationExceptionया फेंका जाएगा या असंगत परिणाम हो सकता है।

चौथा दृष्टिकोण (समानांतर Stream.forEach) - जैसा कि पहले ही उल्लेख किया गया है कि समानांतर धाराओं के मामले में मुठभेड़ आदेश का सम्मान करने की कोई गारंटी नहीं है। यह संभव है कि विभिन्न तत्वों के लिए विभिन्न थ्रेड में कार्रवाई की जाती है जो कभी भी ऐसा नहीं हो सकता है forEachOrdered।

पांचवें दृष्टिकोण (समानांतर Stream.forEachOrdered) -forEachOrdered स्रोत तथ्य के बावजूद द्वारा निर्दिष्ट क्रम में तत्वों पर कार्रवाई करेंगे कि क्या धारा अनुक्रमिक या समानांतर है। तो यह समानांतर धाराओं के साथ इसका उपयोग करने के लिए कोई मतलब नहीं है।

Answer 8

या आप बस Apache Commons उपयोगिताओं का उपयोग कर सकते हैं:

https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/ArrayUtils.html#toString-java.lang.Object-

List<MyObject> myObjects = ...
System.out.println(ArrayUtils.toString(myObjects));

Answer 9

String.join() उदाहरण के लिए उपयोग करें :

System.out.print(String.join("\n", list)));

Answer 10

मैंने ऐसी ही समस्याओं का सामना किया है। मेरा कोड:

List<Integer> leaveDatesList = new ArrayList<>();

.....inserted value in list.......

तरीका 1: एक सूची को लूप में प्रिंट करना

for(int i=0;i<leaveDatesList.size();i++){
    System.out.println(leaveDatesList.get(i));
}

मार्ग 2: सूची को एक forEach में, लूप के लिए प्रिंट करना

for(Integer leave : leaveDatesList){
    System.out.println(leave);
}

रास्ता 3: सूची को जावा 8 में प्रिंट करना

leaveDatesList.forEach(System.out::println);

Answer 11

1. आपने यह निर्दिष्ट नहीं किया है कि सूची में किस प्रकार के तत्व हैं, यदि यह एक आदिम डेटा प्रकार है तो आप तत्वों को प्रिंट कर सकते हैं।

2. लेकिन अगर तत्व वस्तुएं हैं, तो जैसा कि क्षितिज मेहता ने उल्लेख किया है कि आपको उस वस्तु के भीतर "स्ट्रीडिंग" करने की विधि को लागू करने की जरूरत है - अगर यह पहले से ही लागू नहीं है - और इसे वस्तु के भीतर से कुछ अर्थ पूरा करने दें, उदाहरण:

   class Person {
       private String firstName;
       private String lastName;
   
       @Override
       public String toString() {
           return this.firstName + " " + this.lastName;
       }
   }

Answer 12

System.out.println(list); मेरे लिये कार्य करता है।

यहाँ एक पूर्ण उदाहरण है:

import java.util.List;    
import java.util.ArrayList;

public class HelloWorld {
     public static void main(String[] args) {
        final List<String> list = new ArrayList<>();
        list.add("Hello");
        list.add("World");
        System.out.println(list);
     }
}

यह छपेगा [Hello, World]।

Comments

अन्य से अलग नहीं, पहले के उत्तर

— कार्ल रिक्टर

मैंने आयात, वर्ग और मुख्य विधि के साथ एक पूर्ण उदाहरण दिया, जिसे आप कॉपी और पेस्ट कर सकते हैं और परिणाम दिखा सकते हैं। इसलिए, मेरी राय में इसे वोट करने का कोई कारण नहीं है

— jfmg

Answer 13

स्ट्रिंग की सरणी की सूची के लिए

list.forEach(s -> System.out.println(Arrays.toString((String[]) s )));

Answer 14

मैंने एक डंप फ़ंक्शन लिखा है, जो मूल रूप से किसी ऑब्जेक्ट के सार्वजनिक सदस्यों को प्रिंट करता है यदि यह स्ट्रीडिंग () में ओवरराइड नहीं करता है। एक आसानी से कॉल गेटर्स के लिए इसका विस्तार कर सकता है। जावाडोक:

निम्न नियमों का उपयोग करते हुए, किसी दिए गए ऑब्जेक्ट को System.out में रखता है:

• यदि ऑब्जेक्ट Iterable है, तो इसके सभी घटक डंप हो जाते हैं।
• यदि ऑब्जेक्ट या उसके सुपरक्लास में से कोई भी स्ट्रीडिंग () में ओवरराइड करता है, तो "स्ट्रासिंग" डंप हो जाता है
• ऑब्जेक्ट के सभी सार्वजनिक सदस्यों के लिए विधि को पुनरावृत्ति कहा जाता है

/**
 * Dumps an given Object to System.out, using the following rules:<br>
 * <ul>
 * <li> If the Object is {@link Iterable}, all of its components are dumped.</li>
 * <li> If the Object or one of its superclasses overrides {@link #toString()}, the "toString" is dumped</li>
 * <li> Else the method is called recursively for all public members of the Object </li>
 * </ul>
 * @param input
 * @throws Exception
 */
public static void dump(Object input) throws Exception{
    dump(input, 0);
}

private static void dump(Object input, int depth) throws Exception{
    if(input==null){
        System.out.print("null\n"+indent(depth));
        return;
    }

    Class<? extends Object> clazz = input.getClass();
    System.out.print(clazz.getSimpleName()+" ");
    if(input instanceof Iterable<?>){
        for(Object o: ((Iterable<?>)input)){
            System.out.print("\n"+indent(depth+1));
            dump(o, depth+1);
        }
    }else if(clazz.getMethod("toString").getDeclaringClass().equals(Object.class)){
        Field[] fields = clazz.getFields();
        if(fields.length == 0){
            System.out.print(input+"\n"+indent(depth));
        }
        System.out.print("\n"+indent(depth+1));
        for(Field field: fields){
            Object o = field.get(input);
            String s = "|- "+field.getName()+": ";
            System.out.print(s);
            dump(o, depth+1);
        }
    }else{

        System.out.print(input+"\n"+indent(depth));
    }
}

private static String indent(int depth) {
    StringBuilder sb = new StringBuilder();
    for(int i=0; i<depth; i++)
        sb.append("  ");
    return sb.toString();
}

Answer 15

किसी सूची की सामग्री को मुद्रित करने के लिए लूप के लिए:

List<String> myList = new ArrayList<String>();
myList.add("AA");
myList.add("BB");

for ( String elem : myList ) {
  System.out.println("Element : "+elem);
}

परिणाम :

Element : AA
Element : BB

यदि आप एक ही लाइन में प्रिंट करना चाहते हैं (सिर्फ जानकारी के लिए):

String strList = String.join(", ", myList);
System.out.println("Elements : "+strList);

परिणाम :

Elements : AA, BB

Answer 16

    list.stream().map(x -> x.getName()).forEach(System.out::println);

Comments

xओपी के प्रश्न से किस प्रकार का संबंध है और यह कैसा है?

— कार्ल रिक्टर

Answer 17

मैं अब इस पर काम कर रहा हूँ ...

List<Integer> a = Arrays.asList(1, 2, 3);
List<Integer> b = Arrays.asList(3, 4);
List<int[]> pairs = a.stream()
  .flatMap(x -> b.stream().map(y -> new int[]{x, y}))
  .collect(Collectors.toList());

Consumer<int[]> pretty = xs -> System.out.printf("\n(%d,%d)", xs[0], xs[1]);
pairs.forEach(pretty);

Answer 18

यह इस बात पर निर्भर करता है कि किस प्रकार की वस्तुओं को स्टोर किया गया है List, और क्या इसका toString()विधि के लिए कार्यान्वयन है । System.out.println(list)सभी मानक जावा वस्तु प्रकार (प्रिंट चाहिए String, Long, Integerआदि)। मामले में, यदि हम कस्टम ऑब्जेक्ट प्रकारों का उपयोग कर रहे हैं, तो हमें override toString()अपनी कस्टम ऑब्जेक्ट की विधि की आवश्यकता है ।

उदाहरण:

class Employee {
 private String name;
 private long id;

 @Override
 public String toString() {
   return "name: " + this.name() + 
           ", id: " + this.id();
 }  
}

परीक्षा:

class TestPrintList {
   public static void main(String[] args) {
     Employee employee1 =new Employee("test1", 123);
     Employee employee2 =new Employee("test2", 453);
     List<Employee> employees = new ArrayList(2);
     employee.add(employee1);
     employee.add(employee2);
     System.out.println(employees);
   }
}

Answer 19

public static void main(String[] args) {
        answer(10,60);

    }
    public static void answer(int m,int k){
        AtomicInteger n = new AtomicInteger(m);
        Stream<Integer> stream = Stream.generate(() -> n.incrementAndGet()).limit(k);
        System.out.println(Arrays.toString(stream.toArray()));
    }

Answer 20

ओवरस्ट्रिंग () विधि को ओवरराइड करने का प्रयास करें क्योंकि आप चाहते हैं कि तत्व प्रिंटेंड होगा। तो प्रिंट करने की विधि यह हो सकती है:

for(int i=0;i<list.size();i++){
    System.out.println(list.get(i).toString());
} 

Comments

ओपी का कोड यही करता है। कॉल करने के toStringलिए निहित है।

— कार्ल रिक्टर

Answer 21

   List<String> textList=  messageList.stream()
                            .map(Message::getText)
                            .collect(Collectors.toList());

        textList.stream().forEach(System.out::println);
        public class Message  {

        String name;
        String text;

        public Message(String name, String text) {
            this.name = name;
            this.text = text;
        }

        public String getName() {
            return name;
        }

      public String getText() {
        return text;
     }
   }