Wie entferne ich Objekte aus einem Array in Java?

82

Angenommen, ein Array von n Objekten ist ein Array von Zeichenfolgen und hat die folgenden Werte:

foo[0] = "a";
foo[1] = "cc";
foo[2] = "a";
foo[3] = "dd";

Was muss ich tun, um alle Zeichenfolgen / Objekte zu löschen / zu entfernen, die "a" im Array entsprechen?

Ramayac
quelle
2
Sie können die Größe eines Arrays in Java nicht ändern. Ich gehe davon aus, dass Sie die Elemente nicht einfach auf Null setzen möchten, da dies trivial wäre. Möchten Sie die anderen Elemente verschieben, um die Lücken zu entfernen?
Dan Dyer
1
Es ist trivial, jetzt wo ich weiß, dass ich es schaffen kann. ;) Vielen Dank!
Ramayac

Antworten:

112

[Wenn Sie einen gebrauchsfertigen Code wünschen, scrollen Sie bitte zu "Edit3" (nach dem Schnitt). Der Rest ist für die Nachwelt da.]

Um Dustmans Idee zu konkretisieren :

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

Bearbeiten: Ich verwende jetzt Arrays.asListanstelle von Collections.singleton: Singleton ist auf einen Eintrag beschränkt, während Sie mit diesem asListAnsatz weitere Zeichenfolgen hinzufügen können, um sie später herauszufiltern : Arrays.asList("a", "b", "c").

Edit2: Der obige Ansatz behält das gleiche Array bei (das Array hat also immer noch die gleiche Länge). Das Element nach dem letzten wird auf null gesetzt. Wenn Sie ein neues Array wünschen, dessen Größe genau den Anforderungen entspricht, verwenden Sie stattdessen Folgendes:

array = list.toArray(new String[0]);

Edit3: Wenn Sie diesen Code häufig in derselben Klasse verwenden, können Sie dies Ihrer Klasse hinzufügen:

private static final String[] EMPTY_STRING_ARRAY = new String[0];

Dann wird die Funktion:

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

Dadurch wird Ihr Heap nicht mehr mit nutzlosen leeren String-Arrays übersät, die sonst bei newjedem Aufruf Ihrer Funktion bearbeitet würden .

Der Vorschlag von Cynicalman (siehe Kommentare) hilft auch beim Müllhaufen, und der Fairness halber sollte ich ihn erwähnen:

array = list.toArray(new String[list.size()]);

Ich bevorzuge meinen Ansatz, weil es möglicherweise einfacher ist, die explizite Größe falsch zu bestimmen (z. B. size()die falsche Liste aufzurufen ).

Chris Jester-Young
quelle
Schön, dass es dir gefallen hat. Ich habe meinen Eintrag überarbeitet, um das Entfernen aller Instanzen von "a" zu unterstützen, nicht nur der ersten. :-)
Chris Jester-Young
Ooff ... schoss auf die Ziellinie. Ich wusste, ich hätte weiter bearbeiten sollen. Dieses System ist gewöhnungsbedürftig. Gute Bearbeitung!
Dustman
GHad: Hast du mein Edit2 oben gelesen? Es adressiert genau das, was Sie erwähnt haben, und es wurde vor Ihrem Beitrag veröffentlicht.
Chris Jester-Young
2
Warum nicht list.toArray (neuer String [list.size ()]) anstelle von neuem String [0], da der Code das neue Array verwendet, wenn es die richtige Größe hat?
Zyniker
Ja das funktioniert Andernfalls speichert ein Code (hauptsächlich in der Java-Klassenbibliothek) eine statische Instanz von String [0] (und andere ähnliche Arrays mit der Größe Null) und übergibt die statischen Instanzen, anstatt jedes Mal eine neue zu erstellen. :-)
Chris Jester-Young
31

Eine Alternative in Java 8:

String[] filteredArray = Arrays.stream(array)
    .filter(e -> !e.equals(foo)).toArray(String[]::new);
