我试图使用Streams API将以下Scala代码行翻译为Java 8：
// Scala
util.Random.shuffle((1 to 24).toList)
要在Java中编写相当的代码，我创建了一个整数范围：
IntStream.range(1, 25)
我本以为在流API中会找到toList方法，但是IntStream只知道这个奇怪的方法：
collect(
Supplier<R> supplier, ObjIntConsumer<R> accumulator, BiConsumer<R,R> combiner)
如何使用Java 8 Streams API对列表进行洗牌？
toShuffledList()方法很有用。private static final Collector<?, ?, ?> SHUFFLER = Collectors.collectingAndThen(
Collectors.toCollection(ArrayList::new),
list -> {
Collections.shuffle(list);
return list;
}
);
@SuppressWarnings("unchecked")
public static <T> Collector<T, ?, List<T>> toShuffledList() {
return (Collector<T, ?, List<T>>) SHUFFLER;
}
这使得以下一行代码成为可能:
IntStream.rangeClosed('A', 'Z')
.mapToObj(a -> (char) a)
.collect(toShuffledList())
.forEach(System.out::print);
示例输出：
AVBFYXIMUDENOTHCRJKWGQZSPL
给你：
List<Integer> integers =
IntStream.range(1, 10) // <-- creates a stream of ints
.boxed() // <-- converts them to Integers
.collect(Collectors.toList()); // <-- collects the values to a list
Collections.shuffle(integers);
System.out.println(integers);
输出：
[8, 1, 5, 3, 4, 2, 6, 9, 7]
IntStream.boxed()，这几乎是标准的。 - Louis WassermantoList()方法不能保证返回的List是可变的。实际上，因为当前的toList()实现返回的是一个可变的ArrayList，所以这段代码能够正常工作。如果实现发生了改变，为保证正确性，我们可以显式地声明集合类型(Collectors.toCollection(ArrayList::new))或将toList的结果复制到一个可变列表中(new ArrayList<>(integers))。 - M. Justinpublic final class RandomComparator<T> implements Comparator<T> {
private final Map<T, Integer> map = new IdentityHashMap<>();
private final Random random;
public RandomComparator() {
this(new Random());
}
public RandomComparator(Random random) {
this.random = random;
}
@Override
public int compare(T t1, T t2) {
return Integer.compare(valueFor(t1), valueFor(t2));
}
private int valueFor(T t) {
synchronized (map) {
return map.computeIfAbsent(t, ignore -> random.nextInt());
}
}
}
流中的每个对象都会（懒惰地）关联一个随机整数值，我们将其用于排序。对映射进行同步是为了处理并行流。
然后您可以像这样使用它：
IntStream.rangeClosed(0, 24).boxed()
.sorted(new RandomComparator<>())
.collect(Collectors.toList());
[1,5,1,1,5] 将变成 [5,5,1,1,1] 或 [1,1,1,5,5] 中的一个。 - M. JustinT => Integer 的映射，并在该整数上进行比较。由于映射在比较器的生命周期内不会改变，因此 f(A)<f(B) and f(B)<f(C) => f(A)<f(C)，其中 f(x) 是映射函数。这个解决方案等同于 Comparator.comparing(t -> { synchronized (map) { return map.computeIfAbsent(t, ignore -> random.nextInt()); }});，这或许更清楚地说明了它如何满足基本契约。 - M. Justin如果你想在不太麻烦的情况下处理整个流，你可以使用 Collectors.collectingAndThen() 创建自己的收集器：
public static <T> Collector<T, ?, Stream<T>> toEagerShuffledStream() {
return Collectors.collectingAndThen(
toList(),
list -> {
Collections.shuffle(list);
return list.stream();
});
}
但是，如果你想要对结果Stream进行limit()操作，则效果可能不佳。为了克服这个问题，可以创建一个自定义的Spliterator：
package com.pivovarit.stream;
import java.util.List;
import java.util.Objects;
import java.util.Random;
import java.util.RandomAccess;
import java.util.Spliterator;
import java.util.function.Consumer;
import java.util.function.Supplier;
class ImprovedRandomSpliterator<T, LIST extends RandomAccess & List<T>> implements Spliterator<T> {
private final Random random;
private final List<T> source;
private int size;
ImprovedRandomSpliterator(LIST source, Supplier<? extends Random> random) {
Objects.requireNonNull(source, "source can't be null");
Objects.requireNonNull(random, "random can't be null");
this.source = source;
this.random = random.get();
this.size = this.source.size();
}
@Override
public boolean tryAdvance(Consumer<? super T> action) {
if (size > 0) {
int nextIdx = random.nextInt(size);
int lastIdx = --size;
T last = source.get(lastIdx);
T elem = source.set(nextIdx, last);
action.accept(elem);
return true;
} else {
return false;
}
}
@Override
public Spliterator<T> trySplit() {
return null;
}
@Override
public long estimateSize() {
return source.size();
}
@Override
public int characteristics() {
return SIZED;
}
}
接着：
public final class RandomCollectors {
private RandomCollectors() {
}
public static <T> Collector<T, ?, Stream<T>> toImprovedLazyShuffledStream() {
return Collectors.collectingAndThen(
toCollection(ArrayList::new),
list -> !list.isEmpty()
? StreamSupport.stream(new ImprovedRandomSpliterator<>(list, Random::new), false)
: Stream.empty());
}
public static <T> Collector<T, ?, Stream<T>> toEagerShuffledStream() {
return Collectors.collectingAndThen(
toCollection(ArrayList::new),
list -> {
Collections.shuffle(list);
return list.stream();
});
}
}
IntStream 转换为 List<Integer>？ - deamonList<Integer> randomShuffledRange(int startInclusive, int endExclusive) {
return new Random().ints(startInclusive, endExclusive)
.distinct()
.limit(endExclusive-startInclusive)
.boxed()
.collect(Collectors.toList());
}
var shuffled = randomShuffledRange(1, 10);
System.out.println(shuffled);
示例输出：
[4, 6, 8, 9, 1, 7, 3, 5, 2]
int 进行排序。List<Integer> xs=IntStream.range(0, 10)
.boxed()
.sorted( (a, b) -> a.hashCode() - b.hashCode() )
.collect(Collectors.toList());
int[]而不是List<Integer>，那么你可以在之后将它们解包。不幸的是，如果要应用自定义的Comparator，则必须经过装箱步骤，因此无法消除该过程的这一部分。List<Integer> ys=IntStream.range(0, 10)
.boxed()
.sorted( (a, b) -> a.hashCode() - b.hashCode() )
.mapToInt( a -> a.intValue())
.toArray();
Integer :: hashCode返回与Integer :: intValue相同的内容。(这在javadoc中有说明!)即使您使用System :: identityHashCode，由于几个原因，洗牌的随机性也将依赖于系统。 - Stephen CcolourRepository.findAll().stream().sorted((o1,o2)-> RandomUtils.nextInt(-1,1)).findFirst().get()
Comparator 违反了 Comparator 的一般契约。比较相同的两个值是不一致的，并且比较 x 和 y 与比较 y 和 x 并不一定返回相反的结果。通过正确的输入和随机种子，我能够使得这种排序方式抛出异常：java.lang.IllegalArgumentException: Comparison method violates its general contract! 在我的Java版本中，一个具体的例子是：Random r = new Random(9); Collections.nCopies(32, 1).stream().sorted((o1, o2) -> r.nextInt(3) - 1).findFirst().get()。 - M. Justin
toList（）方法并没有保证返回的List是可变的。由于当前实现的toList（）恰好返回一个可变的ArrayList，所以在实践中是有效的。为了确保如果实现更改仍然正确，我们可以显式声明集合类型（Collectors.toCollection(ArrayList:: new)），或者将toList的结果复制到可变的列表中（new ArrayList<>(integers)）。 - M. Justinget方法。与Stream API的许多部分一样，这真是太糟糕了。按照这个论点的逻辑结论，你应该实际使用返回列表上的唯一方法是size和iterator。 - Paul Boddingtonsize操作（虽然这些肯定是异常情况）--https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ConcurrentLinkedQueue.html#size-- - M. Justin