Knoten und Liste verarbeitung

ocsme

Top Contributor
Guten Tag,

habe folgendes gegeben:
Java:
public class Knoten {
    private int wert;
    private Knoten naechster;
   
    Knoten(int w, Knoten n) {
        setWert(w);
        setNaechster(n);
    }
   
    public int getWert() {
        return wert;
    }
   
    public void setWert(int w) {
        wert=w;
    }
   
    public Knoten getNaechster() {
        return naechster;
    }
   
    public void setNaechster(Knoten n) {
        naechster = n;
    }

}


Jetzt wollte ich sehr gerne eine Main Schreiben in der ich neue Knoten erstelle und mit Werten inizialisiere :) Doch leider bin ich gerade mal wieder zu Doof dafür. Naja nach 8 Stunden lernen denke ich kann man mal schwächeln :D

Also ich bin ehrlich ich stehe gerade so sehr auf dem schlauch das ich gar nichts hin bekomme. Womit ich nicht klar komme ist mit dem nächsten Knoten.

Hier mal ein versuch meiner Main :D
Java:
public class MainKnoten {
   
    public static void main(String[] args) {
       
        Knoten erster = null;
        Knoten[] k = new Knoten[10];
        k[0]= new Knoten(0,erster);
       
        for(int i=0;i<k.length;i++) {
            Knoten[i]=new Knoten(i,new Knoten[i+1]);
        }
    }

}

Natürlich ist das voll kommender Käse doch weiß nicht weiter.
Bitte helft mir nochmals :)

LG
 

ocsme

Top Contributor
Oben die ersten Zeilen funktionieren doch das ist ja mal mega doof ich würde es gerne mit der schliefe befühlen doch da habe ich errors :(
Java:
Knoten eins =null;
        Knoten zwei = new Knoten(1,null);
        Knoten drei = new Knoten(2,zwei);
        System.out.println(zwei+" "+drei);
       
        Knoten[] a=new Knoten[10];
        Knoten[0]= new Knoten(0,null);
       
        for(int i=1;i<a.length;i++) {
            Knoten[i] = new Knoten(i,Knoten[i-1]);
        }


Hinzukommt das der nachfolger nicht der nachfolger wäre sondern der vorgänger! also nicht i+1 sondern i-1 :D Wenn i mein derzeitiger Knoten wäre :D

LG
 

fhoffmann

Top Contributor
Das Array von Knoten solltest du komplett weglassen.
Dann ist es am einfachsten, die Liste von hinten nach vorne zu erzeugen:
Java:
Knoten knoten = new Knoten(0, nil);
for(i = 1; i <= 10; ++i) {
   knoten = new Knoten(i, knoten);
}
Dabei enthält knoten immer den ersten Knoten der Liste.
 

ocsme

Top Contributor
ich tu mir da immer noch sehr schwer!
Denn vor allem finde ich es komisch zu sagen eine Klasse Knoten (Objekt Knoten) enthält einen Knoten :D muss man dabei dann immer den ersten Knoten auf null setzen?
Wie würde man es hin bekommen das Knoten 9 die Referenz auf Knoten 10 hat? und absteigend immer so weiter also 7 auf 8 8 auf 9 ... :D
LG
 

mihe7

Top Contributor
Denn vor allem finde ich es komisch zu sagen eine Klasse Knoten (Objekt Knoten) enthält einen Knoten
Warum? Jeder Mensch hat einen Namen und (mit einer Ausnahme) eine Mutter, die ebenfalls ein Mensch ist.
Java:
public class Mensch {
    private String name;
    private Mensch mutter;

    public Mensch(String name, Mensch mutter) {
        this.name = name;
        this.mutter = mutter;
    }

    public Mensch getMutter() { return mutter; }
    public String getName() { return name; }
}

Und jetzt sagen wir:
Java:
Mensch frau = new Mensch("Eva", null); // Frau von Adam, ohne Mutter
frau = new Mensch("Unbekannte Tochter von Eva", frau);
Dann ist frau die unbekannte Tocher von Eva und sie weiß, dass Eva ihre Mutter ist. Das Spiel kann man beliebig fortsetzen:
Java:
String[] linie = {"Eva", "Unbekannte Tochter von Eva", ..., "Priscilla Presley"};
Mensch frau = null;
for (String name : linie) {
    frau = new Mensch(name, frau);
}
// ...
D. h. frau ist die Frau am Ende der dargestellten Linie. Und die kann beliebig erweitert werden:
Code:
// ...
frau = new Mensch("Lisa Marie Presley", frau);
Umgekehrt kannst Du vom Ende der Linie (=Liste) bis zum Beginn wandern:
Code:
Mensch aktuell = frau;
do {
    System.out.println(aktuell.getName());
    aktuell = aktuell.getMutter();
} while (aktuell != null);
 

ocsme

Top Contributor
misst ich dachte ich hätte das jetzt verstanden.
Wird dann nicht immer frau überschrieben? ich erstelle ja immer ein neues Objekt mit dem selben "Namen".
so auch hier mit den Knoten:
Java:
Knoten knoten = new Knoten(0, null);
        for(int i = 1; i <= 10; ++i) {
           knoten = new Knoten(i, knoten);
        }
Benötigt man dazu um die anderen Knoten zu speichern nicht wieder z. B. ein Array von Knoten???
Erst dann habe ich zugriff auf alle Knoten die ich erstellt habe oder :D

LG


PS: hab den code von dir mal Kopiert mihe7 und das klappt ja :) Ich weiß nur nicht wieso schreibt er nicht über Frau eine neue Frau rüber?

