ADT Liste z. B.

ocsme

Top Contributor
Guten Tag zusammen,

ich wollte mal Fragen weiß nicht ob ich so etwas darf, kann ich hier ein Thema erstellen wo ich sehr gerne ein paar Abstrakte Datentypen besprechen möchte. Ich habe heute damit angefangen :) sonst müsste ich für jede Frage ein Thema erstellen so hätte man ein Sammlung und vielleicht kommen ja noch andere auf ähnliche Fragen die dann auch geklärt werden können etc. :)

Heute habe ich eine Lineare Liste erstellt mittels Arrays. Hier mal der Code:
Java:
package ADTListe;

public class ListeArray {
   
    public static boolean istLeer(int[] l) {
        for(int i=0;i<l.length;i++)
            if(l[i]!=0)
                return false;
       
        return true;
    }
   
    public static int[] einfuegen(int x, int p, int[] l) throws ArrayException{
        if(p < 0 || p > l.length-1)
            throw new ArrayException("Platz existiert nicht!");

        int length = l.length;
        int[] b = new int[length+1];
        if(!istLeer(l)) {
            for(int i=0;i<l.length;i++)
                if(i < p)
                    b[i]=l[i];
                else if(i == p) {
                    b[i]=x;
                    b[i+1]=l[i];
                }               
                else if(i > p)
                    b[i+1]=l[i];
        }
        else
            b[0]=x;
       
        return b;
    }
   
    public static int[] entferne(int p, int[] l) throws ArrayException{
        if(p < 0 || p > l.length-1)
            throw new ArrayException("Platz existiert nicht!");
       
        int length = l.length-1;
        int[] b = new int[length];
        for(int i=0;i<b.length;i++)
            if(i < p)
                b[i]=l[i];
            else if(i >= p)
                b[i]=l[i+1];
        return b;
    }
   
    public static int suchen(int x, int[] l) {
        for(int i=0;i<l.length;i++)
            if(l[i]==x)
                return i;
        return -1;
    }
   
    public static int zugriff(int p, int[] l) throws ArrayException {
        if(p < 0 || p > l.length-1)
            throw new ArrayException("Platz existiert nicht!");
        return l[p];
       
    }
}

Java:
package ADTListe;

public class ArrayException extends Exception{
   
    ArrayException() {
       
    }
   
    ArrayException(String message){
        super(message);
    }

}

Wir sollten immer ein neues Array zurück geben deswegen so etwas umständlich :D eine Frage hätte ich zum einfügen. Geht es nicht auch nur mit einer if else Anweisung?
Hab mal in einer Mail es so versucht doch dann fehlt ja immer 1 Wert :(
Java:
int[] a = new int[10];

       for(int i=0;i<a.length;i++)
           a[i]=2*i+1;

int[] c = new int[a.length+1];
        int platz = 4;
        int x = 444;
        for(int i=c.length-1;i>0;i--)
            if(i!=platz)
                c[i]=a[i-1];
            else {
                c[i]=x;
            }

Des weiteren würde ich gerne mal wissen wie man so etwas macht damit es für sämtliche "Primitiven" Datenelemente funktioniert. Vielleicht sogar für Referenztypen.

Bitte um Feedback :) Leider beschäftige ich mich jetzt erst mit den ganzen Algorithmen und Datenstrukturen. Wir hatten ja schon viele Programme geschrieben doch so explizit ist noch nicht drauf eingegangen worden das wird sich im Sommer ändern und ich würde sehr gerne eben etwas vorarbeiten :)

wie immer mit Lieben Grüßen von ocsme :D
 

httpdigest

Top Contributor
Es lässt sich sicherlich darüber streiten, ob eine Menge von statischen Methoden, die auf einem konkreten int[]-Array arbeiten, jetzt einen "abstrakten" Datentypen formulieren. Ich würde sagen: nein. Der Datentyp ist nicht _abstrakt_, sondern durch die zwingende Abbildung als int[]-Array schon ziemlich konkret. Konkreter geht es quasi nicht mehr.
Eine _abstrakte_ Datenstruktur zeichnet sich dadurch aus, dass nichts über die konkrete Speicherabbildung der Datenstruktur bekannt ist und sich die Datenstruktur nur über Methoden mit definiertem Verhalten definiert. Üblicherweise implementiert man abstrakte Datentypen auch mit abstrakten Klassen, bzw. in Java auch mit Interfaces, da man auf Schnittstellenebene keinen Zustand halten darf/sollte.
Das hier wäre dann wohl eher ein abstrakter Datentyp:
Java:
public interface Liste<T> {
  boolean istLeer();
  Liste<T> einfuegen(T x, int p);
  Liste<T> entferne(int p);
  int suchen(T x);
  T zugriff(int p);
}
 

