Methoden ArrayList Werte hinzufügen und löschen

L

lubi27X

Aktives Mitglied
Hallo zusammen, ich bin noch Anfänger in Java und hätte mal paar Fragen, wie ich folgende Aufgabe angehe. Ich soll ein Interface IntegerList anlegen und folgende abstrakte Methoden implementieren:

- int getLength() → liefert die Lange der gesamten Liste
- void insertLast(int value) → fügt value am Ende der Liste an
- int getFirst() → liefert das erste Element der Liste
- void deleteFirst() →löscht das erste Element der Liste
- boolean search(int value) → pruft, ob value in der Liste vorkommt.

Anschließend soll ich eine Klasse ArrayIntegerList anlegen, und alle Methoden testen und eine Liste mit int Zahlen generieren.
Bis jetzt habe ich das Interface angelegt und die Klasse ArrayIntegerList und auch eine ArrayList. Mit einem ganz normalen Array komme ich ja nicht weit.

Würde mich freuen, wenn mir jemand bisschen helfen könnte. Was mache ich als nächstes.. Die Herangehensweise fällt mir hier schwer.
[CODE lang="java" title="Interface IntegerList"]public interface IntegerList {

public abstract int getLength();

public abstract void insertLast(int value);

public abstract int getFirst();

public abstract void deleteFirst();

public abstract boolean search(int value);



}
[/COD
[CODE lang="java" title="class ArrayIntegerList"]import java.util.ArrayList;
public class ArrayIntegerList implements IntegerList{


public static void main(String[] args) {

//ArrayList anlegen
ArrayList<Integer> numbers = new ArrayList<Integer>();


ArrayIntegerList x1 = new ArrayIntegerList();
ArrayIntegerList x2 = new ArrayIntegerList();
ArrayIntegerList x3 = new ArrayIntegerList();

numbers.add(1);
numbers.add(2);
numbers.add(3);

System.out.println(numbers);

x1.insertLast(1);
x2.insertLast(2);
x2.insertLast(3);



}

@Override
public int getLength() {
return 0;
}

@Override
public void insertLast(int value) {

}

@Override
public int getFirst() {
return 0;
}

@Override
public void deleteFirst() {

}

@Override
public boolean search(int value) {
return false;
}

}[/CODE]
E]
 
Also der Name ArrayIntegerList legt schon nahe, dass die Klasse intern mit einem Array arbeitet. Daher wäre hier die Frage: An welcher Stelle kommst Du denn nicht weiter? Wo siehst Du denn Probleme?

Und wozu eine ArrayList? So wie ich die Aufgabenstellung sehe, geht es doch darum, dass ihr eigene Interfaces / Klassen entwickeln wollt und nicht die Collections vom Java Framework nutzen sollt. Daher wird ArrayList vermutlich nicht zu nutzen sein.
 
Wenn du java.util.ArrayList benutzen darfst, musst du in deinen Methoden nur die passenden Methoden von ArrayList aufrufen.

Ansonsten kannst du alle Methoden auch mit Hilfe eines Arrays implementieren. (Das sollte man in der Praxis nicht benutzen, aber es ist eine schöne Übung.) Dazu legst du zunächst ein Array mit fester Länge (z.B. 10) an. Erst, wenn du weitere Elemente einfügen willst, legst du eine neues Array (mit doppelter Größe) an, kopierst das alte Array in das neue und hast dann wieder Platz, ein weiteres Element einzufügen.
Praktisch ist es wahrscheinlich auch, dir die Indexe des ersten und letzten Elements zu merken. Die Methode deleteFirst() besteht dann schlicht daraus, den Index des ersten (echten) Elements um eins zu erhöhen.
 
Es ging in erster Linie darum, zu lernen, wie man ein Interface anlegt und die abstrakten Methoden einfügt.
Ich soll auch alle Methoden gebrauchen..
Zeile 1 bis 15 ist ja mein Interface, wo ich die abstrakten Klassen eingefügt habe.
Dann habe ich in Zeile 24 eine ArrayList angelegt, weil diesa ja dynamisch sein soll. Ich will ja Werte löschen und hinzufügen können.
Zeile 27 bis 39 ist einfach bisschen Spielerei.