so klappt auch das ausgeben der Knoten doch ich hinterfrager gerade alles was ich bis jetzt "gelernt" habe!
Wieso funktioniert das ??? Ich stehe ja heute morgen schon so was von auf einem "dicken" Schlauch :D :(
Java:
Knoten aktuell = knoten;
         do {
             System.out.println(aktuell.getWert());
             aktuell = aktuell.getNaechster();
         } while (aktuell != null);

Wo wird das gespeichert? Wieso werden die Objekte nicht überschrieben :(
LG
 
Zuletzt bearbeitet:

mihe7

Top Contributor
Wird dann nicht immer frau überschrieben?
frau ist ja nur eine Referenz auf ein Objekt. Mit
Code:
frau = new Mensch("Lisa Marie Presley", frau);
wird zuerst ein neues Mensch-Objekt erstellt, das als Mutter frau bekommt. Zu diesem Zeitpunkt referenziert frau noch "Priscilla Presley". Die Referenz auf das neue Objekt wird anschließend frau zugewiesen.

Grafisch
Code:
frau ---> +-------------------------|  mutter
          |       _:Mensch_         |-------> ....
          +-------------------------|
          | name: Priscilla Presley |
          +-------------------------+



frau ---> +--------------------------+      mutter  +-------------------------|  mutter
          |         _:Mensch_        |------------->|       _:Mensch_         |-------> ....
          +--------------------------+              +-------------------------|
          | name: Lisa Marie Presley |              | name: Priscilla Presley |
          +--------------------------+              +-------------------------+
 

ocsme

Top Contributor
Ich glaube so langsam komme ich dahinter :)
Hab nun auch etwas mit den Knoten gespielt und einige Sachen raus gefunden :D
Vielen Lieben Dank nochmals :)

und wow o_O so eine Grafik :) nur um mir etwas versuchen klar zu machen :) WAHNSINN :)
Das ganze muss man einfach auch mal so üben denn das ist was ganz neues für mich. Ansonsten haben wir bis jetzt immer nur Objekte erschaffen wo im großen und ganzen auch nicht wieder Objekte in der Klasse vor kommen und vor allem nicht sowas wie Liste = new Liste(23,null) oder Knoten = new Knoten(23,null) --> etc. :D

Werde mich wieder melden sobald was unklar ist :)

LG
 

ocsme

Top Contributor
Baut Java da nicht automatisch wie eine Verkettete Liste auf? Indem ich die Referenz eines Objektes immer wieder einem anderen Objekt zu weise?

Der Zeiger von frau wandert zum neu erstellten Objekt wieso werden die Zeiger aber mit der do while schleife unten wieder zerstört indem ich das Objekt zurück gebe?

"Ufff das hier macht nur Verwirrung :("

Hier mal ein paar Spielereien von mir :D
Was könnte man noch abfragen bei solchen Knoten?
Java:
public class MainKnoten {
  
    public static boolean kommtVor(int x, Knoten k) {
        do {
            if(x == k.getWert())
                return true;
            k = k.getNaechster();
        } while(k!=null);
          
        return false;
    }
  
    public static boolean zweiGleiche(int x, Knoten k) {
        boolean[] save=new boolean[2];
        int i=0;
        do {
            if(kommtVor(x,k)) {
                save[i]=true;
                if(i<1)
                    i++;
            }
            k=k.getNaechster();
          
        } while(k!=null);
      
        return save[0] & save[1];
      
    }
  