ocsme

Top Contributor
o_O was lernen wir den dann bei uns in Algorithmen und Datenstrukturen :D

Wir haben im ersten Teil Listen behandelt. Dabei wurden eben die Implementierung mit Array und Verbundtypen behandelt. Ist das nun alles Käse?
Denn irgendwie müssen die ADTs ja Implementiert werden Sie fallen ja nicht vom Himmel! Doch wie du sagst soll über das Speicherabbildung von außen nichts bekannt sein. Wenn wir dabei aber immer Arrays benutzen ist es doch klar. Oder hat Java dafür dann eben die Generics? Oder hat das mit Generics nichts zu tun?
Ich verstehe das ganze nicht :( Wenn ich ein Buch aufschlage zu dem Thema machen die das doch auch nur über Arrays und Verbundtypen (class, record, struct,...).
Kann mich da jemand etwas Aufklären?

Sry für die Doofen Fragen! aber ich stehe gerade mehr auf dem Schlauch als vorher schon :D

LG
 

ocsme

Top Contributor
So hab eine Webseite gefunden wo das Thema zur Liste schön erklärt wird. Dort wird es genauso gemacht wie du sagtest httpdigest :)
Das sind mal meine drei Java Dateien :D klar eigentlich nur kopiert. Es fehlen noch 2 Methoden bei ListeVerbund da ich die noch nicht so ganz verstehe. Die anderen Methoden habe ich alle verstanden sind ja auch alle soweit rekursiv.

Ich weiß nur nich ob sowas wirklich effektiv ist. Vorher hatte ich ja wenigstens eine Idee oder einen Ansatz aber hier habe ich alles nur Kopiert. "Könnte gerade mal wieder Weinen" echt misst sowas :( Mir fehlt auch einfach die Vorstellung, liegen die next Zeiger alle in einem Stack? Ist das immer so und werden die dann immer rekursive von oben nach unten abgelaufen? Ich weiß nicht wie ich sowas Lernen soll :(

Webseite:
http://www.ips.tu-braunschweig.de/struckmann/prog12/daten.pdf

Java:
package ADTListe;

interface List {
    boolean isEmpty();
    boolean isInList(Element x);
    Element firstElement();
    int length();
    List insert(Element x);
    List append(Element x);
    List delete(Element x);
    List delete();
}

Java:
package ADTListe;

public class Element {
    private String inhalt;
   
    public Element(String inhalt) {
        this.inhalt = inhalt;
        }
   
    public String toString() {
        return inhalt;
        }
}

Java:
package ADTListe;

public class ListeVerbund implements List {
    private Element item;
    private ListeVerbund next;
   
    ListeVerbund(){
        item=null;
        next=null;
    }
   
    public Element getItem() {
        return item;
    }
   
    public ListeVerbund getNext() {
        return next;
    }
   
    public boolean isEmpty() {
        return next==null;
    }
   
    public boolean isInList(Element x) {
        return (find(x) != null);
    }
   
    public Element firstElement() {
        if(isEmpty())
            return null;
        else return next.item;
    }

    public int length() {
        if(isEmpty())
            return 0;
        else return 1+next.length();
    }
   
    public List insert(Element x) {
        ListeVerbund l = new ListeVerbund();
        l.item=x;
        l.next=next;
        next=l;
        return this;
    }
    //ans ende einfuegen durch die Liste laufen
    public List append(Element x) {
        if (isEmpty())
            return insert(x);
        else return next.append(x);
    }
    @Override
    public List delete(Element x) {
        // TODO Auto-generated method stub
        return null;
    }
    @Override
    public List delete() {
        // TODO Auto-generated method stub
        return null;
    }
   
    private ListeVerbund find(Element x) {
        if (isEmpty())
            return null;
        else
            if (firstElement().equals(x))
                return this;
        else
            return next.find(x);
        }
   
    public String toString() {
        return (next == null ? " |--" : " --> " + next.item + next);
        }

}

Nochmals Danke!
 

mihe7

Top Contributor
Mir fehlt auch einfach die Vorstellung, liegen die next Zeiger alle in einem Stack? Ist das immer so und werden die dann immer rekursive von oben nach unten abgelaufen? Ich weiß nicht wie ich sowas Lernen soll
Hm... Du lernst anscheinend gerade "das Handwerkszeug". Das schaust Du Dir an, wie es funktioniert und wirst es immer wieder brauchen :)

Die Zeiger liegen nicht auf einem Stack. Jedes Element ist ein Objekt, das ein Attribut besitzt, mit dem das nächste Element angegeben wird, sofern ein solches existiert.
 

ocsme

Top Contributor
Hm... Du lernst anscheinend gerade "das Handwerkszeug". Das schaust Du Dir an, wie es funktioniert und wirst es immer wieder brauchen :)

