Java >> Java tutorial >  >> Java

Kopier Array i Java

Java

Kopiér Array i Java | Array-programmer i Java – 9 | I det tidligere Java-program har vi set, hvordan man sammenligner to arrays i Java. Nu i dette indlæg vil vi se Java Array Copy | Sådan klones eller kopieres array i Java? Hvordan kopierer man et 2D-array i Java? Hvad er de forskellige måder at kopiere arrays på i Java? Her vil vi diskutere alle disse punkter.

Der er forskellige indbyggede metoder som System.arraycopy(), Arrays.copyOf(), Arrays.copyOfRange() og clone()-metoden, som kan bruges til at kopiere array i Java. Vi kan også kopiere manuelt ved at tildele hvert element til et andet array-element. Lad os se dem én efter én.

Shallow Copy of Array i Java ved hjælp af assignment Operator (=)

Vi kan kopiere array i Java ved at bruge opgaveoperatoren (=). Lad os demonstrere det gennem et eksempel.

import java.util.Arrays;

public class CopyArray {

   public static void main(String[] args) {
      // original array
      int arr[] = {10, 20, 30, 40, 50};
      
      // copy array using assignment operator
      int newArr[] = arr;
      
      // display array
      System.out.println("Original Array = " 
                        + Arrays.toString(arr));
      System.out.println("Copied Array = " 
                        + Arrays.toString(newArr));
   }
}

Output:-

Original Array =[10, 20, 30, 40, 50]
Kopieret Array =[10, 20, 30, 40, 50]

For at vise arrayet har vi brugt toString()-metoden, som er givet i klassen java.util.Arrays. Men du kan også bruge loops som for loop, for-each loop, og e.t.c. Se:- Forskellige måder at udskrive/vise array på i Java.

Det er et eksempel på en overfladisk kopi . I lav kopi tildeles arrayets reference til det nye array.

Begrænsning af denne tilgang:- Hvis vi ændrer indholdet af det originale array, vil indholdet af det nyoprettede array også ændre sig. Nedenstående program viser dette punkt,

// original array
int arr[] = {10, 20, 30, 40, 50};

// copy array using assignment operator
int newArr[] = arr;

// display array (Before Modification)
System.out.println("Before Modification,");
System.out.println("Original Array = " + Arrays.toString(arr));
System.out.println("Copied Array = " + Arrays.toString(newArr));

// modifying content of original array
arr[0] = 555;
arr[3] = 777;

// display array (After Modification)
System.out.println("\nAfter Modification,");
System.out.println("Original Array = " + Arrays.toString(arr));
System.out.println("Copied Array = " + Arrays.toString(newArr));

Output:-

Før ændring,
Original Array =[10, 20, 30, 40, 50]
Kopieret Array =[10, 20, 30, 40, 50]

Efter ændring,
Original Array =[555, 20, 30, 777, 50]
Kopieret Array =[555, 20, 30, 777, 50]

Deep Copy of Array i Java ved hjælp af Loops

For at skabe en dyb kopi af arrayet i Java ved hjælp af loop, skal vi udføre følgende operationer:-
1) Opret et nyt array med en lignende datatype og størrelse.
2) Brug loopen til at iterere gennem det originale array.
3) Kopiér det ith-element i det originale array til det ith-element i det nye array.

Før du opretter et nyt array, skal du først beregne størrelsen på det originale array. Længdeegenskaben for arrayet kan bruges til at beregne størrelsen af ​​et array i Java. Lad os nu demonstrere den dybe kopi af arrayet ved hjælp af loops.

import java.util.Arrays;

public class CopyArray {

   public static void main(String[] args) {
      // original array
      int arr[] = { 10, 20, 30, 40, 50 };

      // create new array with similar type and size
      int newArr[] = new int[arr.length];

      // copy using loop
      for (int i = 0; i < arr.length; i++) {
         // copy elements
         newArr[i] = arr[i];
      }

      // display array
      System.out.println("Original Array = " 
                          + Arrays.toString(arr));
      System.out.println("Copied Array = " 
                          + Arrays.toString(newArr));
   }
}

Output:-

Original Array =[10, 20, 30, 40, 50]
Kopieret Array =[10, 20, 30, 40, 50]

I en dyb kopi er hvert element i det originale array tildelt til et nyt array, så hver gang vi ændrer indholdet af det originale array, vil elementerne i det nyoprettede array ikke blive påvirket. 

// original array
int arr[] = { 10, 20, 30, 40, 50 };

