4 วิธีในการคัดลอกอาร์เรย์ใน Java

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

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

Java Array

ใน Java อาร์เรย์คือคอนเทนเนอร์ที่เก็บค่าที่มีประเภทเดียว ตัวอย่างเช่น อาร์เรย์สามารถใช้เก็บรายชื่อหนังสือ หรือรายการคะแนนที่ผู้เล่นได้รับในเกมปาเป้า

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

สมมติว่าเราต้องการสร้างอาร์เรย์ที่เก็บกาแฟที่ขายในร้านกาแฟของเรา เราสามารถทำได้โดยใช้รหัสนี้:

String[] coffees = {“Espresso”, “Mocha”, “Latte”, “Cappuccino”, “Pour Over”, “Flat White”};


ในตัวอย่างนี้ เราประกาศอาร์เรย์ที่เรียกว่า coffees ซึ่งเก็บค่าสตริง อาร์เรย์ของเรามีค่าหกค่า

แต่ละรายการในอาร์เรย์จะได้รับหมายเลขดัชนีโดยเริ่มจาก 0 ซึ่งสามารถใช้เพื่ออ้างอิงรายการแต่ละรายการในอาร์เรย์ได้

81% ของผู้เข้าร่วมกล่าวว่าพวกเขารู้สึกมั่นใจมากขึ้นเกี่ยวกับโอกาสในการทำงานด้านเทคโนโลยีหลังจากเข้าร่วม bootcamp จับคู่กับ Bootcamp วันนี้

ผู้สำเร็จการศึกษาจากหลักสูตร bootcamp โดยเฉลี่ยใช้เวลาน้อยกว่าหกเดือนในการเปลี่ยนอาชีพ ตั้งแต่เริ่มต้น bootcamp ไปจนถึงหางานแรก

ตอนนี้เราได้สำรวจพื้นฐานของอาร์เรย์ Java แล้ว เราสามารถพูดถึงวิธีการที่คุณสามารถใช้เพื่อคัดลอกเนื้อหาของอาร์เรย์ของคุณ

คัดลอกอาร์เรย์โดยใช้ตัวดำเนินการมอบหมาย

วิธีการโคลนที่ใช้บ่อยที่สุดวิธีหนึ่งในการคัดลอกอาร์เรย์คือการใช้ตัวดำเนินการกำหนด

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

กลับไปที่ร้านกาแฟกันเถอะ สมมติว่าเราต้องการสร้างสำเนาของ coffees อาร์เรย์ที่เราจะใช้เมนูกาแฟฤดูร้อนของเรา เราสามารถใช้รหัสนี้เพื่อสร้างสำเนาของอาร์เรย์:

class CopyAssignment {
	public static void main(String[] args) {
		String[] coffees = {"Espresso", "Mocha", "Latte", "Cappuccino", "Pour Over", "Flat White"};
		String[] summer_coffees = coffees;

		for (String c: summer_coffees) {
			System.out.print(c + ",");
		}
	}
}

รหัสของเราส่งคืน:

Espresso, Mocha, Latte, Cappuccino, Pour Over, Flat White,


มาทำลายรหัสของเรากัน ในโค้ดบรรทัดแรกในคลาส CopyAssignment เราประกาศอาร์เรย์ชื่อ coffees ซึ่งเก็บเมนูกาแฟมาตรฐานของเราไว้

ในบรรทัดถัดไป เราใช้ตัวดำเนินการมอบหมายเพื่อกำหนดค่าของ coffees ไปยังอาร์เรย์ใหม่ที่ชื่อว่า summer_coffees . จากนั้นเราสร้างลูป "for-each" ที่วนซ้ำทุกรายการใน summer_coffees อาร์เรย์และพิมพ์ออกมาที่คอนโซล

มีข้อเสียประการหนึ่งในการใช้วิธีนี้:หากคุณเปลี่ยนองค์ประกอบของอาร์เรย์หนึ่ง อาร์เรย์อื่นก็จะเปลี่ยนไปด้วย ดังนั้นหากเราเปลี่ยนค่าของ Latte ถึง Summer Latte ใน summer_coffees . ของเรา รายการ coffees . ของเรา รายการก็จะมีการเปลี่ยนแปลง

วนซ้ำเพื่อคัดลอกอาร์เรย์

วิธีแรกที่เราพูดถึงในการคัดลอกอาร์เรย์ — โดยใช้ตัวดำเนินการมอบหมาย — สร้างสิ่งที่เรียกว่า shallow copy. เป็นกรณีนี้เนื่องจากเราได้กำหนดออบเจ็กต์อาร์เรย์ที่มีอยู่ให้กับออบเจกต์อาร์เรย์ใหม่ ซึ่งหมายความว่าเมื่อเราเปลี่ยนออบเจกต์ใดๆ ออบเจ็กต์จะเปลี่ยนไปทั้งคู่ — ทั้งสองออบเจ็กต์เชื่อมโยงกัน

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

วิธีหนึ่งที่สามารถใช้เพื่อสร้างสำเนาลึกคือการสร้าง for วนซ้ำผ่านเนื้อหาของอาร์เรย์และสร้างอาร์เรย์ใหม่

