การวิเคราะห์คำถามและคำตอบจากการสัมภาษณ์นักพัฒนา Java ตอนที่ 16

สวัสดีเพื่อน! ใช้เวลานานแค่ไหนในการเป็นนักพัฒนา? ฉันถามผู้คนมากมายและได้ยินคำตอบที่แตกต่างกันมากมาย สำหรับบางคนเดือนเดียวอาจจะพอ แต่สำหรับบางคนปีเดียวก็ไม่พอ แต่ฉันรู้แน่ว่าการเป็นนักพัฒนา Java นั้นเป็นเส้นทางที่ยุ่งยากและยาวไกล ไม่ว่าคุณจะมีความสามารถเริ่มต้นแค่ไหนก็ตาม ท้ายที่สุดแล้วความสามารถไม่มีความสำคัญเท่ากับความดื้อรั้นและการทำงานหนัก ดังนั้นวันนี้เรายังคงวิเคราะห์คำถามสัมภาษณ์ยอดนิยมสำหรับนักพัฒนา Java อย่างต่อเนื่อง การศึกษาสิ่งเหล่านี้จะค่อยๆ นำคุณเข้าใกล้เป้าหมายที่คุณรักมากขึ้น มาเริ่มกันเลย!

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() สิ่งต่อไปนี้ จะถูกโยนทิ้ง: ซึ่งไม่ดี ในกรณีนี้ ควรใช้โครงสร้างต่อไปนี้:

1. String result = null;
   if (stringOptional.isPresent()) {
    stringOptional.get();
   }

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

2. String result = stringOptional.orElse("default value");

   ในกรณี นี้เราจะระบุค่าเริ่มต้น ซึ่งจะกำหนดให้กับสตริงผลลัพธ์ในกรณีของค่าว่างOptional

3. String result = stringOptional.orElseThrow(() -> new CustomException());

   ในกรณีนี้ เราเองโยนข้อยกเว้นเมื่อOptional ว่าง เปล่า

สิ่งนี้อาจสะดวกในแอปพลิเคชัน ตัวอย่างเช่น เมื่อใช้วิธีการ Spring JPA - findById()ซึ่งส่งคืนค่าเผื่อเลือก ในกรณีนี้ เราจะพยายามรับค่าด้วยวิธีนี้ และหากไม่มี เราจะโยน ข้อ ยกเว้นรันไทม์ บางส่วน ซึ่งประมวลผลที่ระดับคอนโทรลเลอร์โดยใช้ExceptionHandlerและแปลงเป็นการ ตอบสนอง HTTPโดยมีสถานะ404 - NOT FOUND

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 Descant ที่ไม่ได้แต่เดิมอยู่ใน คลาส Catแล้วลองเรียกเมธอดเหล่านั้น เพราะประเภทอ็อบเจ็กต์ของคุณจะกลายเป็นLion ไม่มีตรรกะในเรื่องนี้ ดังนั้น การจำกัดประเภทให้แคบลงจะทำได้ก็ต่อเมื่อออบเจ็กต์ดั้งเดิมเป็นประเภทLionแต่ต่อมาถูกแปลงเป็นคลาสพาเรนต์:

Lion lion = new Lion();
Cat cat = lion;
Lion newLion = (Lion)cat;

นอกจากนี้ เพื่อความน่าเชื่อถือที่มากขึ้น แนะนำให้แคบลงสำหรับวัตถุโดยใช้instanceOf build :

if (cat instanceof Lion) {
 newLion = (Lion)new Cat();
}

อ่านเพิ่มเติมเกี่ยวกับประเภทการอ้างอิงในบทความนี้

21. เหตุใดกรอบงานสมัยใหม่จึงใช้เฉพาะข้อยกเว้นที่ไม่ได้ตรวจสอบเป็นหลัก?

