Tôi đang gặp khó khăn trong việc duy trì cấu trúc dữ liệu mà tôi muốn trong các hoạt động phát trực tuyến bằng Java, rất có thể là do thiếu hiểu biết và thực hành đúng đắn.

lớp công khai Chính {
    public static void main(String[] args) {
        List list = Arrays.asList(1, 1, 1, 2, 3, 3, 3, 3);

            //Nhóm theo
            Bản đồ  countGrouped = list.stream().collect(
                    Collectors.groupingBy(
                            x -> x, Collectors.counting()));
            System.out.println("group by value, count " + countGrouped);

            //Sắp xếp desc
            Bản đồ  giảm dầnSorted = new LinkedHashMap<>();
            countGrouped.entrySet().stream()
                .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
                .forEachOrdered(x ->desendingSorted.put(x.getKey(), x.getValue()));
            System.out.println("sắp xếp " + giảm dầnSắp xếp);

            //lọc
            Bản đồ  được lọc = LinkedHashMap mới<>();
            giảm dầnSorted.entrySet().stream()
                .filter(x -> x.getValue() >= 2)
                .forEach(x -> filter.put(x.getKey(), x.getValue()));;
            System.out.println("đã lọc " + đã lọc);

            // Tách nhóm
            Bản đồ<>>> nhóm = filter.entrySet().stream()
                    .collect(Collectors.groupingBy(x -> x.getValue()));
            System.out.println("được nhóm " + nhóm);
    }
}

dẫn đến

nhóm theo giá trị, đếm {1=3, 2=1, 3=4}
đã sắp xếp {3=4, 1=3, 2=1}
đã lọc {3=4, 1=3}
được nhóm {3=[1=3], 4=[3=4]}

Điều đó đúng, nhưng tôi đang dần đi sâu vào các cấu trúc dữ liệu bí truyền hơn không có ý nghĩa cụ thể, như bạn có thể thấy, với (wtf?) Bản đồ<đối tượng,="" danh="">>> Kết thúc là như bạn có thể thấy. Mặc dù nó có thể chỉ là một Bản đồ> .

Vì vậy, câu hỏi cụ thể là làm cách nào để chuyển đổi và chứa đầu ra cấu trúc dữ liệu do các hoạt động truyền phát tạo ra?

Tôi đã thấy rằng Người sưu tập cung cấp các hoạt động chuyển đổi cho Map(...) và tôi đoán đó là cách tốt nhất, nhưng tôi không thể (tôi nghĩ do thiếu kiến ​​​​thức phù hợp) làm cho nó hoạt động.

Trong trường hợp này, đối với tôi, có vẻ như việc dạy giải thích, liên kết đến các tài nguyên toàn diện để hiểu rõ hơn về quy trình và lập trình hàm hoặc thứ gì đó tương tự, sẽ tốt hơn các giải pháp thực tế cho các tình huống cụ thể (điều này sẽ rất tốt cho việc tập thể dục, nhưng Bạn hiểu rồi)

câu trả lời hay nhất

Hơi ngạc nhiên khi bạn gặp rắc rối ở đây vì bạn đã thể hiện kiến ​​thức về tất cả những điều cần thiết. Bạn biết nhómTheo có thể sử dụng cái khác Người sưu tầm, bạn đã đặt tên đúng bản đồ, và bạn đã sử dụng chức năng để trích xuất >Bản đồ.Entry Giá trị đã tồn tại.

Kết hợp những điều này mang lại cho bạn

Bản đồ> nhóm = filter.entrySet().stream()
    .collect(Collectors.groupingBy(x -> x.getValue(),
        Collectors.toMap(x -> x.getKey(), x -> x.getValue())));
System.out.println("được nhóm " + nhóm);

Để thể hiện rõ hơn thao tác, tôi đã thay đổi đầu vào thành

List list = Arrays.asList(1, 1, 1, 2, 3, 3, 3, 3, 4, 4, 4);

结果

được nhóm {3=[1=3, 4=3], 4=[3=4]}

Tuy nhiên, sẽ không có ý nghĩa gì nếu lặp lại số đếm luôn giống với khóa bản đồ bên ngoài. Vì vậy, một lựa chọn khác là

