คลาสอาร์เรย์ ตอนที่ 2

"Rishi ฉันตั้งตารอที่จะเรียนรู้เกี่ยวกับวิธีการที่เหลือของคลาส Arrays

"ความกระตือรือร้นในการเรียนรู้นั้นไม่สามารถทำให้ครูเก่าของคุณพอใจได้ แต่ถ้าคุณต้องการค้นหาทุกสิ่งจริง ๆ พ่อมดผู้ใจดีชื่อ Google จะช่วยคุณทั้งวันทั้งคืน"

"เอ่อ..."

"ล้อเล่นครับ แน่นอนครับ ผมจะอธิบายทุกอย่างให้ดีขึ้น แต่ถ้ามีอะไรเกิดขึ้น ให้จำพ่อมดที่ดีไว้ ผมจะเริ่มบทเรียนวันนี้ด้วยวิธีArrays.fillการ

"เมื่อทำงานกับอาร์เรย์ โปรแกรมเมอร์ Java มักจะต้องเติมอาร์เรย์ด้วยค่าเดียวกัน แน่นอนว่าคุณสามารถเขียนลูปและกำหนดค่าให้กับแต่ละเซลล์ของอาร์เรย์ในลูปได้:

int[] x = new int[100];
for (int i = 0; i < x.length; i++)
x[i] = 999;

"หรือแทนที่จะเรียกทั้งหมดนี้ คุณสามารถเรียกใช้Arrays.fill()เมธอด ซึ่งทำสิ่งเดียวกันทุกประการ: มันเติมอาร์เรย์ที่ส่งผ่านด้วยค่าที่ส่งผ่าน นี่คือลักษณะที่ปรากฏ:

Arrays.fill(name, value)

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

int[] x = new int[100];
Arrays.fill(x, 999);

"สวย!"

"คุณสามารถใช้Arrays.fill()เมธอดเพื่อเติมอาร์เรย์ทั้งหมด แต่เพียงบางส่วนด้วยค่าบางอย่าง:

Arrays.fill(name, first, last, value)

"ที่แรกและสุดท้ายคือดัชนีของเซลล์แรกและเซลล์สุดท้ายที่จะเติม

" ตามประเพณีเก่าที่ดี (หรือไม่ดี) ของ Java โปรดจำไว้ว่าองค์ประกอบสุดท้ายไม่รวมอยู่ในช่วง

ตัวอย่าง:

int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

Arrays.fill(x, 3, 7, 999);


String str = Arrays.toString(x);

" Arrays.fill()เมธอดใช้ได้กับอาร์เรย์หนึ่งมิติเท่านั้น หากคุณส่งต่ออาร์เรย์สองมิติไปยังเมธอด จะถือว่าเมธอดนั้นเป็นหนึ่งมิติ โดยมีผลที่ตามมาทั้งหมด

Arrays.copyOf()

"Amigo โปรดบอกวิธีเปลี่ยนขนาดของอาร์เรย์หลังจากสร้างแล้ว"

"อืม... นั่นเป็นคำถามหลอกใช่ไหม ฉันไม่ใช่มือใหม่อีกต่อไป คำตอบที่ถูกต้องคือคุณทำไม่ได้! คุณไม่สามารถปรับขนาดอาร์เรย์ได้หลังจากที่สร้างเสร็จแล้ว"

“แต่ถ้าคุณต้องการจริงๆล่ะ?”

“ยังเป็นไปไม่ได้!

"อันที่จริง ถ้าคุณต้องการจริงๆ คุณก็ทำได้! ด้วยความช่วยเหลือของเคล็ดลับการเขียนโปรแกรม:

1. ขั้นแรก คุณต้องสร้างอาร์เรย์ใหม่ตามความยาวที่ต้องการ
2. จากนั้นคุณคัดลอกองค์ประกอบทั้งหมดจากอาร์เรย์แรกลงไป

"นี่คือสองสิ่งที่Arrays.copyOf()เมธอดทำ นี่คือสิ่งที่เรียกมันว่า:

Type[] name2 = Arrays.copyOf(name, length);

"วิธีนี้ไม่ได้เปลี่ยนอาร์เรย์ที่มีอยู่แต่สร้างอาร์เรย์ใหม่ แทน และคัดลอกองค์ประกอบของอาร์เรย์เก่าลงไป"

