Предоставляет ли Java 8 хороший способ повторить значение или функцию?

На многих других языках, например. Haskell, легко повторить значение или функцию несколько раз, например. чтобы получить список из 8 копий значения 1:

take 8 (repeat 1)

но я еще не нашел этого в Java 8. Есть ли такая функция в JDK Java 8?

Или, альтернативно, что-то эквивалентное диапазону вроде

[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метод существует с тех пор, как Collections Framework был представлен еще в JDK 1.2. Конечно, в Java SE 8 была добавлена ​​возможность создавать поток из его результата.

Подумайте, еще один способ сделать то же самое примерно с таким же количеством строк.

Однако, этот метод быстрее IntStream.generateи IntStream.iterateподходы, и удивительно, это также быстрее , чем IntStream.rangeподход.

Для iterateи generateрезультат может быть , не слишком удивительно. Структура потоков (на самом деле, разделители для этих потоков) построена на предположении, что лямбда-выражения потенциально будут генерировать разные значения каждый раз и что они будут генерировать неограниченное количество результатов. Это особенно затрудняет параллельное разделение. 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: (Core2Duo 2,8 ГГц)

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 есть немало различий, но в целом она кажется в 20 раз быстрее, чем версия диапазона. (Хотя мне бы хотелось поверить, что я сделал что-то не так.)

Я удивлен, насколько хорошо nCopiesработает эта техника. Внутри он не делает ничего особенного, поток виртуализированного списка просто реализуется с помощью IntStream.range! Я ожидал, что потребуется создать специализированный сплитератор, чтобы все работало быстро, но это уже кажется неплохим.

Для полноты, а также потому, что я ничего не мог с собой поделать :)

Генерация ограниченной последовательности констант довольно близка к тому, что вы видели бы в Haskell, только с детализацией уровня Java.

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's

take 8 (repeat 1)

Вы могли написать

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

Это мое решение для реализации функции времени. Я юниор, поэтому признаю, что это могло быть не идеально, я был бы рад услышать, если это не лучшая идея по какой-либо причине.

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!");