So sieht es aus :) Denn vorher kam ich auch sehr gut Ohne zurecht. Doch DAS ist eben "das Handwerkzeug" :) also möchte ich es verstehen.

Die Zeiger liegen nicht auf einem Stack. Jedes Element ist ein Objekt, das ein Attribut besitzt, mit dem das nächste Element angegeben wird, sofern ein solches existiert.

Mir fehlt dazu jede Vorstellung vielleicht ist es auch wieder so das ich mir viel zu viele Gedanken um das drum herum mache!
Wenn ich ein next Zeiger habe dann müsste man doch wenn Sie nicht wie in einem Stack liegen direkt ein Element (Objekt) aus der Liste raus suchen ohne Sie durchzutraversieren. Ich raffe das nicht wie das verarbeitet wird :( Aber ich glaube das sprengt sicherlich auch an dieser Stelle das Thema. Vielleicht hat ja jemand einen Link wo ich es nachlesen kann :)

LG


Kurz das Problem konkretisieren:
Ich verstehe nicht wenn ich einen next Zeiger habe woher Java weiß wo es anfängt und wo es aufhört. Vielleicht kann mir das jemand erklären? Deswegen dachte ich an einen Stack.
 
Zuletzt bearbeitet:

mihe7

Top Contributor
Das ist ganz einfach.

Mit
Java:
ListeVerbund l = new ListeVerbund();
erzeugst Du ein neues ListeVerbund-Objekt
Code:
+-------+     next
| elem1 | -------> null
+-------+
und speicherst die Referenz auf dieses Objekt in einer Variablen l. Damit ist l der Zeiger, der auf das erste ListeVerbund-Objekt zeigt:
Code:
      +-------+     next
l-->  | elem1 | -------> null
      +-------+
Um ein weiteres Element einzufügen, hängst Du einfach ein weiteres ListeVerbund-Objekt (das nur dieses Element enthält) an die bestehende Liste an:
Code:
      +-------+     next +-------+    next
l --> | elem1 | -------> | elem2 |-------> null
      +-------+          +-------+

Den Anfang macht immer die Referenz, mit der Du auf die Liste zugreifst, das Ende wird in der Liste durch next == null gekennzeichnet.
 

ocsme

Top Contributor
Fügt man so nicht immer am Anfang einer Liste ein?
Java:
    public List insert(Element x) {
        ListeVerbund l = new ListeVerbund();
        l.item=x;
        l.next=next;
        next=l;
        return this;
    }

also element1 -> null
element2 -> element1 -> null

oder? Wenn ja wie macht man es dann anders rum :D
 

httpdigest

Top Contributor
Fügt man so nicht immer am Anfang einer Liste ein?
Korrekt.

Wenn ja wie macht man es dann anders rum
Sag mal, guckst du dir überhaupt auch nur ein einziges Mal den Code an, den du von woanders kopierst und versuchst, ihn zu verstehen?
Java:
  // ans ende einfuegen durch die Liste laufen
  public List append(Element x) {
    if (isEmpty())
      return insert(x);
    else
      return next.append(x);
  }
 

mihe7

Top Contributor
Fügt man so nicht immer am Anfang einer Liste ein?
Das ist gerade ein Vorteil von verketten Listen. Bei einem Array müsstest Du n Elemente nach hinten verschieben, um ein Element am Anfang einfügen zu können. Das Einfügen hat somit eine lineare Laufzeit. Bei einer verketteten Liste ersetzt Du einfach das erste Element. Die Laufzeit ist damit konstant.

Bei Deiner Liste ist dafür das Anfügen ans Ende nur in linearer Laufzeit möglich.

