Java 8 เป็นวิธีที่ดีในการทำซ้ำค่าหรือฟังก์ชันหรือไม่?

ในภาษาอื่น ๆ อีกมากมายเช่น Haskell เป็นเรื่องง่ายที่จะทำซ้ำค่าหรือฟังก์ชันหลาย ๆ ครั้งเช่น เพื่อรับรายการ 8 สำเนาของค่า 1:

take 8 (repeat 1)

แต่ฉันยังไม่พบสิ่งนี้ใน Java 8 มีฟังก์ชันดังกล่าวใน JDK ของ Java 8 หรือไม่?

หรืออีกทางเลือกหนึ่งที่เทียบเท่ากับช่วงเช่น

[1..8]

ดูเหมือนว่าจะแทนที่คำสั่ง verbose ใน 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องค์ประกอบ จะสร้างรายการ "virtualized" ที่มีเฉพาะค่าและความยาวและการเรียกไปยังgetภายในช่วงจะส่งกลับค่า nCopiesวิธีการได้รับรอบตั้งแต่คอลเลกชันกรอบได้รับการแนะนำทางกลับใน JDK 1.2 แน่นอนความสามารถในการสร้างสตรีมจากผลลัพธ์ได้ถูกเพิ่มใน Java SE 8

เรื่องใหญ่อีกวิธีหนึ่งในการทำสิ่งเดียวกันในจำนวนบรรทัดเดียวกัน

แต่เทคนิคนี้จะเร็วกว่าIntStream.generateและIntStream.iterateวิธีการและที่น่าแปลกใจก็ยังเร็วกว่าIntStream.rangeวิธีการ

สำหรับiterateและgenerateผลลัพธ์อาจไม่น่าแปลกใจเกินไป เฟรมเวิร์กของสตรีม (จริงๆคือ Spliterators สำหรับสตรีมเหล่านี้) สร้างขึ้นจากสมมติฐานที่ว่า lambdas อาจสร้างค่าที่แตกต่างกันในแต่ละครั้งและจะสร้างผลลัพธ์ที่ไม่ถูกผูกมัด ทำให้การแยกขนานยากเป็นพิเศษ iterateวิธีการยังเป็นปัญหาสำหรับกรณีนี้เพราะการโทรแต่ละครั้งต้องมีผลมาจากการอย่างใดอย่างหนึ่งก่อนหน้านี้ ดังนั้นสตรีมที่ใช้generateและiterateทำได้ไม่ดีนักในการสร้างค่าคงที่ซ้ำ ๆ

ประสิทธิภาพที่ค่อนข้างแย่rangeเป็นที่น่าแปลกใจ สิ่งนี้ก็เสมือนจริงเช่นกันดังนั้นองค์ประกอบทั้งหมดจึงไม่มีอยู่ในหน่วยความจำจริง ๆ และขนาดจะถูกรู้ล่วงหน้า สิ่งนี้ควรทำให้ตัวแยกสัญญาณที่รวดเร็วและขนานกันได้ง่าย แต่น่าแปลกใจที่ทำได้ไม่ดีนัก บางทีเหตุผลก็คือrangeต้องคำนวณค่าสำหรับแต่ละองค์ประกอบของช่วงแล้วเรียกใช้ฟังก์ชัน แต่ฟังก์ชั่นนี้ไม่สนใจอินพุตของมันและส่งกลับค่าคงที่ดังนั้นฉันจึงแปลกใจที่นี่ไม่อินไลน์และถูกฆ่า

Collections.nCopiesเทคนิคมีการทำมวย / unboxing 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! ฉันคาดไว้ว่าจะต้องสร้างตัวแยกเฉพาะเพื่อให้มันทำงานได้เร็ว แต่ดูเหมือนว่าจะดีอยู่แล้ว

เพื่อความสมบูรณ์และเพราะยังช่วยตัวเองไม่ได้ :)

การสร้างลำดับค่าคงที่ จำกัด นั้นค่อนข้างใกล้เคียงกับสิ่งที่คุณเห็นใน 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"));

นี่คือวิธีแก้ปัญหาของฉันในการใช้ฟังก์ชัน 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!");