Vitalii Fedorenko
quelle
Dies sollte die akzeptierte Antwort sein. Obwohl es nicht schön ist, wenn man bedenkt, dass andere Programmiersprachen dies mit weniger und klarerem Code tun können ... ist dies das Beste, was Java zu bieten hat, ohne von einer anderen Bibliothek abhängig zu sein.
Jason
6
Obwohl ordentlich, wird dies im Vergleich zu System.arraycopy erstaunlich ineffizient sein. Sollte dies wahrscheinlich nicht in echtem Code tun.
Bill K
Wenn foo eine dynamische Zeichenfolgenvariable ist, wird ein Fehler bei der Kompilierungszeit
ausgelöst. Die
Die Frage lautet "Gegeben ein Array von n Objekten" - Stream.of(foo).filter(s -> ! s.equals("a")).toArray()wäre also ausreichend.
Kaplan
20

Machen Sie Listaus dem Array ein Arrays.asList()und rufen Sie remove()alle entsprechenden Elemente auf. Rufen Sie dann toArray()die 'Liste' auf, um wieder in ein Array zurückzukehren.

Nicht besonders performant, aber wenn Sie es richtig einkapseln, können Sie später immer etwas schneller machen.

Dustman
quelle
3
Zu Ihrem Kommentar: Es ist okay, Sie werden sich bald daran gewöhnen. :-) Ich habe meinen Beitrag gepostet, weil ich nicht wollte, dass die Leser auf die Idee kommen, dass Elemente aus dem Ergebnis von Arrays.asList () entfernt werden können (es ist eine unveränderliche Liste), also dachte ich, ein Beispiel könnte sich darum kümmern. :-)
Chris Jester-Young
Äh, ich meinte nicht veränderbare Liste (add () und remove () funktionieren nicht). :-P Es gibt noch eine verwendbare set () -Methode. :-)
Chris Jester-Young
Obwohl es seltsam erscheinen mag, ist meine Erfahrung, dass der Leistungsverlust dieses Ansatzes minimal ist.
Marcus Downing
8
Was ist damit? @ Chris wies darauf hin, dass die daraus resultierende Liste Arrays.asList()nicht unterstützt remove(). Ist diese Antwort also völlig ungültig? Vielleicht wurden einige Kommentare entfernt, daher weiß ich nicht, ob dies besprochen wurde.
LarsH
1
Sowohl Chris als auch LarsH haben Recht: Array-gestützte Listen (mit anderen Worten diejenigen, die mit Arrays.asList () erstellt werden) sind strukturell unveränderlich, was diese Antwort völlig ungültig macht. Bis jetzt sehe ich jedoch siebzehn positive Stimmen. Ein Wunder ...
Igor Soudakevitch
15

Sie können 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);

quelle
6

Sie können eine externe Bibliothek verwenden:

org.apache.commons.lang.ArrayUtils.remove(java.lang.Object[] array, int index)

Es ist im Projekt Apache Commons Lang http://commons.apache.org/lang/

bugs_
quelle
ArrayUtils.removeElement(boolean[] array, boolean element)ist auch sehr nützlich.
Scai
5

Siehe Code unten

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

Wenn Sie mehrere Elemente aus dem Array entfernen müssen, ohne es zu konvertieren Listoder ein zusätzliches Array zu erstellen, können Sie dies in O (n) tun, unabhängig von der Anzahl der zu entfernenden Elemente.

Hier aist das anfängliche Array, int... rsind verschiedene geordnete Indizes (Positionen) der zu entfernenden Elemente:

public int removeItems(Object[] a, int... r) {
    int shift = 0;                             
    for (int i = 0; i < a.length; i++) {       
        if (shift < r.length && i == r[shift])  // i-th item needs to be removed
            shift++;                            // increment `shift`
        else 
            a[i - shift] = a[i];                // move i-th item `shift` positions left
    }
    for (int i = a.length - shift; i < a.length; i++)
        a[i] = null;                            // replace remaining items by nulls

    return a.length - shift;                    // return new "length"
}  

Kleine Tests:

String[] a = {"0", "1", "2", "3", "4"};
removeItems(a, 0, 3, 4);                     // remove 0-th, 3-rd and 4-th items
System.out.println(Arrays.asList(a));        // [1, 2, null, null, null]