"จะเกิด อะไรขึ้นถ้าความยาวของอาร์เรย์ใหม่น้อยกว่าความยาวของอาร์เรย์ที่มีอยู่

"เป็นคำถามที่ดี Amigo! หากองค์ประกอบไม่เหมาะสม ค่าพิเศษก็จะถูกเพิกเฉย"

"และในทางกลับกัน ถ้ามีเซลล์พิเศษ ค่าเริ่มต้นของพวกมันคืออะไร?

"ถ้าความยาวของอาร์เรย์ใหม่มากกว่าความยาวของอาร์เรย์เก่า เซลล์จะเต็มไปด้วยเลขศูนย์

ตัวอย่าง:

int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

int[] x2 = Arrays.copyOf(x, 5);
String str2 = Arrays.toString(x2);

int[] x3 = Arrays.copyOf(x, 15);
String str3 = Arrays.toString(x3);

Arrays.copyOfRange()

"แล้วถ้าคุณต้องการรับอาร์เรย์ที่มีความยาว 5 จากอาร์เรย์ที่มีความยาว 10 แต่คุณต้องการให้องค์ประกอบ 5 ตัวสุดท้ายมากกว่า 5 ตัวแรกล่ะ ในกรณีนี้ คุณต้องการเมธอดอื่นของคลาส มันArraysคือArrays.copyOfRange()นี่คือสิ่งที่เรียกว่า:

Type[] name2 = Arrays.copyOfRange(name, first, last);

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

"ฮ่า! ดังที่ครูผู้ยิ่งใหญ่ของฉันเคยพูดว่า ' ตามประเพณีเก่าที่ดี (หรือไม่ดี) ของ Java โปรดจำไว้ว่าองค์ประกอบสุดท้ายไม่รวมอยู่ในช่วง '"

"อามิโก คุณเติบโตต่อหน้าต่อตาเรา

ตัวอย่าง:

int[] x = {11, 12, 13, 14, 15, 16, 17, 18, 19, 20};

int[] x2 = Arrays.copyOfRange(x, 5, 10);
String str2 = Arrays.toString(x2);

int[] x3 = Arrays.copyOfRange(x, 5, 15);
String str3 = Arrays.toString(x3);

Arrays.sort()

"และสุดท้าย ฉันได้ทิ้งวิธีที่ดีที่สุด... mmm... ไว้เป็นลำดับสุดท้าย: sortingอาร์เรย์ถูกจัดเรียงค่อนข้างบ่อยในการเขียนโปรแกรม นี่คือการกระทำยอดนิยม 3 อันดับแรกเมื่อทำงานกับอาร์เรย์:

• การเรียงลำดับอาร์เรย์
• การค้นหาองค์ประกอบต่ำสุด (หรือสูงสุด) ของอาร์เรย์
• การกำหนดดัชนีขององค์ประกอบในอาร์เรย์ (การค้นหาองค์ประกอบในอาร์เรย์)

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

Arrays.sort(name);

วิธีนี้จะเรียงลำดับอาร์เรย์ที่ส่งผ่านจากน้อยไปหามาก

ตัวอย่าง:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};

Arrays.sort(x);
String str = Arrays.toString(x);

"เยี่ยมมาก! ฉันเรียกเพียงวิธีเดียวและจัดเรียงอาร์เรย์ สิ่งที่สวยงาม!"

"อย่างไรก็ตาม คุณสามารถจัดเรียงได้ไม่เพียงแค่อาร์เรย์ทั้งหมดเท่านั้น แต่ยังสามารถจัดเรียงเพียงบางส่วนได้ด้วย นี่คือสิ่งที่เรียกมันว่า:

Arrays.sort(name, first, last);

"ที่แรกและสุดท้ายคือดัชนีของเซลล์แรกและเซลล์สุดท้ายที่การเรียงลำดับควรสัมผัส และ...

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

ตัวอย่าง:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};

Arrays.sort(x, 4, 8);
String str = Arrays.toString(x);

"ในการจัดเรียงอาร์เรย์ Java ใช้อัลกอริธึมการเรียงลำดับที่เร็วที่สุด — QuickSortความซับซ้อนในการคำนวณขึ้นอยู่กับขนาดของอาร์เรย์และคำนวณโดยใช้สูตร N log(N)

