Копирование массивов Java

В этом руководстве вы узнаете о различных методах копирования массивов (одномерных и двумерных) в Java с помощью примеров.

　В Java мы можем копировать один массив в другой. Есть несколько техник для копирования массивов в Java.

1. Копирование массива с помощью оператора присваивания

Давайте приведем пример

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, мы видим, что изменилось и значение в нем.

Это потому, что оба массива ссылаются на один и тот же объект массива. Это связано с shallow copy. Для получения дополнительной информации о shallow copy посетитеShallow copy。

Теперь, чтобы создать новый объект массива при копировании массива, нам нужно выполнять глубокое копирование, а не shallow copy.

2. Kopирование массива с помощью цикла

Давайте приведем пример:

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 для遍ения каждого элемента исходного массива. В каждом итерации мы копировали элемент из массива source в массив destination.

Здесь исходный и целевой массивы являются ссылками на разные объекты (глубокое копирование). Поэтому, если изменяется элемент одного массива, соответствующий элемент другого массива также останется неизменным.

Обратите внимание на следующие строки:

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

Здесь метод toString() используется для преобразования массива в строку.

3. Kopирование массива с помощью метода 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];
　　　　　　　　//Создание массива n2 длиной n1
　　　　　　　　int[] n2 = new int[n1.length];
　　　　　　
　　　　　　　　//Копирование всего массива n1 в n2
　　　　　　　　System.arraycopy(n1, 0, n2, 0, n1.length);
　　　　　　　　System.out.println("n2 = " + Arrays.toString(n2));　　
　　　　　　
　　　　　　　　　//Элементы копируются из индекса 2 массива n1
　　　　　　　　　//Элементы копируются в индекс 1 массива n3
　　　　　　　　//Копирование 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) - Два элемента массива n1, начинающиеся с индекса 2, копируются в массив 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 и копируем в него исходный массив перед вызовом метода copyOfRange(). Мы не создаем массив destination1 до вызова copyOfRange() метода. Для получения дополнительной информации о методе посетитеJava copyOfRange。

5. Копирование двумерного массива с помощью цикла

Как и одномерный массив, мы можем использовать цикл for для копирования двумерного массива. Например, например,

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]]

　Здесь мы можем видеть, что замена внутреннего цикла for методом arraycopy() приводит к одинаковому выводу.