标签: java-stream

我试图在Integer流上使用reduce方法来获取所有值的总和。但出现语法错误，无法找出错误。

List<Integer> ee = new ArrayList<Integer>();
Function<? super Integer, ? extends Integer> f3 = x -> x / 2;
BinaryOperator<? extends Integer> accumulator = (x, y) -> x + y;
ee.stream().map(f3).reduce(new Integer(0), accumulator);

它给出了错误：

The method reduce(capture#2-of ? extends Integer, BinaryOperator<capture#2-of ? extends Integer>) in the type Stream<capture#2-of ? extends Integer> is not applicable for the arguments (Integer, BinaryOperator<capture#7-of ? extends Integer>)

我有简单对象的列表：

private String unit;
private Double value;

列表看起来像这样：

f, 1.0;
ml, 15.0;
g, 9.0

我创建了一个简单的函数，希望将这些值分组并以unit为键将它们放入地图，并将对象列表作为值，但是我想像在原始列表中那样保存顺序。这是我目前的解决方案：

myList.stream()
    .collect(groupingBy(MyObject::getUnit));

但是之后，我的地图按字母顺序排序：f，g，ml，而不是f，ml，g。有没有其他分组方法可以解决？

我正在尝试将玩家列表转换为地图。播放器包含名称并作为变量运行。

List<Player> runnerList = Arrays.asList(new Player("Virat", 4654), new Player("Jaddu", 5798),
            new Player("Dhoni", 4581), new Player("Virat", 8709), new Player("Dhoni", 4711),
            new Player("Virat", 4541));

我的问题是我试图通过使用流合并运行来转换为地图，而无法通过。

尝试每个并合并值，如下所示，并获得预期结果。

playerList.forEach(n -> {
            mapVal.merge((n.getName()), (n.getDistance()), (val1, val2) -> IntStream.of(val1, val2).sum());
        });

寻找使用流的解决方案的结果将是{Dhoni = 9292，Jaddu = 5798，Virat = 17904}。

我确实有一些问题，无法理解当将Stream来自Spring数据jpa的查询结果接收到的手动包装到a中时，幕后是怎么回事Flux。

考虑以下：

实体：

@NoArgsConstructor
@AllArgsConstructor
@Data
@Entity
public class TestEntity {
    @Id
    private Integer a;
    private Integer b;
}

仓库：

public interface TestEntityRepository extends JpaRepository<TestEntity, Integer> {
    Stream<TestEntity> findByBBetween(int b1, int b2);
}

简单的测试代码：

@Test
@SneakyThrows
@Transactional
public void dbStreamToFluxTest() {
    testEntityRepository.save(new TestEntity(2, 6));
    testEntityRepository.save(new TestEntity(3, 8));
    testEntityRepository.save(new TestEntity(4, 10));

    testEntityFlux(testEntityStream()).subscribe(System.out::println);
    testEntityFlux().subscribe(System.out::println);
    Thread.sleep(200);
}

private Flux<TestEntity> testEntityFlux() {
    return fromStream(this::testEntityStream);
}

private Flux<TestEntity> testEntityFlux(Stream<TestEntity> testEntityStream) {
    return fromStream(() -> testEntityStream);
}

private Stream<TestEntity> testEntityStream() {
    return …

作为学习Java 8+ Streams的练习，我想将一些简单的Codility实现转换为Stream解决方案。

例如，BinaryGap问题..使用Streams的一个简单的线性解决方案可能类似于：

public static int solution(int N) {
    return Integer.toBinaryString(N).chars().
                     filter(x -> x == 1).whichIndexes().diff().max();
}

唯一的问题是，虽然，whichIndexes并且diff不存在。我需要一种方法来获取已过滤元素的索引，然后计算它们的成对差异，这将是基于Streams的单线解决方案的良好起点。

更新：这是我的C ++ BinaryGap解决方案，但是Java非Stream-ed版本将非常相似：

#include <bitset>
#include <iostream>
#include <math.h>

using namespace std;

int solution(int N) {
    bitset<32> bs(N);
    int maxGap = 0;
    std::size_t i = 0;
    while (bs[i] == 0) {
        i++;
    }
    int startPos = i;
    for (; i < bs.size(); ++i) {
        if (bs[i] == 1) {
            int gap = i - startPos …