ฉันคิดว่าทั้งหมดนี้เป็นเพราะการจัดการ ข้อยกเว้น ที่ตรวจสอบแล้วยังคงเป็นโค้ดสปาเก็ตตี้ที่ทำซ้ำทุกที่ แต่ไม่จำเป็นจริงๆ ในทุกกรณี ในกรณีเช่นนี้ การประมวลผลภายในเฟรมเวิร์กจะง่ายกว่า เพื่อไม่ให้สิ่งนี้ตกเป็นภาระของนักพัฒนาอีกต่อไป ใช่ แน่นอนว่าอาจมีสถานการณ์ฉุกเฉินเกิดขึ้น แต่ ข้อยกเว้น ที่ไม่ได้รับการตรวจ สอบเหล่านี้ สามารถจัดการได้ในวิธีที่สะดวกกว่า โดยไม่ต้องยุ่งยากกับการประมวลผลแบบtry-catchและไม่ต้องส่งต่อผ่านวิธีการเพิ่มเติม เพียง แปลงข้อยกเว้นเป็นการตอบสนอง HTTP บางส่วน ใน ExceptionHandlerก็เพียงพอแล้ว

22. การนำเข้าแบบคงที่คืออะไร?

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

import static java.lang.Math.cos;

เป็นผลให้เราสามารถใช้เมธอดได้โดยไม่ต้องระบุชื่อคลาส:

double result = cos(60);

นอกจากนี้เรายังสามารถโหลดวิธีการคงที่ทั้งหมดของคลาสได้ในครั้งเดียวโดยใช้การนำเข้าแบบคงที่:

import static java.lang.Math.*;

23. ความสัมพันธ์ระหว่างเมธอด hashCode() และเท่ากับ() คืออะไร?

ตามข้อมูลของOracleกฎคือ: หากสองวัตถุเท่ากัน (เช่น เมธอด เท่ากับ ()ส่งคืนtrue ) ทั้งสองจะต้องมีรหัสแฮชเดียวกัน ในเวลาเดียวกัน อย่าลืมว่าวัตถุสองชิ้นที่แตกต่างกันสามารถมีรหัสแฮชเดียวกันได้ เพื่อให้เข้าใจว่าเหตุใดเท่ากับ()และhashCode()จึงถูกแทนที่เป็นคู่เสมอ ให้พิจารณากรณีต่อไปนี้:

1. ทั้งสองวิธีถูกแทนที่

   ในกรณีนี้ ออบเจ็กต์สองรายการที่มีสถานะภายในเหมือนกันจะส่งกลับค่าเท่ากับ() - trueในขณะที่hashCode()จะส่งกลับตัวเลขเดียวกันทั้งคู่

   ปรากฎว่าทุกอย่างเรียบร้อยดีเพราะกำลังปฏิบัติตามกฎ

2. ทั้งสองวิธีไม่ได้ถูกแทนที่

   ในกรณีนี้ ออบเจ็กต์ที่แตกต่างกันสองรายการที่มีสถานะภายในเหมือนกันจะส่งคืนค่าเท็จ เมื่อ เท่ากับ()เนื่องจากการเปรียบเทียบจะทำโดยการอ้างอิงผ่าน ตัวดำเนิน การ==

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

   ปรากฎว่าในกรณีนี้ทุกอย่างเรียบร้อยดีและปฏิบัติตามกฎแล้ว

3. แทนที่เท่ากับ()ไม่แทนที่hashCode( )

   ในกรณีนี้ สำหรับอ็อบเจ็กต์ที่แตกต่างกันสองรายการที่มีสถานะภายในเหมือนกันเท่ากับ()จะส่งกลับค่าจริงและhashCode()จะส่งกลับค่าที่ต่างกัน (โดยมาก)

   นี่เป็นการละเมิดกฎดังนั้นจึงไม่แนะนำให้ทำเช่นนี้

4. เท่ากับ()ไม่ถูกแทนที่, 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) - ส่งคืนการเป็นตัวแทนที่ไม่สามารถแก้ไขได้ของรายการที่ส่งผ่าน

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