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

สวัสดีชาวโลก! การพัฒนาอย่างต่อเนื่องเป็นสิ่งสำคัญมากสำหรับนักพัฒนาทุกคน ท้ายที่สุด หากคุณหยุด ก็มีความเสี่ยงที่จะไม่มีใครอ้างสิทธิ์และหลุดออกจากตลาดโดยสิ้นเชิง: โลกไอทีมีการพัฒนาและก้าวไปข้างหน้าอย่างต่อเนื่อง และคุณต้องก้าวไปกับมัน แต่ในขณะเดียวกันเราไม่สามารถมุ่งเน้นไปที่เทคโนโลยีใหม่ ๆ เท่านั้นเพื่อที่จะไม่ลืมเกี่ยวกับคลาสสิก (หัวข้อคลาสสิก) วันนี้ฉันต้องการวิเคราะห์คำถามในหัวข้อ "คลาสสิก" สำหรับนักพัฒนา Java ต่อไป ฉันทราบว่าคำตอบของฉันไม่ใช่อำนาจขั้นสุดท้าย - นี่เป็นเพียงวิธีที่ฉันเห็นคำตอบที่ถูกต้องสำหรับคำถามเหล่านี้ และคุณอาจไม่เห็นด้วยกับบางข้อ นี่จะค่อนข้างปกติ ดังนั้นอย่าลังเลที่จะแบ่งปันความคิดเห็นของคุณในความคิดเห็น ลิงก์ไปยังส่วนของการวิเคราะห์อยู่ท้ายบทความ

ห้องสมุดและมาตรฐาน

52. ไฮเบอร์เนตคืออะไร? JPA และไฮเบอร์เนตแตกต่างกันอย่างไร?

ฉันคิดว่าจะตอบคำถามนี้ ก่อนอื่นเราต้องเข้าใจว่าJPA คือ อะไร JPAเป็นข้อกำหนดที่อธิบายการแมปเชิงวัตถุสัมพันธ์ของวัตถุ Java แบบธรรมดา และจัดเตรียม API สำหรับการจัดเก็บ เรียกค้น และจัดการวัตถุดังกล่าว นั่นคืออย่างที่เราจำได้ว่าฐานข้อมูล เชิงสัมพันธ์ (DB) จะถูกนำเสนอในรูปแบบของตารางที่เชื่อมต่อถึงกันจำนวนมาก และJPAก็เป็นมาตรฐานที่ได้รับการยอมรับอย่างกว้างขวาง ซึ่งอธิบายว่าอ็อบเจ็กต์สามารถโต้ตอบกับฐานข้อมูลเชิงสัมพันธ์ได้อย่างไร อย่างที่คุณเห็นJPAเป็นสิ่งที่เป็นนามธรรมและไม่มีตัวตน มันเหมือนกับความคิด วิธีการ ในเวลาเดียวกันHibernateเป็นไลบรารีเฉพาะที่ใช้ กระบวน ทัศน์JPA นั่นคือด้วยความช่วยเหลือของไลบรารีนี้ คุณสามารถทำงานกับฐานข้อมูลเชิงสัมพันธ์ผ่านอ็อบเจ็กต์ที่เป็นตัวแทนข้อมูลจากฐานข้อมูล (เอนทิตี) อย่างที่พวกเขาพูดกันว่าห้องสมุดแห่งนี้ใกล้เคียงกับอุดมคติของJPA มาก และบางทีนั่นอาจเป็นเหตุผลว่าทำไมห้องสมุดแห่งนี้ถึงได้รับความนิยม และตามที่คุณเข้าใจ ความนิยมในการใช้งานถือเป็นข้อโต้แย้งที่ดีสำหรับการพัฒนาและปรับปรุงเพิ่มเติม นอกจากนี้ เบื้องหลังการใช้งานบ่อยครั้งนี้ยังมีชุมชนขนาดใหญ่ที่ได้แยกแยะคำถามที่เป็นไปได้และเป็นไปไม่ได้ทั้งหมดที่เกี่ยวข้องกับเครื่องมือนี้แล้ว นี่คือตัวอย่างหนังสือที่เจาะลึกทุกมุมมืดของเทคโนโลยีนี้ นั่นคือไฮเบอร์เนตได้รับการศึกษามากที่สุดเท่าที่จะเป็นไปได้และปรากฎว่ามีความน่าเชื่อถือ จริงๆ แล้ว แม้แต่การนำ JPA ไปใช้ในฝั่ง Spring ในอุดมคติก็มักจะใช้ Hibernate อยู่ข้างใต้ไม่ใช่เพื่ออะไร

