Fjern element fra Array i Java

Java

Sådan fjerner du et element fra et array i Java efter indeks eller værdi. Der er forskellige måder at fjerne et element fra et array efter indeks og at fjerne efter værdien, find først indekset for et givet element/værdi og brug derefter den tidligere fremgangsmåde. Lad os diskutere dem i detaljer.

Indholdsfortegnelse

Fjern element fra Array by Index i Java

Fjern element ved hjælp af et andet array og loop
Brug af System.arraycopy()
Ved hjælp af Java 8 Streams
Brug af ArrayList

Fjern element fra array i Java efter værdi

Fjern element fra array efter indeks i Java

Der er forskellige måder at fjerne et element på et specifikt indeks fra et array i Java.
a) Fjern element ved hjælp af et andet array og Loop
b) Brug af System.arraycopy()
c) Med hjælp fra Java 8 Streams
d) Brug af ArrayList

Fjern element ved hjælp af et andet array og loop

Det er den naive eller grundlæggende tilgang til at fjerne et element ved hjælp af et andet array og loops. Operationerne kan udføres som,

a) Tag et array og indekset.
b) Opret et nyt array med størrelse 1 mindre end det originale array.
c) Kopier elementer af det originale array til det nye array.
d ) Spring kopieringselementet over ved indekspositionen.
e) Returner det kopierede nye array.

import java.util.Arrays;
public class ArrayTest {

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

      // index of element to be removed 
      int index = 3;

      // display old array
      System.out.println("Original array: " + Arrays.toString(arr));

      // remove
      arr = removeElement(arr, index);

      // display new array
      System.out.println("New array: " + Arrays.toString(arr));
   }

   // method to remove element at specific index
   public static int[] removeElement(int[] arr, int index) {

      // if array is null or index is negative or more then size 
      // return original array
      if(arr == null || index < 0 || index >= arr.length) {
         System.out.println("Invalid array or index.");
         return arr;
      }
      
      // create new array of size-1
      int temp[] = new int[arr.length-1];
      
      // copy and skip at index
      for (int i = 0, j = 0; i < arr.length; i++) {
         if(i == index) {
            continue;
         }
         temp[j++] = arr[i];
      }

      return temp;
   }
}

Output:-

Original matrix:[10, 20, 30, 40, 50]
Ny matrix:[10, 20, 30, 50]

Brug af System.arraycopy()

Metoden System.arraycopy() bruges til at kopiere et array. Da det er en native metode, giver den bedre ydeevne sammenlignet med loops.

public static native void arraycopy(Object src,  int  srcPos,
                    Object dest, int destPos, int length);

Argumenterne er:-
• src:- Kildearrayet.
• srcPos:- Startposition i kildearrayet.
• dest:- Destinationsarrayet.
• destPos :- startposition i destinationsmatrixen.
• længde:- antallet af matrixelementer, der skal kopieres.

Denne tilgang ligner den forrige, men her vil vi bruge System.arraycopy() metoden i stedet for loops. Her kan operationerne også udføres som,

a) Tag et array og indekset.
b) Opret et nyt array med størrelse 1 mindre end det oprindelige array.
c) Kopier elementer af det originale array fra 0 til index-1 til det nye array.
d) Kopier ikke elementet på den angivne indeksposition.
e) Kopier elementer af det originale array fra index+1 til slutningen til det nye array.
f) Returner det kopierede nye array .

Metoden kan skrives som,

// method to remove element at specific index using arraycopy()
public static int[] removeElement(int[] arr, int index) {

   // if array is null or index is negative or more then size 
   // return original array
   if(arr == null || index < 0 || index >= arr.length) {
      System.out.println("Invalid array or index.");
      return arr;
   }
   
   // create new array with size-1
   int temp[] = new int[arr.length-1];
   
   // copy from 0 to index-1
   System.arraycopy(arr, 0, temp, 0, index);

   // copy from index+1 to end
   System.arraycopy(arr, index+1, temp, index, arr.length-index-1);
      
   return temp;
}

Ved hjælp af Java 8 Streams

Ved hjælp af Java 8-stream kan vi også fjerne elementet fra arrayet. For at vi skal importere java.util.stream.IntStream; I denne tilgang,

a) Tag et array og indekset.
b) Konverter arrayet til IntStream ved hjælp af IntStream.range()-metoden.
c) Fjern elementet ved det specificerede indekselement ved hjælp af filter()-metoden.
d) Kortlæg og form en ny matrix af de filtrerede elementer ved hjælp af map() og toArray() metoder.
e) Returner den dannede matrix.

