Elemente aus zwei verschiedenen Arrays miteinander vergleichen und gegeben falls entfernen

Bademeister007

Bademeister007

Mitglied
public class Satz2
{
public ArrayList<Wort> satz = new ArrayList<Wort>();
public Wort w;

public Satz2(ArrayList<Wort> satz)
{
this.satz = satz;
System.out.println("\n---Satz mit vereinzelten Woertern geaddet---");

}


public void entferneStoppWoerter(ArrayList<Wort> stoppwoerter) throws FileNotFoundException
{
System.out.println("---Stoppwoerter entfernen---");


String [] s = new String[satz.size()];
String[] stopp = new String[stoppwoerter.size()];
//maybe my loops are wrong?
for( int i =0; i <s.length; i++)
{

s = satz.get(i).getWoerter();

for( int j =0; j < stopp.length; j++)
{

stopp[j] = stoppwoerter.get(j).getWoerter();


}
if(s.equals(stopp))
{
System.out.println("---gefunden-------------------");
satz.remove(satz.get(i)); //i thought remove is the right command
setWoerterListe(satz);
}
else
i++;

}
}


}

Hallo Leute ich hoffe ihr könnt mir bei mein Problem weiterhelfen.
Ich versuche ein bestimmtes Element zu entfernen. Hierbei geht es um ein Wort z. B "dabei" und wenn dieses Wort in beiden Arrays vorhanden ist, soll es entfernt werden.
Ich dachte Der Remove Befehl wäre hier optimal aber anscheinend gibt es Schwierigkeiten.

ich freue mich auf Antworten.
 
B

Barista

Top Contributor
Das übliche hier:

1. Code-Tags benutzen,

2. eine richtige Frage stellen
 
B

Barista

Top Contributor
Bei der remove-Methode musst Du aufpassen.

Es gibt leider eine Überladung:

remove(int) (hier wäre removeAt() besser gewesen, aber Autoboxing kam erst mit Java5, die remove-Methoden gab es schon vorher)

remove(Object)

Ich vermute, Du rufst versehentlich remove(Object) auf
 
B

Barista

Top Contributor
Es gibt auch noch

removeAll()

Damit reduziert sich alles auf ein Statement.

Aber da wäre der Lerneffekt sehr gering.
 
Oneixee5

Oneixee5

Bekanntes Mitglied
Das Array-gewurstel ist völlig unnötig. Direkt mit Listen arbeiten ist viel komfortabler:
Java:
        List<String> stopwords = Arrays.asList("red", "blue");
        List<String> otherList = new ArrayList(Arrays.asList("red", "green", "green", "yellow"));

        System.out.println(otherList);

        Iterator<String> iter = otherList.iterator();
        String s;
        while (iter.hasNext()) {
            s = iter.next();
            if (stopwords.contains(s)) {
                iter.remove();
            }
        }

        System.out.println(otherList);
Wobei stopwords auch ein Set sein könnte. Im Prinzip musst du ja nur die Liste durchgehen und alle Elemente entfernen, welche dir nicht passen.
Da du eine Klasse Wort verwendest, muss diese ggf. equals implementieren damit die contains-Methode funktioniert.
 
Zuletzt bearbeitet:
Bademeister007

Bademeister007

Mitglied
Das Array-gewurstel ist völlig unnötig. Direkt mit Listen arbeiten ist viel komfortabler:
Java:
        List<String> stopwords = Arrays.asList("red", "blue");
        List<String> otherList = new ArrayList(Arrays.asList("red", "green", "green", "yellow"));

        System.out.println(otherList);

        Iterator<String> iter = otherList.iterator();
        String s;
        while (iter.hasNext()) {
            s = iter.next();
            if (stopwords.contains(s)) {
                iter.remove();
            }
        }

        System.out.println(otherList);
