Generics ArrayList: Bug im Quellcode

Hallo,
ich wollte die Klasse ArrayList selbst implementieren. Meiner Meinung ist nur noch die public boolean contains(X x) Methode falsch. Seit Stunden sitze ich schon dran aber ich finde den Fehler aber nicht. Eine Vermutung, wo der Fehler liegt habe ich schon.
Aus irgendeinem Grund gibt die Abfrage if(!contains(x)) false zurück, obwohl Sie das nicht sollte.
Da, die Zahl 123 im Array enthalten ist.
Also Probleme macht diese Zeile Code im Programm:
System.out.println(l1.remove(new Integer(123)));

Könntet ihr mir helfen meinen Fehler herauszubekommen?

Java:
public class MyArrayList<X> {

    private X[] arrayList;
    int cardinality = 0;
  
    public MyArrayList(int capacity) {
        arrayList = ( X[] ) new Object[capacity];
    }
  
    public int getNextFreeSlot() {
        return cardinality;
    }

    private void setNextFreeSlot(int nextFreeSlot) {
        this.cardinality = nextFreeSlot;
    }
  
    public boolean contains(X x) {
        for(int i=0;i<size();i++) {
            if(arrayList[i].equals(x)) {
                return true;
            }
        }
        return false;
    }

    public void add(X x) throws IllegalArgumentException{
        if(x==null) {
            throw new IllegalArgumentException();
        }
        if(getNextFreeSlot()+1==arrayList.length) {
            X[] tmpArray= ( X[] ) new Object[arrayList.length];
            for(int i=0;i<tmpArray.length;i++) {
                tmpArray[i]=arrayList[i];
            }
            arrayList= ( X[] )new Object[2*arrayList.length];
            for(int i = 0;i<tmpArray.length;i++) {
                arrayList[i]=tmpArray[i];
            }
        }
        arrayList[cardinality]=x;
        setNextFreeSlot(cardinality+1);;
    }
    public boolean remove(X x) throws IllegalArgumentException{
        if(x==null) {
            throw new IllegalArgumentException();
        }
        if(!contains(x)) {
            return false;
        }
        int index=0;
        for(int i=0;i<arrayList.length;i++) {
            if(arrayList[i].equals(x)) {
                index=i;
            }
        }
        remove(index);
        return true;
    }
    public X remove(int index) throws IllegalArgumentException{
        if(index <0 || index >= arrayList.length) {
            throw new IllegalArgumentException();
        }
        X deletedObject = arrayList[index];
        for(int i=index;i<arrayList.length-1;i++) {
            arrayList[i]=arrayList[i+1];
        }
        setNextFreeSlot(getNextFreeSlot()-1);
        return deletedObject;
    }
    public X get(int i) throws IllegalArgumentException{
        if(i<0 || i >= arrayList.length) {
            throw new IllegalArgumentException();
        }
        return arrayList[i];
    }
    public void clear() {
        /*for(int i =0;i<nextFreeSlot;i++) {
            arrayList[i]=null;
        }*/
        setNextFreeSlot(0);
    }
    public boolean isEmpty() {
        if(getNextFreeSlot()!=0) {
            return false;
        }
        return true;
    }
  
    public int size() {
        return getNextFreeSlot();
    }
  
    public void print() {
        System.out.print(arrayList[0]);
        for(int i=1;i<arrayList.length;i++) {
            System.out.print(", " + arrayList[i]);
        }
        System.out.print("\n");
    }
}


Java:
public class MyArrayList<X> {

    private X[] arrayList;
    int cardinality = 0;
  
    public MyArrayList(int capacity) {
        arrayList = ( X[] ) new Object[capacity];
    }
  
    public int getNextFreeSlot() {
        return cardinality;
    }

    private void setNextFreeSlot(int nextFreeSlot) {
        this.cardinality = nextFreeSlot;
    }
  
    public boolean contains(X x) {
        for(int i=0;i<size();i++) {
            if(arrayList[i].equals(x)) {
                return true;
            }
        }
        return false;
    }

