Een element verwijderen uit een array (Java)

Is er een snelle (en mooie) manier om een ​​element uit een array in Java te verwijderen?

Antwoord 1, autoriteit 100%

Je zou de ArrayUtils van commons lang kunnen gebruiken.

array = ArrayUtils.removeElement(array, element)

commons. apache.org bibliotheek:Javadocs

Antwoord 2, autoriteit 19%

Uw vraag is niet erg duidelijk. Uit je eigen antwoord kan ik beter opmaken wat je probeert te doen:

public static String[] removeElements(String[] input, String deleteMe) {
    List result = new LinkedList();
    for(String item : input)
        if(!deleteMe.equals(item))
            result.add(item);
    return result.toArray(input);
}

NB: Dit is niet getest. Foutcontrole wordt overgelaten als een oefening voor de lezer (ik zou IllegalArgumentException gooien als input of deleteMe null is; een lege lijst op null-lijstinvoer heeft geen zin. Het verwijderen van null-strings uit de array kan logisch zijn, maar ik’ Ik laat dat ook als een oefening; momenteel zal het een NPE gooien wanneer het probeert gelijken aan te roepen op deleteMe als deleteMe null is.)

Keuzes die ik hier heb gemaakt:

Ik heb een LinkedList gebruikt. Iteratie zou net zo snel moeten zijn, en u vermijdt het wijzigen van de grootte of het toewijzen van een te grote lijst als u uiteindelijk veel elementen verwijdert. U kunt een ArrayList gebruiken en de begingrootte instellen op de invoerlengte. Het zou waarschijnlijk niet veel uitmaken.

Antwoord 3, autoriteit 18%

De beste keuze zou zijn om een ​​verzameling te gebruiken, maar als dat om de een of andere reden niet meer mogelijk is, gebruik dan arraycopy. Je kunt het gebruiken om van en naar dezelfde array te kopiëren met een iets andere offset.

Bijvoorbeeld:

public void removeElement(Object[] arr, int removedIdx) {
    System.arraycopy(arr, removedIdx + 1, arr, removedIdx, arr.length - 1 - removedIdx);
}

Bewerken in reactie op opmerking:

Het is geen andere goede manier, het is echt de enige acceptabele manier – alle tools die deze functionaliteit toestaan ​​(zoals Java.ArrayList of de apache utils) zullen deze methode onder de dekmantel gebruiken. Je zou ook ECHT ArrayList moeten gebruiken (of gekoppelde lijst als je veel uit het midden verwijdert), dus dit zou geen probleem moeten zijn, tenzij je het als huiswerk doet.

Om een ​​collectie toe te wijzen (creëert een nieuwe array), verwijder dan een element (wat de collectie zal doen met arraycopy) en roep vervolgens toArray erop aan (creëert een TWEEDE nieuwe array) voor elke verwijdering brengt ons op het punt waar dit niet het geval is een optimalisatieprobleem, het is crimineel slechte programmering.

Stel dat je een array hebt die bijvoorbeeld 100 MB ram in beslag neemt. Nu wil je het herhalen en 20 elementen verwijderen.

Probeer het eens…

Ik weet dat je AANNEEMT dat het niet zo groot zal zijn, of dat als je er zoveel tegelijk zou verwijderen, je het anders zou coderen, maar ik heb ontzettend veel code gerepareerd waarin iemand zulke aannames deed.

Antwoord 4, autoriteit 16%

U kunt een element niet verwijderen uit de standaard Java-array. Bekijk in plaats daarvan verschillende collecties en ArrayList.

Antwoord 5, autoriteit 6%

Een mooie oplossing zou zijn om in de eerste plaats een lijst te gebruiken in plaats van een array.

List.remove(index)

Als u moetarrays gebruiken, zijn twee aanroepen naar System.arraycopywaarschijnlijk de snelste.

Foo[] result = new Foo[source.length - 1];
System.arraycopy(source, 0, result, 0, index);
if (source.length != index) {
    System.arraycopy(source, index + 1, result, index, source.length - index - 1);
}