// create new array with similar type and size
int newArr[] = new int[arr.length];

// copy using loop
for (int i = 0; i < arr.length; i++) {
   // copy elements
   newArr[i] = arr[i];
}

// display array (Before Modification)
System.out.println("Before Modification,");
System.out.println("Original Array = " + Arrays.toString(arr));
System.out.println("Copied Array = " + Arrays.toString(newArr));

// modifying content of original array
arr[0] = 555;
arr[3] = 777;

// display array (After Modification)
System.out.println("\nAfter Modification,");
System.out.println("Original Array = " + Arrays.toString(arr));
System.out.println("Copied Array = " + Arrays.toString(newArr));

Output:-

Før ændring,
Original Array =[10, 20, 30, 40, 50]
Kopieret Array =[10, 20, 30, 40, 50]

Efter ændring,
Original Array =[555, 20, 30, 777, 50]
Kopieret Array =[10, 20, 30, 40, 50]

Kopiér Array i Java ved hjælp af System.arraycopy()

System.arraycopy()-metoden i Java er givet for at kopiere et array til et andet array. Den kopierer et array fra det angivne kildearray, begyndende ved den angivne position, til den angivne position for destinationsarrayet.

Syntaks for arraycopy()-metoden i java.lang.System class:- public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);

I denne syntaks,

  • src:- Kildearrayet.
  • srcPos:- Startposition i kildearrayet.
  • dest:- Destinationsarrayet.
  • destPos:- startposition i destinationsdataene.
  • længde:- antallet af array-elementer, der skal kopieres.

Da java.lang.System-klassen importeres som standard i alle Java-klasser, er det derfor ikke nødvendigt at bruge arraycopy()-metoden eksplicit.

Program til at kopiere array i Java ved hjælp af System.arraycopy()-metoden 

import java.util.Arrays;

public class CopyArray {

   public static void main(String[] args) {
      // original array
      int arr[] = { 10, 20, 30, 40, 50 };

      // create new array with similar type and size
      int newArr[] = new int[arr.length];

      // copy array using System.arraycopy
      System.arraycopy(arr, 0, newArr, 0, arr.length);

      System.out.println("Original Array = " + Arrays.toString(arr));
      System.out.println("Copied Array = " + Arrays.toString(newArr));
   }

}

Output:-

Original Array =[10, 20, 30, 40, 50]
Kopieret Array =[10, 20, 30, 40, 50]

Den udfører en overfladisk kopi af arrayet. Det betyder, at når arraycopy() anvendes på ikke-primitive arrays, så kopierer den objektreferencer i stedet for objektdata.

I dens respektive post af System.arraycopy()-metoden har vi allerede verificeret dette punkt gennem 2D-arrayet og ved hjælp af en række objekter. Igen i dette indlæg vil vi se det, mens vi diskuterer kopien af ​​2D-array.

Bemærk:- arraycopy() er sandsynligvis den hurtigste måde at kopiere et array, og det giver bedre ydeevne sammenlignet med normal array-kopiering ved hjælp af loops. Det er i systemet, fordi det bruger en direkte hukommelseskopi uden for Java-land. Java.lang.System-klassen giver nyttige metoder til standardinput og -output, til indlæsning af filer og biblioteker eller til at få adgang til eksternt definerede egenskaber.

Kopiér array i Java ved hjælp af Arrays.copyOf()-metoden

copyOf()-metoden af java.util.Arrays-klassen i Java kopierer det angivne array, trunkerer eller udfylder med nuller/nuller (hvis nødvendigt). Internt kalder denne metode System.arraycopy()-metoden .

Der er i alt 10 overbelastede former for Arrays.copyOf()-metoden. Nogle af dem er angivet nedenfor. De resterende overbelastede former for Arrays.copyOf()-metoden implementeres på lignende måde. CopyOf()-metoden med alle dens overbelastede former blev introduceret i Java 1.6-version .

  • public static int[] copyOf(int[] original, int newLength)
  • public static <T> T[] copyOf(T[] original, int newLength)

I disse metoder er parametrene,

  • original:- Det array, der skal kopieres.
  • newLength:- Længden af ​​den kopi, der skal returneres.

Program til at kopiere array i Java ved hjælp af Arrays.copyOf()-metoden, 

import java.util.Arrays;

public class CopyArray {

   public static void main(String[] args) {
      // original array
      int arr[] = { 10, 20, 30, 40, 50 };

      // copy array using Arrays.copyOf()
      int[] newArr = Arrays.copyOf(arr, arr.length);

      System.out.println("Original Array = " + Arrays.toString(arr));
      System.out.println("Copied Array = " + Arrays.toString(newArr));
   }

}