In Ihrer Aufgabe können Sie zuerst das Array scannen, um Positionen von "a" zu erfassen, und dann aufrufen removeItems().

Alex Salauyou
quelle
1
Bitte tu das nicht. Es ist verwirrend, langsam und fehleranfällig. Verwenden Sie stattdessen einfach System.arraycopy () - obwohl Bonuspunkte für die Tatsache, dass Sie die Länge verfolgen müssen, wenn Sie ein Array auf diese Weise manipulieren möchten.
Bill K
3

Etwas an dem Erstellen einer Liste, das dann entfernt und dann wieder zu einem Array zurückkehrt, scheint mir falsch zu sein. Noch nicht getestet, aber ich denke, dass das Folgende besser abschneiden wird. Ja, ich optimiere wahrscheinlich übermäßig vor.

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];
   }
}
shsteimer
quelle
3

Mir ist klar, dass dies ein sehr alter Beitrag ist, aber einige der Antworten hier haben mir geholfen, also hier ist meine Tuppence 'ha'pennys Wert!

Ich hatte eine ganze Weile Mühe, dies zum Laufen zu bringen, bevor ich feststellte, dass die Größe des Arrays, in das ich zurückschreibe, geändert werden musste, es sei denn, die an der vorgenommenen Änderungen ArrayListlassen die Listengröße unverändert.

Wenn das ArrayList, das Sie ändern, mehr oder weniger Elemente enthält als es begonnen hat, verursacht die Zeile List.toArray()eine Ausnahme. Sie benötigen also etwas wie List.toArray(new String[] {})oder List.toArray(new String[0]), um ein Array mit der neuen (richtigen) Größe zu erstellen.

Klingt jetzt offensichtlich, wo ich es weiß. Nicht so offensichtlich für einen Android / Java-Neuling, der sich mit neuen und unbekannten Codekonstrukten auseinandersetzt, und nicht offensichtlich aus einigen der früheren Beiträge hier, also wollte ich diesen Punkt nur für alle anderen klar machen, die sich stundenlang am Kopf kratzen, wie ich es war !

DDSports
quelle
Ich hatte das Bedürfnis, dies zu posten, da ich oft Codeausschnitte verwende, die nicht funktionieren, weil ich etwas verpasst habe, das andere Programmierer für selbstverständlich halten. GHad machte auf die Array-Größe aufmerksam, die meinen Code zum Laufen gebracht hat (danke, dass Sie das klargestellt haben). Das Ausprobieren ist der Weg zu lernen, und wenn das bedeutet, dass ich alles verdiene, was ich bekomme, um Code von SO zu nehmen und zu verstehen, wie / warum es funktioniert, dann soll es so sein. Als unbezahlter Amateur bin ich nicht das Java-Genie, von dem manche gerne glauben, dass sie es sind! Zum Glück beantworten die meisten SO-Mitwirkenden Fragen, um anderen zu helfen, besseren Code zu schreiben: Dafür verdienen Sie Dank!
DDSports
3

Hier gibt es viele Antworten - das Problem ist meines Erachtens, dass Sie nicht gesagt haben, WARUM Sie ein Array anstelle einer Sammlung verwenden. Lassen Sie mich daher einige Gründe vorschlagen und welche Lösungen zutreffen würden (die meisten Lösungen) wurden hier bereits in anderen Fragen beantwortet, damit ich nicht zu sehr ins Detail gehe):

Grund: Sie wussten nicht, dass das Sammlungspaket vorhanden ist, oder haben ihm nicht vertraut

Lösung: Verwenden Sie eine Sammlung.

Wenn Sie in der Mitte hinzufügen / löschen möchten, verwenden Sie eine LinkedList. Wenn Sie sich wirklich Sorgen um die Größe machen oder häufig mitten in der Sammlung indizieren, verwenden Sie eine ArrayList. Beide sollten Löschvorgänge haben.

Grund: Sie sind besorgt über die Größe oder möchten die Speicherzuweisung steuern

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

Eine ArrayList ist einfach ein Array, das sich selbst erweitern kann, dies muss jedoch nicht immer der Fall sein. Das Hinzufügen / Entfernen von Elementen ist sehr klug. Wenn Sie jedoch eine Menge in der Mitte einfügen / entfernen, verwenden Sie eine LinkedList.

