java - जावा 8 सूची<V> मानचित्र में<के, वी>




lambda java-8 (10)

मैं जावा 8 की धाराओं और लैम्बडास का उपयोग करके वस्तुओं की एक सूची को मानचित्र में अनुवाद करना चाहता हूं।

इस प्रकार मैं इसे जावा 7 और नीचे लिखूंगा।

private Map<String, Choice> nameMap(List<Choice> choices) {
        final Map<String, Choice> hashMap = new HashMap<>();
        for (final Choice choice : choices) {
            hashMap.put(choice.getName(), choice);
        }
        return hashMap;
}

मैं जावा 8 और अमरूद का उपयोग करके इसे आसानी से पूरा कर सकता हूं लेकिन मैं जानना चाहता हूं कि यह कैसे अमरूद के बिना करना है।

अमरूद में:

private Map<String, Choice> nameMap(List<Choice> choices) {
    return Maps.uniqueIndex(choices, new Function<Choice, String>() {

        @Override
        public String apply(final Choice input) {
            return input.getName();
        }
    });
}

और जावा 8 लैम्बडास के साथ अमरूद।

private Map<String, Choice> nameMap(List<Choice> choices) {
    return Maps.uniqueIndex(choices, Choice::getName());
}

सरल तरीके से एक और विकल्प

Map<String,Choice> map = new HashMap<>();
choices.forEach(e->map.put(e.getName(),e));

GetName () को कुंजी के रूप में उपयोग करें और मानचित्र के मान के रूप में स्वयं चुनें:

Map<String, Choice> result =
    choices.stream().collect(Collectors.toMap(Choice::getName, c -> c));

उदाहरण के लिए, यदि आप ऑब्जेक्ट फ़ील्ड को मानचित्र में कनवर्ट करना चाहते हैं:

उदाहरण वस्तु:

class Item{
        private String code;
        private String name;

        public Item(String code, String name) {
            this.code = code;
            this.name = name;
        }

        //getters and setters
    }

और ऑपरेशन सूची में मानचित्र कनवर्ट करें:

List<Item> list = new ArrayList<>();
list.add(new Item("code1", "name1"));
list.add(new Item("code2", "name2"));

Map<String,String> map = list.stream()
     .collect(Collectors.toMap(Item::getCode(), Item::getName()));

मैं इस वाक्यविन्यास का उपयोग करता हूं

Map<Integer, List<Choice>> choiceMap = 
choices.stream().collect(Collectors.groupingBy(choice -> choice.getName()));

यदि आप collect.toMap () का उपयोग नहीं करना चाहते हैं तो यहां एक और तरीका है

Map<String, Choice> result =
   choices.stream().collect(HashMap<String, Choice>::new, 
                           (m, c) -> m.put(c.getName(), c),
                           (m, u) -> {});

यदि आपकी कुंजी सूची में सभी तत्वों के लिए अद्वितीय होने की गारंटी नहीं है , तो आपको इसे Map<String, List<Choice>> बजाय एक Map<String, List<Choice>> परिवर्तित करना चाहिए Map<String, Choice>

Map<String, List<Choice>> result =
 choices.stream().collect(Collectors.groupingBy(Choice::getName));

यदि आपको तृतीय पक्ष पुस्तकालयों का उपयोग करने में कोई फर्क नहीं पड़ता है, तो एओएल के cyclops-react lib (प्रकटीकरण मैं योगदानकर्ता हूं) में सभी जेडीके संग्रह प्रकारों के लिए एक्सटेंशन हैं, जिनमें List और Map

ListX<Choices> choices;
Map<String, Choice> map = choices.toMap(c-> c.getName(),c->c);

Collectors प्रलेखन के आधार पर यह उतना आसान है जितना:

Map<String, Choice> result =
    choices.stream().collect(Collectors.toMap(Choice::getName,
                                              Function.identity()));

Map<String, Set<String>> collect = Arrays.asList(Locale.getAvailableLocales()).stream().collect(Collectors
                .toMap(l -> l.getDisplayCountry(), l -> Collections.singleton(l.getDisplayLanguage())));

Map<String,Choice> map=list.stream().collect(Collectors.toMap(Choice::getName, s->s));

यहां तक ​​कि मेरे लिए इस उद्देश्य को भी सेवा प्रदान करता है,

Map<String,Choice> map=  list1.stream().collect(()-> new HashMap<String,Choice>(), 
            (r,s) -> r.put(s.getString(),s),(r,s) -> r.putAll(s));






java-stream