Output:-

Original Array =[10, 20, 30, 40, 50]
Kopieret Array =[10, 20, 30, 40, 50]

Yderligere point,

  • Denne metode kaster NullPointerException, hvis det beståede originale array er null. Derfor er det bedre at tjekke if(original !=null) og derefter kalde copyOf().
  • Den kaster også NegativeArraySizeException, hvis den beståede længde (dvs. newLength) er negativ.

Siden Arrays.copyOf() metode internt ved hjælp af System.arraycopy() derfor er det også udførelse overfladisk kopi.

Kopiér array i Java ved hjælp af Arrays.copyOfRange()-metoden

I lighed med Arrays.copyOf()-metoden kan vi også bruge Arrays.copyOfRange()-metoden . Begge metoder er meget ens, og metoden copyOfRange() udfører kun kopieringsoperationer inden for det angivne område. I lighed med copyOf()-metoden internt, bruger den også System.arraycopy() metoden og udfører den overfladiske kopi . Der er mange overbelastede former for denne metode,

  • public static int[] copyOfRange(int[] original, int from, int to)

I denne metode er parametrene,

  • original:- Det array, hvorfra et område skal kopieres.
  • fra:- Det indledende indeks for det område, der skal kopieres, er inklusive.
  • til:- det endelige indeks for det område, der skal kopieres, eksklusivt. Dette indeks kan ligge uden for arrayet.

Metoden copyOfRange() returnerer en ny matrix, der indeholder det angivne interval fra den originale matrix, trunkeret eller polstret med nuller for at opnå den nødvendige længde. Lad os demonstrere det gennem et eksempel.

Program til kopiering af array i Java ved hjælp af Arrays.copyOfRange()-metoden 

// original array
int arr[] = { 10, 20, 30, 40, 50 };

// copy array 
int[] newArr = Arrays.copyOfRange(arr, 0, arr.length);

System.out.println("Original Array = " + Arrays.toString(arr));
System.out.println("Copied Array = " + Arrays.toString(newArr));

Original Array =[10, 20, 30, 40, 50]
Kopieret Array =[10, 20, 30, 40, 50]

Java Array Clone

Vi kan også udføre array-kopiering i Java ved hjælp af clone()-metoden i java.lang.Object-klassen. Clone()-metoden i klassen java.lang.Object udfører en overfladisk kopi . Det betyder, at når clone() anvendes på ikke-primitive arrays, så kopierer den objektreferencer i stedet for objektdata. Lad os demonstrere det gennem et eksempel,

Kopiér array i Java ved hjælp af clone()-metoden 

import java.util.Arrays;

public class CopyArray {

   public static void main(String[] args) {
      // original array
      int arr[] = { 10, 20, 30, 40, 50 };

      // copy array using clone()
      int[] newArr = arr.clone();
       
      // display array (Before Modification)
      System.out.println("Before Modification,");
      System.out.println("Original Array = " + Arrays.toString(arr));
      System.out.println("Copied Array = " + Arrays.toString(newArr));

      // modifying content of original array
      arr[0] = 555;
      arr[3] = 777;

      // display array (After Modification)
      System.out.println("\nAfter Modification,"); 
      System.out.println("Original Array = " + Arrays.toString(arr));
      System.out.println("Copied Array = " + Arrays.toString(newArr));
   }
}

Output:-

Før ændring,
Original Array =[10, 20, 30, 40, 50]
Kopieret Array =[10, 20, 30, 40, 50]

Efter ændring,
Original Array =[555, 20, 30, 777, 50]
Kopieret Array =[10, 20, 30, 40, 50]

Flere eksempel

Alle de foregående eksempler bruger int type array. Lad os se et eksempel på en anden type array. Her vil vi demonstrere System.arraycopy(), Arrays.copyOf(), Arrays.copyOfRange()-metoden i et enkelt eksempel. For at demonstrere hver metode skal du fjerne kommentarer og kommentere de resterende to tilgange. 

import java.util.Arrays;

public class CopyArray {

