Java8流-按最大重复数降序排序_Java_Java 8

Java8流-按最大重复数降序排序

java java-8

Java8流-按最大重复数降序排序,java,java-8,Java,Java 8,使用Java8流，我正在尝试按字段（groupname）的一部分（最大重复数）降序对列表进行排序之前只需使用第一部分：第二部分不相关。唯一行记录顺序不相关。（我只是尝试根据最大重复数将重复记录置于顶部。）测试数据： 100 : 200 200 : 207 200 : 203 200 : 201 300 : 202 103 : 201 103 : 202 200 : 207 200 : 203 200 : 201 103 : 201 103 : 202 100 : 200 300 : 2

使用Java8流，我正在尝试按字段（groupname）的一部分（最大重复数）降序对列表进行排序

之前只需使用第一部分：第二部分不相关。唯一行记录顺序不相关。（我只是尝试根据最大重复数将重复记录置于顶部。）

测试数据：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Play {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("100 : 200",
                "200 : 207",
                "200 : 203",
                "200 : 201",
                "300 : 202",
                "103 : 201",
                "103 : 202");
        List<String> processedList = list.stream().collect(Collectors.groupingBy(string -> string.split(":")[0].trim()))
                .values().stream().sorted((list1, list2) -> Integer.compare(list2.size(), list1.size()))
                .flatMap(List::stream).collect(Collectors.toList());

        System.out.println(processedList);
    }
}

期望值：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Play {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("100 : 200",
                "200 : 207",
                "200 : 203",
                "200 : 201",
                "300 : 202",
                "103 : 201",
                "103 : 202");
        List<String> processedList = list.stream().collect(Collectors.groupingBy(string -> string.split(":")[0].trim()))
                .values().stream().sorted((list1, list2) -> Integer.compare(list2.size(), list1.size()))
                .flatMap(List::stream).collect(Collectors.toList());

        System.out.println(processedList);
    }
}

我尝试了下面的代码，它正确地返回了订单。但只有分组的数据，而不是原始的完整记录和排序

Java代码

@Test
public void testSplit2Optimsation() {

    List<CompatibilityRule> rules = new ArrayList<>();
    CompatibilityRule compatibilityRule1 = new CompatibilityRule();
    compatibilityRule1.setGroupname("100 : 200");

    CompatibilityRule compatibilityRule2 = new CompatibilityRule();
    compatibilityRule2.setGroupname("200 : 207");

    CompatibilityRule compatibilityRule3 = new CompatibilityRule();
    compatibilityRule3.setGroupname("200 : 203");

    CompatibilityRule compatibilityRule4 = new CompatibilityRule();
    compatibilityRule4.setGroupname("200 : 201");

    CompatibilityRule compatibilityRule5 = new CompatibilityRule();
    compatibilityRule5.setGroupname("300 : 202");

    CompatibilityRule compatibilityRule6 = new CompatibilityRule();
    compatibilityRule6.setGroupname("102 : 202");

    CompatibilityRule compatibilityRule7 = new CompatibilityRule();
    compatibilityRule7.setGroupname("103 : 202");

    rules.add(compatibilityRule1);
    rules.add(compatibilityRule2);
    rules.add(compatibilityRule3);
    rules.add(compatibilityRule4);
    rules.add(compatibilityRule5);
    rules.add(compatibilityRule6);
    rules.add(compatibilityRule7);



    rules.stream()
            .map(r -> r.getGroupname().split(":")[0].trim())
            .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
            .entrySet().stream()
            .sorted(Map.Entry.<String, Long>comparingByValue().reversed())
            .forEach(System.out::println);

}

@测试
public void testSplit2Optimsation（）{
列表规则=新建ArrayList（）；
相容性规则相容性规则1=新的相容性规则（）；
兼容性规则1.setGroupname（“100:200”）；
相容性规则相容性规则2=新的相容性规则（）；
兼容性规则2.setGroupname（“200:207”）；
相容性规则相容性规则3=新的相容性规则（）；
兼容性规则3.setGroupname（“200:203”）；
相容性规则相容性规则4=新的相容性规则（）；
兼容性规则4.setGroupname（“200:201”）；
相容性规则相容性规则5=新的相容性规则（）；
兼容性规则5.setGroupname（“300:202”）；
相容性规则相容性规则6=新的相容性规则（）；
兼容性规则6.setGroupname（“102:202”）；
相容性规则相容性规则7=新的相容性规则（）；
兼容性规则7.setGroupname（“103:202”）；
添加（兼容性规则1）；
添加（兼容性规则2）；
添加（兼容性规则3）；
添加（兼容性规则4）；
添加（兼容性规则5）；
添加（兼容性规则6）；
添加（兼容性规则7）；
rules.stream（）
.map（r->r.getGroupname（）.split（“：”[0].trim（））
.collect（Collectors.groupingBy（Function.identity（）、Collectors.counting（））
.entrySet（）.stream（）
.sorted（Map.Entry.comparingByValue（）.reversed（））
.forEach（System.out:：println）；
}

这是一个有效的例子。我希望这能解决你的问题

