อะไรคือจุดสำคัญของคลาสตัวเลือกของ Guava

ฉันเพิ่งอ่านเกี่ยวกับเรื่องนี้และเห็นคนที่ใช้คลาสนี้ แต่ในทุกกรณีการใช้งานnullจะได้ผลเช่นกัน - ถ้าไม่เข้าใจง่ายกว่านั้น ใครสามารถยกตัวอย่างที่เป็นรูปธรรมที่Optionalจะบรรลุสิ่งที่nullทำไม่ได้หรือในวิธีที่สะอาดกว่านี้ได้หรือไม่? สิ่งเดียวที่ฉันคิดได้คือใช้กับMapsที่ไม่ยอมรับnullคีย์ แต่ถึงอย่างนั้นก็ทำได้โดยใช้ "การแมป" ด้านข้างของค่า null ใครสามารถให้ข้อโต้แย้งที่น่าเชื่อถือกว่านี้แก่ฉันได้ไหม ขอขอบคุณ.

สมาชิกทีมฝรั่งนี่.

อาจเป็นข้อเสียที่ใหญ่ที่สุดเพียงข้อเดียวnullคือไม่ชัดเจนว่าควรหมายถึงอะไรในบริบทใด ๆ : ไม่มีชื่อที่เป็นภาพประกอบ ไม่ชัดเจนเสมอไปว่าnullหมายถึง "ไม่มีค่าสำหรับพารามิเตอร์นี้" ซึ่งเป็นค่าที่ส่งกลับบางครั้งหมายถึง "ข้อผิดพลาด" หรือแม้แต่ "ความสำเร็จ" (!!) หรือเพียงแค่ "คำตอบที่ถูกต้องคืออะไร" Optionalมักเป็นแนวคิดที่คุณหมายถึงเมื่อคุณทำให้ตัวแปรเป็นโมฆะ แต่ก็ไม่เสมอไป เมื่อไม่เป็นเช่นนั้นเราขอแนะนำให้คุณเขียนชั้นเรียนของคุณเองคล้ายกับOptionalแต่มีรูปแบบการตั้งชื่อที่แตกต่างกันเพื่อให้ชัดเจนว่าคุณหมายถึงอะไร

แต่ฉันจะบอกว่าข้อได้เปรียบที่ใหญ่ที่สุดของOptionalไม่ได้อยู่ในความสามารถในการอ่าน: ข้อดีคือการพิสูจน์ความงี่เง่า มันบังคับให้คุณคิดอย่างกระตือรือร้นเกี่ยวกับกรณีที่ไม่มีอยู่หากคุณต้องการให้โปรแกรมของคุณรวบรวมเลยเนื่องจากคุณต้องแกะOptionalและจัดการกับกรณีนั้นอย่างแข็งขัน Null ทำให้การลืมสิ่งต่างๆเป็นเรื่องง่ายอย่างไม่น่าเชื่อและแม้ว่า FindBugs จะช่วยได้ แต่ฉันก็ไม่คิดว่ามันจะช่วยแก้ปัญหาได้เช่นกัน สิ่งนี้มีความเกี่ยวข้องโดยเฉพาะอย่างยิ่งเมื่อคุณส่งคืนค่าที่อาจเป็น "ปัจจุบัน" หรือไม่ก็ได้ คุณ (และคนอื่น ๆ ) มีแนวโน้มที่จะลืมไปมากว่าother.method(a, b)สามารถคืนnullค่าได้มากกว่าที่คุณจะลืมซึ่งaอาจทำให้ผู้โทรลืมกรณีนั้นไม่ได้เนื่องจากพวกเขาต้องแกะวัตถุด้วยตัวเองnullother.methodเมื่อคุณกำลังดำเนินการ กลับมาOptional

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

(นี่คือเปลโดยสิ้นเชิงจากการสนทนาที่นี่ )

ดูเหมือนว่าไฟล์ Maybeลายโมนาดจาก Haskell จริงๆ

คุณควรอ่านสิ่งต่อไปนี้ Wikipedia Monad (การเขียนโปรแกรมเชิงฟังก์ชัน) :

และอ่านFrom Optional to Monad with Guavaในบล็อกของ Kerflyn ซึ่งกล่าวถึงเรื่อง Optional of Guava ที่ใช้เป็น Monad:

แก้ไข: ด้วย Java8 มีตัวเลือกในตัวที่มีตัวดำเนินการ monadic เช่นflatMap. เรื่องนี้เป็นเรื่องที่ถกเถียงกัน แต่ในที่สุดก็มีการใช้