Wenn Du Spaß daran hast, kannst Du Dich ja mal an einer einfachen Aufgabe versuchen: erweitere Deine Liste so, dass auch das Anfügen ans Ende der Liste in konstanter Zeit möglich ist.
 

ocsme

Top Contributor
// ans ende einfuegen durch die Liste laufen
public List append(Element x) {
if (isEmpty())
return insert(x);
else
return next.append(x);
}

Kommentar oben //ans ende einfuegen durch die Liste laufen ist von mir.
Ich wollte ja nur wissen ob man das immer so machen muss :D Konkrete hatte ich die Frage so gemeint/gestellt das ich die selbe Antwort erhalten müsste wie die, die du jetzt gepostet hast.
Da mir das mit den Zeigern einfach mega Schwer fällt mir das vorzustellen :D dachte ja erst das Liegt alles dann auf einem Stack und wird Rekursiv abgearbeitet.
 

ocsme

Top Contributor
o_O mihe7 meinst du es so das man Dummys benutzt. Indem ich einen Pointer auf anfang setzte und einen ans ende sollte das setzten ans ende auch linear gehen oder :)

Sry nochmal für die "doofen" Fragen Keine Ahnung wieso ich mir dabei einfach so schwer tut. Hab mir auch schon gedacht vielleicht sollte ich mich in C einlesen da wird ja viel mit Pointer gearbeitet vielleicht geht es dann besser?
Oder ist es einfach Übungssache?

Bin euch echt DANKBAR =)
Danke nochmals :)
 

mihe7

Top Contributor
Indem ich einen Pointer auf anfang setzte und einen ans ende sollte das setzten ans ende auch linear gehen oder
Konstant, nicht linear. Und ja, wobei Ende = letztes Element. Dann hast Du sofort Zugriff darauf und kannst dort sofort das neue Element einfügen.

Da mir das mit den Zeigern einfach mega Schwer fällt mir das vorzustellen
Hm... Zeiger = Variable, die eine Adresse speichert. Mehr ist das nicht.

Oder ist es einfach Übungssache?
Naja, ist es das nicht immer? :)
 

ocsme

Top Contributor
Naja, ist es das nicht immer? :)
Das stimmt wohl :)
Werde die Tage mal wieder danach schau :) hoffe ich bekomme es hin.

Hm... Zeiger = Variable, die eine Adresse speichert. Mehr ist das nicht.
Ich versuche halt oft zu schnell zu verstehen wie der Compiler das alles macht :D also wie man sowas baut :D
Konnte mich auch lange nicht mit Java anfreunden weil ich immer gedacht habe wie geht das den mit System.out.println das er direkt die Ausgabe druckt. Natürlich ist das bei allen Hochsprachen der Fall bis wir beim Assembler angekommen sind.
Davon konnte ich mich etwas lösen ich bin einfach ein Neugieriger Mensch und in solchen Fällen löst man sich vom "roten Faden" und versucht zu schnell zu viel. Irgendwo muss man ja anfangen. Da ich Java ja derzeit brauch um in der Schule weiter zu kommen muss das eben sitzen :)

