Java 8 समूहीकरण करते समय आदेश को बनाए नहीं रख रहा है




java-8 grouping (2)

मैं डेटा द्वारा समूहीकरण के लिए जावा 8 का उपयोग कर रहा हूं। लेकिन प्राप्त परिणाम क्रम में नहीं हैं।

Map<GroupingKey, List<Object>> groupedResult = null;

        if (!CollectionUtils.isEmpty(groupByColumns)) {

            Map<String, Object> mapArr[] = new LinkedHashMap[mapList.size()];

            if (!CollectionUtils.isEmpty(mapList)) {
                int count = 0;
                for (LinkedHashMap<String, Object> map : mapList) {
                    mapArr[count++] = map;
                }
            }
            Stream<Map<String, Object>> people = Stream.of(mapArr);
            groupedResult = people
                    .collect(Collectors.groupingBy(p -> new GroupingKey(p, groupByColumns), Collectors.mapping((Map<String, Object> p) -> p, toList())));


public static class GroupingKey 

        public GroupingKey(Map<String, Object> map, List<String> cols) {

            keys = new ArrayList<>();

            for (String col : cols) {
                keys.add(map.get(col));
            }
        }

        // Add appropriate isEqual() ... you IDE should generate this
        @Override
        public boolean equals(Object obj) {
            if (obj == null) {
                return false;
            }
            if (getClass() != obj.getClass()) {
                return false;
            }
            final GroupingKey other = (GroupingKey) obj;
            if (!Objects.equals(this.keys, other.keys)) {
                return false;
            }
            return true;
        }

        @Override
        public int hashCode() {
            int hash = 7;
            hash = 37 * hash + Objects.hashCode(this.keys);
            return hash;
        }

        @Override
        public String toString() {
            return keys + "";
        }

        public ArrayList<Object> getKeys() {
            return keys;
        }

        public void setKeys(ArrayList<Object> keys) {
            this.keys = keys;
        }

    }

यहाँ मैं अपने वर्ग समूहीकरण का उपयोग कर रहा हूँ जिसके द्वारा im ux से गतिशील रूप से गुजर रहा है। यह समूह कैसे प्राप्त कर सकते हैं


@ Holger के शानदार जवाब पर आधारित। मैं इसे उन लोगों की मदद करने के लिए पोस्ट करता हूं जो ग्रुपिंग के साथ-साथ मैपिंग को बदलने के बाद ऑर्डर रखना चाहते हैं।

आइए सरल करें और मान लें कि हमारे पास व्यक्तियों की एक सूची है (int age, String name, String adresss ... etc) और हम चाहते हैं कि युगों को क्रम में रखते हुए आयु के आधार पर नाम रखे जाएं:

final LinkedHashMap<Integer, List<String> map = myList
            .stream()
            .sorted(Comparator.comparing(p -> p.getAge())) //sort list by ages
            .collect(Collectors.groupingBy(p -> p.getAge()),
                    LinkedHashMap::new, //keep the order
                    Collectors.mapping(p -> p.getName(), //map name
                            Collectors.toList())));

आदेश का पालन न करना Map का एक गुण है जो परिणाम को संग्रहीत करता है। यदि आपको एक विशिष्ट Map व्यवहार की आवश्यकता है, तो आपको एक विशेष Map कार्यान्वयन का अनुरोध करने की आवश्यकता है। उदाहरण के लिए LinkedHashMap प्रविष्टि क्रम रखता है:

groupedResult = people.collect(Collectors.groupingBy(
    p -> new GroupingKey(p, groupByColumns),
    LinkedHashMap::new,
    Collectors.mapping((Map<String, Object> p) -> p, toList())));

वैसे, Stream बनाने से पहले mapList की सामग्री को किसी सरणी में कॉपी करने का कोई कारण नहीं है। आप एक उचित Stream प्राप्त करने के लिए बस mapList.stream() को कॉल कर सकते हैं।

इसके अलावा, Collectors.mapping((Map<String, Object> p) -> p, toList()) अप्रचलित है। p->p एक पहचान मानचित्रण है, इसलिए mapping का अनुरोध करने का कोई कारण नहीं है:

groupedResult = mapList.stream().collect(Collectors.groupingBy(
    p -> new GroupingKey(p, groupByColumns), LinkedHashMap::new, toList()));

लेकिन यहां तक ​​कि GroupingKey अप्रचलित है। यह मूल रूप से मूल्यों की List को लपेटता है, इसलिए आप पहली List में कुंजी के रूप में List उपयोग कर सकते हैं। hashCode लागू करें और equals रूप से List (लेकिन आपको इन कुंजी List बाद में संशोधित नहीं करना चाहिए )।

Map<List<Object>, List<Object>> groupedResult=
  mapList.stream().collect(Collectors.groupingBy(
    p -> groupByColumns.stream().map(p::get).collect(toList()),
    LinkedHashMap::new, toList()));




collect