17. ยกตัวอย่างการใช้งาน Optional ที่ประสบความสำเร็จและไม่สำเร็จ
สมมติว่าเรามีชุดของค่าบางอย่างที่เราใช้ในการสตรีมและในที่สุดเราก็ได้รับตัวเลือก บางอย่าง ตามผลลัพธ์:Optional<String> stringOptional = Stream.of("a", "ab", "abc", "abcd")
.filter(str -> str.length() >= 3)
.findAny();
ตามที่คาดไว้ เรา จำเป็นต้องได้รับค่าจากOptional นี้ การใช้get()เป็นวิธีที่ไม่ดี:
String result = stringOptional.get();
แต่วิธีนี้ควรจะรับค่าจากOptionalแล้วกลับมาให้เราหรือเปล่า? แน่นอนว่านี่เป็นเรื่องจริงแต่ถ้ามันมีความหมาย ถ้าค่าในสตรีมแตกต่างกันและในที่สุดเราได้รับค่าว่างOptionalเมื่อเราพยายามรับค่าจากนั้นโดยใช้ เมธอด get() สิ่งต่อไปนี้ จะถูกโยนทิ้ง: 
-
String result = null; if (stringOptional.isPresent()) { stringOptional.get(); }
ในกรณีนี้ เรากำลังตรวจสอบเพื่อดูว่าองค์ประกอบนั้นอยู่ในOptional หรือ ไม่ ถ้าไม่เช่นนั้น สตริงผลลัพธ์จะมีค่าเดิม
-
String result = stringOptional.orElse("default value");
ในกรณี นี้เราจะระบุค่าเริ่มต้น ซึ่งจะกำหนดให้กับสตริงผลลัพธ์ในกรณีของค่าว่างOptional
-
String result = stringOptional.orElseThrow(() -> new CustomException());
ในกรณีนี้ เราเองโยนข้อยกเว้นเมื่อOptional ว่าง เปล่า

18. เป็นไปได้ไหมที่จะประกาศวิธีหลักเป็นที่สิ้นสุด?
ใช่ ไม่มีอะไรขัดขวางเราจากการประกาศเมธอดmain()ว่าเป็นFinal คอมไพเลอร์จะไม่สร้างข้อผิดพลาด แต่ควรจำไว้ว่าวิธีการใด ๆ หลังจากประกาศว่าเป็น ขั้น สุดท้ายจะกลายเป็นวิธีสุดท้าย - ไม่ถูกแทนที่ แม้ว่าใครจะกำหนดหลักใหม่ ???
19. เป็นไปได้ไหมที่จะนำเข้าแพ็คเกจ/คลาสเดียวกันสองครั้ง? ผลที่ตามมาคืออะไร?
ใช่คุณสามารถ. ผลที่ตามมา? เราจะมีการนำเข้าที่ไม่จำเป็นสองสามรายการที่ Intelijj IDEA จะแสดงเป็นสีเทา เช่น ไม่ได้ใช้

