我想用 Java 8 流复制和并行化以下行为：
for (animal : animalList) {
// find all other animals with the same breed
Collection<Animal> queryResult = queryDatabase(animal.getBreed());
if (animal.getSpecie() == cat) {
catList.addAll(queryResult);
} else {
dogList.addAll(queryResult);
}
}
这是我到目前为止
final Executor queryExecutor =
Executors.newFixedThreadPool(Math.min(animalList.size(), 10),
new ThreadFactory(){
public Thread newThread(Runnable r){
Thread t = new Thread(r);
t.setDaemon(true);
return t;
}
});
List<CompletableFuture<Collection<Animal>>> listFutureResult = animalList.stream()
.map(animal -> CompletableFuture.supplyAsync(
() -> queryDatabase(animal.getBreed()), queryExecutor))
.collect(Collectors.toList());
List<Animal> = listFutureResult.stream()
.map(CompletableFuture::join)
.flatMap(subList -> subList.stream())
.collect(Collectors.toList());
1 - 我不知道如何拆分流，以便获得 …
我有一个可以为空的列表；
List<T> list; // may or may not null
我想与消费者一起处理每个元素。
到目前为止，我做到了。
ofNullable(list)
.map(List::stream)
.ifPresent(stream -> stream.forEach(e -> {}));
或者
ofNullable(eventDataList).ifPresent(v -> v.forEach(e -> {}));
有没有简单或简洁的方法来做到这一点？
使用 Eclipse 和 Java -version 1.8
我有这个代码：
public Stream<Ship> remainingShips() {
return this.b.getShips().stream().filter(s -> !s.isSunk());.
}
public Stream<Ship> sunkShips() {
return this.b.getShips().stream().filter(s -> s.isSunk());.
}
我想通过调用打印出流中的所有项目
System.out.println("Sunk ships => " + this.opponent.sunkShips());
但这只会打印流对象，我如何才能访问流中的所有项目并打印出每个项目？
我有一个带有其他对象列表的对象，每个其他对象都有一个列表等。我需要在层次结构中找到层次结构中具有匹配某个值的属性的第一个（也是唯一的）最后一个元素。看到我现在的代码会更清楚：
@Override
public Poste findByNumeroAndMillesime(String numero, Millesime millesime) {
return millesime
.getDivisions()
.stream()
.filter(
division -> division
.getGroupes()
.stream()
.filter(
groupe -> groupe
.getClasses()
.stream()
.filter(
classe -> classe
.getSousClasses()
.stream()
.filter(
sousClasse -> sousClasse
.getPostes()
.stream()
.filter(poste -> numero.equals(poste.getNumero()))
.findFirst()
.get()
))));
}
我需要返回与作为参数传递的数字相同的 Poste。
提前致谢。
我有这个要求迭代结果集中返回的数百万条记录并处理它们并将它们存储在某些数据结构中。我找不到任何相关的例子或参考。JOOQ 似乎在做一些我可能想要的事情，但它似乎不是免费的。我希望如果使用 java 8 流我可能能够实现它，但不是 example 或 writeup 似乎给了我任何前进的方向。我也对其他选择持开放态度。
基于这个 SO 参考：resultset parallel我在下面尝试过，但它没有给我任何性能改进，如下面的性能指标所示。
代码：顺序迭代：
while(rs.next()) {
System.out.println(rs.getString(1));
}
使用流和拆分器：
Stream<String> s = StreamSupport.stream(new Spliterators.AbstractSpliterator<String>(Long.MAX_VALUE,
Spliterator.ORDERED) {
@Override
public boolean tryAdvance(Consumer<? super String> action) {
try {
if (!rs.next())
return false;
action.accept(rs.getString(1));
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return true;
}
}, true);
s.forEach(System.out::println);
记录总数：3759
Sequential 花费的时间：~83.8 secs
Streams 花费的时间：~83.5 secs
任何人都可以查看并告诉我我是否没有正确实现流。
我有一个Stream，生长成倍创建排列。所以每次调用都会addWeeks增加Stream.
Stream<SeasonBuilder> sbStream = sbSet.stream();
for (int i = 1; i <= someCutOff; i++) {
sbStream = sbStream.map(sb -> sb.addWeeks(possibleWeeks))
.flatMap(Collection::stream);
}
// Collect SeasonBuilders into a Set
return sbStream.collect(Collectors.toSet()); // size > 750 000
addWeeks返回 aSet<SeasonBuilder>并将所有内容收集到 a 中Set需要一段时间。addWeeks不是静态的，需要SeasonBuilder在流中的每一个上调用，每次通过循环
public Set<SeasonBuilder> addWeeks(
final Set<Set<ImmutablePair<Integer, Integer>>> possibleWeeks) {
return possibleWeeks.stream()
.filter(containsMatchup()) // Finds the weeks to add
.map(this::addWeek) // Create new …假设我有以下课程：
public class Foo {
private int id;
private String name;
public int getId() {
return id;
}
public Foo setId(int id) {
this.id = id;
return this;
}
public String getName() {
return name;
}
public Foo setName(String name) {
this.name = name;
return this;
}
}
然后，我有几个Foo对象Collection<Foo> fooCollection和 String Array String[] names。
现在我想fooCollection按属性name排序，与name字符串排序的顺序相同names。
我如何使用 Java 8 Stream 做到这一点？
我正在学习 Oracle 的 Stream API Java 1.8 课程，在阅读讲义时偶然发现了这一点：
无序（）：
– 继承自 BaseStream
– 返回一个无序的流（内部使用）
– 可以提高distinct()和groupingBy()等操作的效率
这是我的问题。无序的属性如何导致更有效的计算distinct()和groupingBy()
我可以按一个字段分组，但我想按两个字段分组
//persons grouped by gender
Map<String, Long> personsGroupedByGender = persons.stream().collect(Collectors.groupingBy(Person::getGender, Collectors.counting()));
//persons grouped by age
Map<Int, Long> personsGroupedByAge = persons.stream().collect(Collectors.groupingBy(Person::getAge, Collectors.counting()));
//persons grouped by gender and age
???
final List<Toy> toys = Arrays.asList("new Toy(1)", "new Toy(2)");
final List<Item> itemList = toys.stream()
.map(toy -> {
return Item.from(toy); //Creates Item type
}).collect(Collectors.toList);
上面的代码可以正常工作，并将从玩具列表中生成项目列表。
我想做的是这样的：
final List<Item> itemList = toys.stream()
.map(toy -> {
Item item1 = Item.from(toy);
Item item2 = Item.fromOther(toy);
List<Item> newItems = Arrays.asList(item1, item2);
return newItems;
}).collect(Collectors.toList);
或者
final List<Item> itemList = toys.stream()
.map(toy -> {
return Item item1 = Item.from(toy);
return Item item2 = Item.fromOther(toy); //Two returns don't make sense but just want to illustrate the idea.
}).collect(Collectors.toList); …