    public static void main(String[] args) {
      
        Knoten knoten = new Knoten(0, null);
        for(int i = 1; i <= 10; ++i) {
            int k = (int) (Math.random()*5+1);
           knoten = new Knoten(k, knoten);
        }
      
        Knoten aktuell = knoten;
        System.out.println(kommtVor(4,aktuell));
        System.out.println(zweiGleiche(2,aktuell));

         do {
             System.out.println(aktuell.getWert()+" "+aktuell.getNaechster());
             aktuell = aktuell.getNaechster();
         } while (aktuell != null);
       
    }
}
 

mihe7

Top Contributor
Der Zeiger von frau wandert zum neu erstellten Objekt wieso werden die Zeiger aber mit der do while schleife unten wieder zerstört indem ich das Objekt zurück gebe?
aktuell ist ja nur eine lokale Variable. Die zeigt auf das aktuelle Knoten/Frau-Objekt. Du hangelst Dich mit der Schleife einfach durch die verkettete Liste:

Code:
Ausgangspunkt:

 frau
   |
   v      mutter             mutter          mutter
:mensch --------> :mensch --------> :Mensch ------> null 

Betreten der do-while-Schleife:

 frau
   |
   v      mutter             mutter          mutter
:mensch --------> :mensch --------> :Mensch ------> null 
   ^
   |
 aktuell


aktuell = aktuell.getMutter():

 frau
   |
   v      mutter             mutter          mutter
:mensch --------> :mensch --------> :Mensch ------> null 
                    ^
                    |
                  aktuell

aktuell != null, also folgt eine weitere Iteration
Dort: aktuell = aktuell.getMutter():

 frau
   |
   v      mutter             mutter          mutter
:mensch --------> :mensch --------> :Mensch ------> null 
                                       ^
                                       |
                                     aktuell

aktuell != null, also folgt eine weitere Iteration
Dort: aktuell = aktuell.getMutter():

 frau
   |
   v      mutter             mutter          mutter
:mensch --------> :mensch --------> :Mensch ------> null 
                                                     ^
                                                     |
                                                   aktuell
aktuell == null: Ende der do-while-Loop
 

mihe7

Top Contributor
Was könnte man noch abfragen bei solchen Knoten?
Du kannst alles machen, was Du mit einer Liste auch machen kannst:
1. wie lang ist die Kette (size())?
2. füge an Index ix ein Element ein (d. h. vor das (ix+1)-te Element)
3. Entferne ein Element
4. Entferne ein Element an Stelle x
5. Suche ein Element z. B. via Comparable
6. Sortiere die Liste
7. usw.
 

ocsme

