Menu

Odebrat / Odstranit prvek z pole v Javě

remove delete an element from an array java

Vyzkoušejte Náš Nástroj Pro Odstranění Problémů

selenový webdriver s okurkovým příkladem v zatmění

Naučte se různé metody pro odstranění nebo odebrání prvku z pole v Javě, například Použití jiného pole, Použití proudů Java 8, Použití ArrayList:

Pole Java neposkytují metodu přímého odebrání k odebrání prvku. Ve skutečnosti jsme již diskutovali, že pole v Javě jsou statická, takže velikost polí se nemůže změnit, jakmile jsou vytvořena instance. Nemůžeme tedy odstranit prvek a zmenšit velikost pole.

Pokud tedy chceme odstranit nebo odebrat prvek z pole, musíme použít různé metody, které jsou obvykle řešením.

=> Přečtěte si celou sérii výukových programů Java pro začátečníky

Odebrat Odstranit prvek z pole

Co se naučíte:

Odebrat / Odstranit prvek z pole v Javě

V tomto kurzu probereme různé metody odstranění prvku z pole.

To zahrnuje:

  • Pomocí jiného pole
  • Používání streamů Java 8
  • Pomocí ArrayList
  • Pomocí System.arraycopy ()

Použití jiného pole

Toto je tradiční a poněkud neefektivní metoda odstranění prvku pole. Zde definujeme nové pole s velikostí menší než 1 k původnímu poli. Potom zkopírujeme prvky z původního pole do nového pole. Ale při tomto kopírování přeskočíme prvek v zadaném indexu.

Tímto způsobem zkopírujeme všechny prvky kromě prvku, který má být odstraněn, do nového pole, což naznačuje, že prvek je odstraněn.

Tuto operaci můžeme znázornit obrazně, jak je znázorněno níže.

Použití jiného diagramu pole

Implementujme tuto metodu v programu Java.

