Wie entferne ich Objekte aus einem Array in Java?

Alternative in Java 8:

String[] filteredArray = Arrays.stream(array)
    .filter(e -> !e.equals(foo)).toArray(String[]::new);

InformationsquelleAutor der Antwort Vitalii Fedorenko

Können Sie immer tun:

int i, j;
for (i = j = 0; j < foo.length; ++j)
  if (!"a".equals(foo[j])) foo[i++] = foo[j];
foo = Arrays.copyOf(foo, i);

InformationsquelleAutor der Antwort

Siehe code unten

ArrayList<String> a = new ArrayList<>(Arrays.asList(strings));
a.remove(i);
strings = new String[a.size()];
a.toArray(strings);

InformationsquelleAutor der Antwort hesam

Etwas über die Liste machen, dann entfernen Sie anschließend wieder in ein array scheint mir falsch. Noch nicht getestet, aber ich denke die folgenden werden besser. Ja, ich bin wahrscheinlich übermäßig pre-Optimierung.

boolean [] deleteItem = new boolean[arr.length];
int size=0;
for(int i=0;i<arr.length;i==){
   if(arr[i].equals("a")){
      deleteItem[i]=true;
   }
   else{
      deleteItem[i]=false;
      size++;
   }
}
String[] newArr=new String[size];
int index=0;
for(int i=0;i<arr.length;i++){
   if(!deleteItem[i]){
      newArr[index++]=arr[i];
   }
}

InformationsquelleAutor der Antwort shsteimer

EDIT:

Den Punkt mit der null-Werte im array gelöscht wurde. Sorry für meine Kommentare.

Original:

Ehm... die Linie

array = list.toArray(array);

ersetzt alle Lücken im array, wobei das entfernte element wurde mit null. Dies könnte gefährlichdenn die Elemente sind entfernt, aber die Länge des Arrays bleibt gleich!

Wenn Sie dies vermeiden wollen, verwenden Sie ein neues Array als parameter für die toArray(). Wenn Sie nicht möchten, zu verwenden, removeAll, eine Reihe wäre eine alternative:

        String[] array = new String[] { "a", "bc" ,"dc" ,"a", "ef" };

        System.out.println(Arrays.toString(array));

        Set<String> asSet = new HashSet<String>(Arrays.asList(array));
        asSet.remove("a");
        array = asSet.toArray(new String[] {});

        System.out.println(Arrays.toString(array));

Gibt:

[a, bc, dc, a, ef]
[dc, ef, bc]

Wo, wie die aktuelle akzeptierte Antwort von Chris Yester Jungen Ausgänge:

[a, bc, dc, a, ef]
[bc, dc, ef, null, ef]

mit dem code

    String[] array = new String[] { "a", "bc" ,"dc" ,"a", "ef" };

    System.out.println(Arrays.toString(array));

    List<String> list = new ArrayList<String>(Arrays.asList(array));
    list.removeAll(Arrays.asList("a"));
    array = list.toArray(array);        

    System.out.println(Arrays.toString(array));

ohne null-Werte hinter sich gelassen.

InformationsquelleAutor der Antwort GHad

Gibt es eine Menge Antworten hier-das problem, wie ich es sehe, ist, dass Sie nicht sagen, WARUM Sie ein array statt einer Sammlung, so lassen Sie mich vorschlagen, ein paar Gründe und welche Lösungen gelten würde (die Meisten Lösungen haben wir bereits beantwortet, die in anderen Fragen hier, damit ich nicht zu sehr ins detail gehen):

Grund: Sie wussten nicht, die Sammlung-Paket existiert nicht mehr oder noch nicht trauen es

Lösung: Verwenden Sie eine Sammlung.

Wenn Sie planen, das hinzufügen/löschen von der Mitte, verwenden Sie eine LinkedList. Wenn Sie wirklich besorgt über die Größe oder oft index rechts in der Mitte der Sammlung, Verwendung einer ArrayList. Beide sollten haben, delete-Operationen.

Grund: Sie sind besorgt über die Größe, oder wollen die Kontrolle über memory allocation

Lösung: Verwenden Sie eine ArrayList mit einer bestimmten ersten Größe.

Einer ArrayList ist einfach ein array, erweitern sich, es muss aber nicht immer so tun müssen. Es wird sehr gut über das hinzufügen/entfernen von Elementen, aber wieder, wenn Sie einfügen/entfernen einer MENGE aus der Mitte, verwenden Sie eine LinkedList.

Grund: Sie haben ein array kommen und ein array ausgehen -, so dass Sie bedienen möchten, auf eine Reihe

Lösung: Konvertieren Sie es zu einer ArrayList löschen Sie das Element aus und konvertieren es zurück

Grund: Sie denken, Sie können schreiben besseren code, wenn Sie es selbst tun

Lösung: Sie können nicht, verwenden Sie ein Array oder verkettete Liste.

Grund: dies ist eine klassenzuordnung, und Sie sind nicht erlaubt, oder Sie haben keinen Zugriff auf die Sammlung von apis für einige Grund