Das ist doch korrekt, dass ich die Methoden nur von einem Objekt des Types ArrayIntegerList benutzen kann, oder?

Dafür habe ich in Zeile 27 bis 29 mal paar Objekte instanziiert..Doch wie sind die nächsten Schritte? Was schreibe ich z.B. in die Funktion

@Override
public void insertLast(int value)
}

um einen Wert hinten anzufügen?
 
Java: 
import java.util.ArrayDeque;

public class ArrayIntegerList implements IntegerList {
    private ArrayDeque<Integer> que = new ArrayDeque<>();

    public static void main(String[] args) {
        ArrayIntegerList queue = new ArrayIntegerList();
        queue.insertLast(0);
        queue.insertLast(3);
        queue.insertLast(1);
        queue.insertLast(2);
        System.out.println(queue.getLength());
        System.out.println(queue.getFirst());
    }

    @Override
    public int getLength() {
        return que.size();
    }

    @Override
    public void insertLast(int value) {
        que.addLast(value);
    }

    @Override
    public int getFirst() {
        return que.getFirst();
    }

    @Override
    public void deleteFirst() {
        que.removeFirst();
    }

    @Override
    public boolean search(int value) {
        return que.contains(value);
    }
}

interface IntegerList {
    public abstract int getLength();

    public abstract void insertLast(int value);

    public abstract int getFirst();

    public abstract void deleteFirst();

    public abstract boolean search(int value);
}

Bei Bedarf siehst du dir einfach die Implementierung der Klasse ArrayDeque an.
 
Also das Interface ist so aber noch nicht wirklich korrekt. Bei einem Interface hast Du generell keine Methoden-Implementationen. (Ist seid einiger zeit nicht mehr ganz korrekt. Default Implementationen sind im Interface erlaubt worden - da findet dann das Schlüsselwort default Verwendung. Daher sollte das abstract weg. Abstract Methoden gibt es nur in Klassen.

Und das Interface gibt Methoden vor, die in einer Klasse, die das Interface implementiert, als public Methode implementiert werden muss. Daher kann das public weg.

Somit wären wir jetzt bei folgendem Code:

Java: 
public interface IntegerList {
    int getLength();
    void insertLast(int value);
    int getFirst();
    void deleteFirst();
    boolean search(int value);
}

Dieses Interface kann nun eine Klasse ArrayIntegerList implementieren:
Java: 
public class ArrayIntegerList implementes IntegerList {
    // ...
}
Das hattest Du schon soweit richtig. Die main Methode muss da aber nicht zwingend rein. Das kann sein, aber das ist erst einmal keine Notwendigkeit. Etwas, das Du in so einer main Methode machst hat auch erst einmal keine Auswirkungen direkt auf die Instanzen - es ist ja nur eine static Methode.

Was Du also jetzt machen solltest, ist dir zu überlegen, wie Du Daten halten kannst. Die Idee war, dass dies ein Array sein könnte. Also brauchst Du eine Instanzvariable:

Java: 
public class ArrayIntegerList implementes IntegerList {
    private int[] values;
    // ...
}

Du musst Dir nun nur überlegen:
a) wie initialisierst Du values im Konstruktor?
b) Was machst Du in den ganzen zu implementierenden Methoden.

Dabei würde ich es einfach halten und noch keine Optimierungen vornehmen. Wie muss das Array values also aussehen, wenn keine Werte enthalten sind? Wie sieht es aus, wenn Du Werte hinzu fügst? Wie sieht es aus, wenn der erste Wert gelöscht wird? u.s.w.

Edit: Formulierung beim abstract angepasst ... das sollte / kann weg wie das public. (Und die gängigen IDEs werden das hoffentlich auch entsprechend anzeigen...)
 