import java.util.Arrays; class Main { public static void main(String() args) { // define original array int() tensArray = { 10,20,30,40,50,60}; // Print the original array System.out.println('Original Array: ' + Arrays.toString(tensArray)); // the index at which the element in the array is to be removed int rm_index = 2; // display index System.out.println('Element to be removed at index: ' + rm_index); // if array is empty or index is out of bounds, removal is not possible if (tensArray == null || rm_index<0 || rm_index>= tensArray.length) { System.out.println('No removal operation can be performed!!'); } // Create a proxy array of size one less than original array int() proxyArray = new int(tensArray.length - 1); // copy all the elements in the original to proxy array except the one at index for (int i = 0, k = 0; i

Výstup:

Použití jiného pole

Používání streamů Java 8

Streamy jsou novým přírůstkem do Javy od verze 8. Pomocí proudů Java8 můžeme odstranit prvek z pole. Za tímto účelem je nejprve pole převedeno na proud. Potom se prvek v zadaném indexu odstraní pomocí metody filtrování proudů.

Jakmile je prvek odstraněn, pomocí metod ‚map‘ a ‚toArray‘ se stream převede zpět do pole.

Níže je uvedena implementace odebrání prvku z pole pomocí proudu.

import java.util.Arrays; import java.util.stream.IntStream; class Main { // Function to remove the element public static int() removeArrayElement(int() oddArray, int index) { //array is empty or index is beyond array bounds if (oddArray == null || index <0 || index>= oddArray.length) { return oddArray; } // delete the element at specified index and return the array return IntStream.range(0, oddArray.length) .filter(i -> i != index) .map(i ->oddArray(i)).toArray(); } public static void main(String() args) { int() oddArray = { 1, 3,5,7,9,11}; // define array of odd numbers System.out.println('Original Array: ' + Arrays.toString(oddArray)); // Print the resultant array int index = 2; // index at which element is to be removed System.out.println('Element to be removed at index: ' + index); // display index // function call removeArrayElement oddArray = removeArrayElement(oddArray, index); // Print the resultant array System.out.println('Array after deleting element: ' + Arrays.toString(oddArray)); } }

Výstup:

Používání streamů Java 8

Pomocí ArrayList

K provedení této operace můžeme použít ArrayList. Chcete-li odebrat prvek z pole, nejprve převedeme pole na ArrayList a poté použijeme metodu ‚remove 'ArrayList k odebrání prvku u konkrétního indexu.

Po odstranění převádíme ArrayList zpět na pole.

Následující implementace ukazuje odebrání prvku z pole pomocí ArrayList.

import java.util.*; import java.util.stream.*; class Main { public static int() remove_Element(int() myArray, int index) { if (myArray == null || index <0 || index>= myArray.length) { System.out.println('non-existing index'); return myArray; } //array to arrayList List arrayList = IntStream.of(myArray) .boxed().collect(Collectors.toList()); // Remove the specified element arrayList.remove(index); // return the resultant array returnarrayList.stream().mapToInt(Integer::intValue).toArray(); } public static void main(String() args) { int() myArray = { 11,22,33,44,55,66,77,88,99,111 }; System.out.println('Original Array: ' + Arrays.toString(myArray)); int index = 10; System.out.println('Index at which element is to be deleted: ' + index); myArray = remove_Element(myArray, index); System.out.println('Resultant Array: ' + Arrays.toString(myArray) + ' '); index = 2; System.out.println('Index at which element is to be deleted: ' + index); myArray = remove_Element(myArray, index); System.out.println('Resultant Array: ' + Arrays.toString(myArray)); } }

Výstup:

UsingArrayList

Výše uvedený program produkuje výstup pro dvě podmínky. Nejprve je předán neexistující index (10), tj. Nad aktuální velikost pole. Program zobrazí příslušnou zprávu a neodstraní žádný prvek.

manuální testovací otázky a odpovědi pro zkušené

V druhém případě je předán index = 2. Tentokrát je prvek na pozici 2 odstraněn a výsledné pole je předáno.

Pomocí System.arraycopy ()

Tato metoda je podobná první metodě, až na to, že pro kopírování prvků původního pole do nového používáme metodu ‚arrayCopy '.

Nejprve zkopírujeme prvky původního pole z 0 do indexu do nového pole. Dále zkopírujeme prvky z indexu + 1 do délky do nového pole. Při kopírování tedy přeskočíme prvek v zadaném indexu a vygenerujeme nové pole.

Toto nové pole označuje výsledné pole, které se získá po odstranění prvku v zadaném indexu.

import java.util.Arrays; class Main { public static void main(String() args) { // define the array of integers int() intArray = { 10,20,30,40,50 }; // display the original array System.out.println('Original Array: ' + Arrays.toString(intArray)); // index at which the element is to be deleted int index = 2; // the index System.out.println('Element to be deleted at index: ' + index); // check if the array is empty or index is out of bounds if (intArray == null || index <0 || index>= intArray.length) { System.out.println('No removal operation can be performed!!'); } // create an array to hold elements after deletion int() copyArray = new int(intArray.length - 1); // copy elements from original array from beginning till index into copyArray System.arraycopy(intArray, 0, copyArray, 0, index); // copy elements from original array from index+1 till end into copyArray System.arraycopy(intArray, index + 1, copyArray, index, intArray.length - index - 1); // display the copied array after deletion System.out.println('Array after deleting an element: ' + Arrays.toString(copyArray)); } }

Výstup:

Pomocí System.arraycopy ()

Často kladené otázky

Otázka č. 1) Jak odebrat jeden prvek z pole?

Odpovědět: Java neposkytuje přímou metodu k odebrání prvku z pole. Ale vzhledem k indexu, ze kterého má být prvek odstraněn, můžeme použít ArrayList k odstranění prvku u zadaného indexu.

Za tímto účelem nejprve převedeme pole na ArrayList a pomocí metody remove odstraníme prvek. Jakmile je hotovo, převedeme ArrayList zpět na pole. Existuje také několik dalších řešení, která pro tento účel můžeme použít.

Otázka 2) Co dělá ArrayList remove?

Odpovědět: Metoda ArrayList remove odstraní prvek v ArrayList v daném indexu, který je poskytován jako argument.

rozdíl mezi java a c ++

Otázka č. 3) Jak odstraníte duplikáty z pole v Javě?

Odpovědět: Duplicitní prvky z pole lze odebrat pomocí dočasného pole, které bude počítat prvky jeden po druhém a do dočasného pole vloží pouze jedinečné prvky. Chcete-li odstranit duplikáty, je třeba pole seřadit.

Otázka č. 4) Vrací filtr nové pole?

Odpovědět: Ano. Filtr vrací nové pole bez ovlivnění původního pole.

Otázka č. 5) Jak funguje R. emove práce v Javě?

Odpovědět: Metoda remove ArrayList v Javě odstraní prvek v zadaném indexu. V propojeném seznamu také metoda remove odstraní uzel na dané pozici.

Závěr

V tomto kurzu jsme viděli různé způsoby nebo alternativní řešení, pomocí kterých můžeme odebrat prvek z pole v daném indexu.

V našich následujících tématech budeme diskutovat o některých dalších operacích prováděných na polích v Javě.

=> Podívejte se na průvodce intenzivním školením Java zde

Doporučené čtení

^