Annahme: Sie brauchen das neue array auf die richtige "Größe"

Lösung:
Scannen Sie den array für die passenden Artikel, und zählen Sie Sie. Erstellen Sie ein neues array mit der richtigen Größe (die original-Größe - Anzahl der matches). verwenden Sie System.arraycopy immer wieder zu kopieren, jede Gruppe von Elementen, die Sie behalten möchten, in das neue Array. Wenn dies eine klassenzuordnung, und Sie nicht verwenden können, System.arraycopy, kopieren Sie einfach Sie ein zu einer Zeit, die von hand in einer Schleife, aber nicht immer tun, diese in der Produktion-Codes, da es viel langsamer. (Diese Lösungen sind sowohl detaillierte als auch in anderen Antworten)

Grund: Sie müssen führen Sie eine bare-metal

Annahme: Sie MÜSSEN nicht reservieren Speicherplatz unnötig oder zu lange dauern

Annahme: Sie verfolgen die Größe verwendet, die in das array (Länge) separat, weil sonst müsste man reservieren Sie Ihr array löscht/einfügt.

Beispiel dafür, warum Sie dies möglicherweise tun möchten: ein einzelnes array von primitives (sagen wir int-Werte) einen beträchtlichen Teil Ihres ram-wie 50%! Eine ArrayList zwingen würde, diese in eine Liste von Zeigern auf Integer-Objekte, die ein paar mal die Menge an Arbeitsspeicher.

Lösung: Iteration über das array und wenn Sie finden, ein element zu entfernen (nennen wir es element n), verwenden Sie System.arraycopy, kopieren Sie den Schwanz des Arrays über den "gelöscht" - element (Quelle und Ziel sind die gleichen array) - es ist smart genug, um die Kopie in die richtige Richtung, damit der Speicher nicht überschrieben selbst:

 System.arraycopy(G, n+1, G, n, Länge-n) 
Länge--; 

Wahrscheinlich wollen Sie klüger sein als diese, wenn Sie das löschen von mehr als einem element zu einem Zeitpunkt. Sie würde nur der Bereich zwischen einem "match" und die nächste, anstatt den gesamten Schwanz und wie immer, vermeiden Sie das verschieben jedes Stück zweimal.

In diesem letzten Fall, müssen Sie unbedingt die Arbeit selbst, und mit System.arraycopy ist wirklich der einzige Weg, es zu tun, da es die beste zu wählen möglicherweise Weg von Speicher für Ihren computer-Architektur-es sollten viele mal schneller als jeder code, den Sie vernünftigerweise selbst schreiben.

InformationsquelleAutor der Antwort Bill K

Arrgh, ich kann nicht den code zu zeigen, richtig. Sorry, ich habe es funktioniert. Sorry nochmal, ich glaube nicht, ich lies die Frage richtig.

String  foo[] = {"a","cc","a","dd"},
remove = "a";
boolean gaps[] = new boolean[foo.length];
int newlength = 0;

for (int c = 0; c<foo.length; c++)
{
    if (foo[c].equals(remove))
    {
        gaps[c] = true;
        newlength++;
    }
    else 
        gaps[c] = false;

    System.out.println(foo[c]);
}

String newString[] = new String[newlength];

System.out.println("");

for (int c1=0, c2=0; c1<foo.length; c1++)
{
    if (!gaps[c1])
    {
        newString[c2] = foo[c1];
        System.out.println(newString[c2]);
        c2++;
    }
}

InformationsquelleAutor der Antwort AngelOfCake

class sd 
{
 public static void main(String[ ] args)
 {
     System.out.println("Search and Delete");

    int key;
    System.out.println("Enter the length of array:");
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int numbers[]=new int[n];

      int i = 0;
      boolean found = false;  
      System.out.println("Enter the elements in Array :");
      for ( i = 0; i < numbers.length; i++)
      {
          numbers[i]=in.nextInt();
      }
      System.out.println("The elements in Array are:");
      for ( i = 0; i < numbers.length; i++)
      {
          System.out.println(numbers[i]);
      }
      System.out.println("Enter the element to be searched:");
      key=in.nextInt();
      for ( i = 0; i < numbers.length; i++)
      {
             if (numbers[ i ]  == key)
            {
                     found = true;      
                     break;
             }
       }
      if (found)   
      {
            System.out.println("Found " + key + " at index " + i + ".");
            numbers[i]=0;//haven't deleted the element in array
            System.out.println("After Deletion:");
        for ( i = 0; i < numbers.length; i++)
          {
              if (numbers[ i ]!=0)
            {   //it skips displaying element in array
                        System.out.println(numbers[i]);
            }
          }
      }
      else
      {
            System.out.println(key + "is not in this array.");
      }
  }
}//Sorry.. if there are mistakes.

InformationsquelleAutor der Antwort Parameshwar

Null zuweisen, das array Standorten.

InformationsquelleAutor der Antwort alfinoba