ดูhttp://www.nurkiewicz.com/2013/08/optional-in-java-8-cheat-sheet.html

public Optional<String> tryFindSimilar(String s)  //...

Optional<Optional<String>> bad = opt.map(this::tryFindSimilar);
Optional<String> similar =       opt.flatMap(this::tryFindSimilar);

ตัวflatMapดำเนินการมีความสำคัญในการอนุญาตให้มีการดำเนินการแบบ monadic และอนุญาตให้เชื่อมโยงการเรียกที่ส่งคืนผลลัพธ์ทางเลือก

ลองคิดดูว่าถ้าคุณใช้mapโอเปอเรเตอร์ 5 ครั้งคุณจะจบลงด้วยการOptional<Optional<Optional<Optional<Optional<String>>>>>ใช้ตัวดำเนินการflatMapจะให้Optional<String>

เนื่องจาก Java8 ฉันไม่อยากใช้ Guava's Optional ซึ่งมีประสิทธิภาพน้อยกว่า

เหตุผลที่ดีอย่างหนึ่งที่จะใช้ก็คือมันทำให้ค่าว่างของคุณมีความหมายมาก แทนที่จะส่งคืนค่าว่างที่อาจมีความหมายหลายอย่าง (เช่นข้อผิดพลาดหรือความล้มเหลวหรือว่างเปล่า ฯลฯ ) คุณสามารถใส่ 'ชื่อ' เป็นค่าว่างได้ ดูตัวอย่างนี้:

ให้กำหนด POJO พื้นฐาน:

class PersonDetails {

String person;
String comments;

public PersonDetails(String person, String comments) {
    this.person = person;
    this.comments = comments;
}

public String getPerson() {
    return person;
}


public String getComments() {
    return comments;
}

}

ตอนนี้ให้ใช้ประโยชน์จาก POJO ง่ายๆนี้:

public Optional<PersonDetails> getPersonDetailstWithOptional () {

  PersonDetails details = null; /*details of the person are empty but to the caller this is meaningless,
  lets make the return value more meaningful*/


    if (details == null) {
      //return an absent here, caller can check for absent to signify details are not present
        return Optional.absent();
    } else {
      //else return the details wrapped in a guava 'optional'
        return Optional.of(details);   
    }
}

ตอนนี้ให้หลีกเลี่ยงการใช้ null และทำการตรวจสอบด้วยตัวเลือกเพื่อให้มีความหมาย

public void checkUsingOptional () {

    Optional<PersonDetails> details = getPersonDetailstWithOptional();

    /*below condition checks if persons details are present (notice we dont check if person details are null,
    we use something more meaningful. Guava optional forces this with the implementation)*/
    if (details.isPresent()) {

      PersonDetails details = details.get();

        // proceed with further processing
        logger.info(details);

    } else {
        // do nothing
        logger.info("object was null"); 
    }

    assertFalse(details.isPresent());
}

ดังนั้นในที่สุดมันก็เป็นวิธีที่จะทำให้โมฆะมีความหมายและมีความคลุมเครือน้อยลง

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

หากคุณทำให้การประชุมมีอยู่เสมอOptionalสำหรับวัตถุว่างที่เป็นไปได้คุณจะเพิ่มคำชี้แจงเพิ่มเติมให้กับกรณีต่างๆเช่น

1. Optional<Integer> maxPrime(Optional<Integer> from, Optional<Integer> to)

   สัญญาระบุไว้อย่างชัดเจนว่ามีโอกาสที่ผลลัพธ์จะไม่ถูกส่งกลับ แต่ยังแสดงให้เห็นว่าจะใช้งานได้fromและtoไม่มีอยู่

2. Optional<Integer> maxPrime(Optional<Integer> from, Integer to)

   สัญญาระบุว่า from เป็นทางเลือกดังนั้นค่าที่ไม่มีอยู่อาจมีความหมายพิเศษเช่น start from 2 ฉันคาดว่าค่า null สำหรับtoพารามิเตอร์จะทำให้เกิดข้อยกเว้น

ดังนั้นส่วนที่ดีของการใช้ตัวเลือกคือว่าสัญญาทั้งสองกลายเป็นพรรณนา (คล้ายกับ@NotNullคำอธิบายประกอบ) แต่ยังไม่เป็นทางการตั้งแต่คุณต้องเขียนโค้ดที่จะรับมือกับ.get()Optional