Grund: Sie haben ein Array, das hereinkommt und ein Array, das ausgeht. Sie möchten also ein Array bearbeiten

Lösung: Konvertieren Sie es in eine ArrayList, löschen Sie das Element und konvertieren Sie es zurück

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

Lösung: Sie können kein Array oder keine verknüpfte Liste verwenden.

Grund: Dies ist eine Klassenzuweisung und Sie sind nicht erlaubt oder Sie haben aus irgendeinem Grund keinen Zugriff auf die Sammlungs-APIs

Annahme: Das neue Array muss die richtige "Größe" haben.

Lösung: Scannen Sie das Array nach passenden Elementen und zählen Sie diese. Erstellen Sie ein neues Array mit der richtigen Größe (Originalgröße - Anzahl der Übereinstimmungen). Verwenden Sie System.arraycopy wiederholt, um jede Gruppe von Elementen, die Sie behalten möchten, in Ihr neues Array zu kopieren. Wenn dies eine Klassenzuweisung ist und Sie System.arraycopy nicht verwenden können, kopieren Sie sie einfach einzeln von Hand in einer Schleife, aber tun Sie dies niemals im Produktionscode, da dies viel langsamer ist. (Diese Lösungen werden beide in anderen Antworten detailliert beschrieben.)

Grund: Sie müssen Bare Metal laufen lassen

Annahme: Sie dürfen nicht unnötig Speicherplatz zuweisen oder zu lange dauern

Annahme: Sie verfolgen die im Array verwendete Größe (Länge) separat, da Sie sonst Ihr Array für Löschungen / Einfügungen neu zuweisen müssten.

Ein Beispiel dafür, warum Sie dies tun möchten: Ein einzelnes Array von Grundelementen (sagen wir int-Werte) nimmt einen erheblichen Teil Ihres RAMs ein - wie 50%! Eine ArrayList würde diese in eine Liste von Zeigern auf Integer-Objekte zwingen, die ein paar Mal so viel Speicher benötigen würden.

Lösung: Durchlaufen Sie Ihr Array. Wenn Sie ein zu entfernendes Element finden (nennen wir es Element n), kopieren Sie mit System.arraycopy das Ende des Arrays über das "gelöschte" Element (Quelle und Ziel sind dasselbe Array) ist klug genug, um die Kopie in die richtige Richtung zu erstellen, damit sich der Speicher nicht selbst überschreibt:

 Systemarraycopy (ary, n + 1, ary, n, Länge-n) 
 Länge--;

Sie möchten wahrscheinlich schlauer sein, wenn Sie mehr als ein Element gleichzeitig löschen. Sie würden nur den Bereich zwischen einem "Match" und dem nächsten verschieben und nicht den gesamten Schwanz. Vermeiden Sie wie immer, einen Block zweimal zu verschieben.

In diesem letzten Fall müssen Sie die Arbeit unbedingt selbst erledigen, und die Verwendung von System.arraycopy ist wirklich die einzige Möglichkeit, da dies die bestmögliche Methode zum Verschieben des Speichers für Ihre Computerarchitektur ist - sie sollte um ein Vielfaches schneller sein als jeder Code, den Sie vernünftigerweise selbst schreiben könnten.

Bill K.
quelle
2

Anfängliches Array

   int[] array = {5,6,51,4,3,2};

Wenn Sie 51 entfernen möchten, dh Index 2, verwenden Sie Folgendes

 for(int i = 2; i < array.length -1; i++){
    array[i] = array[i + 1];
  }
Ebin Joy
quelle
1

BEARBEITEN:

Der Punkt mit den Nullen im Array wurde gelöscht. Entschuldigung für meine Kommentare.

Original:

Ähm ... die Linie

array = list.toArray(array);

Ersetzt alle Lücken im Array, in denen das entfernte Element war, durch null . Dies kann gefährlich sein , da die Elemente entfernt werden, die Länge des Arrays jedoch gleich bleibt!

