ส่งกลับค่าหลายค่าจากวิธี Java: เหตุใดจึงไม่มีวัตถุ n-tuple

ฉันถือว่า OP หมายถึง "เหตุใด Java จึงไม่รองรับวัตถุ n-tuple" Python, Haskell, Lisp, ML ฯลฯ มีความสามารถ n-tuple ที่ต่างกัน บ่อยครั้งที่ความสามารถในการส่งคืนอ็อบเจ็กต์หลายรายการในภาษาหนึ่ง ๆ นั้นเป็นน้ำตาลเชิงวากยสัมพันธ์ (เช่นใน python return 'a', 'b')

เหตุผลก็คือการออกแบบภาษาและความสม่ำเสมอ Java ชอบความชัดเจนมากและไม่ชอบโครงสร้างข้อมูลที่ไม่เปิดเผยตัวตน (แม้ว่าฉันหวังว่าเราจะมีการปิดแบบไม่ระบุชื่อก็ตาม)

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

IMHO แม้ว่ามันจะน่ารำคาญ แต่ฉันมักจะต่อสู้กับปัญหานี้ด้วยการสร้างคลาสอินไลน์แบบคงที่:

private static class Combo {
   String name;
   int weight;
}

ใช่ มันน่าเบื่อ แต่หลังจากนั้นฉันมักจะนำมาใช้ซ้ำและปรับโครงสร้างคลาสเหล่านั้นใหม่ ทำให้คลาสเหล่านั้นอยู่ในระดับสูงสุดและเพิ่มพฤติกรรม ข้อดีอย่างหนึ่งของการไปในเส้นทางนี้คือ การเพิ่มฟิลด์ใหม่ง่ายกว่ามาก โดยที่โครงสร้างข้อมูลที่ไม่ระบุชื่อ (เช่นในภาษา FP) ทำให้การเพิ่มฟิลด์ยากขึ้นมาก (ท้ายที่สุดคุณต้องเปลี่ยนโค้ดจำนวนมาก)

ฉันควรทราบว่าสำหรับ 2-tuples บางคนใช้ (หรือใช้ในทางที่ผิด) java.util.Map.Entry เนื่องจากมี java.util.AbstractMap.SimpleEntry ใน Java 6 นอกจากนี้ บางคนยังใช้ การสนับสนุนการจับคู่ของ Commons Lang3 (2-tuple)

Scala มีการสนับสนุน n-tuple โดยการเรียงลำดับของการโกงและมีอินเทอร์เฟซ tuple 2-16 ชุดที่เป็นมาตรฐานในภาษาและถูกซ่อนทางวากยสัมพันธ์จากโปรแกรมเมอร์

ด้วยเหตุผลด้านการศึกษาเพียงอย่างเดียว คุณอาจต้องการดูว่า ภาษาอื่นๆ บรรลุเป้าหมายนี้ได้อย่างไร

อัปเดต: สำหรับ Java 8

Java 8 จะ/อาจจะ (ดังนั้นนี่คือหมายเลขของฉัน... โทรหาฉันหน่อยสิ) รองรับอินเทอร์เฟซที่เรียกว่า java.lang.BiValue ด้วยการใช้งานที่เป็นรูปธรรมที่คุณสามารถใช้ได้ที่เรียกว่า java.lang.BiVal คลาสเหล่านี้มีไว้เพื่อช่วยสนับสนุนฟังก์ชันแลมบ์ดาใหม่ แต่สังเกตว่านี่เป็นเพียงสิ่งอันดับ 2 เท่านั้น

อัปเดต: สำหรับปี 2015

Java 8 ไม่ ได้รับการสนับสนุนสำหรับสิ่งอันดับ

อัปเดต: จากผู้เขียนปี 2015

หากคุณยังคงต้องการการสนับสนุน tuple มีไลบรารีสามแห่งที่รองรับ tuple ได้ดี:

• javatuples - รองรับ JDK 5 ขึ้นไป มากถึง 10 สิ่ง
• JOOλ - จากผู้เขียน jOOQ แต่ต้องใช้ JDK 8
• Commons Lang 3 - ขณะนี้รองรับ Triple (3-tuple) และรองรับ JDK 6 และ ข้างบน.

