Java 8是否提供了一种重复值或函数的好方法？

在许多其他语言中，例如。Haskell，很容易多次重复一个值或函数，例如。获取值的8个副本的列表1：

take 8 (repeat 1)

但是我还没有在Java 8中找到它。Java 8的JDK中是否有这样的功能？

或替代等效范围

[1..8]

似乎可以明显替代Java中的冗长语句

for (int i = 1; i <= 8; i++) {
    System.out.println(i);
}

有类似的东西

Range.from(1, 8).forEach(i -> System.out.println(i))

尽管这个特定示例实际上看起来不那么简洁...但是希望它更具可读性。

对于此特定示例，您可以执行以下操作：

IntStream.rangeClosed(1, 8)
         .forEach(System.out::println);

如果需要一个不同于1的步骤，则可以使用一个映射函数，例如，对于2步：

IntStream.rangeClosed(1, 8)
         .map(i -> 2 * i - 1)
         .forEach(System.out::println);

或构建自定义迭代并限制迭代的大小：

IntStream.iterate(1, i -> i + 2)
         .limit(8)
         .forEach(System.out::println);

这是我前几天遇到的另一种技术：

Collections.nCopies(8, 1)
           .stream()
           .forEach(i -> System.out.println(i));

该Collections.nCopies调用将创建一个List包含n您提供的任何值的副本。在这种情况下，它是装箱的Integer值1 n。它创建一个“虚拟化”列表，其中仅包含值和长度，并且对get范围内的任何调用都将返回该值。nCopies自从JDK 1.2引入Collections Framework以来，这种方法就一直存在。当然，Java SE 8中增加了根据结果创建流的功能。

没什么大不了的，另一种方法可以在大约相同的行数中完成相同的操作。

但是，此技术比IntStream.generate和IntStream.iterate方法快，而且令人惊讶的是，它也比IntStream.range方法快。

对于iterate，generate结果也许并不奇怪。流框架（实际上是这些流的拆分器）是基于以下假设而建立的：lambda每次可能会生成不同的值，并且它们将生成无数的结果。这使得并行分裂特别困难。iterate对于这种情况，该方法也有问题，因为每个调用都需要前一个的结果。因此，使用generate和的流iterate在生成重复常数方面效果不佳。

相对较差的性能range令人惊讶。这也是虚拟化的，因此元素实际上并不全部存在于内存中，并且大小是预先知道的。这应该构成一个快速且易于并行化的分离器。但是令人惊讶的是，它做得不好。可能的原因是range必须为范围的每个元素计算一个值，然后在其上调用一个函数。但是这个函数只是忽略它的输入并返回一个常量，所以令我惊讶的是它没有被内联和杀死。

该Collections.nCopies技术必须进行装箱/拆箱操作才能处理这些值，因为没有的原始专长List。由于每次的值都相同，因此基本上将其装箱一次，并且所有n副本共享该箱。我怀疑装箱/拆箱是高度优化的，甚至是内在的，并且可以很好地内联。

这是代码：

    public static final int LIMIT = 500_000_000;
    public static final long VALUE = 3L;

    public long range() {
        return
            LongStream.range(0, LIMIT)
                .parallel()
                .map(i -> VALUE)
                .map(i -> i % 73 % 13)
                .sum();
}

    public long ncopies() {
        return
            Collections.nCopies(LIMIT, VALUE)
                .parallelStream()
                .mapToLong(i -> i)
                .map(i -> i % 73 % 13)
                .sum();
}

这是JMH结果：（2.8GHz Core2Duo）

Benchmark                    Mode   Samples         Mean   Mean error    Units
c.s.q.SO18532488.ncopies    thrpt         5        7.547        2.904    ops/s
c.s.q.SO18532488.range      thrpt         5        0.317        0.064    ops/s

ncopies版本中存在相当大的差异，但总体而言，它似乎比range版本快20倍。（不过，我很愿意相信自己做错了。）

我对该nCopies技术的效果感到惊讶。在内部，它并没有什么特别之处，只是使用IntStream.range！来实现虚拟列表流。我曾期望有必要创建一个专门的分离器，以使其快速运行，但是看起来已经相当不错了。

为了完整性，也因为我无法帮助自己:)

仅在Java级别的冗长程度下，生成有限的常量序列与在Haskell中所看到的非常接近。

IntStream.generate(() -> 1)
         .limit(8)
         .forEach(System.out::println);

一旦将重复功能定义为

public static BiConsumer<Integer, Runnable> repeat = (n, f) -> {
    for (int i = 1; i <= n; i++)
        f.run();
};

您可以不时使用这种方式，例如：

repeat.accept(8, () -> System.out.println("Yes"));

获得并相当于Haskell的

take 8 (repeat 1)

你可以写

StringBuilder s = new StringBuilder();
repeat.accept(8, () -> s.append("1"));

这是我实现times函数的解决方案。我是一名大三学生，所以我承认这可能并不理想，我很高兴听到这是否由于任何原因都不是个好主意。

public static <T extends Object, R extends Void> R times(int count, Function<T, R> f, T t) {
    while (count > 0) {
        f.apply(t);
        count--;
    }
    return null;
}

这是一些用法示例：

Function<String, Void> greet = greeting -> {
    System.out.println(greeting);
    return null;
};

times(3, greet, "Hello World!");