   public static void main(String[] args) {
      // original array
      String str[] = {"Java", "Python", "C++"};

      // copy array using System.arraycopy()
      String[] newArr = new String[str.length];
      System.arraycopy(str, 0, newArr, 0, str.length);
      
      // copy using Arrays.copyOf()
      // String[] newArr = Arrays.copyOf(str, str.length);
      
      // copy using clone()
      // String[] newArr = str.clone();
      
      // display array (Before Modification)
      System.out.println("Before Modification,");
      System.out.println("Original Array = " + Arrays.toString(str));
      System.out.println("Copied Array = " + Arrays.toString(newArr));

      // modifying content of original array
      str[0] = "C#";
      str[2] = "HTML";

      // display array (After Modification)
      System.out.println("\nAfter Modification,"); 
      System.out.println("Original Array = " + Arrays.toString(str));
      System.out.println("Copied Array = " + Arrays.toString(newArr));
   }

}

Output:-

Før ændring,
Original Array =[Java, Python, C++]
Kopieret Array =[Java, Python, C++]

Efter ændring,
Original Array =[ C#, Python, HTML]
Kopieret array =[Java, Python, C++]

Kopiér 2D Array i Java

I alle de foregående eksempler kopierede vi det enkeltdimensionelle array. Lad os nu se forskellige tilgange til at kopiere det multidimensionelle array i Java. Vi vil demonstrere alle disse punkter gennem et todimensionelt array.

Shallow Copy af 2D Array i Java

Java-program til at kopiere todimensionelt (2D) array i Java ved hjælp af System.arraycopy()-metoden, 

import java.util.Arrays;

public class CopyArray {
   public static void main(String[] args) {

      // original 2D array 3x2
      int src[][] = { { 1, 2 }, { 4, 5 }, { 7, 8 } };

      // destination array
      int dest[][] = new int[3][2];

      // copy array using System.arraycopy
      System.arraycopy(src, 0, dest, 0, src.length);

      // display both array
      System.out.println("Source array = " + Arrays.deepToString(src));
      System.out.println("Destination array = " 
                          + Arrays.deepToString(dest) );

   }
}

Output:-

Kildearray =[[ 1, 2], [ 4, 5], [ 7, 8]]
Destinationsarray =[[ 1, 2], [ 4, 5], [ 7, 8]]

Java-program til kopiering af todimensional 2D array i Java ved hjælp af Arrays.copyOf () metode, 

// original 2D array 3x2
int src[][] = { { 1, 2 }, { 4, 5 }, { 7, 8 } };

// copy array using Arrays.copyOf()
int dest[][] = Arrays.copyOf(src, src.length);

// display both array
System.out.println("Source array = " + Arrays.deepToString(src));
System.out.println("Destination array =" +Arrays.deepToString(dest));

Output:-

Kildearray =[[ 1, 2], [ 4, 5], [ 7, 8]]
Destinationsarray =[[ 1, 2], [ 4, 5], [ 7, 8]]

Java-program til at kopiere todimensionelt 2D-array i Java ved hjælp af Arrays.copyOfRange()-metoden, 

// original 2D array 3x2
int src[][] = { { 1, 2 }, { 4, 5 }, { 7, 8 } };

// copy array 
int dest[][] = Arrays.copyOfRange(src, 0, src.length);

// display both array
System.out.println("Source array = " + Arrays.deepToString(src));
System.out.println("Destination array = "+Arrays.deepToString(dest));

Kildearray =[[ 1, 2], [ 4, 5], [ 7, 8]]
Destinationsarray =[[ 1, 2], [ 4, 5], [ 7, 8]]

Java-program til kopiering af todimensional 2D array i Java ved hjælp af clone() metode , 

// 2D array 3x2
int src[][] = { { 1, 2 }, { 4, 5 }, { 7, 8 } };

// copy array using clone()
int dest[][] = src.clone();

// display array
System.out.println("Source array = " + Arrays.deepToString(src));
System.out.println("Destination array = " + Arrays.deepToString(dest));

Kildearray =[[ 1, 2], [ 4, 5], [ 7, 8]]
Destinationsarray =[[ 1, 2], [ 4, 5], [ 7, 8]]

Begrænsninger ved disse tilgange

Metoderne System.arraycopy(), Arrays.copyOf(), Arrays.copyOfRange() og clone() udfører overfladisk kopi, hvilket kan skabe flere problemer. Lad os demonstrere det gennem et eksempel:-

import java.util.Arrays;

public class CopyArray {

   public static void main(String[] args) {

      // original array
      int src[][] = { { 1, 2 }, { 4, 5 }, { 7, 8 } };
      
      // copy array using System.arraycopy()
      int dest[][] = new int[3][2];
      System.arraycopy(src, 0, dest, 0, src.length);
      
      // copy array using Arrays.copyOf()
      // int dest[][] = Arrays.copyOf(src, src.length);
      
      // copy array using clone()
      // int dest[][] = src.clone();

      // display array (Before Modification)
      System.out.println("Before Modification,");
      System.out.println("Source array = " + Arrays.deepToString(src));
      System.out.println("Destination array = " 
                        + Arrays.deepToString(dest));

      // modify original array
      src[0][0] = 999;
      src[1][1] = 888;

      // display array (After Modification)
      System.out.println("\nAfter Modification,");
      System.out.println("Source array = " + Arrays.deepToString(src));
      System.out.println("Destination array = " 
                        + Arrays.deepToString(dest));
   }
}

Output:-

Før ændring,
Kildearray =[[ 1, 2], [ 4, 5], [ 7, 8]]
Destinationsarray =[[ 1, 2], [ 4, 5], [ 7, 8]]

Efter ændring,
Kildearray =[[ 999, 2], [ 4, 888], [ 7, 8]]
Destinationsarray =[[ 999, 2], [ 4, 888], [ 7, 8]]

Dyb kopi af 2D Array i Java

Vi kan udføre dyb kopiering ved hjælp af loops. For at gøre dette skal du gentage det multidimensionelle array og kopiere hvert element til det nye array. Lad os se det gennem et eksempel. I dette program vil vi skrive logik for at kopiere et array inde i metoden. Se:- Sådan finder du størrelse/længde af 2D-array

import java.util.Arrays;

public class CopyArray {

   // copy multidimensional array using loop (deep copy)
   public static int[][] copy(int[][] src) {
      // create 2D array and assign size of parent array
      int temp[][] = new int[src.length][];

      for (int i = 0; i < src.length; i++) {
         // assign size of child array
         temp[i] = new int[src[i].length];

         for (int j = 0; j < src[i].length; j++) {
            // copy element
            temp[i][j] = src[i][j];
         }
      }

      // return
      return temp;
   }

   public static void main(String[] args) {

      // original 2D array 3x2
      int src[][] = { { 1, 2 }, { 4, 5 }, { 7, 8 } };

      // copy array 
      int dest[][] = copy(src);

      // display both array
      System.out.println("Source array = " + Arrays.deepToString(src));
      System.out.println("Destination array = " 
                    + Arrays.deepToString(dest));

      // modify original array
      src[0][0] = 999;
      src[1][1] = 888;

      // display array (After Modification)
      System.out.println("\nAfter Modification,");
      System.out.println("Source array = " + Arrays.deepToString(src));
      System.out.println("Destination array = " 
                    + Arrays.deepToString(dest));

   }

}

Output:-

Før ændring,
Kildearray =[[ 1, 2], [ 4, 5], [ 7, 8]]
Destinationsarray =[[ 1, 2], [ 4, 5], [ 7, 8]]

Efter ændring,
Kildearray =[[ 999, 2], [ 4, 888], [ 7, 8]]
Destinationsarray =[[ 1, 2], [ 4, 5], [ 7, 8]]

Da vi tager eksemplet med en 2D-array af heltal, kan vi derfor også tage hjælp af System.arraycopy(), Arrays.copyOf() og Arrays.copyOfRange()-metoden til at kopiere 1D-array.

Bemærk, at disse metoder kun udfører overfladisk kopiering, når den givne matrix er ikke-primitiv. Det betyder, at når disse metoder anvendes på ikke-primitive arrays, så kopierer det kun objektreferencer i stedet for objektdata. Men matrix eller vores 2D-array i dette eksempel indeholder en matrix af int-værdier ved den anden dimension. Derfor kan vi bruge dem som følger:-

// copy multidimensional array (deep copy)
public static int[][] copy(int[][] src) {
      
   // create 2D array and assign size of parent array
   int temp[][] = new int[src.length][];

   for (int i = 0; i < src.length; i++) {
      // copy second dimensional array
      temp[i] = Arrays.copyOf(src[i], src[i].length); 
   }

   // return
   return temp;
}

Erstat denne metode med den forrige metode. Outputtet for denne gang,

Før ændring,
Kildearray =[[ 1, 2], [ 4, 5], [ 7, 8]]
Destinationsarray =[[ 1, 2], [ 4, 5], [ 7, 8]]

Efter ændring,
Kildearray =[[ 999, 2], [ 4, 888], [ 7, 8]]
Destinationsarray =[[ 1, 2], [ 4, 5], [ 7, 8]]


Java tag