Suppression d'un élément d'un tableau (Java) [dupliquer]

votre question n'est pas très claire. De votre propre réponse, je peux mieux dire ce que vous essayez de faire:

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: ceci n'a pas été testé. La vérification des erreurs est laissée comme un exercice au lecteur (je lancerais IllegalArgumentException si input ou deleteMe est null; une liste vide sur la liste nulle input n'a pas de sens. Supprimer les chaînes nulles du tableau pourrait avoir du sens, mais je vais laisser cela comme un exercice aussi; actuellement, il lancera un NPE quand il essaiera de call est égal à deleteMe si deleteMe est null.)

choix que j'ai fait ici:

j'ai utilisé une LinkedList. L'itération devrait être tout aussi rapide, et vous éviterez les redimensionnements, ou l'attribution trop grande d'une liste si vous finissez par supprimer beaucoup d'éléments. Vous pouvez utiliser un ArrayList, et régler la taille initiale à la longueur de l'entrée. Il n'y aurait probablement pas faire beaucoup de différence.

le meilleur choix serait d'utiliser une collection, mais si c'est pour une raison quelconque, utiliser arraycopy . Vous pouvez l'utiliser pour copier à partir et vers le même tableau à un décalage légèrement différent.

par exemple:

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

modifier en réponse au commentaire:

Ce n'est pas une bonne façon, c'est vraiment la seule façon acceptable.

pour attribuer un collection (crée un nouveau tableau), puis supprimer un élément (ce que la collection fera en utilisant arraycopy) puis appeler toArray dessus (crée un second nouveau tableau) pour chaque suppression nous amène au point où ce n'est pas une question d'optimisation, c'est une mauvaise programmation criminelle.

supposons que vous ayez un réseau prenant, disons, 100 Mo de ram. Maintenant, vous voulez itérer sur elle et supprimer 20 éléments.

essayez...

je sais que vous supposez que ce ne sera pas si grand, ou que si vous en supprimiez autant à la fois vous le coderiez différemment, mais j'ai corrigé beaucoup de code où quelqu'un a fait des suppositions comme ça.

vous ne pouvez pas supprimer un élément du tableau Java de base. Jetez un oeil à diverses Collections et ArrayList à la place.

bonne solution serait d'utiliser une liste au lieu d'un tableau en premier lieu.

List.remove(index)

si vous avez pour utiliser des tableaux, deux appels à System.arraycopy sera très probablement le plus rapide.

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.asList est également un bon candidat pour travailler avec des tableaux, mais il ne semble pas soutenir remove .)

je pense que la question demandait une solution sans l'utilisation de L'API Collections. On utilise des tableaux soit pour les détails de bas niveau, où la performance importe, ou pour une intégration SOA faiblement couplée. Dans la suite, il est correct de les convertir en Collections et les passer à la logique d'affaires comme cela.

pour les performances de bas niveau, il est généralement déjà obscurci par l'état impératif rapide et sale-se mêlant par pour les boucles, etc. Dans ce cas, la conversion entre les Collections et les tableaux est fastidieuse, illisible et même exigeante en ressources.

au fait, TopCoder, quelqu'un? Toujours ces paramètres de tableau! Alors préparez-vous à être capable de les manipuler dans l'arène.

ci-Dessous est mon interprétation du problème et une solution. Il est différent dans la fonctionnalité de la deux de celle donnée par Bill K et jelovirt . Aussi, il gère normalement le cas lorsque l'élément n'est pas dans le tableau.

Espère que ça aide!

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;
}

vous pouvez utiliser L'API ArrayUtils pour l'enlever d'une"belle façon". Il met en œuvre de nombreuses opérations (supprimer, rechercher, ajouter, contient,etc) sur les Tableaux.

Prendre un coup d'oeil. Il a rendu ma vie plus simple.

D'autres conditions préalables sont nécessaires pour celles écrites par Bill K et 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;

vous ne pouvez pas changer la longueur d'un tableau, mais vous pouvez changer les valeurs que l'index contient en copiant de nouvelles valeurs et les stocker dans un numéro d'index existant. 1=mike , 2 = jeff // 10 = george 11 va à 1 overwriting mike .

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;    
}

OK, thx beaucoup maintenant j'utilise sth comme ceci:

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];
    }
}

Copiez votre tableau original dans un autre tableau, sans l'élément à supprimer.

une façon plus simple de le faire est d'utiliser une liste, Set... et d'utiliser la méthode remove ().

Swap L'élément à supprimer avec le dernier élément, si redimensionner le tableau vers le bas n'est pas un intérêt.

j'espère que vous utiliserez la java collection / java commons collections!

avec un java.util.ArrayList vous pouvez faire des choses comme ce qui suit:

yourArrayList.remove(someObject);

yourArrayList.add(someObject);

utiliser un ArrayList :

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

bien sûr, créer un autre tableau:)