20. การแคสต์คืออะไร? เมื่อใดที่เราจะได้รับ ClassCastException
การหล่อหรือการหล่อแบบเป็นกระบวนการของการแปลงประเภทข้อมูลหนึ่งไปเป็นประเภทข้อมูลอื่น: ด้วยตนเอง (การหล่อโดยนัย) หรือโดยอัตโนมัติ (การหล่อประเภทที่ชัดเจน)
int value = 17;
double convertedValue = value;
อย่างที่คุณเห็น ไม่ จำเป็นต้อง ดำเนินการใดๆ เพิ่มเติมนอกจาก เครื่องหมาย = ที่นี่ ตัวอย่างการหล่อแบบแมนนวลประเภทดั้งเดิม:
double value = 17.89;
int convertedValue = (int)value;
ในกรณีนี้ เราสามารถสังเกตการร่ายแบบแมนนวลได้ ซึ่งใช้งานโดยใช้(int) โดยที่ส่วน ที่อยู่หลังเครื่องหมายจุลภาคจะถูกละทิ้งและค่าที่แปลงแล้วจะมีค่าเป็น - 17 อ่านเพิ่มเติมเกี่ยวกับการหล่อประเภทดั้งเดิมในบทความนี้ ทีนี้เรามาดูวัตถุกันดีกว่า ประเภทการอ้างอิง สำหรับประเภทการอ้างอิงการแคสต์อัตโนมัติสามารถทำได้สำหรับคลาสสืบทอดไปจนถึงคลาสพาเรนต์ สิ่งนี้เรียกว่าความหลากหลาย สมมติว่าเรามีคลาสLionที่สืบทอดมาจาก คลาส Cat ในกรณีนี้ การแปลงอัตโนมัติจะมีลักษณะดังนี้:
Cat cat = new Lion();
แต่ด้วยนักแสดงที่ชัดเจนทุกอย่างค่อนข้างซับซ้อนกว่า เนื่องจากไม่มีฟังก์ชันสำหรับตัดส่วนเกินออก เช่นเดียวกับแบบดั้งเดิม และเพียงทำการแปลงแบบฟอร์มอย่างชัดเจน:
Lion lion= (Lion)new Cat();
คุณจะได้รับข้อผิดพลาด: 
Lion lion = new Lion();
Cat cat = lion;
Lion newLion = (Lion)cat;
นอกจากนี้ เพื่อความน่าเชื่อถือที่มากขึ้น แนะนำให้แคบลงสำหรับวัตถุโดยใช้instanceOf build :
if (cat instanceof Lion) {
newLion = (Lion)new Cat();
}
อ่านเพิ่มเติมเกี่ยวกับประเภทการอ้างอิงในบทความนี้
21. เหตุใดกรอบงานสมัยใหม่จึงใช้เฉพาะข้อยกเว้นที่ไม่ได้ตรวจสอบเป็นหลัก?
ฉันคิดว่าทั้งหมดนี้เป็นเพราะการจัดการ ข้อยกเว้น ที่ตรวจสอบแล้วยังคงเป็นโค้ดสปาเก็ตตี้ที่ทำซ้ำทุกที่ แต่ไม่จำเป็นจริงๆ ในทุกกรณี
22. การนำเข้าแบบคงที่คืออะไร?
เมื่อใช้ข้อมูลคงที่ (วิธีการ, ตัวแปร) คุณไม่สามารถสร้างวัตถุได้เอง แต่ทำได้โดยใช้ชื่อของคลาส แต่ในกรณีนี้เราจำเป็นต้องมีการอ้างอิงถึงคลาส ทุกอย่างเป็นเรื่องง่าย: มันถูกเพิ่มโดยใช้การนำเข้าปกติ แต่ถ้าเราไปใช้วิธีแบบคงที่โดยไม่ต้องเขียนชื่อคลาสราวกับว่ามันเป็นวิธีการแบบคงที่ของคลาสปัจจุบันล่ะ? สิ่งนี้เป็นไปได้ด้วยการนำเข้าแบบคงที่! ในกรณีนี้ เราต้องเขียนการนำเข้าแบบคงที่และลิงก์ไปยังวิธีการนั้น ตัวอย่างเช่น วิธีการคงที่ของ คลาส Mathสำหรับการคำนวณค่าโคไซน์:import static java.lang.Math.cos;
เป็นผลให้เราสามารถใช้เมธอดได้โดยไม่ต้องระบุชื่อคลาส:
double result = cos(60);
นอกจากนี้เรายังสามารถโหลดวิธีการคงที่ทั้งหมดของคลาสได้ในครั้งเดียวโดยใช้การนำเข้าแบบคงที่:
import static java.lang.Math.*;

