列表<string>获取以另一个列表中的一个字符串结尾的所有元素的计数</string>

Question

Let's say I have one list with elements like:

List<String> endings= Arrays.asList("AAA", "BBB", "CCC", "DDD");

And I have another large list of strings from which I would want to select all elements ending with any of the strings from the above list.

List<String> fullList= Arrays.asList("111.AAA", "222.AAA", "111.BBB", "222.BBB", "111.CCC", "222.CCC", "111.DDD", "222.DDD");

Ideally I would want a way to partition the second list so that it contains four groups, each group containing only those elements ending with one of the strings from first list. So in the above case the results would be 4 groups of 2 elements each.

I found this example but I am still missing the part where I can filter by all endings which are contained in a different list.

Map<Boolean, List<String>> grouped = fullList.stream().collect(Collectors.partitioningBy((String e) -> !e.endsWith("AAA")));

UPDATE: MC Emperor's Answer does work, but it crashes on lists containing millions of strings, so doesn't work that well in practice.

Answer 1

Update

This one is similar to the approach from the original answer, but now fullList is no longer traversed many times. Instead, it is traversed once, and for each element, the list of endings is searched for a match. This is mapped to an Entry(ending, fullListItem) , and then grouped by the list item. While grouping, the value elements are unwrapped to a List .

Map<String, List<String>> obj = fullList.stream()
    .map(item -> endings.stream()
        .filter(item::endsWith)
        .findAny()
        .map(ending -> new AbstractMap.SimpleEntry<>(ending, item))
        .orElse(null))
    .filter(Objects::nonNull)
    .collect(groupingBy(Map.Entry::getKey, mapping(Map.Entry::getValue, toList())));

---

Original answer

You could use this:

Map<String, List<String>> obj = endings.stream()
    .map(ending -> new AbstractMap.SimpleEntry<>(ending, fullList.stream()
        .filter(str -> str.endsWith(ending))
        .collect(Collectors.toList())))
    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

It takes all endings and traverses the fullList for elements ending with the value.

Note that with this approach, for each element it traverses the full list. This is rather inefficient, and I think you are better off using another way to map the elements. For instance, if you know something about the structure of the elements in fullList , then you can group it immediately.

Answer 2

To partition a stream, means putting each element into one of two groups. Since you have more suffixes, you want grouping instead, ie use groupingBy instead of partitioningBy .

If you want to support an arbitrary endings list, you might prefer something better than a linear search.

One approach is using a sorted collection, using a suffix-based comparator.

The comparator can be implemented like

Comparator<String> backwards = (s1, s2) -> {
    for(int p1 = s1.length(), p2 = s2.length(); p1 > 0 && p2 > 0;) {
        int c = Integer.compare(s1.charAt(--p1), s2.charAt(--p2));
        if(c != 0) return c;
    }
    return Integer.compare(s1.length(), s2.length());
};

The logic is similar to the natural order of string, with the only difference that it runs from the end to the beginning. In other words, it's equivalent to Comparator.comparing(s -> new StringBuilder(s).reverse().toString()) , but more efficient.

Then, given an input like

List<String> endings= Arrays.asList("AAA", "BBB", "CCC", "DDD");
List<String> fullList= Arrays.asList("111.AAA", "222.AAA",
        "111.BBB", "222.BBB", "111.CCC", "222.CCC", "111.DDD", "222.DDD");

you can perform the task as

// prepare collection with faster lookup
TreeSet<String> suffixes = new TreeSet<>(backwards);
suffixes.addAll(endings);

// use it for grouping
Map<String, List<String>> map = fullList.stream()
    .collect(Collectors.groupingBy(suffixes::floor));

But if you are only interested in the count of each group, you should count right while grouping, avoiding to store lists of elements:

Map<String, Long> map = fullList.stream()
    .collect(Collectors.groupingBy(suffixes::floor, Collectors.counting()));

If the list can contain strings which match no suffix of the list, you have to replace suffixes::floor with s -> { String g = suffixes.floor(s); return g.=null && s?endsWith(g): g; "_None"; } s -> { String g = suffixes.floor(s); return g.=null && s?endsWith(g): g; "_None"; } s -> { String g = suffixes.floor(s); return g.=null && s?endsWith(g): g; "_None"; } or a similar function.

Answer 3

Use groupingBy .

Map<String, List<String>> grouped = fullList
  .stream()
  .collect(Collectors.groupingBy(s -> s.split("\\.")[1]));

s.split("\\.")[1] will take the yyy part of xxx.yyy .

EDIT: if you want to empty the values for which the ending is not in the list, you can filter them out:

grouped.keySet().forEach(key->{
  if(!endings.contains(key)){
    grouped.put(key, Collections.emptyList());
  }
});

Answer 4

If you create a helper method getSuffix() that accepts a String and returns its suffix (for example getSuffix("111.AAA") will return "AAA" ), you can filter the String s having suffix contained in the other list and then group them:

Map<String,List<String>> grouped =
    fullList.stream()
            .filter(s -> endings.contains(getSuffix(s)))
            .collect(Collectors.groupingBy(s -> getSuffix(s)));

For example, if the suffix always begins at index 4, you can have:

public static String getSuffix(String s) {
    return s.substring(4);
}

and the above Stream pipeline will return the Map :

{AAA=[111.AAA, 222.AAA], CCC=[111.CCC, 222.CCC], BBB=[111.BBB, 222.BBB], DDD=[111.DDD, 222.DDD]}

PS note that the filter step would be more efficient if you change the endings List to a HashSet .

Answer 5

If your fullList have some elements which have suffixes that are not present in your endings you could try something like:

    List<String> endings= Arrays.asList("AAA", "BBB", "CCC", "DDD");
    List<String> fullList= Arrays.asList("111.AAA", "222.AAA", "111.BBB", "222.BBB", "111.CCC", "222.CCC", "111.DDD", "222.DDD", "111.EEE");
    Function<String,String> suffix = s -> endings.stream()
                                                 .filter(e -> s.endsWith(e))
                                                 .findFirst().orElse("UnknownSuffix");
    Map<String,List<String>> grouped = fullList.stream()
                                               .collect(Collectors.groupingBy(suffix));
    System.out.println(grouped);

Answer 6

You can use groupingBy with filter on endings list as,

fullList.stream()
  .collect(groupingBy(str -> endings.stream().filter(ele -> str.endsWith(ele)).findFirst().get()))

Answer 7

One can use groupingBy of substrings with filter to ensure that the final Map has just the Collection of relevant values. This could be sone as:

Map<String, List<String>> grouped = fullList.stream()
        .collect(Collectors.groupingBy(a -> getSuffix(a)))
        .entrySet().stream()
        .filter(e -> endings.contains(e.getKey()))
        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

private static String getSuffix(String a) {
    return a.split(".")[1];
}