小编PeM*_*eMa的帖子

标准收集器在summingInt内部创建一个长度为1的数组：

public static <T> Collector<T, ?, Integer>
summingInt(ToIntFunction<? super T> mapper) {
    return new CollectorImpl<>(
            () -> new int[1],
            (a, t) -> { a[0] += mapper.applyAsInt(t); },
            (a, b) -> { a[0] += b[0]; return a; },
            a -> a[0], CH_NOID);
}

我想知道是否不可能仅定义：

private <T> Collector<T, Integer, Integer> summingInt(ToIntFunction<? super T> mapper) {
    return Collector.of(
            () -> 0,
            (a, t) -> a += mapper.applyAsInt(t),
            (a, b) -> a += b,
            a -> a
    );
}

但是，这不起作用，因为似乎只是忽略了累加器。谁能解释这种行为？

当我使用运行时检查编译程序时，出现以下错误（我不知道为什么）：

ifort -check all test.f90 -o test
./test
forrtl: severe (193): Run-Time Check Failure. The variable 'my_sum$2$_2' is being used without being defined
Image        PC                     Routine           Line           Source
sum          0000000000403098       Unknown              Unknown     Unknown 
sum          0000000000403098       Unknown              Unknown     Unknown 
sum          0000000000403098       Unknown              Unknown     Unknown 
sum          0000000000403098       Unknown              Unknown     Unknown 
.
.
.
sum          0000000000403098       Unknown              Unknown     Unknown 
sum          0000000000402EAF       Unknown              Unknown     Unknown 
sum          0000000000402DE6       Unknown              Unknown     Unknown 
libc.so.6    00007F7FEB268BE5       Unknown              Unknown     Unknown 
sum          0000000000402CD9       Unknown              Unknown     Unknown 

代码是：

program test

   implicit …

在Spring Java配置中，假设我想@Bean在另一个@Bean定义中重复使用a 。我可以在一个文件中执行此操作：

@Bean
public A buildA() {
    return new A();
}

@Bean
public B buildB() {
    return new B(buildA());
}

或者我可以在一个文件中配置A，然后在另一个文件中将其自动连接，例如（为简洁起见，请使用字段注入）：

@Autowired
private A a;

@Bean
public B buildB() {
    return new B(a);
}

我想知道这两种可能性是否完全相同？对我来说，第一个版本可能会使A两次虚假，而第二个版本则不会。

我问这个问题，因为在我的特殊用例中，A正在建立与消息传递代理的连接，并且我有几个B在消耗流（我是.toReactivePublisher()从A中的Spring集成中使用的），并且我不想连接两次或更多给经纪人。

我确实有一些问题，无法理解当将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 …