53. การเรียงซ้อนคืออะไร? มันถูกใช้อย่างไรในไฮเบอร์เนต?

ดังที่ฉันได้กล่าวไว้ก่อนหน้านี้ในการสื่อสารแบบไฮเบอร์เนตจะดำเนินการผ่านวัตถุข้อมูลที่เรียกว่าเอนทิตี . เอนทิตีเหล่านี้เป็นตัวแทนของตารางเฉพาะบางตารางในฐานข้อมูล และอย่างที่คุณจำได้ ในคลาส Java สามารถมีการอ้างอิงถึงคลาสอื่นได้ ความสัมพันธ์เหล่านี้สะท้อนให้เห็นในฐานข้อมูล ตามกฎแล้วในฐานข้อมูลสิ่งเหล่านี้อาจเป็นคีย์นอก (สำหรับ OneToOne, OneToMany, ManyToOne) หรือตารางระดับกลาง (สำหรับ ManyToMany) คุณสามารถอ่าน เพิ่มเติมเกี่ยวกับความสัมพันธ์ระหว่างเอนทิตีได้ในบทความนี้ เมื่อเอนทิตีของคุณมีลิงก์ไปยังเอนทิตีที่เกี่ยวข้องอื่นๆ คำอธิบายประกอบจะถูกวางไว้เหนือลิงก์เหล่านี้เพื่อระบุประเภทของการเชื่อมต่อ: @OneToOne, @OneToMany, @ManyToOne, @ManyToMane ซึ่งคุณสามารถระบุค่าของคุณสมบัติได้ - cascade - the ประเภทของคาสเคดสำหรับการเชื่อมต่อนี้ JPA มีวิธีการเฉพาะสำหรับการโต้ตอบกับเอนทิตี (คงอยู่ บันทึก ผสาน... ) ประเภทการเรียงซ้อนถูกนำมาใช้อย่างแม่นยำเพื่อแสดงให้เห็นว่าข้อมูลที่เกี่ยวข้องควรทำงานอย่างไรเมื่อใช้วิธีการเหล่านี้กับเอนทิตีเป้าหมาย ดังนั้นกลยุทธ์การเรียงซ้อน (ประเภทของการเรียงซ้อน) คืออะไร? มาตรฐาน JPA แสดงถึงการใช้การเรียงซ้อนหกประเภท:

• PERSIST - การดำเนินการบันทึกจะเกิดขึ้นแบบเรียงซ้อน (สำหรับ วิธี การบันทึก()และคงอยู่() ) นั่นคือถ้าเราบันทึกเอนทิตีที่เกี่ยวข้องกับเอนทิตีอื่น พวกเขาจะถูกบันทึกในฐานข้อมูลด้วย (หากยังไม่มี)

• MERGE - การดำเนินการอัปเดตจะเกิดขึ้นแบบเรียงซ้อน (สำหรับ เมธอด Merge() )

• ลบ - การดำเนินการลบเกิดขึ้นในแบบเรียงซ้อน ( วิธี ลบ () )

• ทั้งหมด - มีการดำเนินการเรียงซ้อนสามครั้งพร้อมกัน - PERSIST - MERGE - REMOVE

JPA มีแนวคิดเกี่ยวกับเอนทิตี ถาวร - เอนทิตีที่เกี่ยวข้องกับข้อมูลในฐานข้อมูลซึ่งควบคุมโดยเซสชันปัจจุบัน (การเชื่อมต่อ) หากคุณเปลี่ยนแปลง แต่ไม่บันทึกการเปลี่ยนแปลงในฐานข้อมูล ข้อมูลในฐานข้อมูลจะยังคงมีการเปลี่ยนแปลง