(Arrays.asListis ook een goede kandidaat om met arrays te werken, maar het lijkt removeniet te ondersteunen.)

Antwoord 6, autoriteit 5%

Ik denk dat de vraag om een ​​oplossing vroeg zonderhet gebruik van de Collections API. Men gebruikt arrays ofwel voor details op laag niveau, waar prestaties van belang zijn, ofwel voor een losjes gekoppelde SOA-integratie. In het laatste geval is het OK om ze te converteren naar Collecties en ze zo door te geven aan de bedrijfslogica.

Voor de prestaties op laag niveau wordt het meestal al verdoezeld door de snelle en vuile imperatieve staat-vermenging door for-lussen, enz. In dat geval is het heen en weer converteren tussen verzamelingen en arrays omslachtig, onleesbaar en zelfs arbeidsintensief.

Trouwens, TopCoder, iemand? Altijd die array-parameters! Wees dus voorbereid om ze aan te kunnen in de Arena.

Hieronder staat mijn interpretatie van het probleem en een oplossing. Het verschilt qua functionaliteit van beide die worden gegeven door Bill Ken jelovirt. Het behandelt ook gracieus het geval wanneer het element niet in de array staat.

Hopelijk helpt dat!

public char[] remove(char[] symbols, char c)
{
    for (int i = 0; i < symbols.length; i++)
    {
        if (symbols[i] == c)
        {
            char[] copy = new char[symbols.length-1];
            System.arraycopy(symbols, 0, copy, 0, i);
            System.arraycopy(symbols, i+1, copy, i, symbols.length-i-1);
            return copy;
        }
    }
    return symbols;
}

Antwoord 7, autoriteit 2%

Je zou de ArrayUtils APIom het op een “mooie manier” te verwijderen. Het implementeert veel bewerkingen (verwijderen, zoeken, toevoegen, bevat, enz.) op Arrays.
Kijk eens. Het heeft mijn leven eenvoudiger gemaakt.

Antwoord 8

Er zijn nog enkele voorwaarden nodig voor degene die zijn geschreven door Bill K en dadinn

Object[] newArray = new Object[src.length - 1];
if (i > 0){
    System.arraycopy(src, 0, newArray, 0, i);
}
if (newArray.length > i){
    System.arraycopy(src, i + 1, newArray, i, newArray.length - i);
}
return newArray;

Antwoord 9

U kunt de lengte van een array niet wijzigen, maar u kunt de waarden die de index bevat wel wijzigen door nieuwe waarden te kopiëren en op te slaan in een bestaand indexnummer.
1=mike , 2=jeff // 10 = george 11 gaat naar 1 microfoon overschrijven.

Object[] array = new Object[10];
int count = -1;
public void myFunction(String string) {
    count++;
    if(count == array.length) { 
        count = 0;  // overwrite first
    }
    array[count] = string;    
}

Antwoord 10

oke, heel erg bedankt
nu gebruik ik sth als volgt:

public static String[] removeElements(String[] input, String deleteMe) {
    if (input != null) {
        List<String> list = new ArrayList<String>(Arrays.asList(input));
        for (int i = 0; i < list.size(); i++) {
            if (list.get(i).equals(deleteMe)) {
                list.remove(i);
            }
        }
        return list.toArray(new String[0]);
    } else {
        return new String[0];
    }
}

Antwoord 11

Kopieeruw originele array naar een andere array, zonder dat het element hoeft te worden verwijderd.

Een eenvoudigere manier om dat te doen is door een List, Set… en de methode remove() te gebruiken.

Antwoord 12

Verwissel het te verwijderen item met het laatste item, als het verkleinen van de array niet interessant is.

Antwoord 13

Ik hoop dat je de java-collectie / java commons-collecties gebruikt!

Met een java.util.ArrayList kun je het volgende doen:

yourArrayList.remove(someObject);
yourArrayList.add(someObject);

Antwoord 14

Gebruik een ArrayList:

alist.remove(1); //removes the element at position 1

Antwoord 15

Natuurlijk, maak nog een array 🙂