    public void add(X x) throws IllegalArgumentException{
        if(x==null) {
            throw new IllegalArgumentException();
        }
        if(getNextFreeSlot()+1==arrayList.length) {
            X[] tmpArray= ( X[] ) new Object[arrayList.length];
            for(int i=0;i<tmpArray.length;i++) {
                tmpArray[i]=arrayList[i];
            }
            arrayList= ( X[] )new Object[2*arrayList.length];
            for(int i = 0;i<tmpArray.length;i++) {
                arrayList[i]=tmpArray[i];
            }
        }
        arrayList[cardinality]=x;
        setNextFreeSlot(cardinality+1);;
    }
    public boolean remove(X x) throws IllegalArgumentException{
        if(x==null) {
            throw new IllegalArgumentException();
        }
        if(!contains(x)) {
            return false;
        }
        int index=0;
        for(int i=0;i<arrayList.length;i++) {
            if(arrayList[i].equals(x)) {
                index=i;
            }
        }
        remove(index);
        return true;
    }
    public X remove(int index) throws IllegalArgumentException{
        if(index <0 || index >= arrayList.length) {
            throw new IllegalArgumentException();
        }
        X deletedObject = arrayList[index];
        for(int i=index;i<arrayList.length-1;i++) {
            arrayList[i]=arrayList[i+1];
        }
        setNextFreeSlot(getNextFreeSlot()-1);
        return deletedObject;
    }
    public X get(int i) throws IllegalArgumentException{
        if(i<0 || i >= arrayList.length) {
            throw new IllegalArgumentException();
        }
        return arrayList[i];
    }
    public void clear() {
        /*for(int i =0;i<nextFreeSlot;i++) {
            arrayList[i]=null;
        }*/
        setNextFreeSlot(0);
    }
    public boolean isEmpty() {
        if(getNextFreeSlot()!=0) {
            return false;
        }
        return true;
    }
  
    public int size() {
        return getNextFreeSlot();
    }
  
    public void print() {
        System.out.print(arrayList[0]);
        for(int i=1;i<arrayList.length;i++) {
            System.out.print(", " + arrayList[i]);
        }
        System.out.print("\n");
    }
}
 
Hier ist das dazugehörige main-Programm

Java:
public class MyArrayListTest {

    public static void main(String[] args) {
       
        MyArrayList<Integer> l1 = new MyArrayList(3);
       
       
        System.out.println("isEmpty()");
        System.out.println(l1.isEmpty());
        System.out.println("-------------------\n");
       
       
        System.out.println("add(x)");
        l1.add(1);  // 0
        l1.add(2);  // 1
        l1.add(3);  // 2
        l1.add(13); // 3
        l1.add(2);  // 4
        l1.add(12); // 5
        l1.add(123);// 6
        System.out.println("-------------------\n");
       
       
        System.out.println("contains(x) ");
        System.out.println(l1.contains(1));
        System.out.println(l1.contains(2));
        System.out.println(l1.contains(3));
        System.out.println(l1.contains(100));
        System.out.println("-------------------\n");
       
       
        System.out.println("remove(x) ");
        System.out.println(l1.remove(0));
        System.out.println(l1.remove(1));
        System.out.println(l1.remove(6));
        System.out.println(l1.remove(6));
        System.out.println(l1.remove(new Integer(123)));
        System.out.println("-------------------\n");
       
       
        System.out.println("get(x) ");
        System.out.println(l1.get(5));
        System.out.println("-------------------\n");
       
       
        System.out.println("isEmpty()");
        System.out.println(l1.isEmpty());
        System.out.println("-------------------\n");
       
       
        System.out.println("size()");
        System.out.println(l1.size());
        System.out.println("-------------------\n");
       
       
        System.out.println("clear()");
        l1.clear();
        l1.print();
        System.out.println("-------------------\n");
       
       
        System.out.println("size()");
        System.out.println(l1.size());
        System.out.println("-------------------\n");
    }
}
 
Was ich mich noch frage. Ich habe zwei Methoden mit dem gleichen Namen. Woher weiß der Compiler, welche Methode ich aufrufen will? Mt x.remove(3) kann doch der Index 3 oder das Objekt 3 gemeint sein.