สมมติว่าเราต้องการสร้างสำเนาลึกของ coffees อาร์เรย์ที่เรียกว่า summer_coffees. นี่ต้องเป็นสำเนาที่ลึกซึ้งเพราะเราวางแผนที่จะเปลี่ยนเนื้อหาของ summer_coffees อาร์เรย์เพื่อสะท้อนถึงกาแฟใหม่ที่เราจะนำเสนอในฤดูร้อน

นี่คือรหัสที่เราจะใช้เพื่อสร้างสำเนาลึกโดยใช้ for ห่วง:

import java.util.Arrays;

class LoopCopy {
	public static void main(String[] args) {
		String[] coffees = {"Espresso", "Mocha", "Latte", "Cappuccino", "Pour Over", "Flat White"};
		String[] summer_coffees = new String[6];

		for (int i = 0; i < coffees.length; ++i) {
			summer_coffees[i] = coffees[i];
		}

		System.out.println(Arrays.toString(summer_coffees));
	}
}

เมื่อเรารันโค้ดของเรา ผลลัพธ์จะเป็นดังนี้:

[Espresso, Mocha, Latte, Cappuccino, Pour Over, Flat White]


อย่างที่คุณเห็น รหัสของเราได้สร้างสำเนาอาร์เรย์ดั้งเดิมของเรา มาอธิบายวิธีการทำงานทีละขั้นตอน:

1. เรานำเข้า java.util.Arrays ซึ่งรวมถึงเมธอด toString() เราจะใช้พิมพ์อาร์เรย์ของเราไปยังคอนโซลที่ส่วนท้ายของตัวอย่าง

1. เราประกาศอาร์เรย์ที่เรียกว่า coffees ซึ่งจัดเก็บรายการกาแฟไว้ในเมนูมาตรฐานของเรา
2. เราเริ่มต้นอาร์เรย์ชื่อ summer_coffees ซึ่งจะเก็บค่าได้ 6 ค่า
3. เราใช้ a for loop เพื่อวนซ้ำทุกรายการใน coffees รายการ
4. ทุกครั้งที่ for loop ทำงาน รายการที่ค่าดัชนี i ใน summer_coffees จะได้รับไอเทมที่ค่าดัชนี i ในกาแฟ
5. เราใช้ Arrays.toString() เพื่อแปลง summer_coffees ไปยังสตริง จากนั้นพิมพ์อาร์เรย์ใหม่พร้อมองค์ประกอบที่เราคัดลอกไปยังคอนโซล

การใช้ copyOfRange() Java Methods

Java copyOfRange() ใช้เพื่อคัดลอก Arrays.copyOfRange() เป็นส่วนหนึ่งของคลาส java.util.Arrays นี่คือไวยากรณ์สำหรับเมธอด copyOfRange()

import java.util.arrays;

DataType[] newArray = Arrays.copyOfRange(oldArray, indexPos, length);

มาแบ่งไวยากรณ์สำหรับเมธอด copyOfRange() กัน:

1. ประเภทข้อมูล คือประเภทของข้อมูลที่อาร์เรย์ใหม่จะจัดเก็บ
2. newArray เป็นชื่อของอาร์เรย์ใหม่
3. oldArray คืออาร์เรย์ที่มีค่าที่คุณต้องการคัดลอกไปยัง newArray .
4. indexPos คือตำแหน่งที่การคัดลอกควรเริ่มต้นใน oldArray .
5. ความยาว คือจำนวนค่าที่ควรคัดลอกจาก oldArray ไปที่ newArray .

มาดูตัวอย่างกันเพื่อสาธิตการทำงานของเมธอด copyOfRange() สมมติว่าเราต้องการสร้างสำเนาของ coffees . ของเรา อาร์เรย์จากก่อนหน้านี้ เราสามารถทำได้โดยใช้รหัสนี้:

import java.util.Arrays;

class CopyUsingRange {
	public static void main(String[] args) {
		String[] coffees = {"Espresso", "Mocha", "Latte", "Cappuccino", "Pour Over", "Flat White"};

		String[] summer_coffees = Arrays.copyOfRange(coffees, 0, coffees.length);
		System.out.println("Summer coffees: " + Arrays.toString(summer_coffees));
	}
}

รหัสของเราส่งคืน:

Summer coffees: [Espresso, Mocha, Latte, Cappuccino, Pour Over, Flat White]


มาทำลายรหัสของเรากัน:

1. เรานำเข้า java.util.Arrays ไลบรารีที่เก็บเมธอด copyOfRange() และ toString() ที่เราจะใช้ในตัวอย่างของเรา
2. เราประกาศอาร์เรย์ที่เรียกว่า coffees ซึ่งเก็บกาแฟไว้ในเมนูมาตรฐานของเรา
3. เราประกาศอาร์เรย์ชื่อ summer_coffees และใช้วิธี copyOfRange() เพื่อสร้างสำเนาของกาแฟ coffees อาร์เรย์ พารามิเตอร์ที่เราระบุมีดังนี้:
   1. กาแฟ คือชื่ออาร์เรย์ที่เราต้องการคัดลอก
   2. ระบุว่าเราต้องการคัดลอกค่าเริ่มต้นที่ตำแหน่งดัชนี 0 จาก coffees อาร์เรย์
   3. coffees.length ระบุว่าเราต้องการคัดลอกทุกค่าในรายการ