Top Contributor
1-6 werde ich versuchen dank dir nochmals.
Sobald ich wieder nicht weiter komme melde ich mich :)
Vielleicht klappt das ganze ja besser wenn ich solche Sachen mehr Übe doch ich bin ehrlich ich hatte schon genug zu tun mit "einfachen" aufgaben wie Arrays zu sortieren und der gleichen und darin bin ich auch noch nicht so gut :(
LG
 

ocsme

Top Contributor
Na toll ich hänge jetzt schon 40 Minuten an der Einfüge Methode und komme nicht weiter.
Java:
public static Knoten insert(int stelle, int wert, Knoten k) {
        if(stelle < 0 || k == null)
            return k;
        Knoten hilfszeiger;
        int count=0;
        do {
            if(count==stelle) {
                hilfszeiger=k.getNaechster();
               
            }
               
            k=k.getNaechster();
            count++;
        } while(k!=null);
        return k;
    }

Mir ist klar das ich einen Hilfszeiger benötige der einen Zeiger speichert. Bsp:
1 -> 2 -> 3 wenn ich nun zwischen 1 und 2 eine 5 einfügen möchte 1 -> 5 -> 2 ... dann muss der Knoten 5 erstellt werden der Zeiger von 1 auf das neue Knoten Objekt und der Hilfszeiger der auf 2 Steht (denn haben wir vorher natürlich über getNaechst auf die 2 gestellt) muss nun auf die 5 Zeigen.
Denke das sollte so gehen doch ich bekomme es in Java einfach nicht umgesetzt :(
Kann mir da jemand weiter helfen?

LG
 

mihe7

Top Contributor
Es gibt einen Spezialfall, den Du noch nicht berücksichtigt hast, darauf kommst Du aber noch :D

Zum Thema: deine Liste besteht aus Knoten und der Knoten ist Dein Werte-Träger. Du musst also aus Deinem Wert einen Knoten erzeugen.

Wenn Du zwischen (1)->(2) (die Klammern sollen ein Knotenobjekt darstellen, die Zahl darin ist der Wert) eine 5 einfügen willst, muss am Ende (1)->(5)->(2) rauskommen. Beim Erstellen des Knotens für den neuen Wert gibst Du den Folgeknoten, hier also (2) an. Danach musst Du nur noch dafür sorgen, dass die (1) nicht mehr auf die (2) sondern auf die (5) zeigt.
 

mihe7

Top Contributor
Wenn Du es nicht mehr aushältst :p, hier ein Teil der Lösung:
In den Kommentaren vergleiche ich die Liste mit einem Array knoten[]. Dabei entspricht der übergebene Knoten k dem ersten Knoten, also dem Knoten mit Index 0. Der Code fügt am angegebenen Index einen Wert ein.

Java:
Knoten hilfsknoten = k;
/* hilfsknoten zeigt auf den ersten Knoten (=Stelle 0). Wenn
   an Stelle 3 eingefügt werden soll, müssen wir nur bis
   zum Knoten an Stelle 2 gehen. Dessen Nachfolger
   ist an Stelle 3 und hier müssen wir einklinken.
   Daher gehen wir nur (stelle-1)-mal in der Kette
   weiter: */
for (int i = 0; i < stelle-1; i++) {
    hilfsknoten = k.getNaechster();
}
/* an diesem Punkt zeigt hilfsknoten auf den Knoten
   vor dem einzufügenden Knoten.
   Der neue Knoten muss auf den Nachfolger von 
   hilfsknoten zeigen: */
Knoten neuerKnoten = new Knoten(wert, hilfsknoten.getNaechster());
/* jetzt müssen wir den neuen Knoten nur noch zum Nachfolger des 
   hilfsknotens machen: */
hilfsknoten.setNaechster(neuerKnoten);
 

ocsme

Top Contributor
mhhh... sry ich kam erst um 18 Uhr heim und dann noch essen etc.
konnte es jetzt erst weiter machen :)
Hier mal meine Lösung weiß nur nicht ob es so 100% Funktoniert noch nicht ausprobiert und hab dafür heute auch keine Lust/Nerv mehr :D Das Bett ruft :D

Java:
public static Knoten insert(int stelle, int wert, Knoten k) {
        if (stelle < 0 || k == null)
            return k;
        for (int i = 0; i < stelle; i++) {
            if (k.getNaechster() != null) {
                k = k.getNaechster();
            }
        }
        Knoten input = new Knoten(wert, k.getNaechster());
        k.setNaechster(input);

        return k;
    }

LG
 

ocsme

Top Contributor
Eine kurze Frage habe ich noch da ich hier auf einen netten Link gestoßen bin:
http://www.java-programmieren.com/listen-java.php

Die Methode in der Liste hier:
Java:
public boolean hinzufuegen(String thema) {
        boolean erfolgreich = false;
            ListenElement pos = new ListenElement(thema);
            pos.setNext(anfang);
            anfang = pos;
            erfolgreich = true;
            groesse++;
            return erfolgreich;
    }

anfang = pos; bedeutet dass, das er immer den Zeiger auf das erste Element setzt also wenn man etwas einfügt steht das Element immer am Anfang der Liste nicht hinten?

LG
 
X

Xyz1

Gast
anfang = pos; bedeutet dass, das er immer den Zeiger auf das erste Element setzt also wenn man etwas einfügt steht das Element immer am Anfang der Liste nicht hinten
Ich glaube das nächste Element steht dann auf dem nächsten Element und das muss nicht immer der Anfang der Liste sein. :)
 

mihe7

Top Contributor
anfang = pos; bedeutet dass, das er immer den Zeiger auf das erste Element setzt also wenn man etwas einfügt steht das Element immer am Anfang der Liste nicht hinten?
Ja, das Prinzip ist genau das, was ich im Kommentar #8 beschrieben habe (ersetze "anfang" mit "frau") und wie Du die Listen aufgebaut hast.

Schau Dir mal den Code genau an:
Java:
            ListenElement pos = new ListenElement(thema);
            pos.setNext(anfang);
            anfang = pos;
Wenn Du das nächste Element gleich im Konstruktor von ListenElement hättest, könntest Du Dir pos.setNext sparen. Dadurch würde der Code verkürzt zu:
Java:
            ListenElement pos = new ListenElement(thema, anfang);
            anfang = pos;