import java.util.Arrays;
import java.util.stream.IntStream;

public class ArrayTest {

   public static void main(String[] args) {
      int arr[] = { 10, 20, 30, 40, 50 };
      int index = 3; // index
      System.out.println("Original array: " + Arrays.toString(arr));
      arr = removeElement(arr, index);
      System.out.println("New array: " + Arrays.toString(arr));
   }

   // method to remove element at specific index 
   // using Java 8 Streams
   public static int[] removeElement(int[] arr, int index) {

      // if array is null or index is negative or more then size 
      // return original array
      if(arr == null || index < 0 || index >= arr.length) {
         System.out.println("Invalid array or index.");
         return arr;
      }
      
      // return the resultant array 
       return IntStream.range(0, arr.length) 
           .filter(i -> i != index) 
           .map(i -> arr[i]) 
           .toArray(); 
   }
}

Output:-

Original matrix:[10, 20, 30, 40, 50]
Ny matrix:[10, 20, 30, 50]

Brug af ArrayList

ArrayList kan også bruges til at fjerne elementer fra arrayet i Java-programmeringssproget. I denne tilgang,
a) Tag et array og indekset.
b) Konverter array til ArrayList
c) Form en ArrayList med array-elementerne.
d) Fjern den angivne indekselement ved hjælp af remove()-metoden.
e) Dann et nyt array af ArrayList ved hjælp af mapToInt()- og toArray()-metoderne.
f) Returner det dannede array.

Nedenstående Java-program demonstrerer ovenstående tilgang,

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class ArrayTest {

   public static void main(String[] args) {
      int arr[] = { 10, 20, 30, 40, 50 };
      int index = 2; // index
      System.out.println("Original array: " + Arrays.toString(arr));
      arr = removeElement(arr, index);
      System.out.println("New array: " + Arrays.toString(arr));
   }

   // method to remove element at specific index using ArrayList
   public static int[] removeElement(int[] arr, int index) {
      
      // if array is null or index is negative or more then size
      // return original array
      if (arr == null || index < 0 || index >= arr.length) {
         System.out.println("Invalid array or index.");
         return arr;
      }

      // Create ArrayList to Array
      List<Integer> list = IntStream.of(arr).boxed().
            collect(Collectors.toList());

      // remove the element from specified index
      list.remove(index);

      // return the resultant array
      return list.stream().
            mapToInt(Integer::intValue).toArray();

   }
}

Output:-

Original matrix:[10, 20, 30, 40, 50]
Ny matrix:[10, 20, 30, 50]

Fjern element fra Array i Java efter værdi

At fjerne et bestemt element fra et array , skal vi finde dets indeks. Efter at have fundet indekset kan vi en hvilken som helst af ovenstående metoder til at fjerne et element fra et array ved det angivne indeks.

Hvis arrayet er sorteret, kan vi bruge den binære søgning (Arrays.binarySearch() metoden ) ellers kan vi bruge lineær søgning. Lad os demonstrere det gennem lineær søgning.

import java.util.Arrays;

public class ArrayTest {

   public static void main(String[] args) {

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

      // element to be removed
      int element = 40;

      // display old array
      System.out.println("Original array: " + Arrays.toString(arr));

      // remove specified element
      arr = removeElement(arr, element);

      // display new array
      System.out.println("New array: " + Arrays.toString(arr));
   }
   
   // method to remove specified element from array
   public static int[] removeElement(int[] arr, int element) {
      // find index
      int index = search(arr, element);
      
      // check index
      if(index == -1) {
         System.out.println("Element not found");
         return arr;
      }
      
      // remove element at specified index
      return removeAt(arr, index);
   }

   // linear search to return index of element
   public static int search(int[] arr, int element) {
      for (int i = 0; i < arr.length; i++) {
         if (arr[i] == element) {
            return i;
         }
      }
      return -1; // if element not found 
   }

   // method to remove element at specific index 
   // using System.arraycopy()
   public static int[] removeAt(int[] arr, int index) {
      
      // create new array with size-1
      int temp[] = new int[arr.length - 1];

      // copy from 0 to index-1
      System.arraycopy(arr, 0, temp, 0, index);

      // copy from index+1 to end
      System.arraycopy(arr, index + 1, temp, index, 
            arr.length - index - 1);

      return temp;
   }
}

Output:-

Original matrix:[50, 20, 10, 40, 30]
Ny matrix:[50, 20, 10, 30]

I dette program, hvis det element, der skal fjernes, har dubletter, vil kun det første matchede element blive fjernet, og de resterende elementer vil være live, som det er.