Nochmals Danke.
Ich melde mich weiterhin hier. Die nächsten Tage sind leider bei mir sehr verplannt denke es wird MIttwoch bis ich wider weiter arbeiten kann :(

lg
 
X

Xyz1

Gast
Eine verkettete Liste ist eigentlich simple. Das erste Elem kann null oder Dummy sein - (Vice versa letzte Elem). Dazwischen vorhandene Elem s sollten nicht null sein. Bildlich könnte man sich das auch sehr gut vorstellen, als z B ein Ring oder eine Schlange.
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
R Liste in Variable speichern Java Basics - Anfänger-Themen 6
R Liste und Arrays Java Basics - Anfänger-Themen 12
D 2 ArrayListen gleich sortieren bzw. eine Liste anhand einer anderen Sortieren Java Basics - Anfänger-Themen 6
J Ähnlichen String in Liste finden Java Basics - Anfänger-Themen 6
M Verkettete Liste Java Basics - Anfänger-Themen 1
M Vergleichen, ob eine Liste länger als andere ist Java Basics - Anfänger-Themen 6
H Liste nach String-Länge sortieren Java Basics - Anfänger-Themen 1
D remove Object von einer Liste von Obejcts Java Basics - Anfänger-Themen 3
E Elemente aus Liste entfernen und hinzufügen Java Basics - Anfänger-Themen 3
M Nullpointer beim befüllen meiner Liste im Object Java Basics - Anfänger-Themen 3
D Länge einer Liste aufrufen. Java Basics - Anfänger-Themen 19
B Objekt aus generalisierter Liste entfernen Java Basics - Anfänger-Themen 11
H Liste Knoten NullPointerException Java Basics - Anfänger-Themen 7
W Liste mit Listen in JTable darstellen Java Basics - Anfänger-Themen 1
N Was Passiert mit dem Namen einer Variable, wenn man diese einer Liste Hinzufügt Java Basics - Anfänger-Themen 16
E Suchfunktion in einer Liste Java Basics - Anfänger-Themen 39
T ungeordnete Werte-Paare in einer Liste Java Basics - Anfänger-Themen 7
L Hilfe! Liste mit Items werden ausgegeben aber nicht in zufälliger Reihenfolge Java Basics - Anfänger-Themen 6
berserkerdq2 Warum soll ich shuffle nutzen, um bei Rückgabewert Collection eine Liste zurückzugeben? Java Basics - Anfänger-Themen 3
sserio Wieso werden nicht alle Primzahlen bis 1000 in meine Liste gepackt ? Java Basics - Anfänger-Themen 8
sserio Liste erstellt und ein Problem mit dem Index Java Basics - Anfänger-Themen 8
f3mys Objektwerte in Liste speichern und wieder abrufen Java Basics - Anfänger-Themen 23
H Java verkettete Liste, Wert eines Index zurückgeben Java Basics - Anfänger-Themen 1
K Warum ist die binäre Suche bei der verketteten Liste nicht so effektiv? Java Basics - Anfänger-Themen 3
I 2D-Array Position der Liste ausgeben. Java Basics - Anfänger-Themen 2
I Liste von Infos von einer eigenen Annotation in Liste speichern Java Basics - Anfänger-Themen 0
P Doppelte werte in einer Liste zählen Java Basics - Anfänger-Themen 11
Dorfschmied Kartesisches Produkt von zwei Liste mit Hashmaps<String,String> erstellen Java Basics - Anfänger-Themen 4
Igig1 Autoparkplatz verkettete Liste erstes und letztes Auto Java Basics - Anfänger-Themen 13
thor_norsk Verkette Liste Java Basics - Anfänger-Themen 27
R Rückgabe: verkettete Liste Java Basics - Anfänger-Themen 2
R einfach verkettete Liste Java Basics - Anfänger-Themen 1
R einfach verkettete Liste Java Basics - Anfänger-Themen 12
O Doppelt verkette Liste Element löschen Java Basics - Anfänger-Themen 15
B GUI extension mit einer Liste verbinden Java Basics - Anfänger-Themen 1
B Verkettete Liste durchgehen und einzelne Elemente in neue Liste tun Java Basics - Anfänger-Themen 9
B Bin komplett am verzweifeln :( Verkettete Liste die Objekte hat Attribut auslesen Java Basics - Anfänger-Themen 14
M Java Liste streamen Java Basics - Anfänger-Themen 10
AmsananKING Aussortierung einer Liste Java Basics - Anfänger-Themen 8
A Objekte mit Parametern in eine Liste packen Java Basics - Anfänger-Themen 19
A Korrigierte <String> Liste zurückgeben Java Basics - Anfänger-Themen 22
S Kann nicht auf die Liste zugreifen mit der Methode!? Java Basics - Anfänger-Themen 3
B Datentyp für Einzelnes Objekt oder Liste Java Basics - Anfänger-Themen 9
alice98 Erste Schritte Liste erstellen ohne vorgefertigte Klassen Java Basics - Anfänger-Themen 1
J Doppelt verkette Liste ich bitte um Hilfe Java Basics - Anfänger-Themen 4
I Liste gruppieren nach Monat? Java Basics - Anfänger-Themen 5
districon Element in Liste einfügen Java Basics - Anfänger-Themen 1
B Hilfe bei Map Liste erstellen Java Basics - Anfänger-Themen 10
Y Einfügen in eine doppelt verkettete Liste Java Basics - Anfänger-Themen 8
Y Knoten an einem gegebenen Index aus einer Liste entfernen. Java Basics - Anfänger-Themen 6
H Daten aus einer Datei in eine Liste speichern Java Basics - Anfänger-Themen 23
Gaudimagspam Linked Liste Java Basics - Anfänger-Themen 4
Z Liste umkehren Java Basics - Anfänger-Themen 1
S Eine Liste kopieren Java Basics - Anfänger-Themen 13
java3690 Java- liste füllen ud die werte addieren Java Basics - Anfänger-Themen 13
java3690 Liste mit zufälligen zahlen füllen Java Basics - Anfänger-Themen 27
java3690 eine liste sortieren Java Basics - Anfänger-Themen 12
J Element aus Liste nehmen Java Basics - Anfänger-Themen 3
B JUnit 4: Wie man die eigene Liste testen kann [TDD] Java Basics - Anfänger-Themen 46
B Interface List - Objekt übergeben? Einzelnes Objekt geht, aber Liste nicht? Java Basics - Anfänger-Themen 4
P Was genau bringt mir es ein Array in eine Liste zu bringen Java Basics - Anfänger-Themen 3
A Doppelt verkettete Liste rückwärts ausgeben Java Basics - Anfänger-Themen 17
P Verschachtelte Array Liste Java Basics - Anfänger-Themen 2
H Liste speichern. Was lässt sich verbessern? Java Basics - Anfänger-Themen 7
P Performance Array und Liste Java Basics - Anfänger-Themen 13
M QuickSort und Liste Java Basics - Anfänger-Themen 6
N Methode um Objekte einer Liste hinzuzufügen Java Basics - Anfänger-Themen 1
B Summe von Property innerhalb einer Liste via Lambda Java Basics - Anfänger-Themen 1
V Collections int Werte in einer Liste sortieren Java Basics - Anfänger-Themen 23
B Neue Liste erstellen, wenn Objekte bestimmte Referenz hat / Gruppierung von Einträgen Java Basics - Anfänger-Themen 12
V_Fynn03 Beliebiges Element in einer Liste löschen (Java)(Lineare Datenstrukturen) Java Basics - Anfänger-Themen 9
L Baum aus Integer Liste erstellen Java Basics - Anfänger-Themen 0
CptK Koordinate in Liste suchen Java Basics - Anfänger-Themen 20
C Verschiedene Objekte in einer Liste speichern Java Basics - Anfänger-Themen 6
M Ausgabe einer Liste welche mehrere Stacks enthält Java Basics - Anfänger-Themen 3
D Doppelt Verkettete Zirkular-Liste Java Basics - Anfänger-Themen 1
L Liste in anderem Thread laden Java Basics - Anfänger-Themen 1
M Array liste Verdrehen Java Basics - Anfänger-Themen 8
A Verkettete Liste Java Basics - Anfänger-Themen 2
J Strings untereinander in einer Liste vergleichen Java Basics - Anfänger-Themen 18
B Liste von Tagen generieren ab einem bestimmten Datum und Endedatum Java Basics - Anfänger-Themen 4
S IndexOutOfBoundsException beim hinzufügen eines Elements zu einer Liste Java Basics - Anfänger-Themen 11
B Liste sortieren? Java Basics - Anfänger-Themen 4
O Anonyme Klasse einer Liste erstellen Java Basics - Anfänger-Themen 7
B SWAP List; Liste neu anordnen Java Basics - Anfänger-Themen 4
B CSS Klassen in eine Liste schreiben Java Basics - Anfänger-Themen 4
B Doppelt verkettete Liste implementieren Java Basics - Anfänger-Themen 8
L verkettete Liste Java Basics - Anfänger-Themen 15
scratchy1 doppelt verkettete Liste testen Java Basics - Anfänger-Themen 8
B sortierte Liste Java Basics - Anfänger-Themen 4
O Knoten und Liste verarbeitung Java Basics - Anfänger-Themen 20
R Methoden Entferne alle identische Knoten (Typ String) aus verkettete Liste Java Basics - Anfänger-Themen 8
C Methoden Über eine einfach verkettete Liste Java Basics - Anfänger-Themen 8
J Eine Liste von Listen erstellen Java Basics - Anfänger-Themen 11
A Einträge aus Tupeln nach Regeln in Liste speichern Java Basics - Anfänger-Themen 8
Queiser Liste zurückgeben Java Basics - Anfänger-Themen 7
T Collections Geeignete Collection/Liste/Datenbank Java Basics - Anfänger-Themen 17
S spezielle Wörter aus Liste entfernen Java Basics - Anfänger-Themen 2
H Verkettete Liste Java Basics - Anfänger-Themen 7
E Elemente aus Liste löschen Java Basics - Anfänger-Themen 5

Ähnliche Java Themen

Neue Themen


Oben