Zuletzt bearbeitet von einem Moderator:
Ja, den Satz hatte ich vergessen zu entschärfen. Das es aus Sicht von Java kein Fehler ist, habe ich ja auch direkt angepasst in den folgenden Sätzen. Ich halte es für nicht gut, auch wenn es von der Syntax ok ist.

Da bin ich halt mit von statischen Code Analyse Tools geprägt die sowas anmeckern (z.B. PMD mit UnnecessaryModifier).
 
E27T hat gesagt.:
naja ich würde jetzt einen Konstruktor anlegen, indem ich Werte mitgeben kann.
[CODE lang="java" title="Konstruktor"]import java.util.ArrayList;
public class ArrayIntegerList implements IntegerList{
int wert;


ArrayIntegerList(int x){
this.wert = x;
}
[/CODE]
Zum Vergrößern anklicken....
Also das ist durchaus denkbar, aber da bitte daran denken, dass Du ja mehrere Werte abspeichern möchtest. Den Fall kann man aber durchaus außen vor lassen und erst einmal bei den festen Vorgaben bleiben.

E27T hat gesagt.:
Wenn das Array leer ist, sieht es so aus..
Java: 
        int[] values = {};
Zum Vergrößern anklicken....
Das ist also das leere Array. Sehr gut.

Nun können wir die einzelnen Methoden betrachten, die wir der Reihe nach entwickeln müssen.

Java: 
    int getLength();
Wenn die Werte in einem Array gespeichert werden: Wie kommst Du an die Anzahl der Elemente?

Java: 
    void insertLast(int value);
Jetzt kommt der wirklich interessante part: Ein Array hat eine feste Größe. Wie kann man da noch etwas hinzu fügen? In das bestehende Array geht es nicht, daher muss man einen Umweg gehen. Hast Du da evtl. eine Idee? Du hast einen kleinen Zettel, der ist vollgeschrieben. Jetzt musst Du da noch etwas dazu schreiben? Aber Du willst auch nur einen Zettel haben? Da muss dann ein neuer Zettel her, oder?

Java: 
    int getFirst();
Erstes Element - wie kommst Du an dieses?

Java: 
   void deleteFirst();
Jetzt haben wir ein ähnliches Problem wie zuvor schon: Das Array hat eine feste Größe. Also müsste man hier etwas machen, damit man am Ende ein Array hat mit der richtigen Größe.

Java: 
    boolean search(int value);
Wie schaust Du, ob ein Wert in dem Array mit den gespeicherten Werten enthalten ist?

Aus der großen Aufgabe hast Du jetzt viele kleine Aufgaben gemacht. Die kannst Du der Reihe nach angehen. Jedes für sich dürfte von der Komplexität her auch gut beherrschbar sein.

Und ich nehme noch eine Sache vorweg: Diese Implementierung solltest Du Dir anschauen und dich fragen, wie effektiv die ist. Und dann kannst Du Dir überlegen, ob Du diese optimieren kannst. Das wäre eine super weiterführende Übung. @fhoffmann hat das schon recht gut zusammen gefasst. Da wäre dann die Frage, in wie weit man dies schrittweise einbauen kann. Das lässt sich sehr schön in zwei Teile aufbrechen. Wenn Du Interesse hast, das anzugehen, dann können wir das hier auch noch (nach einer ersten Implementation der obigen Methoden) machen.
 
okay habe gerade die Information erhalten, dass ich das nicht mit einer ArrayList umsetzen soll, sondern einem gewöhnlichen Array
kneitzel hat gesagt.:
Java:
int getLength();
Wenn die Werte in einem Array gespeichert werden: Wie kommst Du an die Anzahl der Elemente?
Zum Vergrößern anklicken....
An die Länge komme ich mit values.length
kneitzel hat gesagt.:
Java:
void insertLast(int value);
Jetzt kommt der wirklich interessante part: Ein Array hat eine feste Größe. Wie kann man da noch etwas hinzu fügen? In das bestehende Array geht es nicht, daher muss man einen Umweg gehen. Hast Du da evtl. eine Idee? Du hast einen kleinen Zettel, der ist vollgeschrieben. Jetzt musst Du da noch etwas dazu schreiben? Aber Du willst auch nur einen Zettel haben? Da muss dann ein neuer Zettel her, oder
Zum Vergrößern anklicken....
Hier hätte ich gesagt, dass ich alles vom vollen array in ein neues array kopiere.
kneitzel hat gesagt.:
Java:
int getFirst();
Erstes Element - wie kommst Du an dieses?
Zum Vergrößern anklicken....
An das erste Element des Char komme ich ja mit values[0]
kneitzel hat gesagt.:
Java:
void deleteFirst();
Jetzt haben wir ein ähnliches Problem wie zuvor schon: Das Array hat eine feste Größe. Also müsste man hier etwas machen, damit man am Ende ein Array hat mit der richtigen Größe.
Zum Vergrößern anklicken....
Hier würde ich auch irgendwie sagen, dass values[0] gelöscht werden soll..aber wie man das löscht ist mir fraglich. Ich würde irgendwie versuchen ein zweites Array zu machen, indem ich das erste Array reinkopiere ohne den ersten Wert
 
Jawoll! Du hast auch mit Deinen Vermutungen Recht. Damit hast Du jetzt eine Lösungsidee für alle Methoden und Du kannst diese nun umsetzen.

Wenn bei einem Punkt die Idee noch nicht genau genug ist (z.B. bei "dass ich alles vom vollen array in ein neues array kopiere.") dann schreibe Dir erst die einzelnen Schritte im Detail auf. Also neues Array der Größe .... erstellen, u.s.w.)
 