วิธีการ Java ส่งคืนค่าศูนย์หรือค่าเดียว นั่น คือ มาตรฐานสำหรับ java หากคุณต้องการส่งคืนค่าหลายค่า ให้สร้างออบเจ็กต์ที่มีหลายค่าแล้วส่งคืน

หากคุณต้องการส่งคืนวัตถุสองชิ้น คุณมักจะต้องการส่งคืนวัตถุเดียวที่ห่อหุ้มวัตถุทั้งสองแทน

มีวิธีที่แฮ็กได้หลายวิธีในการบรรลุเป้าหมายนี้ วิธีหนึ่งคือการส่งคืน Object[] แต่เมื่อคุณมีดัชนีที่ต้องกังวล และการตรวจสอบตัวชี้ค่าว่าง มันก็น่ารังเกียจ อีกวิธีหนึ่งคือการส่งคืน String แต่คุณต้องแยกวิเคราะห์มัน และมันก็น่ารังเกียจ

ฉันคิดว่าคำถามที่แท้จริงคือทำไม

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

เขียนวิธีการของคุณโดยมีความรับผิดชอบเพียงอย่างเดียว หากพวกเขาต้องการส่งคืนข้อมูลมากกว่าที่พวกเขาสามารถทำได้ คุณควรใช้ object หรือแยกออกเป็นวิธีการที่เล็กลง

มีรูปแบบรูปแบบใหม่ให้เลือกใช้งาน และสอดคล้องกับลักษณะ "อะซิงโครนัสทั้งหมด" ที่คุณอาจพบเห็นในภาษาต่างๆ เช่น JavaScript

ทุกวันนี้รหัสของฉันมีลักษณะเช่นนี้ :-)

public class Class1 {

    public interface Callback {
       void setData(String item1, String item2);
    }
    public void getThing(Callback callback) {
        callback.setData("a", "b");
    }
}

public class Class2 {

    public void doWithThing(Class1 o) {
        o.getThing(new Class1.Callback() {
            public void setData(String item1, String item2) {
                ... do something with item 1 and item 2 ...
            }
        });
    }

}

ไม่มีวัตถุใหม่ที่จะสร้างและมีคลาสพิเศษไม่มากนักเนื่องจากอินเทอร์เฟซเป็นคลาสภายในของวัตถุ

นี่คือสิ่งที่ทำให้ Swift ยอดเยี่ยมมาก รหัสอาจมีลักษณะดังนี้:

o.getThing({ item1, item2 -> Void in
    ... do something with item 1 and item 2 ...
});

และเนื่องจากข้อโต้แย้งเพียงอย่างเดียวคือบล็อก แม้แต่สิ่งนี้:

o.getThing { item1, item2 -> Void in
    ... do something with item 1 and item 2 ...
};

Java ต้องการการปรับปรุงเพื่อทำให้โค้ดที่รับภาระในการเรียกกลับอ่านง่ายขึ้นมาก

เนื่องจากการส่งคืนค่าหลายค่าจากวิธีการหนึ่งๆ ไม่ใช่แนวทางปฏิบัติที่แนะนำ (ใน Java)

หากคุณต้องการค่าที่ไม่เกี่ยวข้องจากวิธีการ คุณต้องมีโครงสร้างข้อมูลที่แตกต่างกัน เช่น วัตถุที่มีค่าเหล่านั้น หากคุณต้องการหลายอินสแตนซ์ของคลาสเดียวกัน (เช่น หลาย Strings ) คุณจะต้องส่งคืนอาร์เรย์หรือคอลเลกชันบางส่วนขึ้นอยู่กับความต้องการของคุณ

การส่งกลับค่าหลายค่าในภาษาอื่น ( Go for instance ) ใช้สำหรับอินสแตนซ์เพื่อส่งคืนรหัสข้อผิดพลาด แต่ Java ได้รับการออกแบบให้แตกต่างออกไปโดยใช้ข้อยกเว้น