สำรวจคำถามและคำตอบจากการสัมภาษณ์งานสำหรับตำแหน่ง Java Developer ตอนที่ 8

การปฏิบัติหรือทฤษฎี? อะไรสำคัญกว่ากัน? หลายๆ คนจะพูดเป็นธรรมดาว่าการฝึกฝนมีความสำคัญมากกว่า เช่นฝึกจนพระอาทิตย์ตกแล้วจะมีความสุข ฉันจะกล้าไม่เห็นด้วยกับสิ่งนี้ ในระหว่างการสัมภาษณ์ จะไม่มีใครรู้ว่าคุณเจ๋งแค่ไหนตอนฝึกซ้อม คุณจะถูกขอให้สาธิตการสับทฤษฎีของคุณแทน ไม่นานหลังจากนั้น เมื่อคุณผ่านการสัมภาษณ์หลายชั้นและได้รับมอบหมายให้ทำโปรเจ็กต์แล้ว คุณจะสามารถนำทักษะการปฏิบัติของคุณไปใช้ คุณอาจคัดค้าน โดยบอกว่าบางครั้งพวกเขาจะให้ทดสอบคุณ ดังนั้นการฝึกฝนยังเป็นสิ่งจำเป็น ฉันไม่เห็นด้วย แต่ประเด็นของฉันคือบางครั้ง แต่คุณจำเป็นต้องแสดงความรู้ด้านทฤษฎีในการสัมภาษณ์เสมอ คุณรู้สึกถึงความแตกต่างหรือไม่? ทั้งหมดนี้หมายความว่าคุณต้องมีรากฐานทางทฤษฎีที่มั่นคงอยู่ใต้ฝ่าเท้าของคุณ และนั่นคือสิ่งที่เราจะสร้างต่อไปในวันนี้ โดยเฉพาะอย่างยิ่ง เราจะดูคำถามที่มักถูกถามในการสัมภาษณ์ต่อไป

71. จะเกิดอะไรขึ้นหากเราไม่แทนที่เมธอด toString() ของ Enum

สมมติว่าเรามีenum ต่อไปนี้ :

public enum Role {
   STUDENT,
   TEACHER,
   DIRECTOR,
   SECURITY_GUARD;
}

มาแสดง ฟิลด์ STUDENTบนคอนโซลโดยเรียก เมธอด toString() ของมัน :

System.out.println(Role.STUDENT.toString());

เป็นผลให้เราได้รับเอาต์พุตคอนโซลดังต่อไปนี้: ดังนั้นเราจะเห็นว่าสำหรับ enum การใช้งานเริ่มต้นของtoString()จะส่งคืนชื่อของค่าคงที่นั้นเอง

72. คุณสามารถประกาศ Constructor ภายใน Enum ได้หรือไม่?

แน่นอน. Constructor คือสิ่งที่กำหนดค่าของฟิลด์ภายในของenum ตามตัวอย่าง เราจะเพิ่มสองฟิลด์ลงในแจงนับ ก่อนหน้า ( ageFromและageTo ) เพื่อระบุช่วงอายุสำหรับแต่ละบทบาท:

public enum Role {
   STUDENT(5,18),
   TEACHER(20,60),
   DIRECTOR(40,70),
   SECURITY_GUARD(18,50);

   int ageFrom;
   int ageTo;

   Role(int ageFrom, int ageTo) {
       this.ageFrom = ageFrom;
       this.ageTo = ageTo;
   }
}

73. == และเท่ากับ()แตกต่างกันอย่างไร?

