Apakah Java 8 menyediakan cara yang baik untuk mengulang nilai atau fungsi?

Dalam banyak bahasa lain, mis. Haskell, sangat mudah untuk mengulang nilai atau fungsi beberapa kali, misalnya. untuk mendapatkan daftar 8 salinan dari nilai 1:

take 8 (repeat 1)

tapi saya belum menemukan ini di Java 8. Apakah ada fungsi seperti itu di JDK Java 8?

Atau sebagai alternatif sesuatu yang setara dengan rentang seperti

[1..8]

Tampaknya ini adalah pengganti yang jelas untuk pernyataan verbose di Java seperti

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

untuk memiliki sesuatu seperti

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

meskipun contoh khusus ini sebenarnya tidak terlihat lebih ringkas ... tapi semoga lebih mudah dibaca.

Untuk contoh khusus ini, Anda dapat melakukan:

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

Jika Anda memerlukan langkah yang berbeda dari 1, Anda dapat menggunakan fungsi pemetaan, misalnya, untuk langkah 2:

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

Atau buat iterasi khusus dan batasi ukuran iterasi:

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

Inilah teknik lain yang saya lakukan beberapa hari yang lalu:

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

The Collections.nCopiespanggilan menciptakan Listmengandung nsalinan dari nilai apa pun yang Anda berikan. Dalam hal ini nilai kotaknya Integer1. Tentu saja itu tidak benar-benar membuat daftar dengan nelemen; itu membuat daftar "tervirtualisasi" yang hanya berisi nilai dan panjang, dan setiap panggilan ke getdalam jangkauan hanya mengembalikan nilai. The nCopiesMetode telah ada sejak Koleksi Kerangka diperkenalkan kembali dengan cara di JDK 1.2. Tentu saja, kemampuan untuk membuat aliran dari hasilnya ditambahkan di Java SE 8.

Masalah besar, cara lain untuk melakukan hal yang sama di sekitar jumlah baris yang sama.

Namun, teknik ini lebih cepat dari IntStream.generatedan IntStream.iteratependekatan, dan mengejutkan, itu juga lebih cepat dari IntStream.rangependekatan.

Untuk iterate dan generatehasilnya mungkin tidak terlalu mengejutkan. Kerangka aliran (sebenarnya, Pemisah untuk aliran ini) dibangun dengan asumsi bahwa lambda akan berpotensi menghasilkan nilai yang berbeda setiap saat, dan bahwa mereka akan menghasilkan jumlah hasil yang tidak terbatas. Hal ini membuat pemisahan paralel menjadi sulit. The iterateMetode juga bermasalah untuk kasus ini karena setiap panggilan membutuhkan hasil dari yang sebelumnya. Jadi aliran menggunakan generatedan iteratetidak melakukannya dengan baik untuk menghasilkan konstanta berulang.

Kinerja yang relatif buruk rangecukup mengejutkan. Ini juga tervirtualisasi, jadi elemen sebenarnya tidak semuanya ada di memori, dan ukurannya diketahui sebelumnya. Ini akan membuat spliterator yang cepat dan mudah diparalelkan. Tapi secara mengejutkan tidak berhasil dengan baik. Mungkin alasannya adalah karena rangeharus menghitung nilai untuk setiap elemen rentang dan kemudian memanggil fungsi di atasnya. Tapi fungsi ini mengabaikan inputnya dan mengembalikan konstanta, jadi saya terkejut ini tidak sebaris dan mati.

The Collections.nCopiesTeknik hubungannya tinju / pembukaan kemasan untuk menangani nilai-nilai, karena tidak ada spesialisasi primitif List. Karena nilainya adalah sama setiap kali, pada dasarnya dikotak sekali dan kotak itu dibagikan oleh semua nsalinan. Saya menduga tinju / unboxing sangat dioptimalkan, bahkan diintrinsifikasi, dan dapat disisipkan dengan baik.

Berikut kodenya:

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

Dan berikut adalah hasil 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

Ada cukup banyak variasi dalam versi ncopies, tetapi secara keseluruhan tampaknya nyaman 20x lebih cepat daripada versi range. (Namun, saya akan sangat bersedia untuk percaya bahwa saya telah melakukan sesuatu yang salah.)

Saya terkejut melihat seberapa baik nCopiesteknik ini bekerja. Secara internal itu tidak terlalu istimewa, dengan aliran daftar virtual yang hanya diimplementasikan menggunakan IntStream.range! Saya berharap akan perlu membuat spliterator khusus agar ini bekerja dengan cepat, tetapi tampaknya sudah cukup bagus.

Untuk kelengkapan, dan juga karena saya tidak bisa menahan diri :)

Menghasilkan urutan konstanta terbatas cukup mirip dengan apa yang akan Anda lihat di Haskell, hanya dengan verboseness level Java.

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

Setelah fungsi berulang di suatu tempat didefinisikan sebagai

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

Anda dapat menggunakannya sesekali dengan cara ini, misalnya:

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

Untuk mendapatkan dan setara dengan Haskell's

take 8 (repeat 1)

Anda bisa menulis

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

Ini adalah solusi saya untuk mengimplementasikan fungsi waktu. Saya seorang junior jadi saya akui itu tidak ideal, saya akan senang mendengar jika ini bukan ide yang baik untuk alasan apa pun.

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

Berikut beberapa contoh penggunaan:

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

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