Java SE 8'de Çiftler veya Tuples var mı?

Java SE 8'de tembel fonksiyonel işlemler ile oynuyorum ve bir çift / tuple için mapbir indeks istiyorumi(i, value[i]) , sonra filterikinci value[i]elemente dayanıyorum ve nihayet sadece endeksler çıktı istiyorum.

Hala acı çekmeliyim: Java C + + Pair <L, R> eşdeğeri nedir?lambdas ve akarsuların cesur yeni döneminde?

Güncelleme: Aşağıdaki cevaplardan birinde @dkatzel tarafından sunulan temiz bir çözümü olan oldukça basitleştirilmiş bir örnek sundum. Ancak, yok değil genelleme. Bu nedenle, daha genel bir örnek ekleyeyim:

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

}

Bu , tümü üç sütun için sayılara karşılık gelen yanlış çıktı verir . İhtiyacım olan bu üç sütunun endeksleridir . Doğru çıktı olmalıdır . Bu sonucu nasıl alabilirim?[0, 0, 0]false[0, 2, 4]

GÜNCELLEME: Bu yanıt asıl soruya yanıt niteliğinde, Java SE 8'in Çiftleri veya Tuples'i var mı? (Ve örtük olarak, değilse, neden olmasın?) OP soruyu daha eksiksiz bir örnekle güncelledi, ancak herhangi bir Çifti yapısı kullanılmadan çözülebileceği anlaşılıyor. [OP'den not: İşte diğer doğru cevap .]

Kısa cevap hayır. Ya kendi başınıza dönmeli ya da onu uygulayan birkaç kütüphaneden birini getirmelisiniz.

Sahip olmak PairJava SE'de sınıfa en az bir kez önerildi ve reddedildi. OpenJDK posta listelerinden birinde bu tartışma konusuna bakın . Ödünleşmeler açık değildir. Bir yandan, diğer kütüphanelerde ve uygulama kodunda birçok Pair uygulaması vardır. Bu bir ihtiyaç olduğunu gösterir ve Java SE'ye böyle bir sınıf eklemek yeniden kullanımı ve paylaşımı artıracaktır. Öte yandan, bir Pair sınıfına sahip olmak, gerekli tür ve soyutlamaları yaratmadan Çiftler ve koleksiyonlardan karmaşık veri yapıları yaratma cazibesine katkıda bulunur. (Bu Kevin Bourillion'un mesajından çıkan mesajın bir açıklamasıdır .)

Herkesin tüm e-posta dizisini okumasını tavsiye ederim. Oldukça içgörüseldir ve hiçbir parlaması yoktur. Oldukça inandırıcı. Başladığında, "Evet, Java SE'de bir Pair sınıfı olmalı" diye düşündüm, ancak iş parçacığının sonuna geldiğinde fikrimi değiştirdim.

Ancak JavaFX'in javafx.util.Pair sınıfına . JavaFX'in API'leri, Java SE API'lerinden ayrı olarak gelişti.

Bağlantılı sorudan görebileceğiniz gibi Java C ++ Çifti eşdeğeri nedir? görünüşte bu kadar basit bir API'yi çevreleyen oldukça geniş bir tasarım alanı var. Nesneler değişmez mi olmalı? Serileştirilebilir olmalı mı? Karşılaştırılabilir mi? Sınıf final mi olmalı yoksa değil mi? İki unsur sipariş edilmeli mi? Bir arayüz mü yoksa sınıf mı olmalı? Neden çiftler halinde durmalıyız? Neden üçlü, dörtlü veya N-tuples olmasın?

Ve elbette elementler için kaçınılmaz adlandırma var:

• (a, b)
• (birinci, ikinci)
• (sol sağ)
• (araba, cdr)
• (foo, bar)
• vb.

Bahsedilen büyük bir mesele, Çiftlerin ilkellerle olan ilişkisidir. (int x, int y)2B alanda bir noktayı temsil eden bir referans noktanız varsa, bunu iki 32 bit sözcük yerine üç nesnePair<Integer, Integer> tüketir . Ayrıca, bu nesneler öbek üzerinde bulunmalı ve GC yüküne neden olacaktır.

Akımlar gibi, Çiftler için ilkel uzmanlaşmaların olması gerektiği açıktır. Görmek ister miyiz:

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

Bir IntIntPairyığın bile hala bir nesne gerektirir.

Bunlar elbette, java.util.functionJava SE 8'deki paketteki fonksiyonel arayüzlerin çoğalmasını anımsatıyor. Şişirilmiş bir API istemiyorsanız, hangilerini dışarıda bırakacaksınız? Bunun yeterli olmadığını ve uzmanlık alanlarının,Boolean da ekleneceğini .

Benim düşüncem, Java uzun bir süre önce bir Pair sınıfı ekleseydi, basit ya da basit olurdu ve şu anda öngördüğümüz birçok kullanım örneğini tatmin etmeyecekti. Çifti JDK 1.0 zaman dilimine eklenmiş olsaydı, muhtemelen değişebilir olurdu! (Bkz. Java.util.Date.) İnsanlar bundan memnun olur muydu? Tahminimce, Java'da bir Pair sınıfı olsaydı, bu tür-gerçekten-kullanışlı olmazdı ve herkes hala ihtiyaçlarını karşılamak için kendi başlarına dönecek, dış kütüphanelerde çeşitli Pair ve Tuple uygulamaları olacaktı, ve insanlar hala Java'nın Pair sınıfını nasıl düzelteceklerini tartışıyor / tartışıyorlardı. Başka bir deyişle, bugün bulunduğumuz yerde.

Bu arada, JVM'de (ve nihayetinde Java dilinde) değer türleri için daha iyi destek olan temel sorunu ele almak için bazı çalışmalar devam etmektedir . Bu Değerlerin Durumu belgesine bakın. Bu ön, spekülatif çalışmadır ve sadece JVM perspektifinden meseleleri kapsar, ancak zaten arkasında oldukça fazla düşünce vardır. Elbette bunun Java 9'a gireceği veya herhangi bir yere gireceği konusunda hiçbir garanti yoktur, ancak bu konuyla ilgili mevcut düşünme yönünü gösterir.

Bu yerleşik sınıflara bir göz atabilirsiniz:

• AbstractMap.SimpleEntry
• AbstractMap.SimpleImmutableEntry

Ne yazık ki, Java 8 çiftler veya tuples getirmedi. Her zaman org.apache.commons.lang3.tuple kullanabilirsiniz (ki şahsen Java 8 ile birlikte kullanıyorum) veya kendi paketleyicilerinizi oluşturabilirsiniz. Veya Google Haritalar'ı kullanın. Ya da bağlandığınız bu sorunun kabul edilen cevabında açıklandığı gibi bunun gibi şeyler .

GÜNCELLEME: JDK 14, kayıtları bir önizleme özelliği olarak sunar. Bunlar tuples değil, aynı sorunların çoğunu kurtarmak için kullanılabilir. Yukarıdaki özel örneğinizde, bu şöyle görünebilir:

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

Bayrağını kullanarak JDK 14 (yazma sırasında, bu bir erken erişim derlemesi) ile derlendiğinde ve çalıştırıldığında --enable-preview, aşağıdaki sonucu alırsınız:

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

Görünüşe göre tam örnek, herhangi bir Pair yapısı kullanılmadan çözülebilir. Anahtar, sütun dizinlerini falseo sütundaki giriş sayısı ile eşlemek yerine, tüm sütunu kontrol ederek, sütun dizinlerini filtrelemektir .

Bunu yapan kod burada:

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

Bu sonuç çıktı [0, 2, 4]hangi OP tarafından istenen doğru sonuç olduğunu düşünüyorum.

Ayrıca değerleri nesnelere boxed()kutulama işlemini de not edin . Bu , boksu yapan toplayıcı işlevlerini yazmak yerine önceden var olan toplayıcıyı kullanabilmenizi sağlar .intIntegertoList()

Vavr (eski adıyla Javaslang) ( http://www.vavr.io ) da tuples (8 büyüklüğünde) sağlar. İşte javadoc: https://static.javadoc.io/io.vavr/vavr/0.9.0/io/vavr/Tuple.html .

Bu basit bir örnek:

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

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

JDK'nın neden şimdiye kadar basit bir tür tuple ile gelmediği benim için bir gizem. Paketleyici sınıfları yazmak her gün yapılan bir iş gibi görünüyor.

Java 9'dan bu yana, Map.Entryöncekinden daha kolay örnekler oluşturabilirsiniz :

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

Map.entrydeğiştirilemez döndürür Entryve null'ları yasaklar.

Yalnızca dizinleri önemsediğiniz için, gruplarla eşlemenize gerek yoktur. Neden sadece dizinizdeki arama öğelerini kullanan bir filtre yazmıyorsunuz?

     int[] value =  ...


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

Evet.

Map.Entryolarak kullanılabilir Pair.

Ne yazık ki, Java 8 akışlarına yardımcı olmuyor çünkü lambdas birden fazla argüman alabilse de, Java dili sadece tek bir değer (nesne veya ilkel tip) döndürmeye izin veriyor. Bu, bir akışınız olduğunda, önceki işlemden tek bir nesne geçirmeniz anlamına gelir. Bu, Java dilinde bir eksikliktir, çünkü birden fazla dönüş değeri destekleniyorsa ve akışlar bunları destekliyorsa, akışlar tarafından yapılan çok daha güzel önemsiz olmayan görevler alabiliriz.

O zamana kadar, sadece çok az kullanım var.

EDIT 2018-02-12: Bir proje üzerinde çalışırken, daha sonra ihtiyacınız olan akışta daha önce bir tanımlayıcıya sahip olmanın özel durumunun ele alınmasına yardımcı olan bir yardımcı sınıf yazdım, ancak aradaki akış kısmı bunu bilmiyor. Tek başına serbest bırakana kadar IdValue.java'da IdValueTest.java'da birim testi ile kullanılabilir.

Eclipse Koleksiyonlarında Pairve ilkel / nesne Çiftlerinin tüm kombinasyonları vardır (sekiz ilkel için de).

TuplesFabrika örneklerini oluşturabilir PairvePrimitiveTuples fabrika ilkel / nesne çiftleri tüm kombinasyonlarını oluşturmak için kullanılabilir.

Bunları Java 8 yayınlanmadan önce ekledik. Tüm ilkel / nesne kombinasyonlarında da desteklediğimiz ilkel haritalarımız için anahtar / değer Yineleyicileri uygulamakta faydalı oldular.

Ekstra kütüphane yükünü eklemek istiyorsanız, Stuart'ın kabul edilen çözümünü kullanabilir ve IntListbokstan kaçınmak için sonuçları ilkel olarak toplayabilirsiniz . AkışlardanInt/Long/Double koleksiyonların oluşturulmasına izin vermek için Eclipse Collections 9.0'a yeni yöntemler ekledik Int/Long/Double.

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

Not: Eclipse Collections için bir komisyoncuyum.