นี่เป็นหนึ่งในคำถามสัมภาษณ์ที่พบบ่อยที่สุดของผู้ที่จะเป็น Java Developer เริ่มต้นด้วยการเปรียบเทียบค่าง่าย ๆ ( int , char , double ... ) เราใช้==เนื่องจากตัวแปรเหล่านี้มีค่าที่เป็นรูปธรรมที่สามารถเปรียบเทียบได้โดยตรง ยิ่งไปกว่านั้น ตัวแปรดั้งเดิมไม่ใช่อ็อบเจ็กต์ที่สมบูรณ์ — พวกมันไม่สืบทอด คลาส Objectและไม่มีเมธอดเท่ากับ() หากเรากำลังพูดถึงการเปรียบเทียบตัวแปรที่อ้างอิงถึงวัตถุ เราจำเป็นต้องรู้ว่า==เปรียบเทียบค่าของการอ้างอิงเท่านั้น กล่าวคือ ไม่ว่าพวกมันจะอ้างอิงถึงวัตถุเดียวกันหรือไม่ก็ตาม แม้ว่าข้อมูลทั้งหมดในออบเจ็กต์หนึ่งจะเหมือนกันกับข้อมูลทั้งหมดในออบเจ็กต์อื่น การใช้==สำหรับการเปรียบเทียบจะให้ผลลัพธ์ที่เป็นลบ ( false ) เนื่องจากเป็นออบเจ็กต์ที่แยกจากกัน ดังที่คุณอาจเดาได้ เราใช้ เมธอด เท่ากับ()เพื่อเปรียบเทียบตัวแปรอ้างอิง นี่เป็นหนึ่งใน วิธีมาตรฐานของคลาส Objectและจำเป็นสำหรับการเปรียบเทียบอ็อบเจ็กต์อย่างเต็มรูปแบบ แต่ฉันต้องบอกทันทีว่าเพื่อให้วิธีนี้ทำงานได้อย่างถูกต้อง จะต้องลบล้างเพื่อระบุอย่างชัดเจนว่าควรเปรียบเทียบวัตถุอย่างไร หากคุณไม่แทนที่วิธีการ คุณจะได้รับการใช้งานเริ่มต้น ซึ่งจะเปรียบเทียบออบเจ็กต์โดยใช้== ใน IntelliJ IDEA คุณสามารถแทนที่ได้โดยอัตโนมัติโดยใช้ทางลัด IDEA: Alt +Insert ในหน้าต่างที่ปรากฏขึ้น ให้เลือกเท่ากับ()และhashCode( ) จากนั้นเลือกสาขาที่ควรเกี่ยวข้อง เอาล่ะ! วิธีการต่างๆ จะถูกนำไปใช้โดยอัตโนมัติ นี่คือตัวอย่างวิธีที่ วิธีการ เท่ากับ ที่สร้างขึ้นโดยอัตโนมัติ ค้นหา คลาส Cat ที่ง่ายที่สุดที่เป็นไปได้ โดยมีสองฟิลด์ — int ageและString name :

@Override
public boolean equals(final Object o) {
   if (this == o) return true;
   if (o == null || this.getClass() != o.getClass()) return false;
   final Cat cat = (Cat) o;
   return this.age == cat.age &&
           Objects.equals(this.name, cat.name);
}

เมื่อพูดถึงenumไม่มีความแตกต่างในทางปฏิบัติระหว่าง==และเท่ากับ( ) ท้ายที่สุดenumจะเก็บค่าคงที่ และแม้ว่าเราจะเปรียบเทียบค่าที่เหมือนกันโดยใช้==เราก็จะได้ค่า trueเนื่องจากการอ้างอิงที่เปรียบเทียบจะชี้ไปที่วัตถุเดียวกันเสมอ และการใช้เท่ากับ()ทำให้เราได้ผลลัพธ์ที่ถูกต้องเช่นกัน หากคุณเข้าไปในเนื้อความของ วิธีการ เท่ากับสำหรับEnumคุณจะเห็นว่า คลาส Enumมีการใช้งานดังต่อไปนี้: ภายในเราจะเห็นการเปรียบเทียบการอ้างอิงแบบเก่าที่ดี! โดยสรุป สำหรับenum s เราสามารถเปรียบเทียบได้อย่างถูกต้องโดยใช้ทั้ง==และเท่ากับ( )

74. วิธีลำดับ () ของ Enum ทำหน้าที่อะไร?

เมื่อเราเรียก เมธอด int ordinal()บน ฟิลด์ enumเราจะได้ดัชนีฐานศูนย์ของฟิลด์ในรายการค่า enum ลองเรียกเมธอดนี้บนฟิลด์ในRole enum ซึ่งเราพิจารณาก่อนหน้านี้:

System.out.println(Role.DIRECTOR.ordinal());

ดังนั้นคอนโซลจะแสดง:

75. Enum สามารถใช้กับ TreeSet หรือ TreeMap ใน Java ได้หรือไม่

เราสามารถใช้ประเภทenumในTreeSetและTreeMap และเราสามารถเขียนสิ่งนี้ได้:

TreeSet<Role> treeSet = new TreeSet<>();
treeSet.add(Role.SECURITY_GUARD);
treeSet.add(Role.DIRECTOR);
treeSet.add(Role.TEACHER);
treeSet.add(Role.STUDENT);
treeSet.forEach(System.out::println);

และคอนโซลจะแสดง: เราได้ผลลัพธ์แล้ว แต่ไม่ได้เรียงตามตัวอักษร ประเด็นก็คือ หากเราใช้ ฟิลด์ enumเป็น ค่า TreeSetหรือเป็น คีย์ TreeMapฟิลด์ต่างๆ จะถูกจัดเรียงตามลำดับธรรมชาติ (ตามลำดับที่ระบุไว้ในenum ) การทำความเข้าใจว่านี่คือวิธีการทำงานช่วยให้เราเขียนโค้ดได้ดีขึ้น

76. วิธีการเรียงลำดับของ Enum() และ comparisonTo() เกี่ยวข้องกันอย่างไร

ตามที่กล่าวไว้ก่อนหน้านี้ordinal()ส่งคืนดัชนีของฟิลด์ในรายการฟิลด์ enum นอกจากนี้ ในการพิจารณาคำถามก่อนหน้านี้ คุณเห็นว่า เมื่อฟิลด์ enum ถูกใส่ลงใน TreeSet (ซึ่งเป็นชุดที่เรียงลำดับ) ฟิลด์เหล่านี้จะเรียงลำดับตามที่ได้รับการประกาศในenum และดังที่เราทราบTreeSetและTreeMapเรียงลำดับรายการโดยการเรียกเมธอดcomparisonTo()ของอินเทอร์เฟซที่เปรียบเทียบได้ สิ่งนี้บอกเราว่า คลาส Enumใช้ อินเทอร์เฟซ ที่เปรียบเทียบได้ซึ่งหมายความว่าจะใช้ เมธอด comparisonTo()ซึ่งใช้ เมธอด ordinal() ภายใน เพื่อกำหนดลำดับการจัดเรียง เมื่อเข้าสู่ คลาส Enumเราสามารถยืนยันสมมติฐานของเราได้ และนี่คือเนื้อความของเมธอดเอง: เมธอดordinal()ไม่ได้ถูกเรียกที่นี่ แต่ จะใช้ตัวแปร ลำดับซึ่งเป็นหมายเลขดัชนีขององค์ประกอบในการแจงนับแทน เมธอดordinal()นั้น ไม่มีอะไรมากไปกว่า getter สำหรับตัวแปร ลำดับ

77. เขียนตัวอย่าง Enum

ในคำถามที่กล่าวถึงข้างต้น ฉันได้ยกตัวอย่างenum s แล้ว ฉันไม่เห็นเหตุผลที่จะทำซ้ำโค้ดที่นี่ ตัวอย่างเช่น ดูคำถามที่ 72 เกี่ยวกับตัวสร้างในการแจงนับ

78. Enum สามารถใช้ในกรณีสวิตช์ได้หรือไม่?

มันสามารถเป็นได้และควรจะเป็น! เมื่อพิจารณาจากประสบการณ์ของฉัน ฉันจะสังเกตว่าหนึ่งในการใช้ enumที่พบบ่อยที่สุดคือการใช้โครงสร้างเชิงตรรกะ เช่นคำสั่งswitch ในกรณีนี้ คุณสามารถระบุกรณี ที่เป็นไปได้ทั้งหมด ได้ เมื่อคุณเขียนตรรกะสำหรับ ฟิลด์ enum แต่ละ ฟิลด์ คุณไม่จำเป็นต้องมี อนุประโยค เริ่มต้น ด้วยซ้ำ ! ท้ายที่สุด หากคุณใช้Stringหรือค่าตัวเลข เช่น int คุณอาจได้รับค่าที่ไม่คาดคิด แต่ enum จะเป็นไปไม่ได้ นี่คือ ลักษณะของคำสั่ง switchสำหรับตัวอย่างข้างต้น:

public void doSomething(Role role) {
   switch (role) {
       case STUDENT:
           // some logic for STUDENT
           break;
       case TEACHER:
           // some logic for TEACHER
           break;
       case DIRECTOR:
           // some logic for DIRECTOR
           break;
       case SECURITY_GUARD:
           // some logic for SECURITY_GUARD
           break;
   }
}

79. ฉันจะรับค่าที่เป็นไปได้ทั้งหมดของ Enum ได้อย่างไร

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

Role[] roles = Role.values();
for (Role role : roles) {
   System.out.println(role);
}

เราจะมีสิ่งต่อไปนี้บนคอนโซล:

สตรีม API

80. สตรีมใน Java คืออะไร?

Java Stream APIเป็นวิธีการใหม่ในการโต้ตอบกับสตรีมข้อมูล ช่วยให้เราสามารถประมวลผล Big Data ได้อย่างสะดวกและกะทัดรัดยิ่งขึ้น รวมถึงประมวลผลข้อมูลแบบคู่ขนานระหว่างสตรีมจำนวนหนึ่ง ซึ่งอาจช่วยเพิ่มประสิทธิภาพได้

81. ตั้งชื่อคุณสมบัติหลักของธุรกรรม

หัวข้อที่นี่คือ Stream API แต่คำถามเกี่ยวกับธุรกรรม อืม... ก่อนอื่นมาทำความเข้าใจก่อนว่าธุรกรรมคืออะไร ธุรกรรมคือกลุ่มของการดำเนินการตามลำดับบนฐานข้อมูล มันแสดงถึงหน่วยการทำงานเชิงตรรกะ ธุรกรรมสามารถดำเนินการได้โดยอิสระจากธุรกรรมอื่นๆ ที่ทำพร้อมกันทั้งหมดและประสบความสำเร็จ ดังนั้นจึงรักษาความสมบูรณ์ของข้อมูล หรือไม่ดำเนินการเลย ซึ่งในกรณีนี้จะไม่มีผลกระทบใดๆ ธุรกรรมมีคุณสมบัติหลักสี่ประการซึ่งเราสามารถจดจำได้ง่ายด้วยตัวย่อกรด . เรามาดูกันว่าแต่ละตัวอักษรของตัวย่อนี้หมายถึงอะไร: A ย่อมาจากAtomicity คุณสมบัตินี้รับประกันว่าไม่มีการทำธุรกรรมใด ๆ ที่เกิดขึ้นในระบบ การดำเนินการย่อยทั้งหมดจะถูกดำเนินการ หรือไม่ดำเนินการใดเลย ( all or none ) Сย่อมาจากความสม่ำเสมอ สถานที่ให้บริการนี้รับประกันว่าการทำธุรกรรมที่ประสบความสำเร็จแต่ละครั้งจะกระทำเฉพาะผลลัพธ์ที่ถูกต้องเท่านั้น กล่าวอีกนัยหนึ่ง นี่คือการรับประกันว่าหากการทำธุรกรรมสำเร็จ กฎของระบบสำหรับข้อมูลเฉพาะทั้งหมดจะปฏิบัติตาม หากการทำธุรกรรมไม่สำเร็จก็จะไม่ถูกดำเนินการและข้อมูลของระบบจะกลับสู่สถานะก่อนหน้า ฉันย่อมาจากความโดดเดี่ยว คุณสมบัตินี้หมายความว่าเมื่อมีการดำเนินธุรกรรม ธุรกรรมที่เกิดขึ้นพร้อมกันจะต้องไม่ส่งผลกระทบต่อผลลัพธ์ คุณสมบัตินี้มีทรัพยากรจำนวนมาก ดังนั้น ตามกฎแล้ว คุณสมบัตินี้จะถูกนำไปใช้งานบางส่วน ทำให้สามารถแยกระดับได้ในระดับหนึ่งซึ่งช่วยแก้ปัญหาการแยกเฉพาะได้ เราจะพูดถึงเรื่องนี้โดยละเอียดในคำถามถัดไป Dย่อมาจากDurability ที่พักนี้รับประกันว่าหากผู้ใช้ได้รับการยืนยันว่าธุรกรรมเสร็จสมบูรณ์ เขาหรือเธอสามารถมั่นใจได้ว่าการเปลี่ยนแปลงจะไม่ถูกยกเลิกเนื่องจากความล้มเหลวบางประการ นั่นคือ คุณสามารถมั่นใจได้ว่าระบบปฏิบัติการบางอย่างล้มเหลวจะไม่ทำอะไรกับข้อมูลของคุณ หากคุณได้รับการยืนยันแล้วว่าธุรกรรมของคุณเสร็จสิ้นเรียบร้อยแล้ว

