
71. จะเกิดอะไรขึ้นหากเราไม่แทนที่เมธอด toString() ของ Enum
สมมติว่าเรามีenum ต่อไปนี้ :public enum Role {
STUDENT,
TEACHER,
DIRECTOR,
SECURITY_GUARD;
}
มาแสดง ฟิลด์ STUDENTบนคอนโซลโดยเรียก เมธอด toString() ของมัน :
System.out.println(Role.STUDENT.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ไม่มีความแตกต่างในทางปฏิบัติระหว่าง==และเท่ากับ( ) 


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


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แทน-
คำสั่งใช้เพื่อดำเนินการสืบค้น SQL แบบง่าย ๆ โดยไม่มีพารามิเตอร์อินพุตรันไทม์ PreparStatementสามารถรับพารามิเตอร์อินพุตขณะรันไทม์ได้
-
ในการตั้งค่าพารามิเตอร์สำหรับPreparedStatementพารามิเตอร์อินพุตจะถูกเขียนเป็นเครื่องหมายคำถามในคำขอ เพื่อให้สามารถแทนที่ด้วยค่าบางค่าได้โดยใช้ตัวตั้งค่าต่างๆ เช่นsetDouble() , setFloat() , setInt() , setTime() ... นี้ หมายความว่าคุณจะไม่ใส่ข้อมูลผิดประเภทลงในคำขอ
-
PrecompiledStatementได้รับการคอมไพล์ล่วงหน้าและใช้การแคช จึงสามารถดำเนินการได้เร็วกว่าคำขอที่สร้างจากอ็อบเจ็กต์Statement เล็กน้อย ผลก็คือ คำสั่ง SQL ที่ถูกดำเนินการบ่อยครั้งจะถูกสร้างขึ้นเป็น วัตถุ ReadyStatementเพื่อปรับปรุงประสิทธิภาพ
-
คำสั่งมีความเสี่ยงต่อการถูกแทรก SQL แต่PreparedStatementป้องกันไว้
GO TO FULL VERSION