Bản đồ> nhóm = filter.entrySet().stream()
    .collect(Collectors.groupingBy(Map.Entry::getValue,
        Collectors.mapping(Map.Entry::getKey, Collectors.toList())));
System.out.println("được nhóm " + nhóm);

dẫn đến

được nhóm {3=[1, 4], 4=[3]}

Lưu ý bạn không nên sử dụngforEach/forEachOrdered Sẽđưa vào vào bản đồ. Bước trung gian của bạn phải là

//Sắp xếp desc
Map giảm dầnSắp xếp = countGrouped.entrySet().stream()
    .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue,
        (a,b) -> { ném AssertionError mới(); }, LinkedHashMap::new));
System.out.println("sắp xếp " + giảm dầnSắp xếp);

//lọc
Map đã lọc = giảm dầnSorted.entrySet().stream()
    .filter(x -> x.getValue() >= 2)
    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue,
        (a,b) -> { ném AssertionError mới(); }, LinkedHashMap::new));
System.out.println("đã lọc " + đã lọc);

Chấp nhận nhà máy bản đồ bản đồ Bộ sưu tập buộc chúng tôi phải cung cấp một hàm hợp nhất, nhưng vì đầu vào của chúng tôi đã là một bản đồ phải có các khóa khác nhau, nên tôi cung cấp một hàm ở đây luôn gửi, bởi vì sẽ có điều gì đó cực kỳ sai sót nếu có các bản sao.

Nhưng xin lưu ý rằng việc buộc tất cả các hoạt động này được thu thập vào một bản đồ mới là phức tạp và không hiệu quả một cách không cần thiết. Cũng không cần phải sắp xếp toàn bộ dữ liệu trước rồi mới chuyển lọc Giảm lượng dữ liệu. Việc lọc trước có thể làm giảm công sức của bước sắp xếp và kết quả của thao tác lọc sẽ không phụ thuộc vào thứ tự.

Sẽ tốt hơn nhiều nếu thực hiện toàn bộ hoạt động trong một đường dẫn duy nhất

List list = Arrays.asList(1, 1, 1, 2, 3, 3, 3, 3, 4, 4, 4);

Map countGrouped = list.stream().collect(
    Collectors.groupingBy(x -> x, Collectors.counting()));
System.out.println("group by value, count " + countGrouped);

Bản đồ> nhóm = countGrouped.entrySet().stream()
    .filter(x -> x.getValue() >= 2)
    .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
    .collect(Collectors.groupingBy(Map.Entry::getValue, LinkedHashMap::new, 
        Collectors.mapping(Map.Entry::getKey, Collectors.toList())));

System.out.println("được nhóm " + nhóm);

Lưu ý rằng không giống như đoạn mã trước, thao tác nhóm cuối cùng bây giờ cũng giữ nguyên thứ tự, dẫn đến

được nhóm {4=[3], 3=[1, 4]}

Tức là các nhóm được sắp xếp theo thứ tự giảm dần về số lượng.

Vì số lượng là chìa khóa cho bản đồ kết quả nên chúng ta cũng có thể sử dụng bản đồ được sắp xếp nội tại làm loại kết quả và bỏ qua bước sắp xếp:

Bản đồ> nhóm = countGrouped.entrySet().stream()
    .filter(x -> x.getValue() >= 2)
    .collect(Collectors.groupingBy(Map.Entry::getValue,
        () -> TreeMap mới<>(Comparator.reverseOrder()),
        Collectors.mapping(Map.Entry::getKey, Collectors.toList())));

Sự khác biệt chính là hoạt động truyền phátsau đóHành vi của bản đồ kết quả, ví dụ: nếu bạn chèn thêm phần tử vào đó, bởi vì Bản đồ cây Các khóa mới sẽ được chèn theo thứ tự giảm dần, trong khi Bản đồ LinkedHash sẽ nối chúng vào cuối, duy trì thứ tự chèn.

Về java - Map trả về Map<>> sau khi nhóm theo giá trị thay vì Map<>>>, chúng tôi đang ở trên Stack Overflow Tìm thấy một điều tương tự câu hỏi: https://stackoverflow.com/questions/56288198/