标签: java-stream

我想按 ZoneDateTime 字段以相反顺序对列表进行排序，将计数限制为 20

    public class VisitViewDTO implements Serializable {
      private ZonedDateTime visitDate;
      private int count;

      public ZonedDateTime getVisitDate() {
        return visitDate;
    }
}

……

List<VisitViewDTO> visitViewDTOList;

visitViewDTOList.stream().sorted(Comparator.comparing(VisitViewDTO::getVisitDate).reversed()).limit(20).collect(Collectors.toList());

但得到了NPE：

java.lang.NullPointerException: null
    at java.time.chrono.ChronoZonedDateTime.compareTo(ChronoZonedDateTime.java:570)
    at java.time.chrono.ChronoZonedDateTime.compareTo(ChronoZonedDateTime.java:121)
    at java.util.Comparator.lambda$comparing$77a9974f$1(Comparator.java:469)
    at java.util.Collections$ReverseComparator2.compare(Collections.java:5178)
    at java.util.TimSort.countRunAndMakeAscending(TimSort.java:356)
    at java.util.TimSort.sort(TimSort.java:220)
    at java.util.Arrays.sort(Arrays.java:1512)     

public class Element {

    private Long id;

    private String groupType;

}

我有元素列表。具有不同组类型的列表，例如“group1”、“group2”{1,group1}、{2,group1}、{3,group2}{4,group2}

我想为每个组创建两个不同列表的地图，但使用 ids(Map>) 而不是使用 Element 对象 Map>

下面的代码对于 Map> ie 工作正常

Map<String, List<Element>> elementByGroup = new HashMap<>();
        elementByGroup = element.stream().collect(
                Collectors.groupingBy(Element::getGroupType));

如何以 Map<String, List<Long>> 的形式收集结果。我知道通过迭代 Map，然后迭代列表，我们可以在没有 java 8 的情况下获得 id 列表。但是我想通过在 groupingby 函数之后使用上面的代码进行操作来执行相同的操作。

在 Java 8 Stream API 中，过滤器、映射和查看等中间（无状态）操作的描述被称为“惰性查找”——意味着当终端操作需要时，它将逐个处理元素。

当终端操作命中时，操作是在流中的元素上独立实现的。

但是，当涉及到一些中间（有状态）操作（例如 sort() 、distinct() ）时，需要在生成结果之前处理整个输入。

例如，在看到流的所有元素之前，无法对流进行排序产生任何结果 - 意味着在终端操作要求之前不独立地完成对所有元素的操作。

这引发了我一个问题（可能很愚蠢或误解了 Eager 的惰性查找），这些“有状态中间操作”仍然是惰性查找吗？

https://docs.oracle.com/javase/8/docs/api/java/util/stream/package-summary.html

我有一个List<Map<String, String>>。我想将其转换为单个地图。

列表大小可以是 1..n。不确定如何使用 Java 8 Stream 来做到这一点？

List<Map<String, String>> mapList = new ArrayList<>();

Map<String, String> map1 = new HashMap<>();
map1.put("1", "One");
map1.put("2", "Two");

Map<String, String> map2 = new HashMap<>();
map2.put("3", "Three");
map2.put("4", "Four");

mapList.add(map1);
mapList.add(map2);

Map<String, String> finalMap = new HashMap<>();

我们可以在 Java 7 中做这样的事情：

for(Map<String, String> map : mapList) {            
    for(String key : map.keySet()) {                
        finalMap.put(key, map.get(key));
    }           
}

System.out.println("Final Map " + finalMap); // Final Map {1=One, 2=Two, 3=Three, 4=Four}

我有一个 HashMap 如下：

    Map<String,Object> map = new HashMap<>();
    Map<String,Object> map1 = new HashMap<>();
    map1.put("key1", "value1");
    Map<String,Object> map2 = new HashMap<>();
    Map<String,Object> map3 = new HashMap<>();
    map3.put("key2", "value2");
    map2.put("map3", map3);
    map.put("map1", map1);
    map.put("map2", map2);
    map.put("key3", "value3");

