ทำไม Java String จึงไม่มีวิธีการจัดการสตริงแบบคงที่

ทำไมนักออกแบบ Javaไม่สร้างวิธีการจัดการสตริงแบบคงที่ในjava.lang.Stringคลาส? วิธีการต่อไปนี้เป็นสิ่งที่ฉันอ้างถึง แต่คำถามสามารถขยายไปยังวิธีการไม่คงที่อื่น ๆ ในชั้นเรียนเช่นกัน

concat(String)                        substring(int, int)
replace(char, char)                   toLowerCase()
replace(CharSequence, CharSequence)   toLowerCase(Locale)
replaceAll(String, String)            toString()
replaceFirst(String, String)          toUpperCase()
split(String)                         toUpperCase(Locale)
split(String, int)                    trim()
substring(int)

การมีวิธีการเหล่านี้ในเวอร์ชันที่ไม่คงที่เท่านั้นจะบังคับให้มีการตรวจสอบ Null อย่างชัดเจนไม่ว่าที่ใดก็ต้องเรียกใช้ ยกตัวอย่างเช่นเพียงแค่โทรexample = example.trim()จะนำไปสู่NullPointerExceptionString example = nullถ้า ดังนั้นโปรแกรมเมอร์จะต้องทำการตรวจสอบ boilerplate null ต่อไปนี้:

if (example != null)
    example = example.trim();
// OR:
example = (example==null) ? null : example.trim();
example = (example==null) ? null : example.substring(5);

ฉันคิดว่ามันจะสะดวกกว่านี้มากหากStringมีวิธีคงที่ของเวอร์ชันเหล่านี้ (อาจเป็นแบบเฉพาะ ) ซึ่งจะใช้สตริงอินพุตเป็นอาร์กิวเมนต์แรก:

example = String.trim(example);
example = String.replace(example, 'a', 'b');
example = String.substring(example, 5);

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

ทำไมนักออกแบบ Java ไม่คิดเรื่องนี้เมื่อพวกเขาออกแบบStringคลาสใน Java 1 หรือ Java 2 หรือแม้แต่เพิ่มฟังก์ชั่นดังกล่าวใน Java เวอร์ชันที่ใหม่กว่า?

การกลับมาเป็นโมฆะทำให้ฉันมีเหตุผลตั้งแต่จัดการกับสตริง null ควรส่งผลให้เป็นสตริงว่างไม่ใช่ข้อผิดพลาด

นั่นคือความคิดเห็นของคุณ คนอื่นอาจโต้แย้งว่าการดำเนินการของสตริงบนวัตถุที่เป็นโมฆะซึ่งไม่ได้มีสตริงที่ไม่มีเหตุผลและควรโยนข้อยกเว้น

เหตุใด "นักออกแบบ Java" จึงทำหรือไม่ทำสิ่งที่ยากเกินกว่าจะทำได้

มีไลบรารีอยู่แล้วซึ่งสามารถทำการดำเนินการกับสตริงแบบ null-safe ได้เช่นStringUtilsของ Apache Commons คุณสามารถใช้มันหรือไลบรารีที่คล้ายกันได้หากคุณต้องการ

นอกจากนี้ขึ้นอยู่กับความคิดเห็นของคุณ

การอ่านความคิดเห็นดูเหมือนว่าปัญหาที่แท้จริงที่คุณเผชิญคือคุณต้องตรวจสอบnullรหัสของคุณทั้งหมด นั่นอาจเป็นตัวบ่งชี้การออกแบบโปรแกรมที่ไม่ดีโดยไม่มีสัญญาที่ชัดเจนระหว่างอินเตอร์เฟส คุณอาจต้องการอ่านคำสั่งหลีกเลี่ยง“! = null” ใน Java?

IMO ทั้งหมด "ถ้าหาเรื่องเป็นโมฆะคืนโมฆะ" วิธีการเขียนโดยไม่จำเป็นต้องเพิ่มความซับซ้อนของวงจรของโปรแกรม

Java libs ก่อนหน้านี้ใช้วิธีส่งคืน null แต่กลุ่ม JDK จะป้องกัน null ด้วยข้อยกเว้นเสมอ

เมื่อเวลาผ่านไปฉันคิดว่าวิธีการหลังได้ออกมาเป็นผู้ชนะที่ชัดเจน

ทำไม? เนื่องจากเขตข้อมูลว่างจะทำลายหลักการจำนวนมาก คุณไม่สามารถปฏิบัติต่อพวกเขาในฐานะสมาชิกของคลาส polymorphic ซึ่งหมายความว่าคุณต้องเขียนโค้ดกรณีพิเศษให้เป็นโมฆะและด้วยเหตุนี้ความซับซ้อนในวงจรของคุณจึงสูงขึ้นเมื่อคุณต้องสมมติว่าสิ่งต่าง ๆ เป็นโมฆะ

เพื่อแก้ไขปัญหาของคุณให้พิจารณาใช้รูปแบบวัตถุ null แทนการใช้เขตข้อมูล null

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

เช่นถ้าคุณต้องการ Stings.toUpper (ป้อนข้อมูลสตริง) โค้ดสำหรับการเขียนนั้นง่าย แต่ถ้าคุณต้องการ instance.toUpper และสิ่งที่คุณมีคือ String.toUpper ดีนั่นเป็นไปไม่ได้ ... เว้นแต่พวกเขาจะแนะนำวิธีการขยาย ซึ่งเป็นไปได้มากว่าไม่ได้พิจารณาในเวลานั้น

ใน java สตริงนั้นเป็นวัตถุ นั่นเป็นตัวเลือกการออกแบบ

การอ้างอิงวัตถุสามารถเป็นโมฆะและเป็นโมฆะหากไม่มีการกำหนดวัตถุให้ ถ้าคุณเรียกใช้วัตถุดังกล่าว NullPointerException จะถูกส่งออกไป นั่นเป็นพฤติกรรมที่เป็นมาตรฐาน

นักออกแบบ Java เลือกที่จะมีสตริงเป็นวัตถุและมีวิธีการเหล่านั้นที่มีข้อยกเว้น null-pointer คือสิ่งที่คุณได้รับหากคุณต้องการให้สตริงเป็นวัตถุ

ทำไมนักออกแบบ Java ไม่คิดเรื่องนี้เมื่อพวกเขาออกแบบคลาส String ใน Java 1 หรือ Java 2 หรือแม้แต่เพิ่มฟังก์ชันการทำงานดังกล่าวในเวอร์ชัน Java ในภายหลัง

พวกเขาอาจคิดเกี่ยวกับมันและเลือกที่จะรวมพฤติกรรม oo