标签: java-stream

排序在西里尔文中不能按预期工作。我使用 sorted() 方法，但它不起作用

public static void main(String[] args) {              

    List<String> list = new ArrayList<>();
    list.add("??????");
    list.add("???????????");
    list.add("???????");
    list.add("?????");
    list.add("????");
    list.add("?????????");
    list.add("??????");
    list.add("???-?????");
    list.add("??????");
    list.add("????");
    list.stream().sorted().forEach(System.out::println);
}

结果：

??????
???????????
???????
?????
????
?????????
??????
???-?????
??????
????

我总是对 reduce()的JavaDoc有点困惑。它调用初始值Identity。

当我阅读Lodash文档时，我更加困惑：

似乎条款颠倒了。标识不是初始值，而是每次迭代要调用的函数。并且累加器是初始值：

集合（数组|对象）：要迭代的集合。
[iteratee=_.identity] (Function)：每次迭代调用的函数。
[累加器] (*)：初始值。

JavaScript 的文档Array.prototype.reduce()似乎更简单。它调用初始值：initialValue。

是否有调用 initialValue 的原因Identity以及为什么 Lodashreduce()和 Javareduce()有这种命名冲突？

我正在测试collect流的方法。在这段代码中，我试图通过StringBuilder在第一种情况下使用 a并String在第二种情况下使用连接来从字符串流构建单个字符串。我不明白为什么第二种情况会产生一个空字符串。

    String[] strs = new String[] {"aaaaa", "bbbbbbb", "c", "dd"};
    
    
    StringBuilder sb = Arrays.stream(strs).collect(StringBuilder::new, StringBuilder::append, StringBuilder::append);
    
    System.out.println(sb);
    
    
    String s = Arrays.stream(strs).collect(String::new, String::concat, String::concat);
    
    System.out.println(s);

IntStream.range(x,y)将从x(inclusive)和y(exclusive)返回一个流。 IntStream.rangeClosed(x,y)将从x(inclusive)和y(inclusive)返回一个流。

我希望rangeClosed(x,y)调用range(x,y-1)或range(x,y)调用rangeClosed(x,y-1). 但是在查看range它的源代码时，它就像：

if (startInclusive >= endExclusive) {
    return empty();
} else {
    return StreamSupport.intStream(
    new Streams.RangeIntSpliterator(startInclusive, endExclusive, false /*not closed*/), false);
}

该rangeClosed也有一个非常相似的实现，而不是range(x,y+1)。唯一的区别是，第三个参数Streams.RangeIntSpliterator是true代替false表示该范围被关闭。

然后使用此布尔值来初始化类中的int last字段，Streams.RangeIntSpliterator并针对它提到了以下注释：

1 如果范围是封闭的并且最后一个元素还没有被遍历 否则 0 如果范围是开放的，或者是一个封闭的范围并且所有元素都已经被遍历

为什么这样的实现是必要的，而不是range简单地调用rangeClosed或相反？调用rangeClosed(x,y)而不是调用之间有什么显着区别range(x,y+1)吗？

我在服务中有一个方法可以从数据库中检索课程对象。在将其发送到控制器之前，我需要解压缩字段 byte[] 徽标。Logo 是一张图片，需要在渲染到前端之前从数据库中解压出来。我试图用流来做到这一点，但没有任何成功。map() 方法在 forEach() 方法之后不起作用。

public List<CourseDto> getCoureses() {

    List<Courses> courses = courseRepositoryDao.findAllByIsCourseFreeAndIsCourseActive(true, true);
    List<CourseDto> coursesNameDto = courses
            .stream()
            .forEach(course-> course.setLogo(decompressZLib(course.getLogo()))
            .map(course -> modelMapper.map(CourseMapper.toUserDtoFreeCourses(course), CourseDto.class))
            .collect(Collectors.toList());

    return coursesNameDto;
}

我有三个字符串列表。现在我需要确保一个元素只出现在这三个列表之一中。我不想在列表中重复。您可以假设每个列表中没有重复项。

我尝试使用removeIf()及其服务于我的目的。我确定这不是最好的方法。在 Java 8+ 中有没有其他方法可以做到这一点？

列表的优先级是 list1 > list2 > list3

List<String> list1 = Stream.of("23","45","655","43","199").collect(Collectors.toList());
List<String> list2 = Stream.of("13","23","54","655","111","13").collect(Collectors.toList());
List<String> list3 = Stream.of("76","45","33","67","43","13").collect(Collectors.toList());

list2.removeIf(i->list1.contains(i));
list3.removeIf(i->list1.contains(i) || list2.contains(i));

System.out.println(list1);
System.out.println(list2);
System.out.println(list3);

输出低于预期

[23, 45, 655, 43, 199]
[13, 54, 111, 13]
[76, 33, 67]

我正在尝试从列表创建一个 Map，而 Map 的值将是某种转换的结果，这就是我的代码的样子。

empIdList.stream()
         .map(id-> getDepartment(id))
         .collect(Collectors.toMap(id, department:String -> department)

在上面的示例中，我希望将其id用作键和department值。你能帮我实现我的预期结果吗？

我正在使用 java 流，但遇到了问题。我有这个代码：

clients.stream()
                    .map(Client::getDescription)
                    .map(x -> x.substring(x.lastIndexOf("_v")))
                    .map(x -> x.substring(2))
                    .mapToInt(Integer::parseInt)
                    .max()
                    .getAsInt();

每个客户端的描述可能是“John_abc_v1”、“Bill_crce_v2”、“Joe_ghhj_V3”……我得到了最大值，在这种情况下是 3……但问题是 v 可以是小写或大写，而我没有知道如何解决，所以这行不工作 .map(x -> x.substring(x.lastIndexOf("_v")))，我得到String index out of range -1的时候“V”是大写的。我该如何解决？任何反馈都将受到赞赏。

我正在尝试List<Y>从List<X>. 这是我的两个类：

public class X {
    private String a;
    private String b;
    private String c;
    private String d;
    //Getters, setters
}

public class Y {
        private String a;
        private String b;
        //Getters, setters
   } 

对于 forEach，它将类似于：

List<X> listX = getListX();
List<Y> listY = new ArrayList<>();
listX.forEach( x -> {
     Y object_y = new Y();
     object_y.set_a(x.get_a());
     object_y.set_b(x.get_b());
     listY.add(object_y);
});

有没有其他方法可以使用 Stream() 执行相同的操作？

我有一个Stream<List<Integer>>我收到的并且无法控制生成的 api。列表最多有 4 个元素。但有些元素少于 4 个，但保证至少有一个。我需要修改列表并将零添加到列表中，以使所有列表具有相同的大小 = 4。

举个例子，实际上我没有清单。

List<List<Integer>> myList = List.of(List.of(1,2,3,4),
                                     List.of(7,5),
                                     List.of(2,9),
                                     List.of(1));

Stream<List<Integer>> myStream = myList().stream();

我需要进一步处理长度为 4 的相同大小的列表，所以上面的列表应该看起来像[1,2,3,4],[7,5,0,0],[2,9,0,0],[1,0,0,0]. 我最好不要在中间结果列表中收集流。我的天真方法不起作用，因为 list.add 返回一个布尔值而不是列表，并且没有考虑要添加多少个零。

myStream.map(list -> list.size() == 4 ? list : list.add(0)

如何达到预期的效果？

如果可能，我想避免：

List<List<Integer> collected = myStream.collect(toList());

for(List<Integer> temp : collected){
   if(temp.size() < 4){
      for(int i= 0; i < 4 - temp.size(); i++){
          temp.add(0);
      }
   }
}


myStream = collected.stream();