23. ความสัมพันธ์ระหว่างเมธอด hashCode() และเท่ากับ() คืออะไร?
ตามข้อมูลของOracleกฎคือ: หากสองวัตถุเท่ากัน (เช่น เมธอด เท่ากับ ()ส่งคืนtrue ) ทั้งสองจะต้องมีรหัสแฮชเดียวกัน ในเวลาเดียวกัน อย่าลืมว่าวัตถุสองชิ้นที่แตกต่างกันสามารถมีรหัสแฮชเดียวกันได้ เพื่อให้เข้าใจว่าเหตุใดเท่ากับ()และhashCode()จึงถูกแทนที่เป็นคู่เสมอ ให้พิจารณากรณีต่อไปนี้:-
ทั้งสองวิธีถูกแทนที่
ในกรณีนี้ ออบเจ็กต์สองรายการที่มีสถานะภายในเหมือนกันจะส่งกลับค่าเท่ากับ() - trueในขณะที่hashCode()จะส่งกลับตัวเลขเดียวกันทั้งคู่
ปรากฎว่าทุกอย่างเรียบร้อยดีเพราะกำลังปฏิบัติตามกฎ
-
ทั้งสองวิธีไม่ได้ถูกแทนที่
ในกรณีนี้ ออบเจ็กต์ที่แตกต่างกันสองรายการที่มีสถานะภายในเหมือนกันจะส่งคืนค่าเท็จ เมื่อ เท่ากับ()เนื่องจากการเปรียบเทียบจะทำโดยการอ้างอิงผ่าน ตัวดำเนิน การ==
เมธอดhashCode()จะส่งกลับค่าที่แตกต่างกัน (เป็นไปได้มากที่สุด) เนื่องจากจะสร้างค่าที่แปลงแล้วของที่อยู่ตำแหน่งหน่วยความจำ แต่สำหรับวัตถุเดียวกัน ค่านี้จะเท่ากัน เช่นเดียวกับที่เท่ากับ()ในกรณีนี้จะส่งคืนค่าจริงเฉพาะเมื่อการอ้างอิงชี้ไปที่วัตถุเดียวกัน
ปรากฎว่าในกรณีนี้ทุกอย่างเรียบร้อยดีและปฏิบัติตามกฎแล้ว
-
แทนที่เท่ากับ()ไม่แทนที่hashCode( )
ในกรณีนี้ สำหรับอ็อบเจ็กต์ที่แตกต่างกันสองรายการที่มีสถานะภายในเหมือนกันเท่ากับ()จะส่งกลับค่าจริงและhashCode()จะส่งกลับค่าที่ต่างกัน (โดยมาก)
นี่เป็นการละเมิดกฎดังนั้นจึงไม่แนะนำให้ทำเช่นนี้
-
เท่ากับ()ไม่ถูกแทนที่, hashCode() ถูก แทนที่
ในกรณีนี้ สำหรับอ็อบเจ็กต์สองรายการที่มีสถานะภายในเหมือนกันเท่ากับ ()จะส่งคืนค่าเท็จและhashCode()จะส่งกลับค่าเดียวกัน
มีการละเมิดกฎจึงแนวทางไม่ถูกต้อง