方法：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Play {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("100 : 200",
                "200 : 207",
                "200 : 203",
                "200 : 201",
                "300 : 202",
                "103 : 201",
                "103 : 202");
        List<String> processedList = list.stream().collect(Collectors.groupingBy(string -> string.split(":")[0].trim()))
                .values().stream().sorted((list1, list2) -> Integer.compare(list2.size(), list1.size()))
                .flatMap(List::stream).collect(Collectors.toList());

        System.out.println(processedList);
    }
}

分组为您提供了包含列表的映射，您只需要按其大小排序，然后将其展平，最后收集为列表

代码：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Play {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("100 : 200",
                "200 : 207",
                "200 : 203",
                "200 : 201",
                "300 : 202",
                "103 : 201",
                "103 : 202");
        List<String> processedList = list.stream().collect(Collectors.groupingBy(string -> string.split(":")[0].trim()))
                .values().stream().sorted((list1, list2) -> Integer.compare(list2.size(), list1.size()))
                .flatMap(List::stream).collect(Collectors.toList());

        System.out.println(processedList);
    }
}

import java.util.ArrayList；
导入java.util.array；
导入java.util.List；
导入java.util.stream.collector；
公演{
公共静态void main（字符串[]args）{
List List=Arrays.asList（“100:200”，
"200 : 207",
"200 : 203",
"200 : 201",
"300 : 202",
"103 : 201",
"103 : 202");
List processedList=List.stream（）.collect（收集器.groupingBy（string->string.split（“：”[0].trim（）））
.values（）.stream（）.sorted（（list1，list2）->Integer.compare（list2.size（），list1.size（））
.flatMap（List:：stream）.collect（collector.toList（））；
System.out.println（processedList）；
}
}

如果有多余的操作符，您可以尝试删除它们。您可以使用类的getter方法访问字符串，并按照示例中所示的方法进行操作。

有趣的是，您的输入数据与java代码中的实际示例不一致，并且您已经接受并回答了没有以您想要的格式打印信息的问题：在您的代码中，您想要输入项，被接受的答案没有一个

列表

但无论如何，考虑到你的字面问题，你的方法存在问题，一旦你做了

.collect（Collectors.groupingBy（Function.identity（），Collectors.counting（））

你就“丢失了”了

groupName

的第二部分，因为之前的

map

。你可以使用

Collectors:：mapping

：

    Pattern p = Pattern.compile("\\s:\\s");

    rules.stream()
         .map(CompatibilityRule::getGroupName)
         .collect(Collectors.groupingBy(
             x -> p.splitAsStream(x)
                   .findFirst()
                   .orElseThrow(),
             Collectors.mapping(
                 x -> p.splitAsStream(x).skip(1).findFirst().orElseThrow(),
                 Collectors.toList())
         ))
         .entrySet()
         .stream()
         .sorted(Map.Entry.comparingByValue(Comparator.comparingInt(List<String>::size).reversed()))
         .flatMap(x -> x.getValue().stream()
                        .map(y -> new SimpleEntry<>(x.getKey(), y)))
         .forEachOrdered(System.out::println);

Pattern p=Pattern.compile（“\\s:\\s”）；
rules.stream（）
.map（CompatibilityRule:：getGroupName）
.collect（收集器.groupingBy(
x->p.splitAsStream（x）
.findFirst（）
.orelsetrow（），
图(
x->p.splitAsStream（x）.skip（1）.findFirst（）.OrelsThrow（），
Collectors.toList（））
))
.entrySet（）
.stream（）
.sorted（Map.Entry.comparingByValue（Comparator.comparingInt（List:：size）.reversed（）））
.flatMap（x->x.getValue（）.stream（））
.map（y->newsimplentry（x.getKey（），y）））
.forEachOrdered（System.out:：println）；

谢谢你，好朋友。流英雄：-）不要用减号来反转比较器的结果。由于未指定返回值的大小，因此它可能是

Integer.MIN\u value

，在这种情况下，翻转符号将失败。您可以使用

（list1，list2）->Integer.compare（list2.size（），list1.size（））

。或

Comparator.comparingInt（List:：size）.reversed（）

。或者

Comparator.comparingit（l->-l.size（））

，这是安全的，因为列表的大小从来都不是负数。您可以使用

string.replaceFirst（“\\s*：”）[0].trim（）

（它用所有不需要的子字符串填充数组），而不是使用

string.replaceFirst（“\\s*：*”，”）

。无需创建

ArrayList

作为

数组返回的列表的副本。asList

。问题并不是说最终结果必须是

Map.Entry

实例的列表；它只显示文本输出。此外，您还可以简化比较器，如

.sorted（Map.Entry.comparingByValue）（comparator.comparingit（List:：size）.reversed（））

@Holger-oh-snap，很好。有趣的是，Intellij不编译

List:：size

，而是编译

List:：size

，

splitAsStream

方法既复杂又昂贵。我会使用类似于

Pattern p=Pattern.compile（（.*？\\s:\\s（.*），Pattern.DOTALL）的东西