Apakah Java SE 8 memiliki Pairs atau Tuples?

Saya bermain-main dengan operasi fungsional yang malas di Java SE 8, dan saya ingin mapindeks iuntuk pasangan / tuple (i, value[i]), kemudian filterberdasarkan pada value[i]elemen kedua , dan akhirnya hanya output indeks.

Haruskah saya tetap menderita ini: Apa yang setara dengan C ++ Pair <L, R> di Jawa? di era baru lambda dan aliran yang berani?

Pembaruan: Saya menyajikan contoh yang agak disederhanakan, yang memiliki solusi rapi yang ditawarkan oleh @dkatzel di salah satu jawaban di bawah ini. Namun, itu tidak menyamaratakan. Karena itu, izinkan saya menambahkan contoh yang lebih umum:

package com.example.test;

import java.util.ArrayList;
import java.util.stream.IntStream;

public class Main {

  public static void main(String[] args) {
    boolean [][] directed_acyclic_graph = new boolean[][]{
        {false,  true, false,  true, false,  true},
        {false, false, false,  true, false,  true},
        {false, false, false,  true, false,  true},
        {false, false, false, false, false,  true},
        {false, false, false, false, false,  true},
        {false, false, false, false, false, false}
    };

    System.out.println(
        IntStream.range(0, directed_acyclic_graph.length)
        .parallel()
        .mapToLong(i -> IntStream.range(0, directed_acyclic_graph[i].length)
            .filter(j -> directed_acyclic_graph[j][i])
            .count()
        )
        .filter(n -> n == 0)
        .collect(() -> new ArrayList<Long>(), (c, e) -> c.add(e), (c1, c2) -> c1.addAll(c2))
    );
  }

}

Ini memberikan output yang salah[0, 0, 0] yang sesuai dengan jumlah untuk tiga kolom yang semuanya false. Yang saya butuhkan adalah indeks dari tiga kolom ini. Output yang benar seharusnya [0, 2, 4]. Bagaimana saya bisa mendapatkan hasil ini?

UPDATE: Jawaban ini sebagai tanggapan terhadap pertanyaan awal, Apakah Java SE 8 memiliki Pasangan atau Tuple? (Dan secara implisit, jika tidak, mengapa tidak?) OP telah memperbarui pertanyaan dengan contoh yang lebih lengkap, tetapi sepertinya itu dapat diselesaikan tanpa menggunakan struktur Pair. [Catatan dari OP: inilah jawaban yang benar .]

Jawaban singkatnya adalah tidak. Anda harus menggulung sendiri atau membawa salah satu dari beberapa perpustakaan yang mengimplementasikannya.

Memiliki Pairkelas di Jawa SE diusulkan dan ditolak setidaknya sekali. Lihat utas diskusi ini di salah satu milis OpenJDK. Pengorbanannya tidak jelas. Di satu sisi, ada banyak implementasi Pair di perpustakaan lain dan dalam kode aplikasi. Itu menunjukkan kebutuhan, dan menambahkan kelas seperti itu ke Java SE akan meningkatkan penggunaan kembali dan berbagi. Di sisi lain, memiliki kelas Pair menambah godaan untuk menciptakan struktur data yang rumit dari Pasangan dan koleksi tanpa membuat jenis dan abstraksi yang diperlukan. (Itu adalah parafrase dari pesan Kevin Bourillion dari utas itu.)

Saya sarankan semua orang membaca seluruh utas email itu. Ini sangat berwawasan dan tidak memiliki kerusakan. Cukup meyakinkan. Ketika mulai, saya berpikir, "Ya, seharusnya ada kelas Pair di Java SE" tetapi pada saat thread mencapai akhirnya saya telah berubah pikiran.

Perhatikan bahwa JavaFX memiliki kelas javafx.util.Pair . API JavaFX berevolusi secara terpisah dari Java SE API.

Seperti yang dapat dilihat dari pertanyaan terkait Apa persamaan dari C ++ Pair in Java? ada ruang desain yang cukup besar di sekitar apa yang tampaknya seperti API sederhana. Haruskah benda tidak berubah? Haruskah mereka serial? Haruskah mereka sebanding? Haruskah kelasnya final atau tidak? Haruskah kedua elemen dipesan? Haruskah itu antarmuka atau kelas? Mengapa berhenti berpasangan? Mengapa tidak tiga kali lipat, paha depan, atau N-tupel?

Dan tentu saja ada penamaan yang tak terhindarkan bikeshed untuk elemen:

• (a, b)
• (pertama kedua)
• (kiri kanan)
• (mobil, cdr)
• (foo, bar)
• dll.