public boolean remove(X x)
public X remove(int index)
 
Und wie bekomme ich die andere remove Methode aufgerufen?
Mit x.remove(new Integer(3)); ?

Ein Fehler habe ich schon gefunden. Es muss ein size() hin anstatt dem array.length
for(int i=0;i<size();i++)
 
Ich hab mir den Code mal genauer angeschaut und den einzigen Fehler, den ich vielleicht finde, ist das hier auch size() anstatt arrayList.length hin muss.
if(index <0 || index >= arrayList.length)

Das ist aber kein wirklicher Fehler, weil es doch nicht schlimm ist, wenn man eine null Referenz löscht?
Wo hast du denn noch Fehler gesehen?
 

mrBrown

Super-Moderator
Mitarbeiter
Es waren alles stellen mit length statt size.
Führte zb dazu, dass löschen von Elementen, die gar nicht mehr in der Liste sind (zb an Index 6, wenn wenige als 6 drin sind), die Liste trotzdem verkürzt hat
 
Ok, ich denke jetzt müsste es stimmen?

Java:
public class MyArrayList<X> {

    private X[] arrayList;
    private int cardinality = 0;
  
    public MyArrayList(int capacity) {
        arrayList = ( X[] ) new Object[capacity];
    }
  
    public int getNextFreeSlot() {
        return cardinality;
    }

    private void setNextFreeSlot(int nextFreeSlot) {
        this.cardinality = nextFreeSlot;
    }
  
    public boolean contains(X x) {
        for(int i=0;i<size();i++) {
            if(arrayList[i].equals(x)) {
                return true;
            }
        }
        return false;
    }

    public void add(X x) throws IllegalArgumentException{
        if(x==null) {
            throw new IllegalArgumentException();
        }
        if(getNextFreeSlot()+1==arrayList.length) {
            X[] tmpArray= ( X[] ) new Object[arrayList.length];
            for(int i=0;i<tmpArray.length;i++) {
                tmpArray[i]=arrayList[i];
            }
            arrayList= ( X[] )new Object[2*arrayList.length];
            for(int i = 0;i<tmpArray.length;i++) {
                arrayList[i]=tmpArray[i];
            }
        }
        arrayList[cardinality]=x;
        setNextFreeSlot(getNextFreeSlot()+1);;
    }
    public boolean remove(X x) throws IllegalArgumentException{
        if(x==null) {
            throw new IllegalArgumentException();
        }
        if(contains(x)) {
            return false;
        }
        int index=0;
        for(int i=0;i<size();i++) {
            if(arrayList[i].equals(x)) {
                index=i;
            }
        }
        remove(index);
        return true;
    }
    public X remove(int index) throws IllegalArgumentException{
        if(index <0 || index >= size()) {
            throw new IllegalArgumentException();
        }
        X deletedObject = arrayList[index];
        for(int i=index;i<size()-1;i++) {
            arrayList[i]=arrayList[i+1];
        }
        setNextFreeSlot(getNextFreeSlot()-1);
        return deletedObject;
    }
    public X get(int i) throws IllegalArgumentException{
        if(i<0 || i >= size()) {
            throw new IllegalArgumentException();
        }
        return arrayList[i];
    }
    public void clear() {
        /*for(int i =0;i<nextFreeSlot;i++) {
            arrayList[i]=null;
        }*/
        setNextFreeSlot(0);
    }
    public boolean isEmpty() {
        if(getNextFreeSlot()!=0) {
            return false;
        }
        return true;
    }
  
    public int size() {
        return getNextFreeSlot();
    }
  
    public void print() {
        System.out.print(arrayList[0]);
        for(int i=1;i<arrayList.length;i++) {
            System.out.print(", " + arrayList[i]);
        }
        System.out.print("\n");
    }
}

Bei mir wird die statische Methode Integer.of(3) in eclipse nicht angezeigt und in der Java API hab ich die Methode gar nicht gefunden.
 
Zuletzt bearbeitet:
Ähnliche Java Themen
  Titel Forum Antworten Datum