Danke schonmal für deine Hilfe.

Die ganzen Methoden kann ich aber doch nur mit einer Instanz der Klasse ArraysIntegerList benutzen, oder nicht?

Ich habe jetzt mal bisschen rumgespielt und ein array angelegt und den ersten 4 "Positionen" auch schon Zahlen vergeben. Die beiden restlichen werden dann mit 0 versehen.

Wenn ich jetzt z.B. die Methode getLength() aufrufen will, geht das nicht mit "array". Sobald ich einen Punkt hinter array mache, zeigt mir Eclipse ja alle Methoden an. Diese 5 Methoden zeigt er mir nicht an..

Java: 
import java.util.Arrays;

public class ArraysIntegerList1 implements IntegerList{

    public static void main(String[] args) {
        
        ArraysIntegerList1 list = new ArraysIntegerList1();
        
        list.deleteFirst();
        System.out.println(list);
        
        //Array anlegen
        int[] array = new int[6];
        array[0] = 1;
        array[1] = 2;
        array[2] = 3;
        array[3] = 4;
        
        //Kopie vom array
        int[] array2 = Arrays.copyOfRange(array, 1, array.length);
        System.out.println(Arrays.toString(array));
        System.out.println(Arrays.toString(array2));
        System.out.println(array.length);
        
        //list ausgeben
        System.out.println(list.getLength());
        
        
//        for (int i = 0; i < array.length; ++i)
//        {
//            list[i] = array[i];
//        }
        
    }

    @Override
    public int getLength() {
        
        return 0;
    }

    @Override
    public void insertLast(int value) {
        
    }
 
Also irgendwie ist das alles nicht das, was wir besprochen haben ...

Wie @fhoffmann schon sagte: Vergiss die main Methode. Das war nichts, über das wir gesprochen hatten. Du sollst lediglich die Methoden des Interfaces implementieren.

Und wenn es dann später zu der main Methode kommt: Das Array ist nur intern in der Klasse - die Main Methode interessiert das nicht! Das ist die Kapselung: Die ArrayIntegerList hält intern irgendwie die Daten - wie genau interessiert niemanden außerhalb der Klasse! Und die main Methode ist sozusagen außerhalb - die kannst Du auch in eine Klasse Test oder Main stecken!

Und was die Implementation anging:
a) Hattest Du da doch schon das interne Array values. Das ist das einzige Array welches Du dann von deinen Methoden aus nutzt!
b) getLength hattest Du doch schon gesagt, wie Du die Länge bekommen könntest. Wie kommen wir da jetzt zu einem return 0?
 
