نسخ مجموعات البيانات Java

في هذا الدليل، ستتعرف على طرق مختلفة يمكن استخدامها لنسخ مصفوفات (مستقيمة وثنائية الأبعاد) في Java بمساعدة أمثلة.

　في Java، يمكننا نسخ مصفوفة إلى مصفوفة أخرى. هناك عدة تقنيات يمكن استخدامها لنسخ مصفوفات في Java.

استخدام عمليات الربط لنسخ المصفوفة

دعونا نأخذ مثالاً

class Main {
　　　　public static void main(String[] args) {
　　　　　　　
　　　　　　　　int[] numbers = {1, 2, 3, 4, 5, 6};
　　　　　　　　int[] positiveNumbers = numbers; // نسخ المجموعة
　　　　　　　　for (int number : positiveNumbers) {
　　　　　　　　　　　　System.out.print(number + ", ");
　　　　　　　　}
　　　　}
}

الإخراج:

1، 2، 3، 4، 5، 6

　في المثال السابق، قمنا باستخدام عمليات الربط (الأسلوب =) لنسخ مصفوفة تُدعى numbers إلى مصفوفة أخرى تُدعى positiveEnumbers.

　هذه التقنية هي أبسط التقنيات، وهي فعالة. ومع ذلك، هناك مشكلة واحدة في هذه التقنية. إذا قمنا بتغيير عنصر من مجموعة، فإن العنصر المتبادل في مجموعة أخرى سيُغير أيضًا. على سبيل المثال،

class Main {
　　　　public static void main(String[] args) {
　　　　　　
　　　　　　　　int[] numbers = {1, 2, 3, 4, 5, 6};
　　　　　　　　int[] positiveNumbers = numbers; // نسخ المجموعة
　　　　　　
　　　　　　　　// تعديل قيمة المجموعة الأولى
　　　　　　　　numbers[0] = -1;
　　　　　　　　// طباعة المجموعة الثانية
　　　　　　　　for (int number : positiveNumbers) {
　　　　　　　　　　　　System.out.print(number + ", ");
　　　　　　　　}
　　　　}
}

الإخراج:

-1, 2, 3, 4, 5, 6

　في هذا السياق، نرى أننا قمنا بتغيير قيمة من مجموعة numbers. عندما نقوم بطباعة مجموعة positiveNumbers، يمكننا رؤية أن القيمة نفسها قد تغيرت.

هذا لأن كلا المجموعتين يُشيران إلى نفس كيان المجموعة. هذا بسبب النسخ الضحل. للحصول على معلومات إضافية حول النسخ الضحل، يرجى زيارةالنسخ الضحل.

الآن، لإنشاء مجموعة جديدة أثناء نسخ المجموعة، نحتاج إلى نسخ عميق بدلاً من نسخ ضحل.

2. استخدام دورة لإنشاء نسخة من المجموعة

让我们举个实例：

import java.util.Arrays;
class Main {
　　　　public static void main(String[] args) {
　　　　　　
　　　　　　　　int[] source = {1, 2, 3, 4, 5, 6};
　　　　　　　　int[] destination = new int[6];
　　　　　　　　// تكرار وتحويل العنصر من المصدر إلى الهدف
　　　　　　　　for (int i = 0; i < source.length; ++i) {
　　　　　　　　　　　　destination[i] = source[i];
　　　　　　　　}
　　　　　　
　　　　　　　　　// تحويل المجموعة إلى سلسلة
　　　　　　　　System.out.println(Arrays.toString(destination));
　　　　}
}

الإخراج:

[1, 2, 3, 4, 5, 6]

في المثال السابق، قمنا باستخدام دورة for لمرور كل عنصر من مجموعة المصادر. في كل تكرار، نقوم بنسخ العنصر من مجموعة المصادر إلى مجموعة الهدف.

في هذا السياق، مجموعة المصادر ومجموعة الهدف تشير إلى كيانين مختلفين (نسخ عميق). لذلك، إذا تم تعديل عنصر من مجموعة، فإن العنصر المتبادل في مجموعة أخرى سيظل ثابتًا.

لاحظ الآتي،

System.out.println(Arrays.toString(destination));

في هذا السياق، يتم استخدام طريقة toString() لتحويل المجموعة إلى سلسلة.

3. نسخ المجموعة باستخدام طريقة arraycopy()

في Java،فئة Systemيُضم إلى الحزمة طريقة تُدعى arraycopy() لنسخ المجموعات. بالمقارنة مع الطريقتين السابقتين، هذا الأسلوب هو أفضل طريقة لنسخ المجموعات.

　يُمكّنك هذا الأسلوب من نسخ الجزء المحدد من مجموعة المصادر إلى مجموعة الهدف. على سبيل المثال،

arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

这里，

• src -您要复制的源数组

• srcPos -源数组中的起始位置（索引）

• dest -目标数组，将从源中复制元素

• destPos -目标数组中的起始位置（索引）

• length -要复制的元素数

让我们举个实例：

//使用Arrays.toString()方法
import java.util.Arrays;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　int[]　n1　=　{2,　3,　12,　4,　12,　-2};
　　　　　　
　　　　　　　　int[]　n3　=　new　int[5];
　　　　　　　　//创建长度为n1的n2数组
　　　　　　　　int[]　n2　=　new　int[n1.length];
　　　　　　
　　　　　　　　//将整个n1数组复制到n2
　　　　　　　　System.arraycopy(n1,　0,　n2,　0,　n1.length);
　　　　　　　　System.out.println("n2　=　"　+　Arrays.toString(n2));　　
　　　　　　
　　　　　　　　　//从n1数组的索引2复制元素
　　　　　　　　　//将元素复制到n3数组的索引1
　　　　　　　　//将复制2个元素
　　　　　　　　System.arraycopy(n1,　2,　n3,　1,　2);
　　　　　　　　System.out.println("n3　=　"　+　Arrays.toString(n3));　　
　　　　}
}