G Datentypen verschiedene Objekte in eine ArrayList, Generics Java Basics - Anfänger-Themen 2
E Klassen java.util.ArrayList<E> als Generics Java Basics - Anfänger-Themen 16
G ArrayList und Generics Java Basics - Anfänger-Themen 9
T von ArrayList erben - Problem mit Generics Java Basics - Anfänger-Themen 2
H Generics machen mich verrückt Java Basics - Anfänger-Themen 8
John_Sace Homogene Realisierung von Generics in Java ? Java Basics - Anfänger-Themen 19
MarvinsDepression Datentypen Generics: Erste Berührungen Java Basics - Anfänger-Themen 6
M Generics Vererbung Listen Java Basics - Anfänger-Themen 2
Cassy3 Generics - CompareTo Java Basics - Anfänger-Themen 21
T Collections Sind Subklassen-Objekte in Listen mit Generics erlaubt? Java Basics - Anfänger-Themen 16
districon Generics implementieren Java Basics - Anfänger-Themen 2
CptK Überprüfen ob übergebenes Objekt zu Generics passt Java Basics - Anfänger-Themen 2
CptK Generics: Klassen die Interface implementieren, aber selbst nicht das Interface sind Java Basics - Anfänger-Themen 8
B Hilfe bei Generics Java Basics - Anfänger-Themen 11
G Generics Compilerfehler Java Basics - Anfänger-Themen 6
G Generics Methoden Java Basics - Anfänger-Themen 7
G Generics Java Basics - Anfänger-Themen 3
L Generics Tripel Java Basics - Anfänger-Themen 26
W Fragen zu Generics Java Basics - Anfänger-Themen 14
S Hilfe. Generics und BiFunctions Java Basics - Anfänger-Themen 10
X Wie Generics richtig benutzen ? Java Basics - Anfänger-Themen 5
S Allgemeine Frage über Generics und Vererbungen Java Basics - Anfänger-Themen 5
S Generics-Problem: Class, Class<?>, Class<Object> Java Basics - Anfänger-Themen 4
I Java Generics factory method Java Basics - Anfänger-Themen 2
M Verständnisfrage zu Generics Java Basics - Anfänger-Themen 7
I Generics und Comparable Java Basics - Anfänger-Themen 14
G Generics mit ? und Diamantoperator Java Basics - Anfänger-Themen 4
G Generics: Wildcard ? Java Basics - Anfänger-Themen 12
D Generics methode Java Basics - Anfänger-Themen 2
I Frage zu Generics und Wildcards Java Basics - Anfänger-Themen 2
N Generics und Casting eines Objekts Java Basics - Anfänger-Themen 1
A Generics Java Basics - Anfänger-Themen 6
A Vererbung/Interfaces/Generics Java Basics - Anfänger-Themen 12
W Generics - Typ zurückbekommen Java Basics - Anfänger-Themen 4
Dimax Erste Schritte Generics von Profis leicht erklärt Java Basics - Anfänger-Themen 7
C Warum funktioniert 'instanceof' bei generics nicht? Java Basics - Anfänger-Themen 4
J Collections Generics: Typ wird nicht erkannt Java Basics - Anfänger-Themen 7
C Generics Java Basics - Anfänger-Themen 8
M Generics getter und setter Methoden Java Basics - Anfänger-Themen 4
T Generics in Java... Java Basics - Anfänger-Themen 9
J Generics Java Basics - Anfänger-Themen 3
J Generics Datentypen vergleichen Java Basics - Anfänger-Themen 16
V Generics / eigene Liste Java Basics - Anfänger-Themen 4
O Generics - Implementierung Java Basics - Anfänger-Themen 7
Shizmo Frage zu Generics Java Basics - Anfänger-Themen 3
F Multiple Generics Java Basics - Anfänger-Themen 10
H Typsicherheit/Generics Java Basics - Anfänger-Themen 1
U Java generics funktioniert nicht Java Basics - Anfänger-Themen 0
Tarrew Generics: Erste gemeinse Oberklasse als Rückgabewert Java Basics - Anfänger-Themen 1
N Generics Vererbung Wildcard Interface Java Basics - Anfänger-Themen 8
S Generics und Comparable Interface Java Basics - Anfänger-Themen 5
A Generics Java Basics - Anfänger-Themen 4
M Frage zu Generics in Klassen, Abstrakten Klassen und Interfaces Java Basics - Anfänger-Themen 5
R Compiler-Fehler Generics Problem Java Basics - Anfänger-Themen 2
K Interface Generics, Interfaces und Listen - ich bin verwirrt. Java Basics - Anfänger-Themen 7
K Generics bei Klassen- und Interfacedeklarationen Java Basics - Anfänger-Themen 3
D toArray und Generics Java Basics - Anfänger-Themen 2
D Zwei Generics beim Überladen von Methoden Java Basics - Anfänger-Themen 3
C Erste Schritte Filter für Generics oder ähnliches Java Basics - Anfänger-Themen 2
M Frage zu Generics-Deklaration Java Basics - Anfänger-Themen 5
S Frage zu Collection-Generics in Subklassen Java Basics - Anfänger-Themen 6
J Java Generics - Frage zu Types Java Basics - Anfänger-Themen 2
M <T> Generics Java Basics - Anfänger-Themen 7
B Interface Generics: prüfen ob Interface deklariert wird Java Basics - Anfänger-Themen 18
T Polymorphie Generics-Problem Java Basics - Anfänger-Themen 2
B Hilfe beim Verständnis zu Generics Java Basics - Anfänger-Themen 7
J Array Generics Java Basics - Anfänger-Themen 3
J Generics casten Java Basics - Anfänger-Themen 14
J Generics wildcard Java Basics - Anfänger-Themen 6
E Listen und Generics Java Basics - Anfänger-Themen 9
X Generics Java Basics - Anfänger-Themen 6
M Datei einlesen mit generics? Java Basics - Anfänger-Themen 9
D Warum sind Generics mit Vorsicht zu genießen? Java Basics - Anfänger-Themen 6
M OOP Mit Generics auf Methoden zugreifen? Java Basics - Anfänger-Themen 10
S Generics Java Basics - Anfänger-Themen 4
G Generics kein Zugriff auf getter eines Objekts Java Basics - Anfänger-Themen 4
L Datentypen Problem mit Generics und null Java Basics - Anfänger-Themen 6
W Interface Problem mit Generics Java Basics - Anfänger-Themen 2
M OOP Generics und Wildcards Java Basics - Anfänger-Themen 3
D Generics - Warnmeldungen Java Basics - Anfänger-Themen 2
M Polymorphie generics einsteigerprobleme Java Basics - Anfänger-Themen 3
D Vererbung Generics und Vererbung Java Basics - Anfänger-Themen 8
C Generics Array Java Basics - Anfänger-Themen 43
D Fehler mit generics Java Basics - Anfänger-Themen 10
S Generics - CaseInsensitiveMap selber schreiben? Java Basics - Anfänger-Themen 5
K Datentypen Generics Java Basics - Anfänger-Themen 3
P Comparable und Generics Java Basics - Anfänger-Themen 6
I Generics (Subtypen) Java Basics - Anfänger-Themen 17
N Typeinschränkung bei Generics Java Basics - Anfänger-Themen 13
C Generics und Cast Java Basics - Anfänger-Themen 5
H Generics werden in -source 1.2 nicht unterstützt Java Basics - Anfänger-Themen 16
M Datentypen Generics: Exacten Typ ermitteln Java Basics - Anfänger-Themen 6
N Generics und Interfaces Java Basics - Anfänger-Themen 5
S Generics und "generische Feldzuweisungen" Java Basics - Anfänger-Themen 5
lumo Java Generics Java Basics - Anfänger-Themen 19
M verlinkte Liste mit generics Java Basics - Anfänger-Themen 7
capgeti Datentypen Static methoden aus Superklasse mit Generics definieren? Java Basics - Anfänger-Themen 9
S Generics und Typerkennung Java Basics - Anfänger-Themen 7
A Cast ohne Warnung bei Generics Java Basics - Anfänger-Themen 2
B Java Listen und Generics Java Basics - Anfänger-Themen 35

Ähnliche Java Themen

Neue Themen


Oben