किसी वस्तु की संपत्ति के साथ नई सूची कैसे बनाई जाए जो किसी अन्य सूची में है

Question

कल्पना कीजिए कि मेरे पास कुछ वस्तुओं की सूची है:

List<Student>

और मैं सहित एक और सूची उत्पन्न करने की आवश्यकता है idsके Studentsऊपर की सूची में:

List<Integer>

लूप का उपयोग करने से बचना, क्या अपाचे संग्रह या अमरूद का उपयोग करके इसे प्राप्त करना संभव है ?

मेरे मामले के लिए कौन से तरीके उपयोगी होने चाहिए?

Comments

अरे, मैंने अभी-अभी यह पाया: stackoverflow.com/questions/737244/…

— Javatar

जॉन का जवाब बहुत अच्छा है लेकिन अगर आप इसे देखते हैं, तो यह एक लूप का उपयोग करता है। किसी भी किसी भी समाधान एक पाश का उपयोग करेगा - हालांकि यह आप को दिखाई नहीं हो सकता है, लेकिन आंतरिक रूप से कहीं भी होगी

— हेग

किसी को इसे पूरा करने के लिए लूप लगाना होगा। या तो आप या आपके द्वारा उपयोग किए जा सकने वाले कुछ दायित्व।

— सुदामोंग

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

— वेटिन

Answer 1

जावा 8 करने का तरीका: -

List<Integer> idList = students.stream().map(Student::getId).collect(Collectors.toList());

Comments

अगर मुझे टुपल्स की सूची चाहिए तो क्या होगा? कुछ इस तरह [(आईडी, नाम), (आईडी, नाम)]।

— कोडरोड 95

सभी Android API के लिए सभी 1.8 सुविधाएँ समर्थित नहीं हैं। विशेष रूप से, java.util.stream API 24 तक समर्थित नहीं है।

— ब्लैक हॉर्स

Answer 2

अमरूद से आप फंक्शन का उपयोग कर सकते हैं जैसे -

private enum StudentToId implements Function<Student, Integer> {
        INSTANCE;

        @Override
        public Integer apply(Student input) {
            return input.getId();
        }
    }

और आप इस फ़ंक्शन का उपयोग छात्रों की सूची को आईडी में बदलने के लिए कर सकते हैं जैसे -

Lists.transform(studentList, StudentToId.INSTANCE);

निश्चित रूप से यह सभी आईडी निकालने के लिए लूप होगा, लेकिन याद रखें कि अमरूद के तरीके रिटर्न व्यू और फंक्शन केवल तभी लागू होंगे जब आप इटरेट List<Integer>
नहीं करेंगे, तो यह लूप को कभी लागू नहीं करेगा।

नोट: याद रखें इस दृश्य है और अगर आप पुनरावृति करने के लिए कई बार चाहते हैं कि उसे बेहतर हो कुछ अन्य में सामग्री की प्रतिलिपि करने के लिए होगा List<Integer>की तरह

ImmutableList.copyOf(Iterables.transform(students, StudentToId.INSTANCE));

Comments

मुझे लगता है कि एक समारोह को अलग से परिभाषित करना असंगत है। मुझे लगता है कि यह गुमनाम रूप से और एक कदम प्रक्रिया में भी किया जा सकता है

— मार्क

आप सूची के सदस्यों को स्ट्रिंग (फ्लोट, आदि) कैसे निकालते हैं?

— सितंबर

Answer 3

प्रेमराज को वैकल्पिक शांत विकल्प के लिए धन्यवाद, उत्थान ।

मैंने Apache CollectionUtils और BeanUtils का इस्तेमाल किया है। तदनुसार, मैं निम्नलिखित कोड के प्रदर्शन से संतुष्ट हूं:

List<Long> idList = (List<Long>) CollectionUtils.collect(objectList, 
                                    new BeanToPropertyValueTransformer("id"));

यह ध्यान देने योग्य है कि, मैं अमरुद ( प्रेमराज द्वारा प्रदान की गई) के प्रदर्शन की तुलना करूँगा और मेरे द्वारा उपयोग किए गए संग्रह, और तेजी का फैसला करेंगे।

Comments

मैं अपाचे संग्रहों के बावजूद अमरूद को पसंद करूंगा - जैसे कि अधिक आधुनिक, जेनरिक, परिवर्तनों के लिए प्रतिबिंब का उपयोग नहीं करना आदि। कुल मिलाकर अमरूद कहीं अधिक आधुनिक है कि अपाचे संग्रह - यहाँ