• DETACH - เอนทิตีที่เกี่ยวข้องจะไม่ได้รับการจัดการโดยเซสชัน ( detach() method ) นั่นคือเมื่อมีการเปลี่ยนแปลง จะไม่มีการเปลี่ยนแปลงข้อมูลในฐานข้อมูลโดยอัตโนมัติ - จะถูกถ่ายโอนจากสถานะคงอยู่เป็นแยกออก (เอนทิตีที่ไม่ได้รับการจัดการโดย JPA)

• รีเฟรช - ทุกครั้งที่อัปเดตเอนทิตีด้วยข้อมูลจากฐานข้อมูล ( รีเฟรช() - อัปเดตออบเจ็กต์ที่แยกออก) เอนทิตีที่เกี่ยวข้องจะได้รับการอัปเดตในลักษณะเดียวกัน ตัวอย่างเช่น คุณเปลี่ยนแปลงข้อมูลที่นำมาจากฐานข้อมูลและต้องการส่งกลับค่าดั้งเดิม ในกรณีนี้ การดำเนินการนี้จะเป็นประโยชน์สำหรับคุณ

Hibernate รองรับการดำเนินการเรียงซ้อนมาตรฐานทั้งหมดเหล่านี้ แต่ยังแนะนำการดำเนินการสามประการของตัวเองด้วย:

• จำลอง - ใช้เมื่อเรามีแหล่งข้อมูลมากกว่าหนึ่งแหล่งและเราต้องการให้ข้อมูลซิงโครไนซ์ (วิธีไฮเบอร์เนต - ทำซ้ำ) เอนทิตีทั้งหมดต้องมีตัวระบุ (id) เพื่อไม่ให้เกิดปัญหากับการสร้าง (เพื่อให้เอนทิตีเดียวกันไม่มีรหัสที่แตกต่างกันสำหรับฐานข้อมูลที่แตกต่างกัน)

• SAVE_UPDATE - บันทึก/ลบแบบเรียงซ้อน (สำหรับวิธี Hibernate - saveOrUpdate )

• LOCKเป็นการดำเนินการผกผันกับDETACHEDโดยจะถ่าย โอนเอนทิ ตีที่ แยก ออกกลับไปยัง สถานะ คงอยู่เช่น เอนทิตีจะถูกติดตามอีกครั้งในเซสชันปัจจุบัน

หากไม่ได้เลือกชนิดการเรียงซ้อน การดำเนินการใดๆ ในเอนทิตีจะไม่มีผลกระทบต่อเอนทิตีอื่นๆ ที่เกี่ยวข้อง

54. คลาส Entity สามารถเป็นนามธรรมได้หรือไม่?

ในข้อกำหนด JPAในย่อหน้า2.1 คลาสเอนทิตีมีบรรทัด: “ ทั้งคลาสนามธรรมและคอนกรีตสามารถเป็นเอนทิตีได้ ” ดังนั้นคำตอบคือใช่ คลาสนามธรรมสามารถเป็นเอนทิตีและสามารถใส่คำอธิบายประกอบด้วย @Entity

55. ผู้จัดการกิจการคืออะไร? เขารับผิดชอบอะไร?