Und natürlich musst Du das neue ListeElement nicht erst in einer Variablen zwischenspeichern, sondern kannst es sofort dem "anfang" zuweisen. Somit bleibt übrig:
Java:
            anfang = new ListenElement(thema, anfang);
Diese Zeile darf Dir durchaus bekannt vorkommen ;)
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
H Liste Knoten NullPointerException Java Basics - Anfänger-Themen 7
Y Knoten an einem gegebenen Index aus einer Liste entfernen. Java Basics - Anfänger-Themen 6
R Methoden Entferne alle identische Knoten (Typ String) aus verkettete Liste Java Basics - Anfänger-Themen 8
I Erste Schritte Referenz zum Knoten davor, in einer Liste Java Basics - Anfänger-Themen 4
D An bestimmten Knoten einer Liste zugreifen Java Basics - Anfänger-Themen 4
Cassy3 Binärer Suchbaum Knoten rauslöschen Java Basics - Anfänger-Themen 1
D spezifische Knoten in einem Baum zählen Java Basics - Anfänger-Themen 9
Y Wie greift man auf die Knoten in einem Binärbaum zu? Java Basics - Anfänger-Themen 5
J ActionListener von JCheckBox im Knoten von JTree funktioniert nicht Java Basics - Anfänger-Themen 2
S Binärbäume knoten zählen Java Basics - Anfänger-Themen 16
T Collections Methode (Knoten hinzufügen) für Graphen Java Basics - Anfänger-Themen 32
H Knoten-Reihenfolge einer LinkedList invertieren Java Basics - Anfänger-Themen 11
G Binärer Suchbaum Knoten zählen Java Basics - Anfänger-Themen 1
M Dijkstra Algorithmus in Graphen auf mehrere verschiedene Knoten anwenden lassen Java Basics - Anfänger-Themen 11
O Suchbaum Elternknoten finden Level eines Knoten bestimmen Java Basics - Anfänger-Themen 24
E Knoten eines Baumes unter Bedinung zählen Java Basics - Anfänger-Themen 2
L Baum Knoten zählen Java Basics - Anfänger-Themen 6
L B+Baum innere Knoten erstellen Java Basics - Anfänger-Themen 3
L Graphen: Anzahl Knoten // Knoten in Array speichern Java Basics - Anfänger-Themen 4
J Max. Anzahl von Knoten im Binärbaum Java Basics - Anfänger-Themen 3
M Werte der Knoten in Binärbaum addieren (iterativ) Java Basics - Anfänger-Themen 6
S Baumstruktur: tiefsten Knoten finden Java Basics - Anfänger-Themen 3
B Methoden BinärBaum als String Knoten löschen Java Basics - Anfänger-Themen 5
J Baum Knoten löschen Java Basics - Anfänger-Themen 10
T Datentypen Knoten Großvater finden? Java Basics - Anfänger-Themen 12
S Methoden Abtrennen ab einem gegebenen Knoten eines Binärbaums Java Basics - Anfänger-Themen 4
M Binärbaum - Problem bei Knoten anhängen / löschen Java Basics - Anfänger-Themen 5
B JTree knoten wird nicht übernommen Java Basics - Anfänger-Themen 4
L BinärTree, Knoten löschen Java Basics - Anfänger-Themen 6
Luk10 Anzahl der Knoten in einem Baum ausgeben! Java Basics - Anfänger-Themen 6
T gebe mir den ersten eltern knoten Java Basics - Anfänger-Themen 3
K verkettete Listen - Klasse Knoten Java Basics - Anfänger-Themen 19
L LinkedList vorgänger Knoten zurück geben Java Basics - Anfänger-Themen 4
H B-Baum: Knoten Position als Parameter oder als Variable im Objekt? Java Basics - Anfänger-Themen 4
S Binärbaum - Klasse Knoten - Methode Suchen Java Basics - Anfänger-Themen 5
M Nachbar von Knoten bestimmen Java Basics - Anfänger-Themen 8
0x7F800000 zwei adjazenzlisten für jeden knoten eines graphen sinnvoll? Java Basics - Anfänger-Themen 17
C Bäume in Java. Knoten in Array speichern Java Basics - Anfänger-Themen 3
G eine Knoten aus einem Baum löschen. [SOLVED] Java Basics - Anfänger-Themen 7
F JTree-Knoten (DefaultMutableTreeNode) formatieren ? Java Basics - Anfänger-Themen 3
Y JTree: ein Knoten als Objekt Java Basics - Anfänger-Themen 2
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
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
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

Ähnliche Java Themen

Neue Themen


Oben