Java SE 8 มีคู่หรือ Tuples หรือไม่

ฉันกำลังเล่นกับการทำงานที่ขี้เกียจใน Java SE 8 และฉันต้องการmapดัชนีiไปเป็นคู่ / tuple (i, value[i])จากนั้นfilterขึ้นอยู่กับvalue[i]องค์ประกอบที่สองและสุดท้ายก็ส่งออกดัชนี

ฉันต้องยังคงประสบกับสิ่งนี้: อะไรคือสิ่งที่เทียบเท่าของ C ++ Pair <L, R> ใน Java? ในยุคใหม่ที่กล้าหาญของ lambdas และลำธาร?

อัปเดต:ฉันนำเสนอตัวอย่างที่ค่อนข้างง่ายซึ่งมีโซลูชันที่นำเสนออย่างประณีตโดย @dkatzel ในหนึ่งในคำตอบด้านล่าง อย่างไรก็ตามมันไม่ได้พูดคุยกัน ดังนั้นให้ฉันเพิ่มตัวอย่างทั่วไปมากขึ้น:

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

}

นี้จะช่วยให้ไม่ถูกต้องการส่งออกของ[0, 0, 0]ซึ่งสอดคล้องกับการนับfalseสำหรับคอลัมน์ที่สามที่มีทั้งหมด สิ่งที่ฉันต้องการคือดัชนีของคอลัมน์ทั้งสามนี้ [0, 2, 4]เอาท์พุทที่ถูกต้องควรจะเป็น ฉันจะรับผลลัพธ์นี้ได้อย่างไร

UPDATE:คำตอบนี้เป็นการตอบคำถามเดิมJava SE 8 มีคู่หรือ Tuples หรือไม่? (และโดยปริยายถ้าไม่ใช่ทำไมไม่?) OP ได้อัปเดตคำถามด้วยตัวอย่างที่สมบูรณ์มากขึ้น แต่ดูเหมือนว่ามันจะสามารถแก้ไขได้โดยไม่ต้องใช้โครงสร้าง Pair ใด ๆ [หมายเหตุจาก OP: นี่คือคำตอบที่ถูกต้องอื่น ๆ ]

คำตอบสั้น ๆ คือไม่ คุณต้องม้วนตัวเองหรือนำหนึ่งในหลาย ๆ ไลบรารีที่นำมาใช้

มีPairคลาสใน Java SE ถูกเสนอและปฏิเสธอย่างน้อยหนึ่งครั้ง ดูหัวข้อสนทนานี้ในหนึ่งในรายชื่อผู้รับจดหมาย OpenJDK การแลกเปลี่ยนไม่ชัดเจน ในอีกด้านหนึ่งมีการใช้งาน Pair มากมายในไลบรารี่อื่นและในโค้ดแอปพลิเคชัน นั่นแสดงให้เห็นถึงความต้องการและการเพิ่มคลาสดังกล่าวใน Java SE จะเพิ่มการใช้ซ้ำและการแบ่งปัน ในทางกลับกันการมีคลาส Pair เพิ่มการล่อลวงในการสร้างโครงสร้างข้อมูลที่ซับซ้อนจากคู่และคอลเลกชันโดยไม่ต้องสร้างประเภทและบทคัดย่อที่จำเป็น (นั่นเป็นการถอดความข้อความของKevin Bourillionจากหัวข้อนั้น)

ฉันขอแนะนำให้ทุกคนอ่านกระทู้อีเมลทั้งหมด มันฉลาดอย่างน่าทึ่งและไม่มีความเสียหาย มันค่อนข้างน่าเชื่อถือ เมื่อมันเริ่มฉันคิดว่า "ใช่ควรจะมีคลาส Pair ใน Java SE" แต่เมื่อถึงเวลาที่เธรดจะสิ้นสุดฉันก็เปลี่ยนใจ

โปรดทราบว่า JavaFX มีคลาสjavafx.util.Pair API ของ JavaFX วิวัฒนาการมาแยกจาก Java SE API

อย่างที่เราเห็นได้จากคำถามที่เชื่อมโยงอะไรคือคู่ของ C ++ Pair ใน Java? มีพื้นที่การออกแบบค่อนข้างใหญ่โดยรอบสิ่งที่เห็นได้ชัดคือ API อย่างง่าย วัตถุควรจะไม่เปลี่ยนรูปหรือไม่ ควรจะเป็นแบบอนุกรมหรือไม่ พวกเขาควรจะเทียบเคียง? ชั้นเรียนควรจะเป็นที่สิ้นสุดหรือไม่? ควรสั่งทั้งสององค์ประกอบหรือไม่ มันควรจะเป็นอินเทอร์เฟซหรือคลาสหรือไม่ หยุดที่คู่ทำไม ทำไมไม่ลองเล่นสามคนสี่คนหรือ N-tuples ล่ะ?

และแน่นอนว่ามีการตั้งชื่อ bikeshed สำหรับองค์ประกอบ:

• (a, b)
• (ครั้งแรกที่สอง)
• (ซ้ายขวา)
• (รถยนต์, cdr)
• (foo บาร์)
• เป็นต้น

ประเด็นสำคัญข้อหนึ่งที่แทบจะไม่ได้กล่าวถึงคือความสัมพันธ์ของคู่กับสิ่งดั้งเดิม หากคุณมี(int x, int y)ตัวเลขที่แสดงถึงจุดในพื้นที่ 2 มิติการแสดงสิ่งนี้เป็นการPair<Integer, Integer>ใช้วัตถุสามชิ้นแทนคำ 32 บิตสองคำ นอกจากนี้วัตถุเหล่านี้จะต้องอยู่บนกองและจะมีค่าใช้จ่าย GC

ดูเหมือนจะชัดเจนว่าเช่นสตรีมมันเป็นสิ่งจำเป็นที่จะต้องมีความเชี่ยวชาญดั้งเดิมสำหรับคู่ เราต้องการดู:

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

แม้แต่IntIntPairวัตถุยังต้องการวัตถุหนึ่งบนกอง

แน่นอนว่าสิ่งเหล่านี้ทำให้นึกถึงการเพิ่มขึ้นของอินเทอร์เฟซการทำงานในjava.util.functionแพ็คเกจใน Java SE 8 หากคุณไม่ต้องการ API แบบ bloated สิ่งที่คุณจะทิ้งไว้? คุณอาจโต้เถียงว่าสิ่งนี้ยังไม่เพียงพอและBooleanควรเพิ่มความเชี่ยวชาญเฉพาะด้านเช่นกัน

ความรู้สึกของฉันคือถ้า Java ได้เพิ่มคลาส Pair นานมาแล้วมันอาจจะง่ายหรือแม้แต่เรียบง่ายและมันก็จะไม่เป็นที่พอใจกับกรณีการใช้งานหลายอย่างที่เรามองเห็นในตอนนี้ พิจารณาว่าถ้า Pair ถูกเพิ่มเข้ามาในกรอบเวลาของ JDK 1.0 มันอาจจะไม่แน่นอน! (ดูที่ java.util.Date.) ผู้คนจะมีความสุขกับสิ่งนั้นหรือไม่? ฉันเดาว่าถ้ามีคลาส Pair ใน Java จะเป็น kinda-sort-not- ไม่เป็นประโยชน์จริง ๆ และทุกคนจะยังคงกลิ้งของตัวเองเพื่อตอบสนองความต้องการของพวกเขาจะมีการใช้งาน Pair และ Tuple ในไลบรารีภายนอก และผู้คนก็ยังคงเถียงกัน / พูดคุยเกี่ยวกับวิธีการแก้ไขคลาส Pair ของ Java กล่าวอีกอย่างหนึ่งก็คือเราอยู่ในที่เดียวกัน

ในขณะเดียวกันการทำงานบางอย่างที่เกิดขึ้นเพื่อแก้ไขปัญหาพื้นฐานซึ่งเป็นการสนับสนุนที่ดีใน JVM (และในที่สุดภาษา Java) สำหรับประเภทค่า ดูเอกสารสถานะของค่านี้ นี่เป็นงานเบื้องต้นงานเก็งกำไรและครอบคลุมเฉพาะประเด็นจากมุมมอง JVM แต่มีความคิดอยู่เบื้องหลังพอสมควร แน่นอนไม่มีการรับประกันว่าสิ่งนี้จะเข้าสู่ Java 9 หรือเข้าที่ใดก็ได้ แต่มันแสดงให้เห็นทิศทางของการคิดในปัจจุบันในหัวข้อนี้

คุณสามารถดูคลาสที่มีอยู่ภายในเหล่านี้ได้:

• AbstractMap.SimpleEntry
• AbstractMap.SimpleImmutableEntry

น่าเสียดายที่ Java 8 ไม่ได้แนะนำคู่หรือสิ่งอันดับ คุณสามารถใช้org.apache.commons.lang3.tuple ได้ตลอดเวลา (ซึ่งโดยส่วนตัวฉันใช้ร่วมกับ Java 8) หรือคุณสามารถสร้าง wrappers ของคุณเองได้ หรือใช้ Maps หรืออะไรทำนองนั้นตามที่อธิบายไว้ในคำตอบที่ยอมรับสำหรับคำถามที่คุณเชื่อมโยง

UPDATE: JDK 14 กำลังแนะนำระเบียนเป็นคุณลักษณะแสดงตัวอย่าง สิ่งเหล่านี้ไม่ใช่สิ่งอันดับ แต่สามารถใช้เพื่อบันทึกปัญหาเดียวกันหลายประการ ในตัวอย่างเฉพาะของคุณจากด้านบนอาจมีลักษณะดังนี้:

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

เมื่อคอมไพล์และรันด้วยJDK 14 (ณ เวลาที่เขียนนี่เป็นการสร้างการเข้าถึงก่อนหน้า) โดยใช้--enable-previewแฟล็กคุณจะได้รับผลลัพธ์ต่อไปนี้:

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