Wenn Sie dies vermeiden möchten, verwenden Sie ein neues Array als Parameter für toArray (). Wenn Sie removeAll nicht verwenden möchten, ist ein Set 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 aktuell akzeptierte Antwort von Chris Yester Young ausgibt:

[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 dass Nullwerte zurückbleiben.

GHad
quelle
Netter Versuch, aber keine Zigarre. Ich habe genau zu diesem Thema eine Bearbeitung veröffentlicht, lange bevor Sie Ihren Beitrag verfasst haben. Obwohl Sie "technisch korrekt" sind, schätze ich es nicht, dass Sie versuchen, Leute dazu zu bringen, meinen Beitrag zu verdrängen. Ich dachte nur, das solltest du wissen.
Chris Jester-Young
Es geht nicht um Post-Verschiebung, sondern darum, Fehler und gefährlichen Code zu vermeiden. Greetz GHad
GHad
Fehler können vermieden werden, wenn Leute meinen gesamten Beitrag lesen (einschließlich beider Nachträge). Wenn Leute nur Code ausschneiden und einfügen, ohne nachzudenken, dann verdienen sie alles, was sie bekommen. Programmierer werden dafür bezahlt, was sie tun, weil sie ihr Gehirn trainieren ... Ich hoffe. [Fortsetzung]
Chris Jester-Young
1
[Fortsetzung] Ihr Code ist auch "gefährlich", wenn die Leute nicht wissen, dass durch die Verwendung eines Hash die Elemente ungeordnet werden. Natürlich erkennen denkende Programmierer dies, aber wenn Sie meinen Code als gefährlich bezeichnen, weil Leute ohne nachzudenken ausschneiden und einfügen, ist es nur fair, dasselbe von Ihnen zu sagen.
Chris Jester-Young
Sicher, Sie haben Recht mit dem Hash. Und da der Punkt durch Ihre 2. Bearbeitung klar ist, muss ich dies überlesen haben. Wie gesagt, wollte nur ein Array mit Nullwerten und Duplikaten vermeiden. Sie können Ihren Code basierend auf Ihrer zweiten Bearbeitung ändern und in Edit3 einen Kommentar zum Array hinterlassen.
Ich
1

Mein kleiner Beitrag zu diesem Problem.

public class DeleteElementFromArray {
public static String foo[] = {"a","cc","a","dd"};
public static String search = "a";


public static void main(String[] args) {
    long stop = 0;
    long time = 0;
    long start = 0;
    System.out.println("Searched value in Array is: "+search);
    System.out.println("foo length before is: "+foo.length);
    for(int i=0;i<foo.length;i++){ System.out.println("foo["+i+"] = "+foo[i]);}
    System.out.println("==============================================================");
    start = System.nanoTime();
    foo = removeElementfromArray(search, foo);
    stop = System.nanoTime();
    time = stop - start;
    System.out.println("Equal search took in nano seconds = "+time);
    System.out.println("==========================================================");
    for(int i=0;i<foo.length;i++){ System.out.println("foo["+i+"] = "+foo[i]);}
}
public static String[] removeElementfromArray( String toSearchfor, String arr[] ){
     int i = 0;
     int t = 0;
     String tmp1[] = new String[arr.length];     
         for(;i<arr.length;i++){
              if(arr[i] == toSearchfor){     
              i++;
              }
             tmp1[t] = arr[i];
             t++;
     }   
     String tmp2[] = new String[arr.length-t];   
     System.arraycopy(tmp1, 0, tmp2, 0, tmp2.length);
     arr = tmp2; tmp1 = null; tmp2 = null;
    return arr;
}

}}

Andre
quelle
Dies ist eine wirklich gute Antwort, obwohl Ihr großartiger Testcode ihn viel größer aussehen lässt, als er tatsächlich ist. Die gesamte Lösung könnte eine einzeilige Arraykopie sein (vorausgesetzt, Sie verwenden dasselbe Array, was Sie tun möchten, wenn Sie so nahe an dem Metall arbeiten, dass Sie Arrays anstelle von Sammlungen verwenden).
Bill K
danke, ich habe es geschrieben, damit die Leser ein bisschen sehen können, was unter der Haube vor sich geht, und es testen können, jetzt schaue ich es mir noch einmal an System.arraycopy (tmp1, 0, tmp2, 0, tmp2.length); kann entfernt und durch etwas wie (i = 0; i <(arr.length - t); i ++) {tmp2 [i] = tmp1 [i]; } Sie können auch einen Byte-Puffer erstellen und 8 Bytes gleichzeitig auf einem 64-Bit-Computer kopieren, um zusätzliche Kopierleistung zu erzielen
Andre
0

