Fjern element fra Array i 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.