ก่อนอื่น ฉันอยากจะทราบว่าEntityManagerเป็นหนึ่งในองค์ประกอบสำคัญของ JPAซึ่งใช้ในการโต้ตอบเอนทิตีกับฐานข้อมูล โดยทั่วไปจะเรียกวิธีการโต้ตอบระหว่างเอนทิตีและฐานข้อมูล (คงอยู่ ผสาน ลบ แยกออก)... แต่ฉันก็ทราบด้วยว่าตามกฎแล้วองค์ประกอบนี้ไม่ใช่องค์ประกอบเดียวสำหรับแอปพลิเคชันทั้งหมด: บ่อยที่สุด มันมีน้ำหนักเบาและมักจะถูกลบออกและสร้างอันใหม่โดยใช้EntityManagerFactory หากเราวาดเส้นขนานกับJDBCโดยที่EntityManagerFactoryจะเป็นอะนาล็อกของ DataSourceจากนั้นEntityManagerจะเป็นอะนาล็อกของConnection ในทางกลับ กัน ก่อนหน้านี้ฉันได้กล่าวถึงการคงอยู่เอนทิตีเป็นเอนทิตีที่ถูกควบคุมโดยการเชื่อมต่อปัจจุบัน ดังนั้น: เอนทิตีนี้ได้รับการจัดการอย่างแม่นยำโดย EntityManagerซึ่งเกี่ยวข้องอย่างใกล้ชิดกับการเชื่อมต่อปัจจุบันและTransactionManagerซึ่งรับผิดชอบในการเปิด/ปิดธุรกรรม นอกจากนี้ ในรูปด้านล่าง คุณสามารถดูวงจรชีวิตของเอนทิตีได้: EntityManager จัดการเอนทิตีเมื่ออยู่ในขั้นตอนที่ได้รับการจัดการ (ในขณะนี้ยังคงอยู่ เนื่องจากมีการเชื่อมต่อกับ EntityManager) นั่นคือมันไม่ใช่เรื่องใหม่อีกต่อไปและยังไม่ได้ถูกลบออก เราสามารถพูดได้ว่าเมื่อเอนทิตีใหม่หรือถูกลบออก มันก็จะถูกแยกออกเช่นกันเพราะว่า ไม่ได้รับการจัดการโดย EntityManager มีกลยุทธ์ที่แตกต่างกันสำหรับ EntityManager นั่นคือสามารถมีได้หนึ่ง EntityManager ซิงเกิลตันสำหรับแอปพลิเคชันทั้งหมด หรือสามารถสร้างใหม่ได้ในแต่ละครั้งสำหรับการเชื่อมต่อแต่ละครั้ง หากคุณใช้ Spring การสร้าง/การลบ EntityManager จะถูกควบคุมโดยอัตโนมัติภายใต้ประทุน (แต่ไม่ได้หมายความว่าคุณไม่สามารถปรับแต่งได้ ^^) เป็นเรื่องที่คุ้มที่จะบอกว่า EntityManagers หนึ่งรายการขึ้นไปสร้างบริบท การคงอยู่ บริบทการคงอยู่คือสภาพแวดล้อมที่อินสแตนซ์ของเอนทิตีถูกซิงโครไนซ์กับเอนทิตีที่คล้ายกันในฐานข้อมูล (ดังที่ฉันกล่าวไว้ สิ่งนี้ใช้ได้กับเอนทิตีที่คงอยู่เท่านั้น) หากคุณเจาะลึกเข้าไปในJPA (ซึ่งฉันขอแนะนำอย่างยิ่ง) คุณจะเจอแนวคิดเหล่านี้บ่อยมาก

56. คลาส Assert คืออะไร? ทำไมต้องใช้มัน?

ฉันไม่เคยได้ยินเกี่ยวกับคลาสดังกล่าว ในJPAดังนั้นฉันจะถือว่าสิ่งนี้หมายถึง คลาส JUnitของไลบรารี ซึ่งใช้สำหรับการทดสอบโค้ดหน่วย คลาสของไลบรารีนี้Assertใช้เพื่อตรวจสอบผลลัพธ์ของการเรียกใช้โค้ด ( assertคือคำสั่งที่คุณมีสถานะ/ข้อมูลที่แน่นอนในที่ใดที่หนึ่ง) ตัวอย่างเช่น คุณกำลังทดสอบวิธีที่ควรสร้างแมวขึ้นมา คุณเรียกใช้เมธอดและรับผลลัพธ์:

Cat resultOfTest = createCat();

แต่คุณต้องแน่ใจว่ามันถูกสร้างขึ้นอย่างถูกต้องใช่ไหม? ดังนั้น ก่อนหน้านี้คุณได้สร้าง cat - ExpectedCat - บางตัวด้วย ตนเอง โดยมีพารามิเตอร์ที่คุณคาดหวังจาก cat ที่ได้รับจาก เมธอด createCat() จากนั้นคุณใช้ คลาส Assertเพื่อตรวจสอบผลลัพธ์:

Assert.assertEquals(resultOfTest, expectedCat);

หากแมวแตกต่างกัน ข้อยกเว้น AssertionError จะถูกส่งออกไป ซึ่งบอกเราว่าผลลัพธ์ที่คาดหวังไม่มาบรรจบกัน คลาสAssertมีวิธีการที่แตกต่างกันมากมายซึ่งครอบคลุมงานหลายอย่างในการตรวจสอบผลลัพธ์ที่คาดหวัง นี่คือบางส่วนของพวกเขา:

• assertTrue(<boolean>) - ค่าที่คาดหวังที่ได้รับเป็นอาร์กิวเมนต์จะต้องเป็นจริง

• assertFalse(<boolean>) - ค่าที่คาดหวังที่ได้รับเป็นอาร์กิวเมนต์ควรเป็นเท็จ

• assertNotEquals(<object1>, <object2>) - อ็อบเจ็กต์ที่ได้รับเป็นอาร์กิวเมนต์จะต้องแตกต่างกันเมื่อเปรียบเทียบโดยใช้เท่ากับ ( false )

• assertThrows(<ClassNameOfException>.class, <ExceptionObject>) - อาร์กิวเมนต์ที่สองคาดว่าจะเป็นข้อยกเว้นของคลาสที่ระบุโดยอาร์กิวเมนต์แรก (เช่น ตามกฎแล้ว แทนที่อาร์กิวเมนต์ที่สอง วิธีการจะถูกเรียกที่ควร โยนข้อยกเว้นประเภทที่ต้องการ)

สตริง

57. กำหนดลักษณะสตริงใน Java

Stringเป็นคลาสมาตรฐานใน Java ซึ่งรับผิดชอบในการจัดเก็บและจัดการค่าสตริง (ลำดับของอักขระ) เป็น คลาส ที่ไม่เปลี่ยนรูป ( ฉันเขียนเกี่ยวกับไม่เปลี่ยนรูปก่อนหน้านี้ ) เช่น ข้อมูลของออบเจ็กต์ของคลาสนี้ไม่สามารถเปลี่ยนแปลงได้หลังจากการสร้าง ฉันต้องการทราบทันทีว่าคลาส StringBuilderและStringBufferเป็นคลาสสองคลาสที่แทบจะเหมือนกัน โดยมีข้อแตกต่างเพียงอย่างเดียวคือคลาสใดคลาสหนึ่งมีไว้สำหรับใช้ในสภาพแวดล้อมแบบมัลติเธรด (StringBuffer) คลาสเหล่านี้คล้ายคลึงกับStringแต่ต่างกันตรงที่คลาสเหล่านี้ไม่แน่นอน กล่าวคือ เมื่อสร้างออบเจ็กต์แล้ว อนุญาตให้แก้ไขสตริงที่แสดงได้โดยไม่ต้องสร้างออบเจ็กต์ใหม่ จริงๆ แล้ว วิธีการเหล่านี้แตกต่างจาก วิธี String มาตรฐาน และมีจุดมุ่งหมายเพื่อตอบสนองความต้องการในการเปลี่ยนสตริง (ไม่ใช่เพื่ออะไรที่พวกเขาเรียกว่าตัวสร้าง) อ่านเพิ่มเติมเกี่ยวกับString , StringBufferและStringBuilder ในบทความนี้

58. มีวิธีใดบ้างในการสร้างออบเจกต์ String? มันถูกสร้างขึ้นที่ไหน?

วิธีทั่วไปในการสร้างสตริงคือเพียงระบุค่าที่เราต้องการในวงเล็บคู่:

String str = "Hello World!";

คุณสามารถทำได้โดยตรงผ่านnew :

String str = new String("Hello World!");

คุณสามารถสร้างสตริงโดยเริ่มจากอาร์เรย์ของอักขระ:

char[] charArr = {'H','e','l','l','o',' ', 'W','o','r','l','d','!'};
String str = new String(charArr);

อันเป็นผลมาจาก วิธีการ toString ทำงาน บนวัตถุบางอย่าง:

String str = someObject.toString();