kneitzel hat gesagt.:
Und was die Implementation anging:
a) Hattest Du da doch schon das interne Array values. Das ist das einzige Array welches Du dann von deinen Methoden aus nutzt!
b) getLength hattest Du doch schon gesagt, wie Du die Länge bekommen könntest. Wie kommen wir da jetzt zu einem return 0?
Zum Vergrößern anklicken....
Ich habe die getLaenge() Methode noch nicht implementiert. Es happert an der Sprache.. Ich weiß nicht wie ich meine Gedanken zu code bringe
 
Leider ist in der Beschreibung nicht erwähnt, wie damit umgegangen werden soll, wenn das interne Array voll ist, bzw. wie groß das Array sein soll, wenn eine neue leere ArrayIntegerList erzeugt wird.
E27T hat gesagt.:
An die Länge komme ich mit values.length
Zum Vergrößern anklicken....
Das kann stimmen, muss es aber nicht. Length liefert bei Arrays die Länge mit der das Array deklariert und initialisiert wurde. Nehmen wir an, du erzeugst eine neue leere Liste und nimmst als Initiallänge für das Array den Wert 10, dann liefert dir getLength() diesen Wert zurück, unabhängig, ob bereits ein Wert der Liste hinzugefügt wurde oder nicht. Ob das so gewollt ist? Keine Ahnung.

Falls nicht, dann musst du dir was anderes überlegen (was du im Übrigen, meiner Ansicht nach, für die Methode insertLast() sowieso brauchst).
 
@temi Wir haben das doch im Thread erläutert. @fhoffmann hat eine komplexere, optimierte Logik ja recht früh vorgeschlagen. Aber hier geht es doch noch um absolute Basics und da wird dann das Array immer auf der korrekten Länge gehalten und bei jedem Einfügen oder Löschen werden dann Werte in ein neues Array mit angepasster Größe kopiert.

@E27T Wo hapert es denn derzeit? Wenn Du die main Methode nicht links liegen lassen kannst, dann gebe ich Dir einfach eine vor und diese wird nicht mehr angepasst.

Java: 
public static void main(final String[] args) {
    IntegerList list = new ArrayIntegerList();
    list.insertLast(1);
    list.insertLast(2);
    list.deleteFirst();
    System.out.println("Erster Wert: " + list.getFirst());
}

Hilft das, um erst einmal alle Methoden zu schreiben?
 
Ansonsten auch noch einmal den aktuellen Stand, den wir bis jetzt haben und an dem Du nur weiter machen musst:

Java: 
public class ArrayIntegerList implements IntegerList {
    private int[] values = new int[0];
    
    public int getLength() {
        // An die Länge komme ich mit values.length
    }
    
    public void insertLast(int value) {
        // Hier hätte ich gesagt, dass ich alles vom vollen array in ein neues array kopiere.
    }
    
    public int getFirst() {
        // An das erste Element des Char komme ich ja mit values[0]
    }
    
    public void deleteFirst() {
        // Ich würde irgendwie versuchen ein zweites Array zu machen, indem ich das erste Array reinkopiere ohne den ersten Wert
    }
}

Die Beschreibungen sind teilweise zu ungenau, aber der Weg dürfte deutlich sein ...
 
Sooo...Jetzt habe ich endlich raus..Musste paar Nächte drüber schlafen und mir das einmal durch den Kopf gehen lassen.
Die Main Methode hat in der class ArraysIntegerList selbstverständlich nichts zu suchen.

Jetzt sieht mein Programm so aus...
[CODE lang="java" title="public class ArraysIntegerList implements IntegerList"]import java.util.Arrays;