ปรากฏว่าตัวอย่างทั้งหมดสามารถแก้ไขได้โดยไม่ต้องใช้โครงสร้าง Pair ใด ๆ กุญแจสำคัญคือการกรองในดัชนีคอลัมน์ด้วยเพรดิเคตตรวจสอบคอลัมน์ทั้งหมดแทนการแมปดัชนีคอลัมน์กับจำนวนfalseรายการในคอลัมน์นั้น

รหัสที่ทำนี่คือที่นี่:

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

ผลลัพธ์นี้เป็นผลลัพธ์[0, 2, 4]ซึ่งฉันคิดว่าผลลัพธ์ที่ถูกต้องที่ร้องขอโดย OP

นอกจากนี้ยังทราบการboxed()ดำเนินการที่กล่องintค่าลงในIntegerวัตถุ สิ่งนี้ทำให้ผู้ใช้สามารถใช้ตัวtoList()สะสมที่มีอยู่แล้วแทนที่จะต้องเขียนฟังก์ชันตัวสะสมที่ทำมวยเอง

Vavr (เดิมชื่อ Javaslang) ( http://www.vavr.io ) มี tuples (ขนาด til เท่ากับ 8) เช่นกัน นี่คือ Javadoc นี้: https://static.javadoc.io/io.vavr/vavr/0.9.0/io/vavr/Tuple.html

นี่คือตัวอย่างง่ายๆ:

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

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

ทำไม JDK เองถึงไม่มาพร้อมกับ tuples แบบง่าย ๆ ตอนนี้เป็นเรื่องลึกลับสำหรับฉัน การเขียนคลาส wrapper ดูเหมือนจะเป็นธุรกิจทุกวัน

ตั้งแต่ Java 9 คุณสามารถสร้างอินสแตนซ์Map.Entryได้ง่ายกว่าที่เคยมีมา:

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

Map.entryส่งคืนค่า unmodifiable Entryและห้ามเป็นโมฆะ

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

     int[] value =  ...


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

ใช่.

Map.EntryPairสามารถนำมาใช้เป็น

น่าเสียดายที่มันไม่ได้ช่วยสตรีม Java 8 เนื่องจากปัญหาคือแม้ว่า lambdas สามารถรับอาร์กิวเมนต์ได้หลายภาษา แต่ภาษา Java อนุญาตให้ส่งคืนค่าเดียวเท่านั้น (วัตถุหรือชนิดดั้งเดิม) นี่ก็หมายความว่าเมื่อใดก็ตามที่คุณมีกระแสคุณท้ายด้วยการผ่านวัตถุเดียวจากการดำเนินการก่อนหน้านี้ นี่คือการขาดในภาษาจาวาเพราะถ้าหลายค่าตอบแทนได้รับการสนับสนุนและกระแสสนับสนุนพวกเขาเราอาจมีงานที่ไม่ใช่เรื่องเล็ก ๆ น้อย ๆ ที่ทำโดยลำธาร

จนกว่าจะถึงวันนั้นจะมีการใช้เพียงเล็กน้อยเท่านั้น

แก้ไข 2018-02-12: ในขณะที่ทำงานในโครงการฉันเขียนคลาสผู้ช่วยเหลือซึ่งช่วยจัดการกรณีพิเศษของการมีตัวระบุก่อนหน้านี้ในสตรีมที่คุณต้องการในภายหลัง แต่ส่วนสตรีมในระหว่างไม่ทราบเกี่ยวกับเรื่องนี้ จนกว่าฉันจะได้รับการปล่อยตัวด้วยตัวมันเองก็มีให้ที่IdValue.javaด้วยการทดสอบหน่วยที่IdValueTest.java

Eclipse Collections มีPairและการรวมกันของคู่ดั้งเดิม / วัตถุคู่ (สำหรับทั้งแปดดั้งเดิม)

Tuplesโรงงานสามารถสร้างอินสแตนซ์PairและPrimitiveTuplesโรงงานสามารถใช้ในการสร้างชุดทั้งหมดของดั้งเดิม / คู่วัตถุ

เราเพิ่มสิ่งเหล่านี้ก่อนที่จะปล่อย Java 8 มันมีประโยชน์ในการใช้ Iterators คีย์ / ค่าสำหรับแผนที่ดั้งเดิมของเราซึ่งเรายังสนับสนุนในการรวมกันของวัตถุ / ดั้งเดิมทั้งหมด

หากคุณยินดีที่จะเพิ่มค่าใช้จ่ายห้องสมุดพิเศษคุณสามารถใช้วิธีการแก้ปัญหาที่ได้รับการยอมรับของ Stuart และรวบรวมผลลัพธ์เป็นแบบดั้งเดิมIntListเพื่อหลีกเลี่ยงการชกมวย เราได้เพิ่มวิธีการใหม่ในEclipse Collections 9.0เพื่ออนุญาตให้Int/Long/Doubleสร้างคอลเลกชันจากInt/Long/DoubleStreams

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

หมายเหตุ: ฉันเป็นคอมมิชชันสำหรับ Eclipse Collections