เช่นเดียวกับผลลัพธ์ของวิธีอื่น ก็จะส่งคืนการแสดงสตริง ตัวอย่างเช่น:

BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
String str =  reader.readLine();

ดังที่คุณเข้าใจ สามารถสร้างสตริงได้หลายวิธี เมื่อ สร้างออบเจ็กต์ Stringมันจะถูกเก็บไว้ในstring poolซึ่งเราจะพูดถึงรายละเอียดเพิ่มเติมในหนึ่งในคำถามด้านล่างนี้

59. จะเปรียบเทียบสองสตริงใน Java และวิธีเรียงลำดับได้อย่างไร?

ในการเปรียบเทียบค่าใน Java จะใช้ เครื่องหมายเท่ากับคู่== หากเราต้องการเปรียบเทียบค่าง่ายๆ เช่นintเราก็จะใช้มัน แต่วิธีนี้ใช้ไม่ได้กับการเปรียบเทียบวัตถุที่มีคุณสมบัติครบถ้วน ในกรณีนี้ จะเป็นการเปรียบเทียบการอ้างอิงเท่านั้น ไม่ว่าจะชี้ไปที่วัตถุเดียวกันหรือไม่ก็ตาม นั่นคือเมื่อเปรียบเทียบวัตถุสองชิ้นที่มีค่าเหมือนกันทุกประการของฟิลด์ภายในการเปรียบเทียบผ่าน==จะให้ผลลัพธ์เป็นเท็จ : แม้จะมีฟิลด์ที่เหมือนกันของวัตถุ แต่วัตถุนั้นก็ครอบครองเซลล์หน่วยความจำที่แตกต่างกัน และอ็อบเจ็กต์ของ คลาส Stringแม้จะมีความเรียบง่ายที่หลอกลวง แต่ก็ยังเป็นวัตถุ และการเปรียบเทียบผ่าน==ก็ไม่สามารถใช้ได้กับพวกเขาเช่นกัน (แม้ว่าจะมีพูลสตริงอยู่ก็ตาม) ที่นี่วิธีการมาตรฐานของคลาส Objectเข้ามามี บทบาท - เท่ากับซึ่งจะต้องถูกแทนที่ในคลาสเพื่อให้ทำงานได้อย่างถูกต้อง (มิฉะนั้น โดยค่าเริ่มต้นจะเปรียบเทียบโดยใช้== ) มันถูกแทนที่ ใน คลาส Stringดังนั้นเราจึงรับมันและใช้งาน:

String firstStr = "Hello World!";
String secondStr = "Hello World!";
boolean isEquals = firstStr.equals(secondStr);

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

TreeSet<String> sortedSet = new TreeSet<>();
sortedSet.add("B");
sortedSet.add("C");
sortedSet.add("A");
sortedSet.forEach(System.out::println);

เอาต์พุตคอนโซล:

60. กำหนดอัลกอริทึมสำหรับการแปลงสตริงให้เป็นอักขระ เขียนรหัสที่เหมาะสม

ดังที่ได้กล่าวไปแล้ว วัตถุของ คลาส Stringมีวิธีการที่เป็นประโยชน์มากมาย toCharArrayหนึ่งในนั้นคือ วิธีการนี้แปลงสตริงเป็นอาร์เรย์อักขระ:

String str = "Hello world";
char[] charArr = str.toCharArray();

ต่อไปเรามีอาร์เรย์ของอักขระที่เราสามารถเรียกตามดัชนี:

char firstChar = charArr[0]; // H

61. จะแปลงสตริงเป็นอาร์เรย์ไบต์และย้อนกลับได้อย่างไร? เขียนรหัสที่เหมาะสม

คล้ายกับ เมธอดtoCharArray คลาส String มี เมธอด getBytesที่ส่งคืนอาร์เรย์ไบต์ของสตริง :

String str = "Hello world";
byte[] byteArr = str.getBytes();
byte firstChar = byteArr[6]; // 119

การวิเคราะห์ส่วนหนึ่งของวันนี้ได้สิ้นสุดลงแล้ว ขอขอบคุณสำหรับความสนใจของคุณ!