— प्रेमराज

हां, लेकिन वास्तव में यह मुझे एक अच्छा विचार नहीं लगता कि जिस प्रकार की वस्तु को मैं बदलना चाहता हूं, उसके लिए अतिरिक्त एनम डिक्लेरेशन की अनिवार्य आवश्यकता द्वारा इसके उपयोग को प्रतिबंधित किया जाए।

— जवतार

वैसे यह आपके डिजाइन पर निर्भर करता है - आप इंटरफ़ेस कह सकते हैं Identifiableजो getId()विधि को परिभाषित करता है और फिर आप इस एकल एनम सिंगलटन पैटर्न का उपयोग आमतौर पर आईडी निकालने के लिए कर सकते हैं।

— प्रेमराज

बीन के बर्तनों की तुलना में अमरूद निश्चित रूप से अधिक कुशल है क्योंकि बाद में प्रतिबिंबों का उपयोग किया जाता है ..

— ravi

कंस्ट्रक्टर के नए बीनटॉपरपर्टी वाल्यूट्रांसफॉर्मर ("आईडी") में एक स्ट्रिंग के रूप में संपत्ति के नाम का उपयोग करना कुछ ऐसा है जो मैं निश्चित रूप से बचने की कोशिश करता हूं। मुश्किल हो रहा है! लेकिन मैं इसे हल करने के लिए एक समाधान की तलाश कर रहा हूं। इस बीच, मैं अमरूद के घोल, क्रिया, लेकिन सुरक्षित के साथ जाऊंगा।

— रेडोचका

Answer 4

जावा 8 लैम्ब्डा अभिव्यक्ति समाधान:

List<Integer> iDList = students.stream().map((student) -> student.getId()).collect(Collectors.toList());

Comments

यदि जावा <1.8 तो Apache CollectionUtils का उपयोग करें। उदाहरण: संग्रह <string> firstnames = CollectionUtils.collect (userlist, TransformerUtils.invokerTransformer ("getFirstname"));

— a_subscriber

Answer 5

यदि कोई कुछ वर्षों के बाद यहां आता है:

List<String> stringProperty = (List<String>) CollectionUtils.collect(listOfBeans, TransformerUtils.invokerTransformer("getProperty"));

Comments

और आपने मुझे बचा लिया :)

— बेहराड 3

Answer 6

लूप के बिना ऐसा करना गणितीय रूप से असंभव है। मैपिंग बनाने के लिए, F, मानों के एक असतत सेट को मानों के दूसरे असतत सेट पर बनाने के लिए, F को मूल सेट में प्रत्येक तत्व पर काम करना चाहिए। (मूल रूप से ऐसा करने के लिए लूप की आवश्यकता होती है।)

ऐसा कहे जाने के बाद:

आपको एक नई सूची की आवश्यकता क्यों है? आप गलत तरीके से जो भी समस्या हल कर रहे हैं, उससे संपर्क कर सकते हैं।

यदि आपके पास एक सूची है Student, तो आप केवल एक कदम या दो दूर हैं, जब इस सूची के माध्यम से, छात्रों की आईडी संख्या पर पुनरावृति से।

for(Student s : list)
{
    int current_id = s.getID();
    // Do something with current_id
}

यदि आपको कोई भिन्न प्रकार की समस्या है, तो प्रश्न पर टिप्पणी करें / अपडेट करें और हम आपकी सहायता करने का प्रयास करेंगे।

Comments

आपके उत्तर के लिए पहले धन्यवाद। हालाँकि, यह नाटकीय है कि आपने कहा कि नई सूची की आवश्यकता गलत है। क्योंकि यह जरूरत की क्षमता और सीमा पर निर्भर है। इसलिए, आपका दृष्टिकोण गलत तरीका है :) फिर से "बिना लूप के प्राप्त करने की क्षमता" के बारे में मेरा उल्लेख कोड को अपठनीय और कम प्रदर्शन नहीं करने के लिए एक अधिक सुविधाजनक तरीका है। वैसे भी, मैं पहले से ही इसे हासिल करने का एक तरीका ढूंढ चुका हूं, थोड़ा सा साझा करने जा रहा हूं।

— १६:

मैं कहा नहीं यह है कि है गलत तरीके से, लेकिन यह हो सकता है गलत तरीके से हो सकता है, समस्या को हल करने की कोशिश कर रहे हैं पर निर्भर करता।

— ज़ेचिन