24. คลาส BufferedInputStream และ BufferedOutputStream ถูกใช้เมื่อใด
InputStreamใช้เพื่ออ่านข้อมูลแบบไบต์ต่อไบต์จากทรัพยากรบางส่วน และOutputStreamใช้เพื่อเขียนข้อมูลแบบไบต์-ไบต์ แต่การดำเนินการแบบไบต์ต่อไบต์อาจไม่สะดวกมากและต้องมีการประมวลผลเพิ่มเติม (เพื่อที่จะอ่าน/เขียนข้อความตามปกติ) จริงๆ แล้ว เพื่อลดความซับซ้อนของเรคคอร์ดไบต์ดังกล่าว จึงได้มีการแนะนำ BufferedOutputStreamและBufferedInputStream สำหรับ การ อ่าน คลาสเหล่านี้ไม่มีอะไรมากไปกว่าบัฟเฟอร์ที่สะสมข้อมูล ทำให้คุณสามารถทำงานกับข้อมูลแบบไม่ใช่ไบต์ต่อไบต์ แต่ใช้แพ็กเก็ตข้อมูลทั้งหมด (อาร์เรย์) เมื่อสร้างขึ้นBufferedInputStream จะนำอินสแตนซ์ของประเภท InputStreamเข้ามาในตัวสร้างซึ่งข้อมูลจะถูกอ่าน:BufferedInputStream bufferedInputStream = new BufferedInputStream(System.in);
byte[] arr = new byte[100];
bufferedInputStream.read(arr);
System.inเป็น วัตถุ InputStreamที่อ่านข้อมูลจากคอนโซล นั่นคือการใช้ อ็อบเจ็กต์ BufferedInputStream นี้ เราสามารถอ่านข้อมูลจากInputStream ได้ โดยการเขียนลงในอาร์เรย์ที่ส่งผ่าน นี่กลายเป็น wrapper ของ คลาส InputStream อาร์เรย์ arr จาก ตัวอย่าง นี้คืออาร์เรย์ที่รับข้อมูลจากBufferedInputStream ในทางกลับกันจะอ่านข้อมูลจากInputStreamด้วยอาร์เรย์อื่น ซึ่งโดยค่าเริ่มต้นจะมีขนาด 2,048 ไบต์ เช่นเดียวกับBufferedOutputStream : อินสแตนซ์ของ ประเภท OutputStream จะต้องถูกส่งไปยัง Constructor ซึ่งเราจะเขียนข้อมูลในอาร์เรย์ทั้งหมด:
byte[] arr = "Hello world!!!".getBytes();
BufferedOutputStream bufferedInputStream = new BufferedOutputStream(System.out);
bufferedInputStream.write(arr);
bufferedInputStream.flush();
System.outเป็น วัตถุ OutputStreamที่เขียนข้อมูลไปยังคอนโซล เมธอดflush()ส่งข้อมูลจากBufferedOutputStreamไปยังOutputStream โดยทำการล้าง BufferedOutputStreamในกระบวนการ หากไม่มีวิธีนี้ จะไม่มีอะไรถูกบันทึก และคล้ายกับตัวอย่างก่อนหน้านี้: arrคืออาร์เรย์ที่ใช้เขียนข้อมูลลงในBufferedOutputStream จากนั้นจะถูกเขียนไปยังOutputStreamในอาร์เรย์อื่น ซึ่งโดยค่าเริ่มต้นจะมีขนาด 512 ไบต์ อ่านเพิ่มเติมเกี่ยวกับทั้งสองคลาสใน บทความ
25. อะไรคือความแตกต่างระหว่างคลาส java.util.Collection และ java.util.Collections?
คอลเลกชันเป็นอินเทอร์เฟซที่เป็นส่วนหัวของลำดับชั้นคอลเลกชัน แนะนำคลาสที่อนุญาตให้คุณสร้าง บรรจุ และแก้ไขกลุ่มของวัตถุทั้งหมด มีหลายวิธีสำหรับสิ่งนี้ เช่นadd() , Remove() , contains()และอื่นๆ อินเทอร์เฟซหลักของ คลาส Collection :-
Setคืออินเทอร์เฟซที่อธิบายชุดที่มีองค์ประกอบเฉพาะที่ไม่เรียงลำดับ (ไม่ซ้ำกัน)
-
รายการคืออินเทอร์เฟซที่อธิบายโครงสร้างข้อมูลที่จัดเก็บลำดับของออบเจ็กต์ วัตถุเหล่านี้ได้รับดัชนี (หมายเลข) ของตัวเองซึ่งคุณสามารถโต้ตอบกับวัตถุเหล่านี้ได้: ลบ, เปลี่ยนแปลง, เขียนทับ
-
Queue เป็นอินเทอร์เฟซที่อธิบาย โครงสร้างข้อมูลพร้อมองค์ประกอบการจัดเก็บในรูปแบบของคิวที่เป็นไปตามกฎ - FIFO - เข้าก่อนออกก่อน

-
addAll(Collection<? super T> collection, T...element) - เพิ่มองค์ประกอบที่ส่งผ่านประเภทT ไปยัง คอลเลกชัน
-
copy(List<? super T> dest, List<? extends T> src) - คัดลอกองค์ประกอบทั้งหมดจาก list src ไป ยังรายการในdest
-
EmptyList() - ส่งคืนรายการว่าง
-
max(Collection<? ขยาย T> collection, Comparator<? super T> comp) - ส่งคืนองค์ประกอบสูงสุดของคอลเลกชันที่กำหนดตามลำดับที่ระบุโดยตัวเปรียบเทียบที่ระบุ
-
unmodifiableList(List<? extends T> list) - ส่งคืนการเป็นตัวแทนที่ไม่สามารถแก้ไขได้ของรายการที่ส่งผ่าน


GO TO FULL VERSION