"การจัดเรียงอาร์เรย์ขององค์ประกอบ 1,000 รายการจะเกี่ยวข้องกับการเปรียบเทียบองค์ประกอบอาร์เรย์ประมาณ 10,000 รายการ การจัดเรียงอาร์เรย์ขององค์ประกอบหนึ่งล้านรายการจะเกี่ยวข้องกับการเปรียบเทียบประมาณ 20 ล้านรายการ"

" อย่าเปรียบเทียบมากเกินไปเมื่อคุณพิจารณาจำนวนองค์ประกอบ!"

"นั่นคือสิ่งที่ฉันพูด อัลกอริทึม QuickSortมีประสิทธิภาพมาก

Arrays.binarySearch()

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

• ขั้นแรกให้จัดเรียงอาร์เรย์
• จากนั้นองค์ประกอบตรงกลางของอาร์เรย์จะถูกเปรียบเทียบกับองค์ประกอบที่เรากำลังมองหา
• ถ้าองค์ประกอบมากกว่าองค์ประกอบตรงกลาง การค้นหาจะดำเนินต่อไปในครึ่งขวาของอาร์เรย์
• หากองค์ประกอบที่เรากำลังมองหาน้อยกว่าองค์ประกอบตรงกลาง การค้นหาจะดำเนินต่อไปในครึ่งซ้ายของอาร์เรย์

"เนื่องจากอาร์เรย์ถูกจัดเรียงไว้ จึงเป็นไปได้ที่จะกำจัดครึ่งหนึ่งในการเปรียบเทียบครั้งเดียว จากนั้นในขั้นต่อไป เราจะโยนทิ้งอีกครึ่งหนึ่ง เป็นต้น"

"เยี่ยมมาก! เรามุ่งตรงไปที่เป้าหมายอย่างรวดเร็ว!"

"แน่นอน ในอาร์เรย์ที่มีองค์ประกอบหนึ่งล้าน (!) อัลกอริทึมการค้นหาแบบไบนารีสามารถค้นหาดัชนีขององค์ประกอบที่ต้องการในการเปรียบเทียบเพียง 20 รายการ ข้อบกพร่องของอัลกอริทึมคือต้องเรียงลำดับอาร์เรย์ก่อน และการเรียงลำดับยังต้องใช้เวลา

นี่คือสิ่งที่เรียกว่า:

int index = Arrays.binarySearch(name, value);

" nameชื่อของอาร์เรย์อยู่ที่ไหนซึ่งต้องผ่านการจัดเรียงแล้ว (เช่นใช้เมธอดArrays.sort()) และvalueเป็นองค์ประกอบที่เรากำลังค้นหาในอาร์เรย์ ผลลัพธ์ที่ส่งคืนโดยเมธอดคือดัชนีขององค์ประกอบอาร์เรย์ที่ต้องการ .

ตัวอย่าง:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};
Arrays.sort(x);

int index1 = Arrays.binarySearch(x, 0);
int index2 = Arrays.binarySearch(x, -20);
int index3 = Arrays.binarySearch(x, 99);
int index4 = Arrays.binarySearch(x, 5);

"จะเกิดอะไรขึ้นถ้าองค์ประกอบที่ต้องการปรากฏขึ้นหลายครั้งในอาร์เรย์ "

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

"จะเกิดอะไรขึ้นถ้าอาร์เรย์ไม่มีองค์ประกอบที่ต้องการเลย"

"ในกรณีนี้ อั ลกอริทึมจะส่งกลับดัชนีเชิงลบ

เอกสาร

"ทุกอย่างชัดเจน Rishi! สิ่งนี้น่าสนใจมาก"

"หากคุณพบว่าสิ่งนี้น่าสนใจจริงๆ ให้ อ่านเอกสารทางการของArraysชั้นเรียนและวิธีการต่างๆ ในเว็บไซต์ Oracle ในยามว่าง

"คุณสามารถดูตัวอย่างอย่างละเอียด เช่น the Arrays.mismatch()และArrays.compare()วิธีการ คุณมักจะสามารถนำไปใช้ประโยชน์ได้

"และอย่าสับสนกับจำนวนเมธอด แต่ละเมธอดมี 5-10 ตัวแปร ซึ่งต่างกันแค่ประเภทพารามิเตอร์เท่านั้น"