我一直在浏览 Java 16 的新闻和源代码，并且遇到了名为mapMulti. 早期访问的JavaDoc说它类似于flatMap并且已经被批准用于完全相同的 Java 版本。
<R> Stream<R> mapMulti?(BiConsumer<? super T,?? super Consumer<R>> mapper)
flatMap. 什么时候最好？mapper可以调用多少次？在P下面的类中，该方法test似乎返回相同false：
import java.util.function.IntPredicate;
import java.util.stream.IntStream;
public class P implements IntPredicate {
private final static int SIZE = 33;
@Override
public boolean test(int seed) {
int[] state = new int[SIZE];
state[0] = seed;
for (int i = 1; i < SIZE; i++) {
state[i] = state[i - 1];
}
return seed != state[SIZE - 1];
}
public static void main(String[] args) {
long count = IntStream.range(0, 0x0010_0000).filter(new P()).count();
System.out.println(count);
}
}
但是，将 classP与结合使用 …
在阅读了https://www.airpair.com/java/posts/spring-streams-memory-efficiency之后,我很想从数据库中传出结果,但正如我与同事讨论的那样(cfr.评论他补充说文章),需要记住使用try-with-resources构造来避免任何内存泄漏.
我想以一种由线条组成的方式将InputStream isa 转换为Stream<String> stream给定的a .此外,不应立即读取一行,但仅在需要时才读取.Charset csstreamisisstream
我非常喜欢Java 8流和Guava的不可变集合,但我无法弄清楚如何将两者结合使用.
例如,如何实现将流结果收集到ImmutableMultimap中的Java 8 Collector？
加分点:我希望能够提供键/值映射器,类似于Collectors.toMap()的工作方式.
所以我有一组对象,它们的步长变量可以是1到4.
public class MyClass {
private Long step;
//other variables, getters, setters, etc.
}
Collection<MyClass> myOjbects = /*get collection*/;
然后我想MyClass从集合中获得具有最大步长值的一个实例,所以我这样做:
final Optional<MyClass> objectWithMaxStep =
myObjects.stream().max(Comparator.comparing(MyClass::getStep));
但是,在某些情况MyClass下,集合中将有多个实例,其步长等于4.
所以,我的问题是,如何确定返回哪个实例Optional,或者当流中的多个对象具有要比较的最大值时是否抛出异常？
该max()函数的Java 8文档未指定在这种情况下将发生的情况.
简而言之,我有这个代码,我想使用条件和lambda获取数组的特定元素.代码将是这样的:
Preset[] presets = presetDALC.getList();
Preset preset = Arrays.stream(presets).select(x -> x.getName().equals("MyString"));
但显然这不起作用.在C#中会有类似的东西,但在Java中,我该怎么做？
我有兴趣将一个流分成两个或多个子流,并以不同的方式处理这些元素.例如,(大)文本文件可能包含类型A的行和类型B的行,在这种情况下,我想要执行以下操作:
File.lines(path)
.filter(line -> isTypeA(line))
.forEachTrue(line -> processTypeA(line))
.forEachFalse(line -> processTypeB(line))
以前是我试图抽象的情况.实际上我有一个非常大的文本文件,其中每一行都在测试正则表达式; 如果该行通过,则处理它,而如果它被拒绝,那么我想更新一个计数器.对拒绝字符串的进一步处理是我不仅仅使用的原因filter.
是否有任何合理的方法可以使用流来执行此操作,还是必须回退到循环？(我希望这也是并行运行,所以溪流是我的第一选择).
可以说我有两个类和两个方法:
class Scratch {
private class A{}
private class B extends A{}
public Optional<A> getItems(List<String> items){
return items.stream()
.map(s -> new B())
.findFirst();
}
public Optional<A> getItems2(List<String> items){
return Optional.of(
items.stream()
.map(s -> new B())
.findFirst()
.get()
);
}
}
为什么getItems2编译时getItems会出现编译器错误
incompatible types: java.util.Optional<Scratch.B> cannot be converted to java.util.Optional<Scratch.A>
所以,当我返回get的值和使用编译器再次包装它时,会识别继承,但如果我直接使用结果,则不会.OptionalfindFirstOptional.offindFirst
我试图了解该reduce()方法如何在java-8中工作。
例如，我有以下代码：
public class App {
public static void main(String[] args) {
String[] arr = {"lorem", "ipsum", "sit", "amet"};
List<String> strs = Arrays.asList(arr);
int ijk = strs.stream().reduce(0,
(a, b) -> {
System.out.println("Accumulator, a = " + a + ", b = " + b);
return a + b.length();
},
(a, b) -> {
System.out.println("Combiner");
return a * b;
});
System.out.println(ijk);
}
}
输出是这样的：
Accumulator, a = 0, b = lorem
Accumulator, a = 5, b = …