public class ArraysIntegerList implements IntegerList{

//Attribut array
int[] array;


//Konstruktor
ArraysIntegerList(int... value){ //Array an Kontruktor übergeben //warum geht das nicht mit []?
array = new int[value.length]; //array ist genau so lang wie value
for (int i = 0; i < value.length; ++i)
{
array = value;
}
}

@Override
public int getLength() {
return array.length;
}

@Override
public void insertLast(int value) {
int[] arraynew = Arrays.copyOfRange(array, 0, array.length + 1); //Neues Array +1
arraynew[arraynew.length - 1] = value; //
array = arraynew;
System.out.println(Arrays.toString(array));
}

@Override
public int getFirst() {
return array[0];
}

@Override
public void deleteFirst() {
int[] array2 = Arrays.copyOfRange(array, 1, array.length); //original,von,bis
array = array2;
System.out.println(Arrays.toString(array));
}

@Override
public boolean search(int value) {
for (int i = 0; i < array.length; ++i)
{
if (array == value)
{
System.out.print("Die Zahl " + value + " ist enthalten: "); return true;
}
}
System.out.print("Die Zahl " + value + " ist nicht enthalten: "); return false;
}
}[/CODE]


[CODE lang="java" title="public class main"]import java.util.Arrays;

public class main {

public static void main(String[] args) {

//Instanz erzeugen
ArraysIntegerList list = new ArraysIntegerList(1,2,3);//Werte werden an Konstruktor übergeben


//Länge ausgeben
System.out.println("Das Array hat " + list.getLength() + " Elemente");

//Nach Wert suchen
System.out.println(list.search(25));
//Ausgeben, ob gefunden
System.out.println("Die erste Zahl der Liste ist die " + list.getFirst());

//Array ausgeben
System.out.println("Das Array hat folgende Elemente: " + Arrays.toString(list.array));

//Löscht erste Stelle
list.deleteFirst();

//Neue Zahl hinzufügen
list.insertLast(999);

list.insertLast(1000);

list.insertLast(2000);

list.deleteFirst();
}

}[/CODE]


Lediglich bei dem Konstruktor musste ich bisschen googlen und abgucken wie man ein array an den Konstruktor übergibt..

Doch zu Konstruktor noch eine Frage.. Warum funktioniert lediglich diese Variante: ArraysIntegerList(int... value) und nicht: ArraysIntegerList(int[] value)?
 
Du kannst auch ein Array als Parameter angeben, aber dann muss der Aufruf auch ein Array enthalten und nicht einfach nur mehrere Parameter.
 
quasi irgendwie sowas ArraysIntegerList list = new ArraysIntegerList([1,2,3]); oder sowas in der Art ArraysIntegerList list = new ArraysIntegerList({1,2,3}); ?
 
Sowas in der Art:
ArraysIntegerList list = new ArraysIntegerList(new int[]{1,2,3});

Ansonsten wundert mich noch etwas in Deinem Code, dass Du mal Arrays nutzt und mal nicht. Im Konstruktor kopiert Du selbst, aber bei allen weiteren Methoden kommt Arrays.copyOfRange zum Einsatz... (Aber das ist natürlich auch kein Fehler ..)
 
kneitzel hat gesagt.:
Sowas in der Art:
ArraysIntegerList list = new ArraysIntegerList(new int[]{1,2,3});
Zum Vergrößern anklicken....
Danke.

kneitzel hat gesagt.:
Ansonsten wundert mich noch etwas in Deinem Code, dass Du mal Arrays nutzt und mal nicht. Im Konstruktor kopiert Du selbst, aber bei allen weiteren Methoden kommt Arrays.copyOfRange zum Einsatz..
Zum Vergrößern anklicken....
Was genau meinst du? Die Arrays.copyOfRange Methode habe ich im Buch gefunden und fand die Methode gut anwendbar.

Meinst du damit, dass ich Arrays.copyOfRange auch im Konstruktor verwenden könnte?
 