Wobei stopwords auch ein Set sein könnte. Im Prinzip musst du ja nur die Liste durchgehen und alle Elemente entfernen, welche dir nicht passen.
Da du eine Klasse Wort verwendest, muss diese ggf. equals implementieren damit die contains-Methode funktioniert.
Nein es geht darum, ein bestimmtes Element zu entfernen. Als in deinem Beispiel könnte man red entfernen. Dh if(stopwords.equals(otherList). Es ist auch nicht mein vollständiger Code sondern nur ein Teil Code von einem ganzen, deswegen sieht das so durcheinander aus. Mir gehts ja nur um das Prinzip dahinter.
 
B

Barista

Top Contributor
Nein es geht darum, ein bestimmtes Element zu entfernen.
Dann filterst Du eben deine Stopwords auf dieses Element.

Es ist auch nicht mein vollständiger Code sondern nur ein Teil Code von einem ganzen, deswegen sieht das so durcheinander aus.
Code baut man am besten aus klar definierten Bausteinen.

Am besten Dinge, die in der Informatik einen Namen haben.

Es ist bereits alles erfunden.

"Bei mir" heisst meist "falsch".
 
Oneixee5

Oneixee5

Bekanntes Mitglied
OK, noch mal das Prinzip dahinter. Gegeben ist folgender Code:
Java:
public class App {

    private static class Wort {

        private String content;

        public Wort(String content) {
            this.content = content;
        }

        public String getContent() {
            return content;
        }

        @Override
        public String toString() {
            return "Wort [content=" + content + "]";
        }

    }

    public static void main(String[] args) {
        Wort stopword = new Wort("red");
        List<String> otherList = new ArrayList(
                Arrays.asList(new Wort("red"), new Wort("green"), new Wort("yellow"), new Wort("green")));

        System.out.println("\u001b[31m" + otherList);

        while (otherList.remove(stopword));

        System.out.println("\u001b[32m" + otherList);
    }

}
Ergebnis:
[Wort [content=red], Wort [content=green], Wort [content=yellow], Wort [content=green]]
[Wort [content=red], Wort [content=green], Wort [content=yellow], Wort [content=green]]
Jetzt sollte man meinen, das stopword müsste aus der Liste entfernt werden. Das funktioniert aber nicht weil die Methode equals von Wort nicht überschrieben wurde. Die Standardimplementierung vergleicht irgend einen Kauderwelsch, welcher uns hier nicht interessieren muss.

Wenn wir aber die Klasse Wort ändern, indem equals (und wann immer equals überschrieben wird, sollte man auch hashcode überschreiben) überschreiben, dann sieht die Sache anders aus:
Java:
    private static class Wort {

        private String content;

        public Wort(String content) {
            this.content = content;
        }

        public String getContent() {
            return content;
        }

        @Override
        public String toString() {
            return "Wort [content=" + content + "]";
        }

        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + ((content == null) ? 0 : content.hashCode());
            return result;
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            Wort other = (Wort) obj;
            if (content == null) {
                if (other.content != null)
                    return false;
            } else if (!content.equals(other.content))
                return false;
            return true;
        }

    }
Ergebnis:
[Wort [content=red], Wort [content=green], Wort [content=yellow], Wort [content=green]]
[Wort [content=green], Wort [content=yellow], Wort [content=green]]
Jetzt wird in den Vergleich der konkrete Inhalt einbezogen. Jetzt kann das Stoppwort entfernt werden.
 
Bademeister007

Bademeister007

Mitglied
OK, noch mal das Prinzip dahinter. Gegeben ist folgender Code:
Java:
public class App {

    private static class Wort {

        private String content;

        public Wort(String content) {
            this.content = content;
        }

        public String getContent() {
            return content;
        }

        @Override
        public String toString() {
            return "Wort [content=" + content + "]";
        }

    }

    public static void main(String[] args) {
        Wort stopword = new Wort("red");
        List<String> otherList = new ArrayList(
                Arrays.asList(new Wort("red"), new Wort("green"), new Wort("yellow"), new Wort("green")));

        System.out.println("\u001b[31m" + otherList);

        while (otherList.remove(stopword));

        System.out.println("\u001b[32m" + otherList);
    }

}
Ergebnis:
[Wort [content=red], Wort [content=green], Wort [content=yellow], Wort [content=green]]
[Wort [content=red], Wort [content=green], Wort [content=yellow], Wort [content=green]]
Jetzt sollte man meinen, das stopword müsste aus der Liste entfernt werden. Das funktioniert aber nicht weil die Methode equals von Wort nicht überschrieben wurde. Die Standardimplementierung vergleicht irgend einen Kauderwelsch, welcher uns hier nicht interessieren muss.

Wenn wir aber die Klasse Wort ändern, indem equals (und wann immer equals überschrieben wird, sollte man auch hashcode überschreiben) überschreiben, dann sieht die Sache anders aus:
Java:
    private static class Wort {

        private String content;

        public Wort(String content) {
            this.content = content;
        }

        public String getContent() {
            return content;
        }

        @Override
        public String toString() {
            return "Wort [content=" + content + "]";
        }

        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + ((content == null) ? 0 : content.hashCode());
            return result;
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            Wort other = (Wort) obj;
            if (content == null) {
                if (other.content != null)
                    return false;
            } else if (!content.equals(other.content))
                return false;
            return true;
        }

    }
