O Java 8 oferece uma boa maneira de repetir um valor ou função?

Em muitas outras línguas, por exemplo. Haskell, é fácil repetir um valor ou função várias vezes, por exemplo. para obter uma lista de 8 cópias do valor 1:

take 8 (repeat 1)

mas ainda não encontrei isso no Java 8. Essa função existe no JDK do Java 8?

Ou, alternativamente, algo equivalente a um intervalo como

[1..8]

Pareceria um substituto óbvio para uma instrução detalhada em Java como

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

ter algo como

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

embora este exemplo particular não pareça muito mais conciso na verdade ... mas espero que seja mais legível.

Para este exemplo específico, você poderia fazer:

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

Se precisar de uma etapa diferente de 1, você pode usar uma função de mapeamento, por exemplo, para uma etapa de 2:

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

Ou crie uma iteração personalizada e limite o tamanho da iteração:

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

Aqui está outra técnica que usei outro dia:

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

A Collections.nCopieschamada cria um Listcontendo ncópias de qualquer valor que você fornece. Nesse caso, é o Integervalor 1 na caixa . É claro que, na verdade, ele não cria uma lista com nelementos; ele cria uma lista "virtualizada" que contém apenas o valor e o comprimento, e qualquer chamada para getdentro do intervalo apenas retorna o valor. onCopies método existe desde que o Collections Framework foi introduzido no JDK 1.2. Obviamente, a capacidade de criar um fluxo a partir de seu resultado foi adicionada ao Java SE 8.

Grande coisa, outra maneira de fazer a mesma coisa com aproximadamente o mesmo número de linhas.

No entanto, esta técnica é mais rápido do que o IntStream.generatee IntStream.iteratese aproxima e, surpreendentemente, é também mais rápido do que a IntStream.rangeabordagem.

Pois iteratee generateo resultado talvez não seja muito surpreendente. A estrutura de fluxos (na verdade, os divisores para esses fluxos) é construída na suposição de que os lambdas irão potencialmente gerar valores diferentes a cada vez e que eles irão gerar um número ilimitado de resultados. Isso torna a divisão paralela particularmente difícil. O iteratemétodo também é problemático para este caso porque cada chamada requer o resultado da anterior. Portanto, os fluxos usando generatee iteratenão funcionam muito bem para gerar constantes repetidas.

O desempenho relativamente baixo de rangeé surpreendente. Isso também é virtualizado, de modo que nem todos os elementos existem realmente na memória e o tamanho é conhecido desde o início. Isso deve resultar em um divisor de fácil paralelização rápido e fácil. Mas, surpreendentemente, não foi muito bem. Talvez a razão seja que rangetem que calcular um valor para cada elemento do intervalo e então chamar uma função sobre ele. Mas essa função simplesmente ignora sua entrada e retorna uma constante, então estou surpreso que isso não seja embutido e eliminado.

A Collections.nCopiestécnica tem que fazer boxing / unboxing para lidar com os valores, já que não existem especializações primitivas de List. Como o valor é o mesmo todas as vezes, é basicamente embalado uma vez e essa caixa é compartilhada por todas as ncópias. Eu suspeito que o boxing / unboxing é altamente otimizado, até mesmo intrinsecado, e pode ser bem embutido.

Aqui está o código:

    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();
}

E aqui estão os resultados do JMH: (2.8 GHz 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

Existe uma grande variação na versão ncopies, mas no geral parece confortavelmente 20x mais rápida do que a versão range. (Eu estaria bastante disposto a acreditar que fiz algo errado, no entanto.)

Estou surpreso com o quão bem a nCopiestécnica funciona. Internamente, ele não faz muita coisa especial, com o fluxo da lista virtualizada simplesmente sendo implementado usando IntStream.range! Eu esperava que fosse necessário criar um divisor especializado para fazer isso funcionar rápido, mas já parece estar muito bom.

Para ser completo, e também porque não pude evitar :)

Gerar uma sequência limitada de constantes é bastante próximo ao que você veria em Haskell, apenas com detalhamento de nível Java.

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

Uma vez que uma função de repetição é definida em algum lugar como

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

Você pode usá-lo de vez em quando desta forma, por exemplo:

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

Para obter e equivalente ao de Haskell

take 8 (repeat 1)

Você poderia escrever

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

Esta é minha solução para implementar a função de tempos. Sou um júnior, então admito que não seria o ideal, ficaria feliz em saber se isso não é uma boa ideia por qualquer motivo.

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;
}

Aqui estão alguns exemplos de uso:

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

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