Tag: java stream

java8流和多个

我很好奇，如何在java8流中总结多个变量。 Integer wCPU = 0; Double wnetwork = 0.0; Double wMem = 0.0; this.slaContractList.forEach(sla -> { wCPU += sla.getNumberOfCPUs(); wnetwork += sla.getNetworkBandwith(); wMem += sla.getMemory(); }); 但是，这不会编译，因为lambda表达式中的变量应该是final。

将流收集回到相同的集合类型中

假设我有一个未知类型的集合。 我想要做的是流式传输，在流上做一些事情，并将其收回到与我的原始集合相同的集合类型。 例如： Collection getBigger(Collection col, int value) { return col.stream().filter(v -> v > value).collect(????); } 这个不完整的代码示例的想法是返回一个List如果col是List类（或它的任何子类）， Set如果col是Set类，等等……这里的流的方法名称和实际操作是不重要，我已经指定它们只是为了说明我的问题。 那么，有可能吗？

如何在Stream链中调用setter

如何在不使用forEach（）的情况下调用Stream链中的setter？ List newFoos = foos.stream() .filter(foo -> Foo::isBlue) .map(foo -> foo.setTitle(“Some value”)) //I am unable to use this because also changing the data type into Object .collect(Collectors.toList());

终端执行的Java流操作顺序

我一直试图从官方Java文档中找到明确的合同，关于Java流的顺序，一旦调用终端操作，就处理元素并调用中间操作。 例如，让我们看看这些使用Java流版本和普通迭代版本的示例（两者都产生相同的结果） 。 例1： List ints = Arrays.asList(1, 2, 3, 4, 5); Function map1 = i -> i; Predicate f1 = i -> i > 2; public int findFirstUsingStreams(List ints){ return ints.stream().map(map1).filter(f1).findFirst().orElse(-1); } public int findFirstUsingLoopV1(List ints){ for (int i : ints){ int mappedI = map1.apply(i); if ( f1.test(mappedI) ) return mappedI; } return -1; […]

Java 8 Stream – 为什么filter方法没有执行？

我正在学习使用java流过滤。 但过滤后的流不会打印任何内容。 我认为过滤方法没有被执行。 我的过滤代码如下： Stream.of(“d2”, “a2”, “b1”, “b3”, “c”) .filter(s -> { s.startsWith(“b”); System.out.println(“filter: ” + s); return true; }); 没有编译错误，也没有例外。 有什么建议吗？

java：不兼容类型：推理变量T具有不兼容的边界等式约束：下限：java.util.List

我试图从流中获取一个列表，但我有一个例外。 这是带有对象列表的Movie对象。 public class Movie { private String example; private List movieTranses; public Movie(String example, List movieTranses){ this.example = example; this.movieTranses = movieTranses; } getter and setter 这是MovieTrans： public class MovieTrans { public String text; public MovieTrans(String text){ this.text = text; } getter and setter 我在列表中添加元素： List movieTransList = Arrays.asList(new MovieTrans(“Appel me”), new MovieTrans(“je t’appel”)); […]

Java 8 Spliterator（或类似的），如果只有一个值，则返回值

我是singleOrEmpty流操作员的singleOrEmpty粉丝。 它不在std lib中，但我发现它非常有用。 如果流只有一个值，则在Optional返回该值。 如果它没有值或多个值，则返回Optional.empty() 。 Optional value = someList.stream().{singleOrEmpty} [] -> Optional.empty() [1] -> Optional.of(1) [1, 1] -> Optional.empty() etc. 我之前问了一个关于它的问题，而@ThomasJungblut 想出了这个伟大的实现 ： public static Optional singleOrEmpty(Stream stream) { return stream.limit(2) .map(Optional::ofNullable) .reduce(Optional.empty(), (a, b) -> a.isPresent() ^ b.isPresent() ? b : Optional.empty()); } 唯一的问题是，你必须把它放在通话的开头 singleOrEmpty(someList.stream().filter(…).map(…)) 而不是顺序结束 someList.stream().filter().map().singleOrEmpty() 这使得它比其他流机制更难阅读。 那么作为这个流处理工具的新手，有没有人知道如何在流转换序列结束时建立一个短路的singleOrEmpty机制呢？

Java 8 stream.collect（… groupingBy（… mapping（… reduction）））减少BinaryOperator的使用

我使用groupingBy ， mapping和reducing解决了以下问题的解决方案： 在Java 8中优雅地创建带有对象字段的映射作为对象流的键/值 。 总结的目标是获得一张以年龄为关键的地图和一个人作为一套的爱好。 我提出的解决方案之一（不好，但这不是重点）有一个奇怪的行为。 使用以下列表作为输入： List personList = Arrays.asList( new Person(/* name */ “A”, /* age */ 23, /* hobbies */ asList(“a”)), new Person(“BC”, 24, asList(“b”, “c”)), new Person(“D”, 23, asList(“d”)), new Person(“E”, 23, asList(“e”)) ); 以及以下解决方案： Collector<List, ?, Set> listToSetReducer = Collectors.reducing(new HashSet(), HashSet::new, (strings, strings2) -> { strings.addAll(strings2); return […]

流filter的时间复杂度

我有这样的代码： List Listings = new ArrayList(); Listings.add(listing1); Listings.add(listing2); … … … Listing listing= listings.stream() .filter(l -> l.getVin() == 456) .findFirst(); 我的问题是过滤过程的时间复杂度是多少？ 如果它是O（n），我的直觉是将它转换为HashSet，就像数据结构一样，这样时间复杂度可能变成O（1），是否有一种优雅的方式来实现流 ？

遇到订单友好/不友好的终端操作与并行/顺序与有序/无序流

受这个问题的启发，我开始玩有序与无序流，并行与顺序流和终端操作，这些操作遵循不受其尊重的遭遇顺序与终端操作。 在对链接问题的一个答案中，显示了与此类似的代码： List ordered = Arrays.asList( 1, 2, 3, 4, 4, 3, 2, 1, 1, 2, 3, 4, 4, 3, 2, 1, 1, 2, 3, 4); List result = new CopyOnWriteArrayList(); ordered.parallelStream().forEach(result::add); System.out.println(ordered); System.out.println(result); 这些名单确实不同。 unordered列表甚至从一次运行变为另一次运行，表明结果实际上是非确定性的。 所以我创建了另一个例子： CopyOnWriteArrayList result2 = ordered.parallelStream() .unordered() .collect(Collectors.toCollection(CopyOnWriteArrayList::new)); System.out.println(ordered); System.out.println(result2); 我希望看到类似的结果，因为流是并行和无序的（可能是unordered()是多余的，因为它已经是并行的）。 但是，生成的列表是有序的，即它等于源列表。 所以我的问题是为什么收集的清单是有序的？ collect总是尊重遭遇顺序，即使对于平行，无序的流？ 它是特定的Collectors.toCollection(…)收集器强制遭遇订单吗？