Ergebnis:
[Wort [content=red], Wort [content=green], Wort [content=yellow], Wort [content=green]]
[Wort [content=green], Wort [content=yellow], Wort [content=green]]
Jetzt wird in den Vergleich der konkrete Inhalt einbezogen. Jetzt kann das Stoppwort entfernt werden.
Hey vielen vielen Dank für deine Mühe und Hilfestellungen. Leider bringt mich das ganze doch nicht weiter. Mir fehlt nun mal noch ein gewisses Verständnis. Trotzdem Danke nochmal!
 
mihe7

mihe7

Top Contributor
Um mal auf Deinen ursprünglichen Code zurückzukommen: da stimmt zwar so gut wie nix, aber man sieht ein Problem, nämlich dass Du mittels eines Index stur von vorne nach hinten durch die Liste iterierst und dabei Elemente entfernst. Das verschlimmbesserst Du noch, in dem Du i ein weiteres mal inkrementierst, wenn kein Stopwort gefunden wurde.

Du musst Dir klar machen, was da passiert: die äußere for-Schleife inkrementiert nach jedem Durchlauf i, so dass i normalerweise Werte 0,1,2,3,.. annimmt. Nehmen wir mal an, es gelte i == 2 und Du löscht das Element an dieser Position. Dann rutschen die Folgelemente nach vorne, so dass das Element, das zuvor an Index 3 stand nun an Index 2 steht. Die for-Schleife inkrementiert nun i, so dass i == 3 gilt. Folglich hast Du das Element, das ursprünglich an Inde 3 stand, übersprungen.

Beispiel: Du willst c und d löschen

Code:
0 a
1 b
2 c  <- i
3 d
4 e

Vergleich: ah, c ist das zu löschende Element, also löschen wir Element 2
0 a
1 b
2 d  <- i
3 e

Jetzt inkrementiert die Schleife das i
0 a
1 b
2 d 
3 e <- i
Das d wird niemals verglichen. Weil du zusätzlich i nochmal inkrementierst, wenn das Wort kein Stoppwort ist, passiert noch schlimmeres:
Code:
0 a <- i
1 b
2 c  
3 d
4 e

Ah, a kein Stopwort -> inkrementiere i. Ende der for-Schleife: inkrementiere i nochmal
0 a
1 b
2 c <- i  
3 d
4 e

OK, c Stopwort -> entferne Element 2, inkrementiere i
0 a
1 b
2 d
3 e  <-  i

Kurz: jedes zweite Wort fällt aus dem Vergleich heraus, denn entweder ist es kein Stopwort, dann wird i zweimal inkrementiert oder es ist ein Stopwort, dann wird es gelöscht und i inkrementiert.

Um das zu umgehen, lässt Du den else-Zweig weg und dekrementierst das i, wenn ein Element gelöscht wurde (das Dekrementieren hebt das Inkrementieren der for-Schleife auf). Andere Möglichkeit: Du gehst einfach von hinten nach vorne durch die Liste. Dann muss der Schleifenzähler innerhalb der Schleife nicht angepasst werden.
 
T

Trjavnamen