Satu masalah besar yang hampir tidak disebutkan adalah hubungan Pasangan dengan primitif. Jika Anda memiliki (int x, int y)datum yang mewakili titik dalam ruang 2D, mewakili ini sebagai Pair<Integer, Integer>mengkonsumsi tiga objek, bukan dua kata 32-bit. Selanjutnya, benda-benda ini harus berada di heap dan akan dikenakan overhead GC.

Tampak jelas bahwa, seperti Streams, penting untuk ada spesialisasi primitif untuk Pasangan. Apakah kita ingin melihat:

Pair
ObjIntPair
ObjLongPair
ObjDoublePair
IntObjPair
IntIntPair
IntLongPair
IntDoublePair
LongObjPair
LongIntPair
LongLongPair
LongDoublePair
DoubleObjPair
DoubleIntPair
DoubleLongPair
DoubleDoublePair

Bahkan sebuah IntIntPairmasih akan membutuhkan satu objek di heap.

Ini, tentu saja, mengingatkan pada proliferasi antarmuka fungsional dalam java.util.functionpaket di Java SE 8. Jika Anda tidak ingin API kembung, yang mana yang akan Anda tinggalkan? Anda juga bisa berpendapat bahwa ini tidak cukup, dan bahwa spesialisasi untuk, katakanlah, Booleanharus ditambahkan juga.

Perasaan saya adalah bahwa jika Java telah menambahkan kelas Pair sejak lama, itu akan menjadi sederhana, atau bahkan sederhana, dan itu tidak akan memuaskan banyak kasus penggunaan yang kita bayangkan sekarang. Pertimbangkan bahwa jika Pair telah ditambahkan dalam kerangka waktu JDK 1.0, itu mungkin akan bisa berubah! (Lihatlah java.util.Date.) Apakah orang akan senang dengan itu? Dugaan saya adalah bahwa jika ada kelas Pair di Jawa, itu akan menjadi semacam-agak-tidak-benar-berguna dan semua orang masih akan bergulir sendiri untuk memenuhi kebutuhan mereka, akan ada berbagai implementasi Pair dan Tuple di perpustakaan eksternal, dan orang-orang masih akan berdebat / berdiskusi tentang cara memperbaiki kelas Pasangan Jawa. Dengan kata lain, jenis di tempat yang sama kita di hari ini.

Sementara itu, beberapa pekerjaan sedang berlangsung untuk mengatasi masalah mendasar, yang merupakan dukungan yang lebih baik dalam JVM (dan akhirnya bahasa Jawa) untuk tipe nilai . Lihat dokumen Status Nilai ini . Ini adalah pekerjaan pendahuluan dan spekulatif, dan hanya membahas masalah dari perspektif JVM, tetapi sudah ada cukup banyak pemikiran di baliknya. Tentu saja tidak ada jaminan bahwa ini akan masuk ke Java 9, atau pernah masuk ke mana saja, tetapi hal itu menunjukkan arah pemikiran saat ini tentang topik ini.

Anda dapat melihat kelas bawaan ini:

• AbstractMap.SimpleEntry
• AbstractMap.SimpleImmutableEntry

Sayangnya, Java 8 tidak memperkenalkan pasangan atau tupel. Anda selalu dapat menggunakan org.apache.commons.lang3.tuple tentu saja (yang secara pribadi saya gunakan dalam kombinasi dengan Java 8) atau Anda dapat membuat pembungkus sendiri. Atau gunakan Maps. Atau hal-hal seperti itu, seperti dijelaskan dalam jawaban yang diterima untuk pertanyaan yang Anda tautkan.

PEMBARUAN: JDK 14 memperkenalkan catatan sebagai fitur pratinjau. Ini bukan tupel, tetapi dapat digunakan untuk menyimpan banyak masalah yang sama. Dalam contoh spesifik Anda dari atas, itu bisa terlihat seperti ini:

public class Jdk14Example {
    record CountForIndex(int index, long count) {}

    public static void main(String[] args) {
        boolean [][] directed_acyclic_graph = new boolean[][]{
                {false,  true, false,  true, false,  true},
                {false, false, false,  true, false,  true},
                {false, false, false,  true, false,  true},
                {false, false, false, false, false,  true},
                {false, false, false, false, false,  true},
                {false, false, false, false, false, false}
        };

        System.out.println(
                IntStream.range(0, directed_acyclic_graph.length)
                        .parallel()
                        .mapToObj(i -> {
                            long count = IntStream.range(0, directed_acyclic_graph[i].length)
                                            .filter(j -> directed_acyclic_graph[j][i])
                                            .count();
                            return new CountForIndex(i, count);
                        }
                        )
                        .filter(n -> n.count == 0)
                        .collect(() -> new ArrayList<CountForIndex>(), (c, e) -> c.add(e), (c1, c2) -> c1.addAll(c2))
        );
    }
}