Es kommt darauf an, was du mit "entfernen" meinst? Ein Array ist ein Konstrukt mit fester Größe. Sie können die Anzahl der darin enthaltenen Elemente nicht ändern. Sie können also entweder a) ein neues, kürzeres Array ohne die Elemente erstellen, die Sie nicht möchten, oder b) die Einträge, die Sie nicht möchten, etwas zuweisen, das ihren Status "leer" anzeigt; normalerweise null, wenn Sie nicht mit Grundelementen arbeiten.

Erstellen Sie im ersten Fall eine Liste aus dem Array, entfernen Sie die Elemente und erstellen Sie ein neues Array aus der Liste. Wenn die Leistung wichtig ist, durchlaufen Sie das Array und weisen Sie alle Elemente zu, die nicht zu einer Liste entfernt werden sollen, und erstellen Sie dann ein neues Array aus der Liste. Im zweiten Fall gehen Sie einfach durch und weisen den Array-Einträgen null zu.

DJClayworth
quelle
0

Arrgh, ich kann den Code nicht richtig anzeigen lassen. Entschuldigung, ich habe es geschafft. Entschuldigung nochmal, ich glaube nicht, dass ich die Frage richtig gelesen habe.

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++;
    }
}
AngelOfCake
quelle
0

Kopiert alle Elemente außer dem mit dem Index i:

if(i == 0){
                System.arraycopy(edges, 1, copyEdge, 0, edges.length -1 );
            }else{
                System.arraycopy(edges, 0, copyEdge, 0, i );
                System.arraycopy(edges, i+1, copyEdge, i, edges.length - (i+1) );
            }
PauLy
quelle
0

In einer Reihe von Strings wie

String name = 'abcdeafbde' // könnte wie String name = 'aa bb cde aa f bb de' sein

Ich baue die folgende Klasse

class clearname{
def parts
def tv
public def str = ''
String name
clearname(String name){
    this.name = name
    this.parts = this.name.split(" ")
    this.tv = this.parts.size()
}
public String cleared(){

        int i
        int k
        int j=0        
    for(i=0;i<tv;i++){
        for(k=0;k<tv;k++){
            if(this.parts[k] == this.parts[i] && k!=i){
               this.parts[k] = '';
                j++
            }
        }
    }
    def str = ''
    for(i=0;i<tv;i++){
        if(this.parts[i]!='')

           this.str += this.parts[i].trim()+' '
    } 
    return this.str    
}}



return new clearname(name).cleared()

dieses Ergebnis erhalten

abcdef

hoffe, dieser Code hilft jedem Grüße

Orlando Reyes
quelle
0

Wenn es nicht auf die Reihenfolge der Elemente ankommt. Sie können zwischen den Elementen foo [x] und foo [0] wechseln und dann foo.drop (1) aufrufen.

foo.drop(n) Entfernt (n) erste Elemente aus dem Array.

Ich denke, dies ist der einfachste und ressourceneffizienteste Weg.

PS : indexOfkann auf viele Arten implementiert werden, dies ist meine Version.

Integer indexOf(String[] arr, String value){
    for(Integer i = 0 ; i < arr.length; i++ )
        if(arr[i] == value)
            return i;         // return the index of the element
    return -1                 // otherwise -1
}

while (true) {
   Integer i;
   i = indexOf(foo,"a")
   if (i == -1) break;
   foo[i] = foo[0];           // preserve foo[0]
   foo.drop(1);
}
Milevyo
quelle
-3

Verwenden:

list.removeAll(...);
//post what char you need in the ... section
LOL
quelle
-7

Weisen Sie den Array-Positionen null zu.

Alfinoba
quelle