82. ระดับการแยกธุรกรรมมีอะไรบ้าง?

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

• phantom อ่าน : เมื่อคำขอเดียวกันถูกเรียกมากกว่าหนึ่งครั้งภายในธุรกรรมเดียว ให้ผลลัพธ์ที่แตกต่างกันเนื่องจากการแทรกโดยธุรกรรมอื่น

• การอ่านที่ไม่สามารถทำซ้ำได้ : เมื่อคำขอเดียวกันถูกเรียกมากกว่าหนึ่งครั้งภายในธุรกรรมเดียว ทำให้ได้ข้อมูลที่แตกต่างกันเนื่องจากการเปลี่ยนแปลง (อัปเดต) และการลบโดยธุรกรรมอื่น

• การอ่านที่สกปรก : การอ่านข้อมูลที่ยังไม่มีข้อผูกมัดซึ่งมีการเพิ่มหรือแก้ไขโดยธุรกรรมและถูกย้อนกลับในภายหลัง

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

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

83. Statement และ PreparationStatement แตกต่างกันอย่างไร?

ที่นี่เราได้เปลี่ยนการเปลี่ยนไปใช้ฟีเจอร์ของJDBC อย่าง กะทันหัน ไม่ว่าในกรณีใดก็ตาม เรามาทำความเข้าใจกันก่อนว่าStatementคืออะไร เป็นวัตถุที่ใช้สร้างแบบสอบถาม SQL JDBC ใช้ สามประเภท: Statement , PreparationStatementและCallableStatement เราจะไม่พิจารณาCallableStatementวันนี้ เรากำลังพูดถึงความแตกต่างระหว่างStatementและPreparationStatementแทน

1. คำสั่งใช้เพื่อดำเนินการสืบค้น SQL แบบง่าย ๆ โดยไม่มีพารามิเตอร์อินพุตรันไทม์ PreparStatementสามารถรับพารามิเตอร์อินพุตขณะรันไทม์ได้

2. ในการตั้งค่าพารามิเตอร์สำหรับPreparedStatementพารามิเตอร์อินพุตจะถูกเขียนเป็นเครื่องหมายคำถามในคำขอ เพื่อให้สามารถแทนที่ด้วยค่าบางค่าได้โดยใช้ตัวตั้งค่าต่างๆ เช่นsetDouble() , setFloat() , setInt() , setTime() ... นี้ หมายความว่าคุณจะไม่ใส่ข้อมูลผิดประเภทลงในคำขอ

3. PrecompiledStatementได้รับการคอมไพล์ล่วงหน้าและใช้การแคช จึงสามารถดำเนินการได้เร็วกว่าคำขอที่สร้างจากอ็อบเจ็กต์Statement เล็กน้อย ผลก็คือ คำสั่ง SQL ที่ถูกดำเนินการบ่อยครั้งจะถูกสร้างขึ้นเป็น วัตถุ ReadyStatementเพื่อปรับปรุงประสิทธิภาพ

4. คำสั่งมีความเสี่ยงต่อการถูกแทรก SQL แต่PreparedStatementป้องกันไว้

และด้วยเหตุนี้ เราจะเรียกมันว่าวัน!