Ketika dikompilasi dan dijalankan dengan JDK 14 (pada saat penulisan, ini merupakan akses awal) menggunakan --enable-previewflag, Anda mendapatkan hasil berikut:

[CountForIndex[index=0, count=0], CountForIndex[index=2, count=0], CountForIndex[index=4, count=0]]

Tampaknya contoh lengkap dapat diselesaikan tanpa menggunakan segala jenis struktur Pair. Kuncinya adalah menyaring indeks kolom, dengan predikat memeriksa seluruh kolom, alih-alih memetakan indeks kolom ke jumlah falseentri dalam kolom itu.

Kode yang melakukan ini ada di sini:

    System.out.println(
        IntStream.range(0, acyclic_graph.length)
            .filter(i -> IntStream.range(0, acyclic_graph.length)
                                  .noneMatch(j -> acyclic_graph[j][i]))
            .boxed()
            .collect(toList()));

Ini menghasilkan output [0, 2, 4]yang saya pikir hasil yang benar diminta oleh OP.

Perhatikan juga boxed()operasi yang mengotakkan intnilai ke dalam Integerobjek. Ini memungkinkan seseorang untuk menggunakan toList()kolektor yang sudah ada alih-alih harus menulis fungsi kolektor yang melakukan tinju sendiri.

Vavr (sebelumnya disebut Javaslang) ( http://www.vavr.io ) juga menyediakan tupel (hingga ukuran 8). Inilah javadoc: https://static.javadoc.io/io.vavr/vavr/0.9.0/io/vavr/Tuple.html .

Ini adalah contoh sederhana:

Tuple2<Integer, String> entry = Tuple.of(1, "A");

Integer key = entry._1;
String value = entry._2;

Mengapa JDK sendiri tidak datang dengan jenis tuple yang sederhana sampai sekarang adalah misteri bagi saya. Menulis kelas bungkus tampaknya menjadi bisnis setiap hari.

Sejak Java 9, Anda dapat membuat instance yang Map.Entrylebih mudah daripada sebelumnya:

Entry<Integer, String> pair = Map.entry(1, "a");

Map.entrymengembalikan yang tidak dapat dimodifikasi Entrydan melarang nulls.

Karena Anda hanya peduli pada indeks, Anda tidak perlu memetakan ke tuple sama sekali. Mengapa tidak menulis filter yang menggunakan elemen pencarian di array Anda?

     int[] value =  ...


IntStream.range(0, value.length)
            .filter(i -> value[i] > 30)  //or whatever filter you want
            .forEach(i -> System.out.println(i));

Iya.

Map.Entrydapat digunakan sebagai Pair.

Sayangnya itu tidak membantu dengan stream Java 8 karena masalahnya adalah bahwa meskipun lambdas dapat mengambil beberapa argumen, bahasa Java hanya memungkinkan untuk mengembalikan nilai tunggal (objek atau tipe primitif). Ini menyiratkan bahwa setiap kali Anda memiliki aliran Anda berakhir dengan dilewatkan satu objek dari operasi sebelumnya. Ini adalah kekurangan dalam bahasa Java, karena jika beberapa nilai balik didukung DAN stream mendukung mereka, kita bisa memiliki tugas non-sepele yang jauh lebih baik dilakukan oleh stream.

Sampai saat itu, hanya ada sedikit kegunaan.

EDIT 2018-02-12: Saat mengerjakan proyek saya menulis kelas pembantu yang membantu menangani kasus khusus memiliki pengidentifikasi sebelumnya dalam aliran yang Anda butuhkan di lain waktu tetapi bagian aliran di antara tidak tahu tentang itu. Sampai saya sempat merilis sendiri, itu tersedia di IdValue.java dengan unit test di IdValueTest.java

Eclipse Collections memiliki Pairdan semua kombinasi Pasangan primitif / objek (untuk semua delapan primitif).

The Tuplespabrik dapat membuat contoh Pair, dan PrimitiveTuplespabrik dapat digunakan untuk membuat semua kombinasi dari primitif pasang / objek.

Kami menambahkan ini sebelum Java 8 dirilis. Mereka berguna untuk mengimplementasikan key / value Iterators untuk peta primitif kami, yang kami juga dukung di semua kombinasi primitif / objek.

Jika Anda ingin menambahkan overhead perpustakaan tambahan, Anda dapat menggunakan solusi yang diterima Stuart dan mengumpulkan hasilnya menjadi primitif IntListuntuk menghindari tinju. Kami menambahkan metode baru di Eclipse Collections 9.0 untuk memungkinkan Int/Long/Doublekoleksi dibuat dari Int/Long/DoubleStreams.

IntList list = IntLists.mutable.withAll(intStream);

Catatan: Saya pengendara untuk Eclipse Collections.