E27T hat gesagt.:
Meinst du damit, dass ich Arrays.copyOfRange auch im Konstruktor verwenden könnte?
Zum Vergrößern anklicken....
Ja, wenn Du so Klassen aus dem Framework nutzt, dann würde ich das konsequent erwarten. Da stellt sich nur die Frage, in wie weit dies aus Sicht der Aufgabe erlaubt / erwünscht ist. Wobei man anstatt eine solche Klasse zu nutzen natürlich auch so eine copyOfRange Methode selbst schreiben kann. Dann bleibt Dein Code so schön lesbar und Du nutzt nichts, das ggf. unerwünscht ist. (Ziel der Aufgabe ist ja aus meiner Sicht eher, den Umgang mit Arrays zu üben, also eigenen Code zu schreiben, der entsprechend mit dem Array arbeitet.)

Dann solltest Du Dir ggf. auch die Klasse Arrays im Detail ansehen. Arrays.copyOfRange funktioniert, aber wenn das ganze Array kopiert werden soll, dann ist ggf. Arrays.copyOf besser geeignet / die bevorzugte Wahl.

Das sind aber nur noch absolute Kleinigkeiten. Den Umgang mit Arrays hast Du im Konstruktor ja bereits gezeigt.

Daher wäre jetzt die Frage: Hast Du Interesse, als Übung die Lösung zu optimieren?
- Du kannst z.B. beim Löschen kein neues Array erzeugen. Statt dessen hast Du eine Variable, den den Anfang der Werte kennzeichnet. Dementsprechend musst Du dann halt alle Methoden anpassen.
- Du kannst generell größere Arrays belegen. Dann hast Du eine zusätzliche Variable, die das Ende kennzeichnet. Dann musst Du wiederum alle Methoden prüfen, was geändert werden muss.
Der Vorteil ist, dass Du deutlich weniger Daten umher kopieren musst.

Also als Beispiel: Du legst beim Konstruktor ein Array mit einer festen Größe an, z.B. 10, start ist 0 und end ist -1

Wenn Du dann einfügen willst, dann schaust Du, ob hinter end noch was frei ist. Wenn das der Fall ist, dann erhöhst Du end und füllst das Feld:
end ist dann 0.
Wenn Du etwas entnehmen willst, dann schaust Du, ob start <=end ist, ist dies der Fall, dann entnimmst Du das Element bei start und erhöhst start um 1.

Wenn kein Platz mehr im Array ist, dann erzeugst Du ein neues Array mit angepasster Größe und kopierst die Werte von start - end an den Anfang. start ist dann wieder 0, end zeigt auf das letzte Element ...
 
Das hört sich auf jeden Fall interessant an, doch ich muss schon die nächsten Aufgaben machen. Dazu hätte ich auch schon eine Frage. Es geht um Schnittstellen und und Comparable<Figur>. Jetzt weiß ich nicht, ob ich das in diesem Thread schreiben soll oder einem anderen.
 
Programmer20 hat gesagt.:
Ich muss sagen mir hilft es schon, wenn ich die Lösung sehe. So kann ich den Weg nachvollziehen und Schritt für Schritt noch einmal alles durchgehen. Wenn man so gar keine Ahnung hat, wie es richtig ist, ist das für mich manchmal sehr deprimierend..
Zum Vergrößern anklicken....
Ja, aber der Lerneffekt ist stark begrenzt. Und das Ziel von uns ist nun einmal, dass jemand in die Lage versetzt wird, so Dinge in Zukunft selbst zu lösen. Und das ist deutlich aufwändiger für uns als in 5 Minuten eben irgend eine Lösung hin zu klatschen. Ja, das ist deutlich einfacher als sich hinzu setzen und darüber nach zu denken, wo denn der TE ggf. ein Problem haben könnte um dieses dann zu erläutern.
 

Aktuelle Jobs

Neue Themen

Ähnliche Themen

ArrayList-Element hinzufügen u. löschen
Antworten: 2
Zugriff auf Werte in ArrayList<ArrayList>
Antworten: 4
Bestimmte Werte von Objekten aus einer ArrayList in eine andere ArrayList kopieren
Antworten: 14
ArrayList<ArrayList<ArrayList<String>>>
Antworten: 10
Elemente zur LaufZeit hinzufügen und löschen
Antworten: 14

Zurück
Oben