Java 获取列表中最后出现的特定字符串

我有一个简单的字符串列表。我的目标是按组获取列表中最后出现的每个字符串

这是模式代码：

 List<String> newData =  new ArrayList<>();
    newData.add("A-something");
    newData.add("A-fdfdsfds");
    newData.add("A-fdsfdsfgs");
    newData.add("B-something");
    newData.add("B-dsafdrsafd");
    newData.add("B-dsdfsad");

List newData=newarraylist（）；
newData.add（“A-something”）；
新增数据。添加（“A-FDSFDS”）；
新增数据。添加（“A-fdsfdsfgs”）；
新增数据。添加（“B-something”）；
新增数据。添加（“B-dsafdrsafd”）；
新增数据。添加（“B-dsdfsad”）；

我只希望得到每组的最后一次。换句话说，我只想得到“A-fdsfdsfgs”和“B-dsdfsad”

---

如何操作？

要获取每个组的最后一次出现次数，可以将流api与groupingBy一起使用：

import static java.util.stream.Collectors.*;

Map<String, Optional<String>> collect = newData.stream()
            .collect(groupingBy(strings -> strings.split("-")[0], 
                    mapping(s -> s, maxBy(Comparator.comparingInt(newData::lastIndexOf)))));

---

另外，如果您希望具有不带组名的映射值，则使用

s->s.split（“-”[1]”更改
Function.identity（）
，以获取每个组的最后一次出现次数，您可以将流api与groupingBy一起使用：

import static java.util.stream.Collectors.*;

Map<String, Optional<String>> collect = newData.stream()
            .collect(groupingBy(strings -> strings.split("-")[0], 
                    mapping(s -> s, maxBy(Comparator.comparingInt(newData::lastIndexOf)))));

另外，如果您希望映射值不带组名，则使用
s->s.split（“-”[1]”更改
Function.identity（）
，通过分组收集就足够了

final Map<String, List<String>> grouped =
                newData.stream()
                       .collect(groupingBy(s -> s.split("-")[0]));

final List<String> lastOccurrences =
                grouped.values()
                       .stream()
                       .filter(s -> !s.isEmpty())
                       .map(s -> s.get(s.size() - 1))
                       .collect(toList());

最终地图分组=
newData.stream（）
.collect（分组方式->s.split（“-”[0]）；
最后发生的事件的最终列表=
分组。值（）
.stream（）
.filter（s->！s.isEmpty（））
.map（s->s.get（s.size（）-1））
.collect（toList（））；

对于Java11，
filter
变为
filter（not（List:：isEmpty））

这将为您提供
fdsfdsfgs、dsdfsad
通过分组收集就足够了

final Map<String, List<String>> grouped =
                newData.stream()
                       .collect(groupingBy(s -> s.split("-")[0]));

final List<String> lastOccurrences =
                grouped.values()
                       .stream()
                       .filter(s -> !s.isEmpty())
                       .map(s -> s.get(s.size() - 1))
                       .collect(toList());

最终地图分组=
newData.stream（）
.collect（分组方式->s.split（“-”[0]）；
最后发生的事件的最终列表=
分组。值（）
.stream（）
.filter（s->！s.isEmpty（））
.map（s->s.get（s.size（）-1））
.collect（toList（））；

对于Java11，
filter
变为
filter（not（List:：isEmpty））

这将使用临时的
映射为您提供
fdsfdsfgs、dsdfsad
。
列表
finalList将仅具有所需的值

Map<String, String> tempMap = new HashMap<>();
List<String> finalList = new ArrayList<>();
newData.forEach((val) -> tempMap.put(val.split("-")[0], val.split("-")[1]));
tempMap.forEach((key, val) -> finalList.add(key + "-" + val));

Map tempMap=newhashmap（）；
List finalList=new ArrayList（）；
newData.forEach（（val）->tempMap.put（val.split（“-”[0]，val.split（“-”[1]）；
tempMap.forEach（（key，val）->finalList.add（key+“-”+val））；
使用临时
地图
。
列表
finalList将仅具有所需的值

Map<String, String> tempMap = new HashMap<>();
List<String> finalList = new ArrayList<>();
newData.forEach((val) -> tempMap.put(val.split("-")[0], val.split("-")[1]));
tempMap.forEach((key, val) -> finalList.add(key + "-" + val));

Map tempMap=newhashmap（）；
List finalList=new ArrayList（）；
newData.forEach（（val）->tempMap.put（val.split（“-”[0]，val.split（“-”[1]）；
tempMap.forEach（（key，val）->finalList.add（key+“-”+val））；

算法：

[B-dsdfsad, A-fdsfdsfgs]


从最后一次移动到第一次，而不是从第一次移动到最后一次，因为您希望
最后一次出现
。这将使管理更加容易，代码也更加干净
使用方法获取字符串所属的组
使用可跟踪已访问的组
如果组不在集合中，请将其添加到集合中，并将当前字符串添加到此组的答案（因为这将是最后一次出现）
最后，返回列表

算法：

[B-dsdfsad, A-fdsfdsfgs]


从最后一次移动到第一次，而不是从第一次移动到最后一次，因为您希望
最后一次出现
。这将使管理更加容易，代码也更加干净
使用方法获取字符串所属的组
使用可跟踪已访问的组
如果组不在集合中，请将其添加到集合中，并将当前字符串添加到此组的答案（因为这将是最后一次出现）
最后，返回列表
正如其他答案所示，有几种方法可以做到这一点。我会发现一些类似以下的自然现象：

    Collection<String> lastOfEach = newData.stream()
            .collect(Collectors.groupingBy((String s) -> s.split("-")[0],
                    Collectors.reducing("", s -> s, (l, r) -> r)))
            .values();

    lastOfEach.forEach(System.out::println);

我的分组与其他几个答案中的分组相同。在分组的值上，我执行一个缩减，每次我得到两个字符串，取后者。最后，这将根据请求提供每个组的最后一个字符串。由于
groupingBy
生成一个映射，我使用
values
放弃键（
a
和
B
），只获取原始字符串。
有几种方法可以实现这一点，正如其他答案已经显示的那样。我会发现一些类似以下的自然现象：

    Collection<String> lastOfEach = newData.stream()
            .collect(Collectors.groupingBy((String s) -> s.split("-")[0],
                    Collectors.reducing("", s -> s, (l, r) -> r)))
            .values();

    lastOfEach.forEach(System.out::println);

我的分组与其他几个答案中的分组相同。在分组的值上，我执行一个缩减，每次我得到两个字符串，取后者。最后，这将根据请求提供每个组的最后一个字符串。由于
groupingBy
生成了一个映射，因此我使用
values
丢弃键（
a
和
B
），只获取原始字符串。
循环遍历列表，并用分隔符“-”分割每个字符串。将前缀和当前迭代字符串值保存到在循环外部声明的两个单独的临时字符串变量中。在每次迭代中，使用当前迭代字符串的前缀检查temp变量值。如果两者相同，则继续下一次迭代。如果没有，则将上一个迭代字符串保存到新的结果列表中。您能否解释为什么
a-fdsfdsfgs
和
B-dsdfsad
仅限？a，B=组名。名称可以是完整字符串，而不仅仅是字符。在连字符后面=any text.Loop遍历列表并用分隔符“-”拆分每个字符串。将前缀和当前迭代字符串值保存到在循环外部声明的两个单独的临时字符串变量中。在每次迭代中，使用当前迭代字符串的前缀检查temp变量值。如果两者相同，则继续下一次迭代。如果没有，则将上一个迭代字符串保存到新的结果列表中。您能否解释为什么只使用
a-fdsfdsfgs
和
B-dsdfsad