الإخراج:

n2　=　[2,　3,　12,　4,　12,　-2]
n3　=　[0,　12,　4,　0,　0]

在上面的示例中，我们使用了arraycopy()方法，

• System.arraycopy(n1, 0, n2, 0, n1.length) - 将n1数组中的整个元素复制到n2数组中

• System.arraycopy(n1, 2, n3, 1, 2 )-　 从索引2开始的n1数组的两个元素被复制到从n3数组1开始的索引中

正如您看到的，int类型数组元素的默认初始值为0。

4.使用copyOfRange()方法复制数组

我们还可以使用Java Arrays类中定义的copyOfRange()方法来复制数组。例如，

//使用toString()和copyOfRange()方法
import java.util.Arrays;
class　ArraysCopy　{
　　　　public static void main(String[] args) {
　　　　　　
　　　　　　　　int[]　source　=　{2,　3,　12,　4,　12,　-2};
　　　　　　
　　　　　　　　//将整个源数组复制到目标
　　　　　　　　int[] destination1 = Arrays.copyOfRange(source, 0, source.length);　　　　　　
　　　　　　　　System.out.println("destination1 = " + Arrays.toString(destination1))　
　　　　　　
　　　　　　　　//نسخ من مؤشر 2 إلى 5 (لا يشمل 5)　
　　　　　　　　int[] destination2 = Arrays.copyOfRange(source, 2, 5);　
　　　　　　　　System.out.println("destination2 = " + Arrays.toString(destination2));　　　
　　　　}
}

نتائج الخروج

destination1 = [2, 3, 12, 4, 12, -2]
destination2 = [12, 4, 12]

في المثال أعلاه، يرجى ملاحظة السطر التالي:

int[] destination1 = Arrays.copyOfRange(source, 0, source.length);

في هذا السياق، يمكننا رؤية أننا نقوم بإنشاء مصفوفة destination1 وتسجيل مصفوفة المصدر فيها. لن نقوم بإنشاء مصفوفة destination1 قبل تنفيذ طريقة copyOfRange(). للحصول على مزيد من المعلومات حول هذه الطريقة، يرجى زيارةJava copyOfRange.

5. استخدام الدوران لنسخ مصفوفة ثنائية الأبعاد

مثل مصفوفة أحادية الأبعاد، يمكننا أيضًا استخدام دوران لنسخ مصفوفة ثنائية الأبعاد. على سبيل المثال،

import java.util.Arrays;
class Main {
　　　　public static void main(String[] args) {
　　　　　　
　　　　　　　　int[][] source = {
　　　　　　　　　　　　　　{1, 2, 3, 4},　
　　　　　　　　　　　　　　{5, 6},
　　　　　　　　　　　　　　{0, 2, 42, -4, 5}
　　　　　　　　　　　　　　};
　　　　　　　　int[][] destination = new int[source.length][];
　　　　　　　　for (int i = 0; i < destination.length; ++i) {
　　　　　　　　　　　　// تخصيص مساحة لكل سطر في مصفوفة الهدف
　　　　　　　　　　　　destination[i] = new int[source[i].length];
　　　　　　　　　　　　for (int j = 0; j < destination[i].length; ++j) {
　　　　　　　　　　　　　　　　destination[i][j] = source[i][j];
　　　　　　　　　　　　}
　　　　　　　　}
　　　　　
　　　　　　　　// عرض مصفوفة الهدف
　　　　　　　　System.out.println(Arrays.deepToString(destination));　　
　　　　　　
　　　　}
}

الإخراج:

[[1, 2, 3, 4], [5, 6], [0, 2, 42, -4, 5]]

في البرنامج أعلاه، يرجى ملاحظة السطر التالي:

System.out.println(Arrays.deepToString(destination));

في هذا السياق، يتم استخدام طريقة deepToString() لتقديم تمثيل أفضل للمصفوفة الثنائية الأبعاد. للحصول على مزيد من المعلومات، يرجى زيارةJava deepToString().

استخدام arraycopy() لنسخ مصفوفة ثنائية الأبعاد

لجعل الكود أعلاه أكثر بساطة، يمكننا استخدام System.arraycopy() لاستبدال الدوران الداخلي، مثل معالجة مصفوفة أحادية الأبعاد. على سبيل المثال،

import java.util.Arrays;
class Main {
　　　　public static void main(String[] args) {
　　　　　　
　　　　　　　　int[][] source = {
　　　　　　　　　　　　　　{1, 2, 3, 4},　
　　　　　　　　　　　　　　{5, 6},
　　　　　　　　　　　　　　{0, 2, 42, -4, 5}
　　　　　　　　　　　　　　};
　　　　　　　　int[][] destination = new int[source.length][];
　　　　　　　　for (int i = 0; i < source.length; ++i) {
　　　　　　　　　　　　　// تخصيص مساحة لكل سطر في مصفوفة الهدف
　　　　　　　　　　　　　destination[i] = new int[source[i].length];
　　　　　　　　　　　　　System.arraycopy(source[i], 0, destination[i], 0, destination[i].length);
　　　　　　　　}
　　　　　
　　　　　　　　// عرض مصفوفة الهدف
　　　　　　　　System.out.println(Arrays.deepToString(destination));　　　　　　
　　　　}
}

الإخراج:

[[1, 2, 3, 4], [5, 6], [0, 2, 42, -4, 5]]

　في هذا السياق، يمكننا رؤية أننا نحصل على نفس الناتج من خلال استبدال الدائرة الداخلية باستخدام طريقة arraycopy().