Bekanntes Mitglied
ein anderer Ansartz alle elemente die gelöscht werden sollen mit Null überschreiben , dann sortieren nochmals die schleife rückwärts durchlaufen und alle Null löschen-
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
I Alle Elemente von zwei Listen vergleichen Java Basics - Anfänger-Themen 1
L Erste Schritte Elemente zwei Schlangen vergleichen Java Basics - Anfänger-Themen 14
N ArrayList wird immer um zwei Elemente erweitert Java Basics - Anfänger-Themen 9
B zwei zufällige elemente aus array lesen und überprüfen Java Basics - Anfänger-Themen 8
G zwei Arrays nach gemeinsamme Elemente suchen? Java Basics - Anfänger-Themen 19
T SCC Elemente Java Basics - Anfänger-Themen 0
L ArrayList auf 4 Elemente begrenzen Java Basics - Anfänger-Themen 56
H Array Elemente Java Basics - Anfänger-Themen 17
T Elemente aus Array zu TableView JavaFX übertragen Java Basics - Anfänger-Themen 2
J Array Elemente werden nicht gefunden! Java Basics - Anfänger-Themen 6
GAZ String replace() Elemente tauschen Java Basics - Anfänger-Themen 13
J Array; Elemente kopieren Java Basics - Anfänger-Themen 17
V Array aus Klasse um vererbte Elemente erweitern Java Basics - Anfänger-Themen 3
S Laufzeit Quicksort wenn alle Elemente gleich sind Java Basics - Anfänger-Themen 4
A Array Elemente extrahieren ! Java Basics - Anfänger-Themen 4
J Elemente in einem 2D-Array summieren Java Basics - Anfänger-Themen 6
Kirby.exe Anzahl vorkommender Elemente im Array zählen Java Basics - Anfänger-Themen 9
M Matrix auf 4 Elemente untersuchen mit offenen Enden Java Basics - Anfänger-Themen 8
M Matrix Elemente vergleichen Java Basics - Anfänger-Themen 11
S Elemente eines Arrays bei Ausgabe auslassen Java Basics - Anfänger-Themen 2
L String zerlegen & elemente hinzufügen Java Basics - Anfänger-Themen 5
L Anzahl der Elemente key in einem Array mit log(N) Laufzeit Java Basics - Anfänger-Themen 4
E Elemente aus Liste löschen Java Basics - Anfänger-Themen 5
L Array Elemente verschieben Java Basics - Anfänger-Themen 5
S Elemente in Liste einfügen Java Basics - Anfänger-Themen 2
D jsoup.select findet keine elemente Java Basics - Anfänger-Themen 2
F JList Elemente mit Strings vergleichen Java Basics - Anfänger-Themen 12
W ArrayList löscht alle Elemente bis auf eines Java Basics - Anfänger-Themen 2
M Elemente in einer ArrayList einander zuordnen. Java Basics - Anfänger-Themen 18
T Klassen Doppelte Elemente aus Container entfernen Java Basics - Anfänger-Themen 6
G Verkettete Liste - Neu erzeugte Elemente werden nicht ausgegeben Java Basics - Anfänger-Themen 5
GreenTeaYT HashMap dupliziert meine Elemente? Java Basics - Anfänger-Themen 2
J Elemente in Array speichern, löschen, ... Java Basics - Anfänger-Themen 3
arjoopy Kapselung Elemente aus Objekt-Array ausgeben Java Basics - Anfänger-Themen 8
U Input/Output Elemente eines Binären Suchbaums ausgeben Java Basics - Anfänger-Themen 10
M ComboBox bestimmte Elemente disablen/ausgrauen Java Basics - Anfänger-Themen 3
K Anzahl gleicher Elemente in Array Java Basics - Anfänger-Themen 32
M LinkedList elemente löschen Java Basics - Anfänger-Themen 2
D Klassen Doppelt so viele Elemente in Arraylist ? Java Basics - Anfänger-Themen 4
V Elemente aus einem Array mit null überschreiben Java Basics - Anfänger-Themen 4
A Methoden Char-Arrays auf aufeinanderfolgende Elemente vergleichen! Java Basics - Anfänger-Themen 7
C Array Elemente Paarweise vertauschen Java Basics - Anfänger-Themen 2
kilopack15 Array auf doppelte Elemente überprüfen Java Basics - Anfänger-Themen 16
Wood14Mine Elemente aus einer anderen GUI steuern! Java Basics - Anfänger-Themen 13
R warum kann System.out.println(..) etwas, was Swing-Elemente Nicht können ? Java Basics - Anfänger-Themen 11
R Elemente eine Liste im Ring schliessen Java Basics - Anfänger-Themen 9
B generische LinkedList nach Häufigkeit der Elemente füllen Java Basics - Anfänger-Themen 6
B in einem abstrakten Set ,Elemente einer einfache verkettete List epeichern Java Basics - Anfänger-Themen 13
M Klassen Gesamt speicherbare Elemente in Vector? Java Basics - Anfänger-Themen 3
M Elemente eines Arrays verschieben Java Basics - Anfänger-Themen 9
A Anzahl der Elemente in einem Stack wiedergeben Java Basics - Anfänger-Themen 3
O Rekursiver Durchlauf verschachtelter Elemente Java Basics - Anfänger-Themen 1
P Vector durchsuchen und Elemente löschen Java Basics - Anfänger-Themen 4
R Variablen [GELÖST]Elemente in Array um Schrittweite s verschieben Java Basics - Anfänger-Themen 2
1 Wie addiert man die Elemente einer Verketteten Liste? Java Basics - Anfänger-Themen 5
T Erste Schritte Elemente finden, deren Name erst "zusammengesetzt" wird Java Basics - Anfänger-Themen 8
A Eindeutige Elemente aus Array extrahieren Java Basics - Anfänger-Themen 9
gamebreiti Gui menu ArrayList Elemente wiedererkennen Java Basics - Anfänger-Themen 3
C Matrixmultiplikation ohne einzelne Elemente aufzurufen Java Basics - Anfänger-Themen 2
V wie kann ich in zweidimensionaller Arraylist auf die einzelnen Elemente zugreifen ? Java Basics - Anfänger-Themen 7
W wie legt man die elemente der liste k Mal fest ? Java Basics - Anfänger-Themen 7
S Anzahl unterschiedlicher Elemente zählen Java Basics - Anfänger-Themen 4
G Performance - höhere Anzahl Swing Elemente Java Basics - Anfänger-Themen 5
C ArrayList - überschreibt Elemente Java Basics - Anfänger-Themen 7
A Mehrere 100.000 Elemente verlgeichen Java Basics - Anfänger-Themen 8
A JList Elemente in ein andres JList Adden Java Basics - Anfänger-Themen 5
B Zweidimensionales Array Elemente jeder Spalte zählen Java Basics - Anfänger-Themen 9
L Rückwärtsausgabe der Array-Elemente Java Basics - Anfänger-Themen 5
1 Elemente von 2 Arrays vergleichen Java Basics - Anfänger-Themen 12
1 Minimum aller Elemente in einem Array bestimmen Java Basics - Anfänger-Themen 10
M aus x Elementen y Elemente auswählen Java Basics - Anfänger-Themen 6
J Eingabe Elemente Aktivieren Java Basics - Anfänger-Themen 2
R Best Practice Elemente aus ArrayList entfernen (performant) Java Basics - Anfänger-Themen 6
G String Elemente auf Zahlen Überprüfen Java Basics - Anfänger-Themen 21
T Elemente im Array umdrehen Java Basics - Anfänger-Themen 9
L Elemente zufällig in ein Array verteilen Java Basics - Anfänger-Themen 12
T Wieviel Array-Elemente Java Basics - Anfänger-Themen 19
M Elemente im DefaultListModel separat auslesen Java Basics - Anfänger-Themen 2
T Collections Zugriff auf Elemente aus Iterator() Schleife Java Basics - Anfänger-Themen 4
P BitSet- Objekt- Anzahl der Elemente bestimmen Java Basics - Anfänger-Themen 2
S JPA / Elemente einer Liste ansprechen Java Basics - Anfänger-Themen 5
B mit einem Iterrator elemente aus einer liste löschen Java Basics - Anfänger-Themen 3
Mrtwomoon Collections Hashset elemente ohne Eckigeklammer ausgeben Java Basics - Anfänger-Themen 9
W Elemente in einem Array nach 'oben' verschieben Java Basics - Anfänger-Themen 9
M Vector überschreibt Elemente bei add()-Methode Java Basics - Anfänger-Themen 10
H Redundante Elemente aus ArrayList entfernen Java Basics - Anfänger-Themen 3
T Elemente im Vector werden einfach überschrieben! Java Basics - Anfänger-Themen 3
A Elemente aus Liste entfernen Java Basics - Anfänger-Themen 5
A Elemente in HashSet enthalten oder nicht Java Basics - Anfänger-Themen 6
C Elemente im StringBuffer ersetzen Java Basics - Anfänger-Themen 19
E Elemente einer (öffentlichen) ArrayList in einer anderen Klasse zu einer ArrayList dazu fügen. Java Basics - Anfänger-Themen 7
L ArrayList Elemente verknüpfen Java Basics - Anfänger-Themen 2
M Jlist Elemente hinzufügen Java Basics - Anfänger-Themen 2
G Gleiche Elemente in Feld zählen Java Basics - Anfänger-Themen 13
G Elemente von Feld und Liste auf Gleichheit überprüfen Java Basics - Anfänger-Themen 13
H Arrays, Elemente löschen Java Basics - Anfänger-Themen 12
M wie kann ich am besten die kleinste 2 elemente von einer Liste kriegen Java Basics - Anfänger-Themen 4
S XML Datei einlesen und Elemente ausgeben Java Basics - Anfänger-Themen 4
A Elemente in array umkehren Java Basics - Anfänger-Themen 32
L Elemente die in Array1 sind aus Array2 löschen Java Basics - Anfänger-Themen 6

Ähnliche Java Themen


Oben