4. เราพิมพ์ “กาแฟฤดูร้อน:“ ตามด้วยอาร์เรย์ผลลัพธ์ที่เรียกว่า summer_coffees ไปที่คอนโซล

ตอนนี้เราได้สร้างสำเนาของ “coffees รายการชื่อ summer_coffees .

การใช้ arraycopy() วิธีการของ Java

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

นี่คือไวยากรณ์ของเมธอด arraycopy()

System.arraycopy(sourceArray, startingPos, newArray, newArrayStartingPos, length);


มาทำลายวิธีนี้กัน copyarray() ยอมรับห้าพารามิเตอร์:

• sourceArray คือชื่อของอาร์เรย์ที่คุณต้องการคัดลอก
• เริ่มต้นPos คือตำแหน่งดัชนีที่คุณต้องการเริ่มคัดลอกค่าใน source_array .
• newArray เป็นชื่อของอาร์เรย์ใหม่ที่จะคัดลอกค่า
• newArrayStartingPos คือตำแหน่งดัชนีที่ควรเพิ่มค่าที่คัดลอกมา
• ความยาว คือจำนวนองค์ประกอบที่คุณต้องการคัดลอกไปยัง new_array .

กลับไปที่ร้านกาแฟกันเถอะ สมมติว่าเราต้องการคัดลอกทุกค่าใน coffees . ของเรา อาร์เรย์ไปยังอาร์เรย์ใหม่ที่เรียกว่า summer_coffees . เราสามารถทำได้โดยใช้รหัสนี้:

import java.util.Arrays;

class ArrayCopyMethod {
	public static void main(String[] args) {
		String[] coffees = {"Espresso", "Mocha", "Latte", "Cappuccino", "Pour Over", "Flat White"};
		String[] summer_coffees = new String[6];

		System.arraycopy(coffees, 0, summer_coffees, 0, coffees.length);
		System.out.println("Summer coffees: " + Arrays.toString(summer_coffees));
	}
}

รหัสของเราส่งคืน:

Summer coffees: [Espresso, Mocha, Latte, Cappuccino, Pour Over, Flat White]


มาแบ่งรหัสของเราทีละขั้นตอน:

1. เรานำเข้า java.util.Arrays แพ็คเกจเมื่อเริ่มต้นโปรแกรมของเรา ซึ่งรวมถึงเมธอด toString() ที่เราจะใช้ในการพิมพ์สำเนาอาร์เรย์ที่เราสร้างขึ้นเมื่อสิ้นสุดโปรแกรมของเรา
2. เราประกาศอาร์เรย์ที่เรียกว่า coffees ซึ่งเก็บกาแฟไว้ในเมนูมาตรฐานของเรา
3. เราเริ่มต้นอาร์เรย์ชื่อ summer_coffees ซึ่งจะเก็บ 6 ค่า
4. เราใช้ arraycopy() เพื่อสร้างสำเนาของ coffees อาร์เรย์ นี่คือพารามิเตอร์ที่เราระบุ:
   1. กาแฟ คืออาร์เรย์ที่เราต้องการคัดลอก
   2. เป็นตำแหน่งที่เราต้องการให้สำเนาของเราเริ่มต้นใน coffees อาร์เรย์
   3. summer_coffees คืออาร์เรย์ที่เราต้องการให้เพิ่มค่าที่คัดลอกมา
   4. คือตำแหน่งที่เราต้องการให้ค่าที่คัดลอกมาเริ่มเพิ่มใน summer_coffees อาร์เรย์
   5. coffees.length คือจำนวนขององค์ประกอบอาร์เรย์ที่เราต้องการคัดลอก ในกรณีนี้ ใช้ coffees.length ทำให้เราสามารถคัดลอกทุกองค์ประกอบจาก coffees รายการ
5. เราพิมพ์ข้อความที่ระบุว่า "กาแฟฤดูร้อน:" ตามด้วยรายการกาแฟฤดูร้อนที่เราสร้างขึ้น

บทสรุป

การคัดลอกอาร์เรย์เป็นการดำเนินการทั่วไปเมื่อคุณทำงานกับรายการ บทช่วยสอนนี้สำรวจสี่วิธีที่คุณสามารถคัดลอกอาร์เรย์ใน Java

ขั้นแรก เราพูดถึงวิธีสร้างสำเนาแบบตื้นโดยใช้ตัวดำเนินการมอบหมาย จากนั้นจึงอธิบายวิธีสร้างสำเนาแบบลึกโดยใช้ for ห่วง จากนั้น เราได้สำรวจวิธีการใช้เมธอด copyOfRange() เพื่อสร้างสำเนาของอาร์เรย์ และวิธีการใช้เมธอดของระบบ arraycopy() เพื่อคัดลอกอาร์เรย์

ตอนนี้คุณพร้อมที่จะเริ่มคัดลอกอาร์เรย์ใน Java อย่างมืออาชีพแล้ว!