Liste

Hallo,

ich habe einen eigenen Datentyp erstellt, der aus mehreren Int-Werten, einem String und einem Double besteht. Ich möchte davon jetzt eine Liste oder eine Schlange oder LinkedList, was es da so gibt, von machen. Ziel ist die Überprüfung einzelner Objekte (ob sie vorhanden sind), sowie die Sortierung der Liste nach dem ausgewählten Int-Wert.
Was bietet sich dafür an, und wo finde ich eine gute Erklährung für die Andwendung? Bei Galileo-Computing (Java ist auch eine Insel 6) wurde mir eher weniger geholfen.

Danke für die Hilfe,
Rogge

Es kommt darauf an wie du es machen willst ob du nach beiden richtungen suchen willst oder nur nach einer. Hier erstmal die einfache methode von vorne nach hinten

class list
public list(Variable){//variablen initiieren
// deine Variablen eintragen
list next_element
}
public list(list erstes_element, Variablen){
// deine Variablen eintragen
list tmp = letztes_element(erstes_element);
tmp.next_element = die adresse dieses element;
}
list letztes_element(list){
hier suchst du immer jedes element durch bis du bei der Variablen
next_element nichts mehr findest und gibst dann das letzte
listelemt adresse zurück. Wie das genau funzt must du schon
selber ausknobeln.
}

und das wars auch schon im grossen und ganzen beim löschen must du noch einige feinheiten berücksichtigen das du die nicht verlirst aber ansonsten funktioniert das so ziehmlich gut.

Wenn du allerdings eine feste anzahl von elementen hast kannst du auch einfach ein Array von deinen elementen machen und sie dann mittels for schleife durarbeiten das geht schneller zu programieren und ist nicht so kompliziert.

paladin

[Bei dieser Antwort wurde das Vollzitat nachträglich automatisiert entfernt]

Hallo,

danke für die Antwort.

Ich hab mich dann in der Zwischenzeit mal selber bemüht und eine Implementierung einer doppelt verketteten Liste vorgenommen.

Teilweise schon getestet sollte das meinen Ansprüchen genügen.

Mein Datentyp(Datensatz) sieht so aus:

public class Datensatz {
 private int Id, Econ, Fleet, Tech, Exp, Acc;
 private String Player;
 private double Lvl;

 public void setId(int x) { Id=x; }
 public void setEcon(int x) { Econ=x; }
 public void setFleet(int x) { Fleet=x; }
 public void setTech(int x) { Tech=x; }
 public void setExp(int x) { Exp=x; }
 public void setAcc(int x) { Acc=x; }
 public void setPlayer(String s) { Player=s; }
 public void setLvl(double l) { Lvl=l; }

 public int getId() { return Id; }
 public int getEcon() { return Econ; }
 public int getFleet() { return Fleet; }
 public int getTech() { return Tech; }
 public int getExp() { return Exp; }
 public int getAcc() { return Acc; }
 public String getPlayer() { return Player; }
 public double getLvl() { return Lvl; }
}

Ein Element meiner Liste sieht so aus:

public class Element {
 private Object obj;
 private Element prev;
 private Element next;

 public Element() { obj=prev=next=null; }
 public Element(Object ob) { obj=ob; prev=null; next=null; }

 public void setObject(Object ob) { obj=ob; }
 public void setPrev(Element x) { prev=x; }
 public void setNext(Element x) { next=x; }

 public Object getObject() { return obj; }
 public Element getPrev() { return prev; }
 public Element getNext() { return next; }
}

Die Liste selbst sieht so aus:

public class Liste{
 private Element first;
 private Element last;

 public Liste(){ first=last=null; }

 public Object getFirst(){ return first; }
 public Object getLast() { return last; }

 public void insert(Object ob){
 Element neu = new Element(ob);
 if(first==null) { first=last=neu; }
 else {
 last.setNext(neu);
 neu.setPrev(last);
 last=neu;
 }
 }

 public int length(){
 if(first==null) return 0;
 if(first==last) return 1;
 else{
 int i=1;
 Element temp=first;
 while(temp.getNext()!=null){
 temp=temp.getNext();
 i++;
 }
 return i;
 }
 }
}

Zur Liste könnte ich noch ein Interface machen. Hab das in meinen Unterlagen gefunden. Kann mir dazu bitte jemand erklähren, wozu soein Interface gut ist? Werden darin nur die Methoden deklatiert, die in

Liste

zur Verfügung stehen?

Hier mal was allgemeines:

„Obwohl Schnittstellen auf den ersten Blick nichts »bringen« – Programmierer wollen gerne etwas vererbt bekommen, damit sie Implementierungsarbeit sparen können –, sind sie eine enorm wichtige Erfindung. Denn über Schnittstellen lässt sich eine Sicht auf ein Objekt beschreiben. Jede Schnittstelle definiert eine neue Sicht, eine Art Rolle. Implementiert eine Klasse diverse Schnittstellen, können ihre Exemplare in verschiedenen Rollen auftreten. Hier wird erneut das Substitutionsprinzip wichtig, bei dem ein mächtigeres Objekt verwendet wird, auch wenn weniger erwartet wird.“

Aus http://www.galileodesign.de/openbook/javainsel5/java…

Eine Klasse kann mehrere Interfaces implementieren. Damit kann man Funktionalität besser kapseln und die Struktur der OO ganz gut abbilden. Ansonsten könntest Du ja keine Schnittmengen über mehrere Klassen vererben.

Hehe, mal wieder sehr schwammig ausgedrückt. Ich denk, das Buch oben und ein paar Beispiele würden besser weiterhelfen.