Supprimer l'élément du tableau en Java
Comment supprimer un élément d'un tableau en Java par index ou par valeur. Il existe différentes manières de supprimer un élément d'un tableau par index et de le supprimer par la valeur. Trouvez d'abord l'index de l'élément/de la valeur donné, puis utilisez l'approche précédente. Discutons-en en détail.
Table des matières- Supprimer l'élément du tableau par index en Java
- Supprimer un élément à l'aide d'un autre tableau et d'une boucle
- Utilisation de System.arraycopy()
- Avec l'aide de Java 8 Streams
- Utiliser ArrayList
- Supprimer l'élément du tableau en Java par valeur
Supprimer l'élément du tableau par index en Java
Il existe différentes manières de supprimer un élément à un index spécifique d'un tableau en Java.
a) Supprimer un élément à l'aide d'un autre tableau et d'une boucle
b) Utiliser System.arraycopy()
c) Avec aide de Java 8 Streams
d) Utilisation de ArrayList
Supprimer un élément à l'aide d'un autre tableau et d'une boucle
C'est l'approche naïve ou basique pour supprimer un élément en utilisant un autre tableau et des boucles. Les opérations peuvent être effectuées comme,
a) Prenez un tableau et l'index.
b) Créez un nouveau tableau avec une taille inférieure de 1 au tableau d'origine.
c) Copiez les éléments du tableau d'origine dans le nouveau tableau.
d ) Ignore l'élément de copie à la position d'index.
e) Renvoie le nouveau tableau copié.
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;
}
} Sortie :-
Tableau d'origine :[10, 20, 30, 40, 50]
Nouveau tableau :[10, 20, 30, 50]
Utilisation de System.arraycopy()
La méthode System.arraycopy() est utilisée pour copier un tableau. Comme il s'agit d'une méthode native, elle offre donc de meilleures performances par rapport aux boucles.
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos, int length);
Les arguments sont :-
• src :- le tableau source.
• srcPos :- la position de départ dans le tableau source.
• dest :- le tableau de destination.
• destPos :- position de départ dans le tableau de destination.
• longueur :- le nombre d'éléments du tableau à copier.
Cette approche est similaire à la précédente, mais ici nous utiliserons la méthode System.arraycopy() au lieu de boucles. Ici aussi, les opérations peuvent être effectuées comme,
a) Prenez un tableau et l'index.
b) Créez un nouveau tableau avec une taille inférieure de 1 au tableau d'origine.
c) Copiez les éléments du tableau d'origine de 0 à index-1 dans le nouveau tableau.
d) Ne copiez pas l'élément à la position d'index spécifiée.
e) Copiez les éléments du tableau d'origine de l'index+1 à la fin dans le nouveau tableau.
f) Renvoyez le nouveau tableau copié .
La méthode peut être écrite comme,
// 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;
} Avec l'aide de Java 8 Streams
En utilisant l'aide du flux Java 8, nous pouvons également supprimer l'élément du tableau. Pour cela, nous devons importer java.util.stream.IntStream ; Dans cette approche,
a) Prenez un tableau et l'index.
b) Convertissez le tableau en IntStream à l'aide de la méthode IntStream.range().
c) Supprimez l'élément à l'élément d'index spécifié à l'aide de la méthode filter().
d) Mappez et formez un nouveau tableau des éléments filtrés à l'aide des méthodes map() et toArray().
e) Renvoyez le tableau formé.
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();
}
} Sortie :-
Tableau d'origine :[10, 20, 30, 40, 50]
Nouveau tableau :[10, 20, 30, 50]
Utiliser ArrayList
ArrayList peut également être utilisé pour supprimer des éléments du tableau dans le langage de programmation Java. Dans cette approche,
a) Prenez un tableau et l'index.
b) Convertissez le tableau en ArrayList
c) Formez un ArrayList avec les éléments du tableau.
d) Supprimez le spécifié index à l'aide de la méthode remove().
e) Formez un nouveau tableau de ArrayList à l'aide des méthodes mapToInt() et toArray().
f) Renvoyez le tableau formé.
Le programme Java ci-dessous illustre l'approche ci-dessus,
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();
}
} Sortie :-
Tableau d'origine :[10, 20, 30, 40, 50]
Nouveau tableau :[10, 20, 30, 50]
Supprimer l'élément du tableau en Java par valeur
Pour supprimer un élément spécifique d'un tableau , nous devons trouver son index. Après avoir trouvé l'index, nous pouvons utiliser l'une des approches ci-dessus pour supprimer un élément d'un tableau à l'index spécifié.
Si le tableau est trié, nous pouvons utiliser la recherche binaire (méthode Arrays.binarySearch() ) sinon nous pouvons utiliser la recherche linéaire. Démontrons-le par une recherche linéaire.
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;
}
} Sortie :-
Tableau d'origine :[50, 20, 10, 40, 30]
Nouveau tableau :[50, 20, 10, 30]
Dans ce programme, si l'élément qui doit être supprimé a des doublons, seul le premier élément correspondant sera supprimé et les éléments restants seront en ligne tels quels.