我想把它压扁。预期输出是：

[map1.key1, value1]
[map2.map3.key2, value2]
[key3, value3]
...

for这可以使用简单的循环和以下代码来完成：

public static Map<String, String> flat(Map<String, Object> input){
    Map<String, String> toReturn = new HashMap<>();
    for (Map.Entry<String, Object> entry: input.entrySet()) {
        if(entry.getValue() instanceof Map){
            Map<String, Object> innerMap = (Map<String, Object>)entry.getValue();
            for(Map.Entry<String, Object> innerEntry: innerMap.entrySet()) {
                if(innerEntry.getValue() instanceof …

我想使用 java 8 将给定的二维数组转换为映射。输入 - { { 1, 0 }, { 2, 0 }, { 3, 1 }, { 3, 2 } } 输出的形式应为 Map<Integer,列表>映射=新的HashMap<>(); 输出 - {1=[0], 2=[0], 3=[1, 2]}

下面是我的解决方案

for (int[] prereq : prerequisites) {
            map.computeIfAbsent(prereq[0], k -> new ArrayList<>()).add(prereq[1]);
        }

任何更好的方法，如果 for 循环可以用流代替。

有没有办法从处理中排除最后 n 个元素？与skip方法类似但从最后一个跳过。

我有一个整数列表

List<Integer> lst = new ArrayList<>();
lst.add(10);
lst.add(15);
lst.add(16);
lst.add(8);
lst.add(100);
lst.add(1);
lst.add(40);

如何编写代码以便我可以从列表中获取前 5 个最大元素，即100, 40, 16, 15, 10？

我尝试过使用 Java 流 API：

Integer var = lst.stream().max(Integer::compare).get();

但只得到一个值元素。

我正在学习Java8，想要使用Java8中的流API执行以下操作。

输入： (1,2,3,4,5,6,7,8,9) 列表

输出： 奇数列表 - (1,3,5,7,9) 偶数列表 - (2,4,6,8)

我可以在传统java中的单个for循环中执行此操作，例如

List<Integer> ints = Arrays.asList(3,4,2,5,6,7,4,5);
List<Integer> oddList = new ArrayList<>();
List<Integer> evenList = new ArrayList<>();

for (Integer i : ints) {
    if (i % 2 == 0) {
        evenList.add(i);
    } else {
        oddList.add(i);
    }
}

我知道一种以 Java8 风格执行此操作的方法，如下所示 -

List<Integer> evens = ints.stream().filter(i -> i % 2 == 0).collect(Collectors.toList());
List<Integer> odds = ints.stream().filter(i -> i % 2 == 1).collect(Collectors.toList());

但这里的问题是我迭代了两次而不是一次整数。有没有一种方法可以做到这一点而无需在流中迭代两次？

我正在尝试从 JsonArray 获取键的值。结果，我得到了 JsonObject，格式如下

{
  "docs": [
    {
      "_index": "esindex",
      "_type": "esmessage",
      "_id": "4",
      "_version": 1,
      "found": true,
      "_source": {
        "account_number": 4,
        "balance": 27658
      }
    }
  ]
}

我需要找到id所有这些文件的"found": true. 生成的 JsonArray 的格式为

[
  {
    "_index": "esindex",
    "_type": "esmessage",
    "_id": "4",
    "_version": 1,
    "found": true,
    "_source": {
      "account_number": 4,
      "balance": 27658
    }
  }
]

我可以使用下面的java代码获取所有id的列表

 List<Integer> documents = new ArrayList<>();
JsonObject result = esClient.execute(builder.build()).getJsonObject();
        JsonArray jsonArray = result.getAsJsonObject().get("docs").getAsJsonArray();
        while (i < request.getIds().size()) {
            JsonPrimitive checkIfExists = …