# linkedlist generische klassen



## Heyoka955 (20. Apr 2019)

hallo, ich habe ein kleines problem.
Ich wollte eine linkedlist herstellen, die Objekte entgegennimmt und ich wollte immer testen ob die Objekte vom gleichen Typ sind indem listnode von comparable erbt jedoch tretten dauern fehler ein.



```
public class LinkedList< T >{
    ListNode<T> first = null;
    
        public void insert(ListNode<T> node) {

        node.setNext(first);

        first = node;

    }
    private void printList(ListNode<T> node) {

        System.out.println("Node is " + node.getValue());

        if(node.getNext()!=null) printList(node.getNext());

    }



    public void print(){

        printList(first);

    }
    
    
    public void add( T value){
        
        new ListNode<T>(value);
    }
    
    
}








public class ListNode<T extends Comparable<T>> {
    
    private ListNode<T> next;
    private T value;
    
    
    public ListNode( T value){
        this.value = value;
        
        
    }
    
    public T getValue(){
        
        return value;
        
    }
    
    public void setNext(ListNode<T> next){
        this.next = next;
        
        
        
    }
    
    public ListNode<T> getNext() {

        return next;

    }
    
    
}
```


----------



## Tarrew (20. Apr 2019)

Nur weil deine generischen Typen beide "T" heißen, haben die nichts miteinander zu tun.
Wenn du also in der ListNode Klasse sagt "ListNode<T extends Comparable<T>>"
und in deiner LinkedList-Klasse wieder "T" verwendest, bedeutet das nicht, dass dieses T wieder Comparable implementiert.

Das musst du schon separat nochmal angeben:
"class LinkedList< T extends Comparable<T>>".

Wenn du nichts angibst wie in deinem Fall, ist das das gleiche wie: 
"class LinkedList< T extends Object>".

Und das passt nicht, wie du siehst.


----------



## Heyoka955 (20. Apr 2019)

Tarrew hat gesagt.:


> Nur weil deine generischen Typen beide "T" heißen, haben die nichts miteinander zu tun.
> Wenn du also in der ListNode Klasse sagt "ListNode<T extends Comparable<T>>"
> und in deiner LinkedList-Klasse wieder "T" verwendest, bedeutet das nicht, dass dieses T wieder Comparable implementiert.
> 
> ...


habe ich auch gemacht aber dan kam bei runtine ein fehler der so aussieht


Exception in thread "main" java.lang.NoSuchMethodError: ListNode.<init>(Ljava/lang/ObjectV
        at Test.main(Test.java:29)






wenn ich bei beiden Klassen extendx comprable mache, dann kommt die fehlermeldung hier, wenn ich aber nur in linknode extends verwende dann kommt ein kompiliefehler und wenn ich das comparable bei beidem weglasse dann kommt diese obige listenausgabe.


----------



## Heyoka955 (20. Apr 2019)

Tarrew hat gesagt.:


> Nur weil deine generischen Typen beide "T" heißen, haben die nichts miteinander zu tun.
> Wenn du also in der ListNode Klasse sagt "ListNode<T extends Comparable<T>>"
> und in deiner LinkedList-Klasse wieder "T" verwendest, bedeutet das nicht, dass dieses T wieder Comparable implementiert.
> 
> ...


mir fällt gerade ein, dass dies nicht Sinn der Sache ist sondern ich muss nur bei der Methode insert prüfen ob der Value Typ von comparable ist. Daher würde es reichen wenn nur linkedlist davon erbt und nicht linknode.


----------



## Tarrew (20. Apr 2019)

Dein Fehler scheint aber trotzdem ein anderer zu sein. Du rufst eine Methode bzw. in deinem Fall wohl einen Konstruktor auf, den es so nicht gibt.
Zeig mal deinen kompletten Code.


----------



## Heyoka955 (20. Apr 2019)

Tarrew hat gesagt.:


> Dein Fehler scheint aber trotzdem ein anderer zu sein. Du rufst eine Methode auf, die es so nicht gibt.
> Zeig mal deinen kompletten Code.


der steht da direkt


----------



## Tarrew (20. Apr 2019)

Deine main-Methode ist nirgendwo zu sehen.


----------



## Heyoka955 (20. Apr 2019)

Tarrew hat gesagt.:


> Deine main-Methode ist nirgendwo zu sehen.


achso ja der bug ist aber auch weg eig!

```
public class Test{
    
    public static void main (String[] args) {
         LinkedList<Integer> liste = new LinkedList<Integer>();
         liste.insert(new ListNode<Integer>(1));
         liste.insert(new ListNode<Integer>(2));
         liste.insert(new ListNode<Integer>(3));
         liste.insert(new ListNode<Integer>(4));
         liste.insert(new ListNode<Integer>(7));
        
         liste.print();
        
     }
}
```


----------



## Tarrew (20. Apr 2019)

Ich kann zwar nicht nachvollziehen was du gemacht hast und wann der Fehler mit welchem Code aufgetreten ist, aber wenns funktioniert, ist ja gut.


----------



## Heyoka955 (20. Apr 2019)

Tarrew hat gesagt.:


> Ich kann zwar nicht nachvollziehen was du gemacht hast und wann der Fehler mit welchem Code aufgetreten ist, aber wenns funktioniert, ist ja gut.


mein Problem ist jetzt die ausgabe, ich möchte die ausgabe dass er mit dem index startet aber irgendwie klappt es nicht.



```
private void printList(ListNode<T> node) {
        int count = 0;
        count++;
        
        System.out.println(count + " Index = " + node.getValue());
        
        if(node.getNext()!=null) printList(node.getNext());

    }
```


----------



## Tarrew (20. Apr 2019)

Du rufst die Methode rekursiv auf, und initialisierst deinen Counter jedes mal mit 0.
Entsprechend wird auch jedes mal 1 ausgegeben.

Wenn du die Variable hochzählen willst in deiner Rekursion musst du die als Parameter mit übergeben.


----------



## Heyoka955 (20. Apr 2019)

Tarrew hat gesagt.:


> Du rufst die Methode rekursiv auf, und initialisierst deinen Counter jedes mal mit 0.
> Entsprechend wird auch jedes mal 1 ausgegeben.
> 
> Wenn du die Variable hochzählen willst in deiner Rekursion musst du die als Parameter mit übergeben.


ne das wird so schwer funzen, dann wäre eine for schleife besser geeignet.


----------



## Heyoka955 (20. Apr 2019)

Heyoka955 hat gesagt.:


> ne das wird so schwer funzen, dann wäre eine for schleife besser geeignet.


hat geklappt, der code sieht natürlich nicht schön aus aber er funktioniert.


----------



## Tarrew (20. Apr 2019)

Schwer ist daran garnichts, einfacher geht Rekursion kaum:


```
private void printList(ListNode<E> node, int count) {
        System.out.println(count++ + " Index = " + node.getValue());

        if (node.getNext() != null) printList(node.getNext(), count);
    }
 
    public void print() {
        printList(first, 0);
    }
```

for-Schleife geht natürlich auch.

Bei so einer print-Methode ist eine for-Schleife auch besser, bei Listen mit ein paar tausend Einträgen läuft man sonst direkt in einen Stackoverflow.


----------



## Heyoka955 (20. Apr 2019)

Tarrew hat gesagt.:


> Schwer ist daran garnichts, einfacher geht Rekursion kaum:
> 
> 
> ```
> ...


so habe ich das auch gemacht jetzt muss ich die insert Methode so umschreiben dass er das sortiert...
Weißt du wie man da rangehen sollte?


----------



## Tarrew (20. Apr 2019)

Du warst doch der, der in naher Zukunft 100k verdienen wollte oder nicht 
Am besten geht man daran, in dem man ein bisschen Eigeninitiative zeigt.

Deine Einträge implementieren alle das Comparable Interface, du kannst also die compareTo-Methode aufrufen.
Du läufst also so lange von vorne nach hinten durch deine Liste und vergleichst deinen neu-einzufügenden Eintrag mit den bestehenden Einträgen, bis du die passende Stelle zum Einfügen gefunden hast.

So ich geh mal zum Sport, viel Erfolg noch.


----------



## Heyoka955 (20. Apr 2019)

Tarrew hat gesagt.:


> Du warst doch der, der in naher Zukunft 100k verdienen wollte oder nicht
> Am besten geht man daran, in dem man ein bisschen Eigeninitiative zeigt.
> 
> Deine Einträge implementieren alle das Comparable Interface, du kannst also die compareTo-Methode aufrufen.
> ...



jo meld mich abends wieder! denke mache pause jetzt


----------



## Heyoka955 (20. Apr 2019)

ich habe ein kleines problem, habe mich dran gesetzt und es gibt ein probem, die aufgabe verlangt, dass die Sortierung automatisch erfolgt. Das heißt ich muss das so sortieren, dass das automatisch bei der insert Methode als letzte zeile aufgerufen wird nachdem er das neue objekt hinzugefügt hat. Aber leider kann ich nicht mehr auf die liste selbst zugreifen.


----------



## kneitzel (20. Apr 2019)

Also ich habe es schon mehrfach geschrieben: mal es dir auf einem Zettel auf und mache es doch einfach mal von Hand.

Wie fügst Du neue Elemente ein, damit die Liste sortiert ist?


----------



## Heyoka955 (20. Apr 2019)

kneitzel hat gesagt.:


> Also ich habe es schon mehrfach geschrieben: mal es dir auf einem Zettel auf und mache es doch einfach mal von Hand.
> 
> Wie fügst Du neue Elemente ein, damit die Liste sortiert ist?


ich habe das einfügen hinbekommen, das problem ist ich kriege dauernd eine fehlemeldung in der main methode

```
for(ListNode listNode : liste<Integer>){

            
            
            
         }



da kommt ein fehler illegal start of expression
```


----------



## kneitzel (20. Apr 2019)

Du willst eine for each Schleife machen. Wie wird die genau aufgebaut?

Da ist eigentlich alles richtig, aber schau Dir dieses liste<Integer> einmal an. Was gehört da hin?
Kannst auch an der Stelle einmal überlegen, wann Generics wie eingesetzt werden.


----------



## Heyoka955 (20. Apr 2019)

kneitzel hat gesagt.:


> Du willst eine for each Schleife machen. Wie wird die genau aufgebaut?
> 
> Da ist eigentlich alles richtig, aber schau Dir dieses liste<Integer> einmal an. Was gehört da hin?
> Kannst auch an der Stelle einmal überlegen, wann Generics wie eingesetzt werden.


for(Objekt a : ArrayList){


}



Nehmen wir an in Arraylist wird jetzt nur Objekte abgespeichert und diese Objekte sind von typ objekt dann muss man ähnlich wie bei einer for schleife gehen das heißt, du musst ein neues objekt in der schleifenbedinung initilaiseren um von anfnag an anzufangen und danach musst du den namen  der Liste oder map etc angeben damit er die durchgeht.

In dem Falle wäre das so aber das klappt auch nicht



for(Integer a : liste){


}


----------



## kneitzel (20. Apr 2019)

Also da ist jetzt die Syntax schon einmal richtig,

Das kann aber nur funktionieren, wenn liste entweder ein Array ist oder Iterable implementiert. Das ist die Voraussetzung für eine for each Schleife.


----------



## Heyoka955 (20. Apr 2019)

kneitzel hat gesagt.:


> Also da ist jetzt die Syntax schon einmal richtig,
> 
> Das kann aber nur funktionieren, wenn liste entweder ein Array ist oder Iterable implementiert. Das ist die Voraussetzung für eine for each Schleife.


ich habe eine liste aber es geht nicht

```
public class Test{
    
    public static void main (String[] args) {
         LinkedList<Integer> liste = new LinkedList<Integer>();
         liste.insert(new ListNode<Integer>(1));
         liste.insert(new ListNode<Integer>(2));
         liste.insert(new ListNode<Integer>(3));
         liste.insert(new ListNode<Integer>(4));
         liste.insert(new ListNode<Integer>(7));
         int index = 0;
         liste.print(index);
        
        
        
         for(Integer a : liste){

            
            
            
         }
        
     }
}
```


----------



## kneitzel (20. Apr 2019)

LinkedList ist eine Klasse, die du geschrieben hast? Implementiert diese Iterable? Wenn nicht: Entweder auf das for each verzichten oder eben Iterable implementieren.

Bitte schau dir das Java for each genau an, damit du diese Anforderungen lernst!


----------



## Heyoka955 (20. Apr 2019)

kneitzel hat gesagt.:


> LinkedList ist eine Klasse, die du geschrieben hast? Implementiert diese Iterable? Wenn nicht: Entweder auf das for each verzichten oder eben Iterable implementieren.
> 
> Bitte schau dir das Java for each genau an, damit du diese Anforderungen lernst!


ja habe ich selber geschrieben? stand in der aufgabe aber was ist an meiner for each falsch, und nein sie tut es icht implementieren

aber auch wenn ich eine normale for schleife mache und dann liste.size() mache, funktioniert das nicht


----------



## thecain (20. Apr 2019)

Du hast ja auch keine size Methode...


----------



## Heyoka955 (20. Apr 2019)

Heyoka955 hat gesagt.:


> ja habe ich selber geschrieben? stand in der aufgabe aber was ist an meiner for each falsch



die habe ich gerade umgeändert aber warte 



```
for(int i = 0; i < liste.size(); i++){
            
            
            
        }
```


----------



## thecain (20. Apr 2019)

sag ich ja...


----------



## Heyoka955 (20. Apr 2019)

thecain hat gesagt.:


> sag ich ja...


was?


----------



## thecain (20. Apr 2019)

thecain hat gesagt.:


> Du hast ja auch keine size Methode


----------



## Heyoka955 (20. Apr 2019)

achso hä müsste er das nicht selber aufrufen? geht das nicht mit packages?

normalerweise ist das doch in java gespeichert


----------



## Tarrew (20. Apr 2019)

https://docs.oracle.com/javase/7/docs/api/java/util/Collection.html#size()

Das ist die Methode, die du bei anderen Listen (ArrayList, LinkedList etc) aus dem JDK immer aufrufst.

Deine eigene Klasse "LinkedList" hat diese Methode aber nicht, die kommt auch nicht magisch von irgendwoher durch Java oder so.


----------



## thecain (20. Apr 2019)

Nicht wenn du eine eigene Klasse dafür schreibst... woher auch?

Dir fehlen immer noch so viele Grundlagen. Hol doch die erstmal auf bevor du hier mit Generics rumhantierst und alles durchmischst


----------



## Heyoka955 (20. Apr 2019)

thecain hat gesagt.:


> Nicht wenn du eine eigene Klasse dafür schreibst... woher auch?
> 
> Dir fehlen immer noch so viele Grundlagen. Hol doch die erstmal auf bevor du hier mit Generics rumhantierst und alles durchmischst


ne ich muss mich an das übungsblatt ranmachen, die Übung kommt mit der zeit.
das problem ist unsere uni bietet alle jahre nur die programmier praktiken an von daher muss ich gas geben


----------



## Heyoka955 (20. Apr 2019)

Tarrew hat gesagt.:


> https://docs.oracle.com/javase/7/docs/api/java/util/Collection.html#size()
> 
> Das ist die Methode, die du bei anderen Listen (ArrayList, LinkedList etc) aus dem JDK immer aufrufst.
> 
> Deine eigene Klasse "LinkedList" hat diese Methode aber nicht, die kommt auch nicht magisch von irgendwoher durch Java oder so.


gibt es irgendwie eine Anleitung wie ich das implementieren kann.

Woher hätte ich das auch wissen sollen?

der prof macht nur zu 80% witze.


----------



## Tarrew (20. Apr 2019)

Bevor das nächste Blatt ansteht, wiederhol lieber nochmal die Basics, dann wird das nächste Blatt auch leichter.
Jemand der mit Joggen anfängt, läuft auch nicht als erstes einen Halbmarathon.

Und die eigene Unwissenheit auf den Professor zu schieben ist sehr schwach, das macht man nicht.
Das sind absolute Basics, du solltest du als Informatikstudent wissen, dass man keine Methode aufrufen kann, die nicht existiert. Du siehst doch das *deine eigene Klasse *keine size Methode enthält, entsprechend kannst du auch keine aufrufen.

Guck dir mal deine print-Methode an, eventuell kommst du dann drauf, wie man daraus eine size-Methode bastelt.


----------



## Heyoka955 (20. Apr 2019)

Tarrew hat gesagt.:


> Bevor das nächste Blatt ansteht, wiederhol lieber nochmal die Basics, dann wird das nächste Blatt auch leichter.
> Jemand der mit Joggen anfängt, läuft auch nicht als erstes einen Halbmarathon.
> 
> Und die eigene Unwissenheit auf den Professor zu schieben ist sehr schwach, das macht man nicht.
> ...


Naja denke nicht dass das an Basics liegt Manchnal ist man so verspannt dass man nicht daran denkt.

sinst  würde ich doch nicht eine linkedlist implementieren.
Manchnal vergisst man halt Sachen


----------



## Tarrew (20. Apr 2019)

Du solltest dir nicht alles schönreden. Wenn du nicht nochmal von Grund auf die Grundlagen wiederholst, dann wirst du ganz schnell den Anschluss verpassen. Es macht leider den Eindruck, als wäre das schon längst passiert.

Ein Prof von mir meinte früher öfter mal in der Vorlesung, dass das Wort "Studieren" von dem lateinischen "studere" kommt, was wiederum "sich bemühen" / "streben" / "wollen" bedeutet. Damals konnte ich diese blöde Aussage echt nicht mehr hören, aber es hat sich durchaus als wahr bewiesen. Dir wird nicht immer alles mundgerecht vorgekaut werden, du musst dich da schon selbst etwas reinarbeiten. Mit dieser "Ich-weiß-nicht-wie-das-gehen-soll,-der-Prof-ist-Schuld,-habt ihr eine Idee"-Mentalität wirst du nicht weit kommen. Trotzdem viel Erfolg.


----------



## thecain (20. Apr 2019)

Heyoka955 hat gesagt.:


> sinst würde ich doch nicht eine linkedlist implementieren.


Die nicht funktioniert, aber ignorier ruhig alle Hinweise. Du weisst es bestimmt besser


----------



## Heyoka955 (20. Apr 2019)

thecain hat gesagt.:


> Die nicht funktioniert, aber ignorier ruhig alle Hinweise. Du weisst es bestimmt besser


ich bringe mir alles bei was ich brauche, ich habe eben für das alles ganze aufgemischt.
Wieso klappt meine linkedlist nicht?

so ich habe die size Methode implementiert

```
ublic class LinkedList< T extends Comparable<T>>{
    ListNode<T> first = null;
     LinkedList<T> liste = new LinkedList<T>();
   
        public void insert(ListNode<T> node) {
        if(node.value instanceof Comparable){
           
            Comparable wert = (Comparable) node.value;
           
           
        }
        node.setNext(first);
        first = node;
       
       
       
        int count = 0;
       
        size(first,count);
       
       
       

    }
    private void printList(ListNode<T> node, int count) {
        count++;
       
        System.out.println(count + " Index = " + node.getValue());
       
        if(node.getNext()!=null) printList(node.getNext(),count);

    }



    public void print(int count){

        printList(first,count);
       
   
       
       

    }
   
private int size(ListNode<T> node,int count) {
  count++;
 
 
  if(node.getNext()!=null) size(node.getNext(),count);
 
  return count;
 }
       
   
   
   
}
```


----------



## Tarrew (20. Apr 2019)

print und size solltest du nicht rekursiv implementieren. Mag in deinen Augen schick aussehen, aber wenn du mal ein paar mehr Elemente einfügst, fliegt dir das um die Ohren. Abgesehen davon ist deine size-Methode auch falsch, weil du den Rückgabewert deines rekursiven Aufrufs einfach ignorierst.

Aber wieso hat deine LinkedList ein Attribut "liste" vom gleichen Typen? Und wieso rufst du am Ende deiner Insert-Methode size() auf? Und wieso das: "node.value instanceof Comparable)". Durch deinen generischen Typen "T extends Comparable<T> " weißt du doch schon, dass T Comparable sein muss.


----------



## Heyoka955 (20. Apr 2019)

```
private int size() {
        int count = 0;
        ListNode current = first;
       
       
        while(first != null){
            count++;
            current = current.getNext();
           
           
        }
       
        return count;

    }


bitteschön, habe es verschönert :)
   
    ich merke langsam wie ich reinkomme :)
```



Tarrew hat gesagt.:


> print und size solltest du nicht rekursiv implementieren. Mag in deinen Augen schick aussehen, aber wenn du mal ein paar mehr Elemente einfügst, fliegt dir das um die Ohren. Abgesehen davon ist deine size-Methode auch falsch, weil du den Rückgabewert deines rekursiven Aufrufs einfach ignorierst.
> 
> Aber wieso hat deine LinkedList ein Attribut "liste" vom gleichen Typen? Und wieso rufst du am Ende deiner Insert-Methode size() auf? Und wieso das: "node.value instanceof Comparable)". Durch deinen generischen Typen "T extends Comparable<T> " weißt du doch schon, dass T Comparable sein muss.



okay habe die size Methode hinbekommen, in dem code waren paar kleine bugs, aber die habe ich gefixed.


----------



## flopalko (20. Apr 2019)

Heyoka955 hat gesagt.:


> ```
> private int size() {
> int count = 0;
> ListNode current = first;
> ...


Hast du das getestet? Das kann einfach nicht funktionieren...Du hast hier eine Endlosschleife erzeugt. Gut kommst du da rein, Respekt...


----------



## Heyoka955 (20. Apr 2019)

flopalko hat gesagt.:


> Hast du das getestet? Das kann einfach nicht funktionieren...Du hast hier eine Endlosschleife erzeugt. Gut kommst du da rein, Respekt...


ja habe ich war auch so aber das ging dann klar als ic realisierte dass eig current stehen müsste, ich verpeile das oft.
arbeite sehr schnell daher.

Die ausgabe ist auch richtig als ich current dorthin geschrieben habe, aber jetzt muss ich schauen wie ich die compareto Methode implementiere, denn die aufgabe will dass wir die werte bei der linkedlist sortieren.

Scheint so dass ich doch nicht so schlecht bin 

bin aber jetzt raus, arbeite morgen oder heute abend daran weiter.

wenn da noch ein fehler ist wäre es cool wenn ihr mir das sagen würdet und paar tipps zu compareto Methode gibt!


```
public int size() {
        int count = 0;
        ListNode<T> current = first;
        
        
        while(current != null){
            count++;
            current = current.getNext();
            
            
        }
        
        return count;

    }
```


----------



## kneitzel (20. Apr 2019)

Heyoka955 hat gesagt.:


> Naja denke nicht dass das an Basics liegt Manchnal ist man so verspannt dass man nicht daran denkt.
> 
> sinst  würde ich doch nicht eine linkedlist implementieren.
> Manchnal vergisst man halt Sachen



Doch! Natürlich liegt es an den Basics! Du verwendest Befehle irgendwie, ohne sie im Detail zu kennen und hoffst, dass es durch Zufall klappt. Einfache Hinweise kannst Du auf Grund der fehlenden Basics nicht verstehen (Mein Hinweis auf Iterable scheinst du nicht verstanden zu haben ....)

Ich habe eben mal schnell ins frei verfügbare Java ist auch eine Insel geschaut, aber das scheint nur die normale for Schleife zu behandeln....

Mein Tipp wäre jetzt: Java - the complete Reference von Herbert Schild. Dann hast du eine sehr gute Reference. Kostet um 50€. (Ggf findet man auch ein PDF per Google, aber das ist natürlich nicht legal) wäre nicht wirklich nötig, wenn man Google nutzen könnte... ich selbst liebe so eine Reference ....

Man kann sich auch an das Java ist auch eine Insel Buch halten. Dann nutzt man aber gewisse Dinge nicht.

Was du lernen musst:
- Recherchieren von Fakten. Wenn etwas nicht geht oder du nicht weißt, wie man das überhaupt machen kann, dann kommt man an einer Recherche nicht vorbei.
- debugged - wenn etwas nicht so funktioniert wie es soll, dann muss man wissen, wie man den Fehler einkreist und dann am Ende findet.

Das wären so meine Hinweise im Augenblick.


----------



## kneitzel (20. Apr 2019)

Heyoka955 hat gesagt.:


> ja habe ich war auch so aber das ging dann klar als ic realisierte dass eig current stehen müsste, ich verpeile das oft.
> arbeite sehr schnell daher.
> 
> wenn da noch ein fehler ist wäre es cool wenn ihr mir das sagen würdet und paar tipps zu compareto Methode gibt!



Schnell arbeiten ist blöd, wenn dabei nur Scheisse raus kommt. In einem Studium ist es sogar fatal, da darauf ja später auch aufgesetzt wird.

Und wir kriegen Code Schnipsel und sollen sagen, ob es funktioniert?
Zu jeder Entwicklung gehört die QA, sprich die Tests, ob es funktioniert. Also hast du dir Gedanken zu den Tests gemacht, die notwendig sind?

Wenn das eine sortierte Liste ist, dann muss mindestens getestet worden sein:
Einfügen in eine leere Liste.
Einfügen in eine bestehende Liste, Wert landet am Ende.
Wie zuvor, aber Wert landet in der Mitte
Wie Zuvor, aber Wert landet in der Mitte
Wert hinzufügen, der bereits enthalten ist
...

Vor dem Abschluss der Tests ist man nicht fertig!


----------



## Heyoka955 (20. Apr 2019)

kneitzel hat gesagt.:


> Schnell arbeiten ist blöd, wenn dabei nur Scheisse raus kommt. In einem Studium ist es sogar fatal, da darauf ja später auch aufgesetzt wird.
> 
> Und wir kriegen Code Schnipsel und sollen sagen, ob es funktioniert?
> Zu jeder Entwicklung gehört die QA, sprich die Tests, ob es funktioniert. Also hast du dir Gedanken zu den Tests gemacht, die notwendig sind?
> ...


Das ist aber nicht an erster Stelle.
Das wichtigste ist erstmal dass ich die Compare Methode und den notwendigen Stuff mache um das zu sortieren.


----------



## thecain (20. Apr 2019)

Na dann los, du sagst es ja richtig. DU musst das machen, nicht WIR


----------



## AndiE (20. Apr 2019)

Das ist mir zu undurchsichtig. Wieso erstellst du nicht erst einmal eine einfache verkettete Liste mit den Klassen Item und ItemList. Also nicht generisch. Dann kannst du erst einmal ausprobieren, wie man sich von Objekt zu Objekt durchhangelt. Außerdem ist dein "insert" ein "append", da es die Objekte immer am Ende einfügt. Ein "insert" würde sie aber da einfügen, wo gerade das aktuelle Element ist, entweder davor oder danach.Und dann würde ich die Objekte auch mit "String" befüllen, um so die Sortierreihenfolge und den Inhalt voneinander abgrenzen zu können. Aus "ADCBE" soll ja "ABCDE" werden. Auf jeden Fall ist auch ein "delete" notwendig, um Objekte an der aktuellen Prosition zu löschen. 

Und dann wäre es gut, wenn es OOP wäre, dazu ist JAVA ja da.


----------



## Heyoka955 (20. Apr 2019)

AndiE hat gesagt.:


> Das ist mir zu undurchsichtig. Wieso erstellst du nicht erst einmal eine einfache verkettete Liste mit den Klassen Item und ItemList. Also nicht generisch. Dann kannst du erst einmal ausprobieren, wie man sich von Objekt zu Objekt durchhangelt. Außerdem ist dein "insert" ein "append", da es die Objekte immer am Ende einfügt. Ein "insert" würde sie aber da einfügen, wo gerade das aktuelle Element ist, entweder davor oder danach.Und dann würde ich die Objekte auch mit "String" befüllen, um so die Sortierreihenfolge und den Inhalt voneinander abgrenzen zu können. Aus "ADCBE" soll ja "ABCDE" werden. Auf jeden Fall ist auch ein "delete" notwendig, um Objekte an der aktuellen Prosition zu löschen.
> 
> Und dann wäre es gut, wenn es OOP wäre, dazu ist JAVA ja da.


Ja aber denke das reicht jetzt firm Anfang.


----------



## mihe7 (21. Apr 2019)

kneitzel hat gesagt.:


> Ich habe eben mal schnell ins frei verfügbare Java ist auch eine Insel geschaut, aber das scheint nur die normale for Schleife zu behandeln....







__





						Klassen und Objekte
					





					openbook.rheinwerk-verlag.de


----------



## kneitzel (21. Apr 2019)

mihe7 hat gesagt.:


> __
> 
> 
> 
> ...


Super, danke. War ich offensichtlich blind und hab zu schnell/kurz geschaut.

Ist auch eine schöne Box bezüglich Iterable ... Also reicht das freie Buch auch für sowas voll und ganz aus!


----------



## mihe7 (21. Apr 2019)

kneitzel hat gesagt.:


> War ich offensichtlich blind und hab zu schnell/kurz geschaut.


Ich habe es auch erst nicht gefunden (man würde ja annehmen, dass das unter den Schleifen steht). Da ich nicht glauben konnte, dass das Thema nicht behandelt wird, bin ich mal weiter bis zu Arrays...


----------



## Heyoka955 (21. Apr 2019)

kneitzel hat gesagt.:


> Super, danke. War ich offensichtlich blind und hab zu schnell/kurz geschaut.
> 
> Ist auch eine schöne Box bezüglich Iterable ... Also reicht das freie Buch auch für sowas voll und ganz aus!


ich habe keine ahnug wie ich das sortieren soll. DAs ist derzeit mein code.



```
public void sortingLL(){
  ListNode<T> current = first;
  ListNode<T> c = current.getNext();
  
  
  for(int i = 1; i < size(); i++) {
   for(int j = 0; j < size(); j++){
    if(current.value.compareTo(c.value) <= 0){
     
     
     
     
    }
    current = current.getNext();
    
    
    
    
    
   }
   
   
   c = c.getNext();
   
   
   
  }
  
       
    
    
    
 }
```


----------



## kneitzel (21. Apr 2019)

Also es gibt zwei Möglichkeiten:

a) du sortiert die Liste erst auf Aufruf. das hat den Vorteil, dass du viel Zeit verballerst, wenn du es sortieren musst, aber dafür geht das Einfügen schneller.

b) du hast generell eine sortierte Liste. Dann brauchst Du keinen Sortier Aufruf mehr. Das Einfügen dauert dann aber halt etwas länger....

Generell macht es durchaus Sinn, b) zu wählen. Dann musst Du Dir nur Gedanken machen, wie das mit dem Einfügen gebaut werden soll. Wenn du es nach a) machen willst, dann müsstest Du Dir erst einmal Gedanken machen, wie Du sortieren willst. Da gibt es diverse Ansätze. Bubble Sort wäre da eine einfache Alternative.

Egal, was Du wie machen willst: Der erste Schritt ist immer, dass Du Dir Gedanken machst, wie etwas funktionieren soll. Formulier es aus in einer Art Pseudo Code. Spiel es ggf. auf einem Zettel etwas durch. Erst dann kannst Du es implementieren. Ohne genaue Vorstellung wirst Du kaum eine Chance haben, etwas funktionierendes zu entwickeln.


----------



## Heyoka955 (21. Apr 2019)

Antwort


kneitzel hat gesagt.:


> Also es gibt zwei Möglichkeiten:
> 
> a) du sortiert die Liste erst auf Aufruf. das hat den Vorteil, dass du viel Zeit verballerst, wenn du es sortieren musst, aber dafür geht das Einfügen schneller.
> 
> ...


ich hatte an bubblesort gedacht aber wie greife ich auf die werte zu wenn diese fehler kommen.


----------



## kneitzel (21. Apr 2019)

Wenn solche Fehler kommen schaut man sich die Java Grundlagen an. Was für Vergleiche gibt es? Und dann nutzt man, was es eben gibt.

Daher immer der Hinweis, dass Du Dir doch die Java Grundlagen erarbeiten solltest. In diesem Fall wäre https://docs.oracle.com/javase/tutorial/java/nutsandbolts/opsummary.html eine Seite, die das Notwendige enthält. Java ist eine Insel wird das aber bestimmt auch haben und das Buch Java The Complete Reference selbstverständlich auch.

Wenn du Englisch sprichst, dann lernst Du das doch auch. Grammatik, Vokabeln, ... Du gehst doch nicht hin und sagst: Ich kann Deutsch, das wird schon irgendwie gehen.


----------



## Heyoka955 (21. Apr 2019)

kneitzel hat gesagt.:


> Wenn solche Fehler kommen schaut man sich die Java Grundlagen an. Was für Vergleiche gibt es? Und dann nutzt man, was es eben gibt.
> 
> Daher immer der Hinweis, dass Du Dir doch die Java Grundlagen erarbeiten solltest. In diesem Fall wäre https://docs.oracle.com/javase/tutorial/java/nutsandbolts/opsummary.html eine Seite, die das Notwendige enthält. Java ist eine Insel wird das aber bestimmt auch haben und das Buch Java The Complete Reference selbstverständlich auch.
> 
> Wenn du Englisch sprichst, dann lernst Du das doch auch. Grammatik, Vokabeln, ... Du gehst doch nicht hin und sagst: Ich kann Deutsch, das wird schon irgendwie gehen.


Habe ich aber hatte nix gefunden


<<      Signed left shift
>>      Signed right shift


Was soll ich damit anfangen ? Also ich kann das nicht so gut interpretieren. Das hat eher was mit Syntax Fehler zu tun.

Also


----------



## Heyoka955 (22. Apr 2019)

Heyoka955 hat gesagt.:


> Habe ich aber hatte nix gefunden
> 
> 
> <<      Signed left shift
> ...





kneitzel hat gesagt.:


> Wenn solche Fehler kommen schaut man sich die Java Grundlagen an. Was für Vergleiche gibt es? Und dann nutzt man, was es eben gibt.
> 
> Daher immer der Hinweis, dass Du Dir doch die Java Grundlagen erarbeiten solltest. In diesem Fall wäre https://docs.oracle.com/javase/tutorial/java/nutsandbolts/opsummary.html eine Seite, die das Notwendige enthält. Java ist eine Insel wird das aber bestimmt auch haben und das Buch Java The Complete Reference selbstverständlich auch.
> 
> Wenn du Englisch sprichst, dann lernst Du das doch auch. Grammatik, Vokabeln, ... Du gehst doch nicht hin und sagst: Ich kann Deutsch, das wird schon irgendwie gehen.





Heyoka955 hat gesagt.:


> Habe ich aber hatte nix gefunden



Sorry hbe das falsche Bild gesendet, den Fehler hatte ich längst gebugged.

Es komtm der Fehler >> expected.


----------



## Tarrew (22. Apr 2019)

Welcher Code führt zu welchem Fehler?

Hier hat keiner Lust Rätselraten zu spielen, bei den unvollständigen Infos, die du immer raushaust.


----------



## Heyoka955 (22. Apr 2019)

Tarrew hat gesagt.:


> Welcher Code führt zu welchem Fehler?
> 
> Hier hat keiner Lust Rätselraten zu spielen, bei den unvollständigen Infos, die du immer raushaust.


Die if Bedingung wo ich get value vergleiche


----------



## Heyoka955 (22. Apr 2019)

Tarrew hat gesagt.:


> Nur weil deine generischen Typen beide "T" heißen, haben die nichts miteinander zu tun.
> Wenn du also in der ListNode Klasse sagt "ListNode<T extends Comparable<T>>"
> und in deiner LinkedList-Klasse wieder "T" verwendest, bedeutet das nicht, dass dieses T wieder Comparable implementiert.
> 
> ...


Also diese Stelle, ich habe den Fehler da gefixt aber der zeigt einen Fehler wo er expected <<>> .


----------



## mihe7 (22. Apr 2019)

Was ist `=<`?


----------



## Heyoka955 (22. Apr 2019)

mihe7 hat gesagt.:


> Was ist `=<`?


Sollte größer gleich sein.
Aber da war Fehler weil ich zu schnell tipopte


----------



## mihe7 (22. Apr 2019)

Heyoka955 hat gesagt.:


> weil ich zu schnell tipopte


Tippfehler hin oder her: der Punkt ist, dass Du über eine Stunde wegen eines Fehlers nicht weiterkommst, den man mit ein wenig Übung selbst ohne IDE auf den ersten Blick sieht. Wenn man mit der Großzügigkeit bis zum Äußersten geht, dann darf es mit Hilfe der IDE keinesfalls länger als 5 Minuten dauern, um einen solchen Fehler zu erkennen und zu beheben.


----------



## Heyoka955 (22. Apr 2019)

mihe7 hat gesagt.:


> Tippfehler hin oder her: der Punkt ist, dass Du über eine Stunde wegen eines Fehlers nicht weiterkommst, den man mit ein wenig Übung selbst ohne IDE auf den ersten Blick sieht. Wenn man mit der Großzügigkeit bis zum Äußersten geht, dann darf es mit Hilfe der IDE keinesfalls länger als 5 Minuten dauern, um einen solchen Fehler zu erkennen und zu beheben.


Geany

Aber was ist denn jetzt mit meinem Bug den ich habe. Du hast den Fehler nicht ganz verstanden der Fehler ist nicht dass <= sondern dass er die Werte nicht vergleichen knn die im
Objekt gespeichert sind.
Da komtm eine Fehlermeldung!


----------



## thecain (22. Apr 2019)

Ja, weil du die Generics Grundlagen nicht verstehst...


----------



## kneitzel (22. Apr 2019)

Also die Grundlagen sind sehr wichtig. Die Seite, die ich genannt hatte, hat auch die Vergleichs-Operatoren aufgelistet. Das war ja erst einmal der erste ganz offensichtliche Fehler.

Und dann kommen wir zu dem nächsten Punkt: Verständnis der Aufgabe. Was hast Du bzw. was wurde denn gemacht, dass die Werte der implementierten Liste vergleichbar sind? Wenn Du Dir das anschaust dann solltest Du wissen, wie Du Werte vergleichen kannst.
=> Es ist existenziell, den Code zu verstehen!


----------



## mihe7 (22. Apr 2019)

Heyoka955 hat gesagt.:


> Aber was ist denn jetzt mit meinem Bug den ich habe. Du hast den Fehler nicht ganz verstanden der Fehler ist nicht dass <= sondern dass er die Werte nicht vergleichen knn die im
> Objekt gespeichert sind.
> Da komtm eine Fehlermeldung!


Der Punkt ist: Du erkennst triviale Dinge nicht bzw. brauchst hierzu viel zu lange. Es bringt Dir nichts, Dich in irgendwelchen Ausreden zu flüchten: "Ich arbeite schnell", "Ich tippe zu schnell", "Ich programmiere erst seit Dezember" etc. etc. Es interessiert später niemanden, was _Du_ für ein Problem hattest, wenn etwas nicht so läuft, wie es soll.


----------



## Heyoka955 (22. Apr 2019)

mihe7 hat gesagt.:


> Tippfehler hin oder her: der Punkt ist, dass Du über eine Stunde wegen eines Fehlers nicht weiterkommst, den man mit ein wenig Übung selbst ohne IDE auf den ersten Blick sieht. Wenn man mit der Großzügigkeit bis zum Äußersten geht, dann darf es mit Hilfe der IDE keinesfalls länger als 5 Minuten dauern, um einen solchen Fehler zu erkennen und zu beheben.





kneitzel hat gesagt.:


> Also die Grundlagen sind sehr wichtig. Die Seite, die ich genannt hatte, hat auch die Vergleichs-Operatoren aufgelistet. Das war ja erst einmal der erste ganz offensichtliche Fehler.
> 
> Und dann kommen wir zu dem nächsten Punkt: Verständnis der Aufgabe. Was hast Du bzw. was wurde denn gemacht, dass die Werte der implementierten Liste vergleichbar sind? Wenn Du Dir das anschaust dann solltest Du wissen, wie Du Werte vergleichen kannst.
> => Es ist existenziell, den Code zu verstehen!






das ist der fehler , wenn ich es mit compare to mache tritt auch ein fehler auf


----------



## kneitzel (22. Apr 2019)

Der Fehler ist und schon klar. Aber du scheinst erkannt zu haben, dass das Comparable ein Ansatz sein sollte. Was hast Du denn da probiert? Wie ist das denn prinzipiell zu verwenden?

Nur als kleine Erläuterung: Java bietet ein Überladen von Operatoren. Daher kann man Instanzen eben nicht generell mit Operatoren nutzen (Abgesehen von gewissen Dingen, die für Object erlaubt sind, wie z.B. ==)
Das ist in anderen Sprachen anders, also z.B. C++ oder c#: Das hat dann z.B. zur Folge, dass man Instanzen von Klassen (z.B. Strings) per == sinnvoll vergleichen kann und eben kein equals nutzen muss.
(Das nur am Rande, denn wer Informatik studiert, der sollte doch etwas mehr sehen als nur die Sprache selbst sondern etwas abstrahieren und dann so einen besseren Überblick bekommen ... hilft dann auch beim lernen neuer Sprachen und so.)


----------



## Heyoka955 (22. Apr 2019)

kneitzel hat gesagt.:


> Der Fehler ist und schon klar. Aber du scheinst erkannt zu haben, dass das Comparable ein Ansatz sein sollte. Was hast Du denn da probiert? Wie ist das denn prinzipiell zu verwenden?
> 
> Nur als kleine Erläuterung: Java bietet ein Überladen von Operatoren. Daher kann man Instanzen eben nicht generell mit Operatoren nutzen (Abgesehen von gewissen Dingen, die für Object erlaubt sind, wie z.B. ==)
> Das ist in anderen Sprachen anders, also z.B. C++ oder c#: Das hat dann z.B. zur Folge, dass man Instanzen von Klassen (z.B. Strings) per == sinnvoll vergleichen kann und eben kein equals nutzen muss.
> (Das nur am Rande, denn wer Informatik studiert, der sollte doch etwas mehr sehen als nur die Sprache selbst sondern etwas abstrahieren und dann so einen besseren Überblick bekommen ... hilft dann auch beim lernen neuer Sprachen und so.)


equals kenne ich aber hilft nicht weiter, ich glaube der bug liegt an compareabla. ich muss schauen wie ich das vergleichenn kann.

habe keinen ansatz derzeit



ich muss meinen compareto selbst implementieren denke ich mal.


----------



## kneitzel (22. Apr 2019)

Heyoka955 hat gesagt.:


> equals kenne ich aber hilft nicht weiter, ich glaube der bug liegt an compareabla. ich muss schauen wie ich das vergleichenn kann.
> 
> habe keinen ansatz derzeit


Das mit dem equals am Ende war nur ein Beispiel für das überladen von Operatoren was in anderen Sprachen teilweise möglich ist, aber eben nicht in Java. Das wäre etwas, das interessant sein könnte für jemanden, der etwas mit Informatik studiert....

Und ja, bei Deiner Aufgabe wird Comparable genutzt, also sollte man sich das einmal im Detail ansehen. Hätte man schon machen sollen, direkt nachdem man dieses Comparable das erste mal erblickt hat, denn ohne ein Verständnis von Comparable kann man ja nicht den Code verstehen, der eben genau dies nutzt....


----------



## Heyoka955 (22. Apr 2019)

kneitzel hat gesagt.:


> Das mit dem equals am Ende war nur ein Beispiel für das überladen von Operatoren was in anderen Sprachen teilweise möglich ist, aber eben nicht in Java. Das wäre etwas, das interessant sein könnte für jemanden, der etwas mit Informatik studiert....
> 
> Und ja, bei Deiner Aufgabe wird Comparable genutzt, also sollte man sich das einmal im Detail ansehen. Hätte man schon machen sollen, direkt nachdem man dieses Comparable das erste mal erblickt hat, denn ohne ein Verständnis von Comparable kann man ja nicht den Code verstehen, der eben genau dies nutzt....


ich will phyton lernen etc, aber erst die Grundlagen von java. Csharp ist cool und viele unternehmen verwenden c++


----------



## Heyoka955 (22. Apr 2019)

kneitzel hat gesagt.:


> Das mit dem equals am Ende war nur ein Beispiel für das überladen von Operatoren was in anderen Sprachen teilweise möglich ist, aber eben nicht in Java. Das wäre etwas, das interessant sein könnte für jemanden, der etwas mit Informatik studiert....
> 
> Und ja, bei Deiner Aufgabe wird Comparable genutzt, also sollte man sich das einmal im Detail ansehen. Hätte man schon machen sollen, direkt nachdem man dieses Comparable das erste mal erblickt hat, denn ohne ein Verständnis von Comparable kann man ja nicht den Code verstehen, der eben genau dies nutzt....


ich habe eine kline frage sollte man das compareable implmenetieren oder erben?

mein prof hat extends geschrieben aber irgendwie steht in internet implememnts, da dies ein iinterface ist.


----------



## Heyoka955 (22. Apr 2019)

Das funktioniert auch nicht ...


----------



## kneitzel (22. Apr 2019)

Womit wir wieder beim Thema Grundlagen sind. Jetzt würde es mich nicht mehr wundern, wenn jemand das ganze Buch "Java ist auch eine Insel" hier einmal als Antwort postet.

Generics - Einschränken der Typen über Bounds: http://openbook.rheinwerk-verlag.de/javainsel/10_003.html#u10.3

Lesen - dann verstehst Du hoffentlich, warum der Professor extends im Code geschrieben hat (Denn das ist halt so vorgegeben)

Dann hast Du eine Instanz von der Klasse erzeugen können mit einem bestimmten Typ. Wenn das geklappt hat, dann hat der Typ wohl die Anforderungen an T der generischen Klasse erfüllt..... => Also muss da kein Comparable mehr implementiert werden, weil das schon der Fall ist.

*Collections.sort*
Du hast da was gefunden und willst es nutzen. Aber du hast darüber selbst nichts gelesen oder recherchiert. Wenn Du eine Klasse nutzen willst, dann lies darüber etwas! Wenn Du eine Klasse des Java Frameworks nutzen willst, dann such bei google nach "Oracle <Klassenname|Interfacename> class|interface" also in diesem konkreten Fall "Oracle Collections class" und dann solltest Du Treffer bekommen, die heissen: <Klassenname> (Java Platform SE<Version>) - Oracle Docs, also jetzt in diesem Fall Collections (Java Platform SE7) - Oracle Docs. Das klickt man dann an und dann sieht man ja, was da so definiert ist.

Und dann siehst Du genau, was die sort Funktion für Parameter hat und was da erfüllt sein muss. So erwartet die Funktion ein List<T> mit T extends Comparable. List ist dabei ein Link, auf den Du als nächstes klicken solltest und dann siehst Du, was das genau ist.
Und siehe da: Das ist ein Interface. Implementiert Deine Klasse dieses Interface? Wenn nein, dann kannst Du eine Instanz von deiner Klasse da nicht übergeben. (Womit wir wieder beim Thema Java Grundlagen sind.)

Dir wird seid mindestens 11. April gesagt, dass Du die Java Grundlagen lernen solltest. Hast Du damit wenigstens schon einmal angefangen? Was machst Du um die Grundlagen zu lernen und wie weit bist du bereits? Java ist auch eine Insel wurde mehrfach vorgeschlagen... Das wäre eine Option. Generell war bei uns die Erwartungshaltung der Profs, dass wir eine neue Sprache in 2 Tagen Vollzeit lernen können. Teilzeit waren sie damals großzügig: 2 Wochen. Aber nach den zwei Wochen ging es dann auch gleich richtig zur Sache und da gab es dann keine Ausreden ... 
Und hier würde ich auch bald dazu über gehen, dass ich nur noch Verweise auf das Kapitel in Java is auch eine Insel poste, sobald offensichtlich ist, dass da eine Grundlage schlicht fehlt.


----------



## Heyoka955 (22. Apr 2019)

kneitzel hat gesagt.:


> Womit wir wieder beim Thema Grundlagen sind. Jetzt würde es mich nicht mehr wundern, wenn jemand das ganze Buch "Java ist auch eine Insel" hier einmal als Antwort postet.
> 
> Generics - Einschränken der Typen über Bounds: http://openbook.rheinwerk-verlag.de/javainsel/10_003.html#u10.3
> 
> ...


mache ich aber ich änder gerade meine ganze klasse !


----------



## kneitzel (22. Apr 2019)

Also ich weiss nicht, was du da machst. Ich würde nicht die ganze Klasse ändern. Ich mein, dass ich auch schon einmal geschrieben habe, wo und wie das lösbar wäre. Die Idee war, schon beim Einfügen auf die Sortierung zu achten ....

Aber klar: manchmal muss man eine Klasse umschreiben oder neu schreiben ... Muss also nicht falsch sein. Aber statt blind umher zu irren, könnte es besser sein, erst Mal mehr Zeit für Grundlagen zu opfern.


----------



## Heyoka955 (22. Apr 2019)

kneitzel hat gesagt.:


> Also ich weiss nicht, was du da machst. Ich würde nicht die ganze Klasse ändern. Ich mein, dass ich auch schon einmal geschrieben habe, wo und wie das lösbar wäre. Die Idee war, schon beim Einfügen auf die Sortierung zu achten ....
> 
> Aber klar: manchmal muss man eine Klasse umschreiben oder neu schreiben ... Muss also nicht falsch sein. Aber statt blind umher zu irren, könnte es besser sein, erst Mal mehr Zeit für Grundlagen zu opfern.




```
public class ListNode<T extends Comparable<T>> {
    ListNode head;
    T value;
    ListNode next;
    
    
    public ListNode(T value){
        
        this.value=value;
        
        
    }
    
    
    
    public void insert( T newvalue){
        
    
        
        head = new ListNode(newvalue);
        
        
    }
    
    public void printList(String a){
        System.out.print(a + value);
        a += " ";
        if(head != null){
            head.printList(a);
            
            
            
        }
        
        
    }
        
        
    public void sorting(){
        ListNode current = head;
        ListNode currentvor = current.next;
        
        for(int i= 1; i < 4; i++){
            for(int j = 0; i < 4; i++){
                if(current.value.compareTo(currentvor.value) < 0){
                    
                    
                    
                    
                }
                
                
                
            }
            
            
            
            
        }
        
        
        
        
    }   
        
    
    
    
    bitteschön. jetzt muss ich nun wissen wie ich die beiden weirte vergleiche
```


----------



## kneitzel (22. Apr 2019)

Also wenn ich mir etwas erarbeiten will, dann nutze ich nie ein komplexes Projekt. Ich nutze da immer ein kleinen, abgeschlossenen Bereich, den ich dafür dann verwende.

Du willst Dir Compareable erabeiten. Also könnte man erst einmal das Interface ansehen. Die Doku bietet da sehr viele Informationen, u.a. welche Klassen das Interface alle implementieren. Da kann man sich dann etwas raussuchen. Was genau, ist eigentlich egal. Sollte nichts zu komplexes sein. Ich habe einfach einmal Long genommen.

Damit kann man dann etwas experimentieren:

```
package comparable;

public class ComparableExample {
    public static void main (String[] args) {
        Long firstNumber = 10l;
        Long secondNumber = 1l;

        System.out.println(firstNumber.compareTo(secondNumber));
    }
}
```

Da kann man die Werte verändern und schauen, was da wann wie raus kommt. (So die Dokumentation von Comparable nicht reicht. Die kann aber auch schon reichen:



> int compareTo(T o)
> Compares this object with the specified object for order. Returns a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object.
> The implementor must ensure sgn(x.compareTo(y)) == -sgn(y.compareTo(x)) for all x and y. (This implies that x.compareTo(y) must throw an exception iff y.compareTo(x)throws an exception.)
> The implementor must also ensure that the relation is transitive: (x.compareTo(y)>0 && y.compareTo(z)>0) implies x.compareTo(z)>0.
> ...


----------



## Heyoka955 (22. Apr 2019)

o


kneitzel hat gesagt.:


> Also wenn ich mir etwas erarbeiten will, dann nutze ich nie ein komplexes Projekt. Ich nutze da immer ein kleinen, abgeschlossenen Bereich, den ich dafür dann verwende.
> 
> Du willst Dir Compareable erabeiten. Also könnte man erst einmal das Interface ansehen. Die Doku bietet da sehr viele Informationen, u.a. welche Klassen das Interface alle implementieren. Da kann man sich dann etwas raussuchen. Was genau, ist eigentlich egal. Sollte nichts zu komplexes sein. Ich habe einfach einmal Long genommen.
> 
> ...


okay das verstehe ich, die Methode sorgt dazu ob das objekt das die Methode aufruft größer oder kleiner ist aber wie hilft mir das weiter bezüglich von bubblesort?

achso okay glaube ich habe es, 

ich könnte die werte vergleichen dass wenn das objekt das den parameter aufruft gleich 1 ist, dann heißt es ja dass dann dieses objekt größer ist als das objekt das in paramter übergeben wird und dadurch kann ich das dann bestimmen welcher größer ist, vllt weiß ich nicht die werte genau aber ich weiß welches größer ist.

Schonmal riesen anfang


----------



## Heyoka955 (22. Apr 2019)

```
public class ListNode<T extends Comparable<T>> {
    ListNode head = null;
    T value;
    ListNode next;
    
    
    public ListNode(T value){
        
        this.value=value;
        
        
    }
    
    
    
    public void insert( T newvalue){
        if(head == null){
             head = new ListNode(newvalue);
             head.next = null;
             return;
         }
        
        
        
        ListNode current = head; //gehe anfang durch
        
        while(current != null){
            
            if(newvalue.compareTo(current.value) == 1 && newvalue.compareTo(current.next.value) < 0){ 
                
                current.next = new ListNode(newvalue); //der derzeitige zeiger zeigt auf den einfügenden knoten
                
                current.next = current.next.next; //der zeiger der eingefügt wurde zeigt auf das Objekt, das größer ist als er.
                return;
            }
            current = current.next; //gehe einen schritt weiter
            
            
        }
        
        
        
    }
    
    public void printList(String a){
        System.out.print(a + value);
        a += " ";
        if(head != null){
            head.printList(a);
            
            
            
        }
        
        
    }
        
        

    
    
    public int size() {
        
        ListNode<T> current = head;
        int count = 0;
        
        while(current != null){
            
            count++;
            current = current.next;
            
            
        }
        
        return count;
        
        
        
        

    }   
        
    
    
    
}
```


----------



## kneitzel (22. Apr 2019)

Thema Generics: Wie definiert man eine Instanz von einer Generics Klasse?
Und wie definierst Du Instanzen von ListNode innerhalb Deiner ListNode Klasse?


----------



## Heyoka955 (22. Apr 2019)

kneitzel hat gesagt.:


> Thema Generics: Wie definiert man eine Instanz von einer Generics Klasse?
> Und wie definierst Du Instanzen von ListNode innerhalb Deiner ListNode Klasse?


Node<T> = new node<T>;


----------



## kneitzel (22. Apr 2019)

Heyoka955 hat gesagt.:


> Node<T> = new node<T>;


Und wie hast Du in Deiner Klasse Instanzen von ListNode definiert? Einmal innerhalb der insert Methode und einmal außerhalb der Methode?


----------



## Heyoka955 (22. Apr 2019)

kneitzel hat gesagt.:


> Und wie hast Du in Deiner Klasse Instanzen von ListNode definiert? Einmal innerhalb der insert Methode und einmal außerhalb der Methode?


einmal als Instanz variable für head . und einmals als hilfsvariable als current


----------



## mihe7 (22. Apr 2019)

Heyoka955 hat gesagt.:


> einmal als Instanz variable für head . und einmals als hilfsvariable als current


Wo ist da der Typparameter?


----------



## Heyoka955 (22. Apr 2019)

mihe7 hat gesagt.:


> Wo ist da der Typparameter?


muss man die typ paramrer mit erwähnen?


----------



## mihe7 (22. Apr 2019)

Überall, wo Du ListNode verwendest.

Nachtrag: vergleiche z. B. mal current in Methode size() mit current in Methode insert().


----------



## Heyoka955 (22. Apr 2019)

mihe7 hat gesagt.:


> Überall, wo Du ListNode verwendest.
> 
> Nachtrag: vergleiche z. B. mal current in Methode size() mit current in Methode insert().


hab es gemacht, funktioniert jetzt, aber meine insert Methode ist leider falsch, irgendwie funktioniert das nicht wirklich, was ich erdacht hatte.


----------



## mihe7 (22. Apr 2019)

Heyoka955 hat gesagt.:


> hab es gemacht, funktioniert jetzt,


Das glaub ich kaum.


----------



## kneitzel (22. Apr 2019)

mihe7 hat gesagt.:


> Das glaub ich kaum.


Naja .. der Compile Fehler ist erst mal weg, also ein Schritt näher dran. Aber wir sind ja auch noch unter 100 ... da geht also noch einiges bis 500 ....


----------



## Heyoka955 (22. Apr 2019)

mihe7 hat gesagt.:


> Das glaub ich kaum.


ne der bug ist weg aber das program bleibt stehen, es printet nur die 5 raus


habe mal mein insert code auskommentiert und mal das normale einfügen gemacht und das hat geklappt.

also meine insert methode hat leider einen bug

```
public void insert( T newvalue){

        
        
        
        if(head == null){
             head = new ListNode<T>(newvalue);
             head.next = null;
             return;
         }
        
        
        ListNode<T> newnode = new ListNode<T>(newvalue);
        
        
        ListNode<T> current = head;
        
        while(current != null){
            
            if(newvalue.compareTo(current.value) == 1 && newvalue.compareTo(current.next.value) < 0){ 
                
                newnode.next = current.next;
                current.next = newnode;
            }
            current = current.next;
            
            
        }
        
        
        
        
        
        
        
        
    }
```


----------



## mihe7 (22. Apr 2019)

kneitzel hat gesagt.:


> Aber wir sind ja auch noch unter 100 ... da geht also noch einiges bis 500 ....


OMG. 



Heyoka955 hat gesagt.:


> ne der bug ist weg aber das program bleibt stehen, es printet nur die 5 raus


Sag ich doch: es funktioniert nicht.

Schau Dir mal die Bedingung der if-Abfrage sowie den then-Zweig genau an. Ggf. kannst Du auch das while umschreiben. Aber ich überlasse das weitere Procedere besser @kneitzel


----------



## kneitzel (22. Apr 2019)

Also schau doch nur, was du da machst... current.next wird das einzufügende Element und dann im nächsten Befehl setzt du current.next wieder und überschreibst damit den Verweis auf das neue Element.

Und der Zugriff auf current.next.value scheint auch dubios zu sein. next kann ja null sein und dann sollte da eine NPE kommen.....


----------



## kneitzel (22. Apr 2019)

mihe7 hat gesagt.:


> OMG.
> 
> 
> Sag ich doch: es funktioniert nicht.
> ...


Danke, du bist zu gütig ...


----------



## mihe7 (22. Apr 2019)

kneitzel hat gesagt.:


> Danke, du bist zu gütig ...


Ja, so bin ich nun mal. Schrei einfach, wenn Du's nicht mehr aushältst.


----------



## Tarrew (22. Apr 2019)

Ich will mal die 100 vollmachen und sagen, dass dieser Thread mal wieder ein Beweis für die unendliche Geduld von einigen Mitgliedern hier ist.

Ist ja echt unglaublich, wie man da teilweise noch ruhig bleiben kann, bei mir schwankt es zwischenzeitlich echt zwischen Wut, Verzweifelung, Belustigung und tiefer Trauer


----------



## mihe7 (22. Apr 2019)

Tarrew hat gesagt.:


> bei mir schwankt es zwischenzeitlich echt zwischen Wut, Veruweifelung, Belustigung und tiefer Trauer


Kommt mir bekannt vor.


----------



## Heyoka955 (22. Apr 2019)

kneitzel hat gesagt.:


> Also schau doch nur, was du da machst... current.next wird das einzufügende Element und dann im nächsten Befehl setzt du current.next wieder und überschreibst damit den Verweis auf das neue Element.
> 
> Und der Zugriff auf current.next.value scheint auch dubios zu sein. next kann ja null sein und dann sollte da eine NPE kommen.....


ich habe das jetzt returnt aber es kommt immernoch nix raus außer die 5


----------



## kneitzel (22. Apr 2019)

Tarrew hat gesagt.:


> Ich will mal die 100 vollmachen und sagen, dass dieser Thread mal wieder ein Beweis für die unendliche Geduld von einigen Mitgliedern hier ist.
> 
> Ist ja echt unglaublich, wie man da teilweise noch ruhig bleiben kann, bei mir schwankt es zwischenzeitlich echt zwischen Wut, Verzweifelung, Belustigung und tiefer Trauer


Ach was ... Gibt doch schlimmeres ... Könnte ja Geschichten erzählen, die ich z.B. bei der Feuerwehr erlebt habe .... Da zweifelt man am GMV (Gesunder Menschen Verstand).

Da ist das doch noch relativ harmlos....

Und soll ich euch eine Schlaflose Nacht bescheren? Ich habe gehört, dass er morgen bei euch im Team als Software Entwickler anfangen soll ....

Das ist doch besser als jeder Horror Film


----------



## mihe7 (22. Apr 2019)

kneitzel hat gesagt.:


> Ich habe gehört, dass er morgen bei euch im Team als Software Entwickler anfangen soll ....


Achtung, es könnte sein, dass Kinder mitlesen.


----------



## kneitzel (22. Apr 2019)

Heyoka955 hat gesagt.:


> ich habe das jetzt returnt aber es kommt immernoch nix raus außer die 5


Ich weiss nicht, was du wo zurück gegeben hast, aber evtl. ist es an der Zeit das Debuggen zu üben. Oder einfach noch einmal mit Papier und Stift genau überlegen, welche Fälle es alle gibt und was du da erwartest. (Einfügen in leere Liste, mit Wert an den Anfang, ans Ende und zwischen zwei Werte...)


----------



## Xyz1 (22. Apr 2019)

kneitzel hat gesagt.:


> Und soll ich euch eine Schlaflose Nacht bescheren?





Spoiler: Kinder dürfen das nicht lesen:


----------



## Heyoka955 (23. Apr 2019)

Hab alles durch den Kopf gehen lassen.

Laut meiner Auffassung musste der Fehler bei 

Newnode.next= current.next;

Es müsste heißen newnode = current.next;

Hab es leider nicht ausgetestet denn habe Laptop nicht mit aber würde mich aufn Statement freuen.


----------



## kneitzel (23. Apr 2019)

Heyoka955 hat gesagt.:


> Hab alles durch den Kopf gehen lassen.
> 
> Laut meiner Auffassung musste der Fehler bei
> 
> ...


Also Du brauchst erst einmal keinen Laptop. Alles was Du brauchst ist ein Stift und ein leeres Blatt Papier.

Und dann überlegst Du Dir alle Fälle, die es geben könnte (und die ich Dir sogar schon genannt habe!).

Und dann malst Du Dir das richtig auf, d.h. ein ListNode ist dann ein Kästchen mit mehreren Feldern für alles, was da so drin ist (value und next habe ich jetzt im Kopf).

Und bei Referencen machst Du einfach einen Pfeil.

Erster Fall: Liste leer. Also Head enthält null. Wenn das der Fall ist, dann muss head auf das neue Element zeigen und das das next vom neuen Element behält null. => Super, das scheinst Du in Deinem Code schon zu haben.

Zweiter Fall: Liste nicht leer, Eingefügt werden soll am Anfang der Liste. Mal es Dir auf und dann sag, was wie gesetzt werden muss!

Dritter Fall: Liste nicht leer, Eingefügt werden soll zwischen zwei Elementen. Auch hier wieder aufmalen und dann kannst Du sagen, was gesetzt werden muss. (Das scheinst Du in Deinem Code auch schon zu haben. Hattest Du zu dem Code davor schon angepasst. Aber die Schleife stimmt so noch nicht und das Problem habe ich auch schon genannt meine ich!)

Vierter Fall: Liste nicht leer, Eingefügt werden soll am Ende. Aufmalen und dann kannst Du sagen, was da wie gesetzt werden muss.

Also selbst ich male mir sowas immer auf. Visualisieren ist extrem wichtig! Ansonsten geht schnell etwas schief. Ok, einfach verkettete Liste ist trivial, aber es geht auch komplexer z.B. binärer, ausbalancierter Suchbaum ist schon etwas komplexer mit den Drehungen rechts oder links nach dem Einfügen .... Da hilft (bei mir) nur das Durchspielen auf einem Zettel.


----------



## Heyoka955 (23. Apr 2019)

kneitzel hat gesagt.:


> Also Du brauchst erst einmal keinen Laptop. Alles was Du brauchst ist ein Stift und ein leeres Blatt Papier.
> 
> Und dann überlegst Du Dir alle Fälle, die es geben könnte (und die ich Dir sogar schon genannt habe!).
> 
> ...


Ich hatte mit Stift und Papier nur die Falle abgedeckt am Anfang wenn Head = null ist und einfügen in der Mitte.
Ich gehe das durch später.


----------



## Heyoka955 (23. Apr 2019)

kneitzel hat gesagt.:


> Also Du brauchst erst einmal keinen Laptop. Alles was Du brauchst ist ein Stift und ein leeres Blatt Papier.
> 
> Und dann überlegst Du Dir alle Fälle, die es geben könnte (und die ich Dir sogar schon genannt habe!).
> 
> ...


er vertauscht die werte die er einfügt aber irgendwie gibt er die 5 nicht aus?




```
public class ListNode<T extends Comparable<T>> {
    ListNode<T> head = null;
    T value;
    ListNode<T> next;
    
    
    public ListNode(T value){
        
        this.value=value;
        
        
    }
    
    
    
    public void insert( T newvalue){
        ListNode<T> node = new ListNode<T>(newvalue);
        
        //einfügen anfang
        if(head == null){
                head = node;
                return;
            
            
            
        }
            
        //einfügen zwei elemeente
        
        if(head.next == null){
            if(head.value.compareTo(node.value) == -1){
                head.next = node;                    // wenn mein neues element größer als head ist
                return;
                
                
            }                                                                 
            else {
                

            node.next = head;    //wenn mein neues element kleiner head ist.
            
            head = node;
                return;
            }
        
        
        }
        
        
        
        
    
        
        
        

        
        
        
        
    }
    
    public void printList(){
        ListNode<T> current = head;
        
        while(current != null){
            System.out.print(current.value + "  --> ");
            
            current = current.next;
            
            
        }
        
        
    }
        
        

    
    
    public int size() {
        
        ListNode<T> current = head;
        int count = 0;
        
        while(current != null){
            
            count++;
            current = current.next;
            
            
        }
        
        return count;
        
        
        
        

    }   
        
    
    
    
}




import java.util.Collections;

public class Test {
    
    public static void main (String[] args) {
        ListNode<Integer> head = new ListNode<Integer>(5);
        head.insert(9);
        head.insert(1);
        head.insert(3);
        head.insert(2);
        
        
        head.printList();
        
        
    }
}
```


----------



## kneitzel (23. Apr 2019)

Dann geh doch einmal deinen Code und spiel es händisch durch....
Head=null und du fügst ein Element ein:
Head -> 9
Nun kommt mit die 1, Head ist nicht null, aber Head.next ist null, also vergleicht er und fügt die 1 entsprechend ein ....
Head -> 1 -> 9
Nun kommt die nächste Zahl, was macht Dein Code?


----------



## Heyoka955 (23. Apr 2019)

kneitzel hat gesagt.:


> Dann geh doch einmal deinen Code und spiel es händisch durch....
> Head=null und du fügst ein Element ein:
> Head -> 9
> Nun kommt mit die 1, Head ist nicht null, aber Head.next ist null, also vergleicht er und fügt die 1 entsprechend ein ....
> ...


nichts weil es keine Abfragung dazu gibt aber das problem ist die 5 die ich am anfang einfüge
beim herstelllen des nodes gebe ich eine 5 als paramter aber die funz net wirklich, 
er spuckt die nicht aus.


----------



## kneitzel (23. Apr 2019)

Du fügst keine 5 ein. Dein Listenkopf sollte eigentlich nur eine Referenz auf ein ersten Node haben und keinen Wert. Bei Dir steckt aber auch ein Wert mit drin.

Wenn das der erste Wert sein soll, dann musst du den Wert natürlich mit ausgeben und einigen Code ändern. Aber dann hast Du auch keine leere Liste mehr....

Also normalerweise ist eine Liste eine Klasse und ListNode eine andere Klasse, meist eine inner class. So kenne ich die Implementationen zumindest.


----------



## Heyoka955 (23. Apr 2019)

kneitzel hat gesagt.:


> Du fügst keine 5 ein. Dein Listenkopf sollte eigentlich nur eine Referenz auf ein ersten Node haben und keinen Wert. Bei Dir steckt aber auch ein Wert mit drin.
> 
> Wenn das der erste Wert sein soll, dann musst du den Wert natürlich mit ausgeben und einigen Code ändern. Aber dann hast Du auch keine leere Liste mehr....
> 
> Also normalerweise ist eine Liste eine Klasse und ListNode eine andere Klasse, meist eine inner class. So kenne ich die Implementationen zumindest.


ich eig auch aber mein prof hat im video alles auf einmal gemacht und daher dachte ich evtl auch komm der willl das vllt so machen.

ja dann mache ich die Abfragung wenn mehrere Elemente vorhanden sind.


----------



## AndiE (23. Apr 2019)

Ich finde den Code so überhaupt nicht wartbar. Ich würde so vorgehen:

1. Liste anlegen
2. Objekt erzeugen
3. Objekt an Liste einfügen
( 2. und 3. solange wiederholen, bis alle Elemente eingefügt sind)
4. Liste ausgeben
5. Liste sortieren
6. Liste ausgeben

Dabei soll sich die Liste um ihre Dinge kümmern und das Objekt um seine.

Und das sauber in zwei ( oder drei) Klassen trennen, damit die Funktion auch nachvollziehbar ist, und Fehler behoben werden können. 

So ein Mischmasch mag ja cool sein, aber auch beim "Rover" war das Programm dadurch recht undurchsichtig und schlecht nachvollzieh- und schlecht wartbar.


----------



## Heyoka955 (23. Apr 2019)

AndiE hat gesagt.:


> Ich finde den Code so überhaupt nicht wartbar. Ich würde so vorgehen:
> 
> 1. Liste anlegen
> 2. Objekt erzeugen
> ...


mein prof hat das in vl so gemacht er hat einen bintree mit einer klasse gemacht daher wollte ich es auch so machen.

So das funktioniert jedoch sobald ein weiterer node hinzukommt wird

```
public class ListNode<T extends Comparable<T>> {
    ListNode<T> head = null;
    T value;
    ListNode<T> next;
    
    
    public ListNode(T value){
        
        this.value=value;
        
        
    }
    
    
    
    public void insert( T newvalue){
        ListNode<T> node = new ListNode<T>(newvalue);
        
        //einfügen anfang
        if(head == null){
                head = node;
                return;
            
            
            
        }
            
        //einfügen zwei elemeente
        
        if(head.next == null){
            if(head.value.compareTo(node.value) == -1){
                head.next = node;                    // wenn mein neues element größer als head ist
                return;
                
                
            }                                                                 
            else {
                

            node.next = head;    //wenn mein neues element kleiner head ist.
            
            head = node;
                return;
            }
        
        
        }
        
        //einfügen bei der mitte
        
        
        
         ListNode<T> current = head;
        
        
         while(current != null){
             if(node.value.compareTo(current.value) == 1 && node.value.compareTo(current.next.value) == -1){
                 node.next = current.next;
                 current.next = node;
                 return;
                
                
             }
            
            
            
         }
        

        
        
        
        
    }
    
    public void printList(){
        ListNode<T> current = head;
        
        while(current != null){
            System.out.print(current.value + "  --> ");
            
            current = current.next;
            
            
        }
        
        
    }
        
        

    
    
    public int size() {
        
        ListNode<T> current = head;
        int count = 0;
        
        while(current != null){
            
            count++;
            current = current.next;
            
            
        }
        
        return count;
        
        
        
        

    }   
        
    
    
    
}
```


----------



## mrBrown (23. Apr 2019)

AndiE hat gesagt.:


> Ich finde den Code so überhaupt nicht wartbar. Ich würde so vorgehen:
> 
> 1. Liste anlegen
> 2. Objekt erzeugen
> ...


Genau so wie du es beschreibst ist es doch umgesetzt? Bis auf Schritt 5 & 6, da die Liste immer sortiert sein soll.


----------



## Heyoka955 (23. Apr 2019)

mrBrown hat gesagt.:


> Genau so wie du es beschreibst ist es doch umgesetzt? Bis auf Schritt 5 & 6, da die Liste immer sortiert sein soll.


Nein ist es nicht, ich habe keine wirkliche List initialisiert sondern nur die nodes auf next referenziert.

Brauche Hilfe bei den Bug


----------



## mrBrown (24. Apr 2019)

Heyoka955 hat gesagt.:


> Brauche Hilfe bei den Bug




Aktuell kommt der Fehler daher, dass dein head nicht nur Kopf der Liste, sondern auch Teil der Liste ist. Wenn du innerhalb ListNode head benutzt, überspringst du das erste Listen-Element ("this"). Eben das musst du verhindern, wie das geht, solltest du schon selbst rausfinden  Leere Listen sind dabei aber nicht möglich.



Sinnvoller wären aber zwei Varianten:
Entweder zusätzlich zu ListNode eine List-Klasse einführen, und head aus ListNode in diese verschieben.
Oder head aus ListNode entfernen, der Knoten mit value==null ist dann der implizite Head.


----------



## Heyoka955 (24. Apr 2019)

mrBrown hat gesagt.:


> Aktuell kommt der Fehler daher, dass dein head nicht nur Kopf der Liste, sondern auch Teil der Liste ist. Wenn du innerhalb ListNode head benutzt, überspringst du das erste Listen-Element ("this"). Eben das musst du verhindern, wie das geht, solltest du schon selbst rausfinden  Leere Listen sind dabei aber nicht möglich.
> 
> 
> 
> ...





mrBrown hat gesagt.:


> Aktuell kommt der Fehler daher, dass dein head nicht nur Kopf der Liste, sondern auch Teil der Liste ist. Wenn du innerhalb ListNode head benutzt, überspringst du das erste Listen-Element ("this"). Eben das musst du verhindern, wie das geht, solltest du schon selbst rausfinden  Leere Listen sind dabei aber nicht möglich.
> 
> 
> 
> ...


Sorry ich wusste was du meintest erst jetzt, das current blieb gaze zeit stehen bei head,

hatte das wohl ausversehen gelöscht, aber wieso printet der die 5 nicht aus?


----------



## kneitzel (24. Apr 2019)

Bitte male Dir doch einmal genau auf einen Zettel, wie die Instanzen, die Du erzeugt hast, aussehen. Zu jeder Instanz gehört head, value und next.

Und dann spielst Du Deinen Code einmal durch. Dann solltest Du es genau sehen.

Und bezüglich Deines Designs haben wir mehrfach etwas gesagt. Das macht so absolut keinen Sinn. Zum einen gibt es eine Trennung zwischen einer Liste und einem ListenNode. Beides in eine Klasse zu packen ist Unsinn, denn so hat jeder Node den head, den der Node aber gar nicht braucht. Und die Liste hat Value und Next, was auch keinen Sinn macht.

Und wenn man sowas wirklich machen wollte (Wofür ich keinen Sinn sehe), dann sollten die Schnittstellen passen. Eine Liste erzeugt man leer. Also ein Konstruktor, der ein ersten Wert bekommt, macht wenig Sinn (Zumindest so lange das der Einzige ist).
Und dann müsste man genau unterscheiden, welche Funktionen wie erreichbar sein müssen. Viele Funktionen wären dann schlicht private. Der Konstruktor mit dem Wert macht nur Sinn innerhalb der Liste, also private. Und alles, was die Liste nur intern braucht, wäre dann auch private.

Aber das macht man dann normalerweise mit zwei Klassen und da der ListNode ein Implementierungsdetail der List ist, wird dieser auch gerne als inner class definiert. Außer der List muss da auch nie jemand zugreifen.


----------



## Heyoka955 (24. Apr 2019)

kneitzel hat gesagt.:


> Bitte male Dir doch einmal genau auf einen Zettel, wie die Instanzen, die Du erzeugt hast, aussehen. Zu jeder Instanz gehört head, value und next.
> 
> Und dann spielst Du Deinen Code einmal durch. Dann solltest Du es genau sehen.
> 
> ...


jo ich habe es gemacht und kam zu dem entschluss dass es eig sinn macht wenn ich im Konstruktor die insert Methode aufrufe aber leider erscheint ein bug.


----------



## mrBrown (24. Apr 2019)

Wie erstellst du denn eine leere Liste?


----------



## Heyoka955 (24. Apr 2019)

mrBrown hat gesagt.:


> Wie erstellst du denn eine leere Liste?


indem ich im konstukrot garnix übergebe und nichts einfüge oder wenn head auf null zeigt


----------



## mrBrown (24. Apr 2019)

Und wie übergibst du deinem Konstruktor gar nichts?


----------



## Heyoka955 (24. Apr 2019)

mrBrown hat gesagt.:


> Und wie übergibst du deinem Konstruktor gar nichts?


indem ich ListNode<Integer> head = new ListNode<Integer>();

oh man ich dümmerchen, stimmt ja man kann mehrere konstukroren implementieren


----------



## mrBrown (24. Apr 2019)

und das funktioniert auch schon?

Falls ja: mach den anderen Konstruktion jetzt noch private...


----------



## Heyoka955 (24. Apr 2019)

mrBrown hat gesagt.:


> und das funktioniert auch schon?
> 
> Falls ja: mach den anderen Konstruktion jetzt noch private...


ja aber kann ich ihn nicht komplett enfernen


----------



## kneitzel (24. Apr 2019)

Heyoka955 hat gesagt.:


> ja aber kann ich ihn nicht komplett enfernen


Verwendest Du ihn irgendwo? Wenn nein: Weg damit. Wenn ja: von wo? Dann kannst Du es so modifizieren, dass es evtl. niemand anderes mehr aufruft....


----------



## Heyoka955 (24. Apr 2019)

kneitzel hat gesagt.:


> Verwendest Du ihn irgendwo? Wenn nein: Weg damit. Wenn ja: von wo? Dann kannst Du es so modifizieren, dass es evtl. niemand anderes mehr aufruft....


ne brauche ich nicht merh zu verwenden.

es gibt noch einen fall zu beachten und zwar falls ein wert eingefügt wird der kleiner als der erste node ist,
sagen wir wir haben die liste mir werten drinne wie 1-2-3-4

und wenn man 0 oder -5 einfügt dann sortiert er das nicht, aber ich pausiere mal.

denke das reicht


----------



## mrBrown (24. Apr 2019)

Und wie sieht dein Code jetzt aus?


----------



## Heyoka955 (24. Apr 2019)

mrBrown hat gesagt.:


> Und wie sieht dein Code jetzt aus?




```
public class ListNode<T extends Comparable<T>> {
    ListNode<T> head = null;
    T value;
    ListNode<T> next;
    
    
    
    public ListNode(T value){
        
        this.value=value;
        
        
    }
    
    
    public ListNode(){
        
        
        
        
    }
    
    public void insertEmptyList(ListNode<T> node){
        //einfügen wenn liste leer
        if(head == null){
                head = node;
                
            return;
            
            
        }
    }
        
    public void insertIfNodeexists(ListNode<T> node){
        
        if(head.value.compareTo(node.value) == -1){
                head.next = node;                    // wenn mein neues element größer als head ist
                return;
                
                
            }                                                                 
            
                

            node.next = head;    //wenn mein neues element kleiner head ist.
            
            head = node;
                return;
            
        
        
        
        
        
        
        
    }
    
    
    public void insert( T newvalue){
        ListNode<T> node = new ListNode<T>(newvalue);
        
        if(head == null){
            insertEmptyList(node);
            return;
        }
        
        //einfügen zwei elemeente
        
        if(head.next == null){
            insertIfNodeexists(node);
            return;
        }
        //einfügen bei der mitte oder am ende
        
        insertInTheMiddleOrLast(node);   
    }
    
    
    
    
    
    public void insertInTheMiddleOrLast(ListNode<T> node){
        ListNode<T> current = head;
         while(current != null){
            
            if(node.value.compareTo(current.value) == 1 && current.next == null){
                     current.next = node;
                    node.next = null;
                    return;
                    
            }
            
            else if(node.value.compareTo(current.value) == 1 && node.value.compareTo(current.next.value) == -1){
                    
                 node.next = current.next;
                 current.next = node;
                 return;
                
                
            }
              

        current = current.next;
        }
        
        
        
    }
    
    public void printList(){
        
        ListNode<T> current = head;
        
        while(current != null){
            System.out.print(current.value + "  --> ");
            
            current = current.next;
            
            
        }
        
        
    }
        
        

    
    
    public int size() {
        
        ListNode<T> current = head;
        int count = 0;
        
        while(current != null){
            
            count++;
            current = current.next;
            
            
        }
        
        return count;
        
        
        
        

    }   
        
    
    
    
}
```


----------



## kneitzel (24. Apr 2019)

Also ich finde den Code relativ unübersichtlich.

Wenn ich etwas in die Liste einfügen muss, dann mache ich es komplett anders! Ich würde das Umgangssprachlich wie folgt umschreiben:
a) Ich prüfe, ob ich das Element am Anfang  einfügen muss. Wenn dies der Fall ist, dann füge ich das neue Element an den Anfang und bin fertig.
b) Dann gehe ich so lange durch die Liste, bis ich bei dem Element bin, hinter das ich das neue Element einfügen muss und füge das Element dann entsprechend ein.

Die genauen Kriterien sowie das genaue Vorgehen sind noch zu benennen. Aber der Code wird dann relativ einfach und übersichtlich.

Zur Hilfe: Bei a und b sind jeweils zwei Dinge zu prüfen!


----------



## mrBrown (24. Apr 2019)

Heyoka955 hat gesagt.:


> ```
> ListNode<T> head = null;
> T value;
> ListNode<T> next;
> ...


Um das mal zusammenzufassen: du hast alle Vorschläge und Hinweise ignoriert und alles nur noch schlimmer gemacht.


----------



## Heyoka955 (24. Apr 2019)

kneitzel hat gesagt.:


> Also ich finde den Code relativ unübersichtlich.
> 
> Wenn ich etwas in die Liste einfügen muss, dann mache ich es komplett anders! Ich würde das Umgangssprachlich wie folgt umschreiben:
> a) Ich prüfe, ob ich das Element am Anfang  einfügen muss. Wenn dies der Fall ist, dann füge ich das neue Element an den Anfang und bin fertig.
> ...


ich hätte dann zwei Methoden zu einer machen können evtl aber ich sollte für jeden Aufgabenbereich in Methoden aufteilen.


----------



## Heyoka955 (24. Apr 2019)

mrBrown hat gesagt.:


> Um das mal zusammenzufassen: du hast alle Vorschläge und Hinweise ignoriert und alles nur noch schlimmer gemacht.


hä wieso?  ich habe doch alles befolgt ?
achso ja stimmt ich sollte ja das aufteilen in node und list, ja aber ich hass es wenn ich etwas nicht zu ende bringen kann. 
hätte ich das jetzt beendet würde ich mich schlecht fühlen,

Ich kann es natürlich umändern


----------



## mrBrown (24. Apr 2019)

kneitzel hat gesagt.:


> a) Ich prüfe, ob ich das Element am Anfang einfügen muss. Wenn dies der Fall ist, dann füge ich das neue Element an den Anfang und bin fertig.
> b) Dann gehe ich so lange durch die Liste, bis ich bei dem Element bin, hinter das ich das neue Element einfügen muss und füge das Element dann entsprechend ein.


Kann man auch etwas einfacher lösen (abhängig davon, wie man mit dem Listenkopf umgeht):

Solange über die Knoten iterieren, bis der nächste Wert kleiner als der aktuelle ist, dann vor diesem einfügen.

Sind knapp 10 Zeilen, anstatt 4 Methoden über zig Zeilen wie bei ihm...


----------



## mrBrown (24. Apr 2019)

Heyoka955 hat gesagt.:


> hä wieso? ich habe doch alles befolgt ?


Mach den einen Konstruktiv privat.

Schmeiß das head-Feld weg, das ist Unsinn (wenn, gehört das in eine Wrapper-Klasse für die Liste.

Beim Einfügen musst du keinerlei Sonderfälle berücksichtigen. Vor allem braucht man dazu keine vier öffentlichen Methoden, sondern nur eine: insert.


----------



## Heyoka955 (24. Apr 2019)

mrBrown hat gesagt.:


> Kann man auch etwas einfacher lösen (abhängig davon, wie man mit dem Listenkopf umgeht):
> 
> Solange über die Knoten iterieren, bis der nächste Wert kleiner als der aktuelle ist, dann vor diesem einfügen.
> 
> Sind knapp 10 Zeilen, anstatt 4 Methoden über zig Zeilen wie bei ihm...


ich hatte ja eine Stellung dazu gemacht aber, ich kann auch alles in einer Methode packen aber ich sollte das aufteilen.


----------



## kneitzel (24. Apr 2019)

mrBrown hat gesagt.:


> Kann man auch etwas einfacher lösen (abhängig davon, wie man mit dem Listenkopf umgeht):
> 
> Solange über die Knoten iterieren, bis der nächste Wert kleiner als der aktuelle ist, dann vor diesem einfügen.
> 
> Sind knapp 10 Zeilen, anstatt 4 Methoden über zig Zeilen wie bei ihm...


Nunja, beim Vorher einfügen ist der Fall mit dem einfügen vor dem ersten Element wichtig. Da muss man so wie so prüfen. Daher lag es für mich auf der Hand, dass ich dann nur noch das danach einfügen prüfen würde mit einer Schleife.

Aber klar, so wie von Dir beschrieben geht es natürlich auch


----------



## mrBrown (24. Apr 2019)

Heyoka955 hat gesagt.:


> ich hatte ja eine Stellung dazu gemacht aber, ich kann auch alles in einer Methode packen aber ich sollte das aufteilen.


Wenn du die Liste sinnvoll umsetzte (hier gab es mehr als genug Tipps...), hast du in der Methode keinerlei zu berücksichtigende Sonderfälle, für die du jetzt die drei Methoden brauchst.
Du kannst das dann aber natürlich auch in sinnvolle Methoden aufteilen, aber eben sinnvoll geteilt nach dem, was sie machen (zB Position suchen und an dieser Position einfügen), und nicht nach "die Liste ist leer", "die Liste hat ein Element", "die Liste hat mehrere Elemente und am ende oder der Mitte einfügen" (was ja wie du merkst auch noch nicht klappt).


----------



## mrBrown (24. Apr 2019)

@Heyoka955 wie ist denn eigentlich die genaue Aufgabenstellung? Das ist doch sicherlich mehr, als nur "eine sortierte LinkedList"?


----------



## kneitzel (24. Apr 2019)

Evtl. ist das aus der Auflistung der zu testenden Fälle gekommen. Ich habe ja mehrfach aufgelistet, was für Fälle es aus meiner Sicht gibt:
- Einfügen in leere Liste
- Einfügen an den Anfang der Liste
- Einfügen in die Mitte der Liste
- Einfügen an das Ende der Liste

Aber daraus folgt nicht, dass die alle separat zu implementieren sind, sondern es muss ein Algorithmus gefunden werden, der bei allen Fällen erfolgreich ist.


----------



## Heyoka955 (24. Apr 2019)

mrBrown hat gesagt.:


> @Heyoka955 wie ist denn eigentlich die genaue Aufgabenstellung? Das ist doch sicherlich mehr, als nur "eine sortierte LinkedList"?


Implementieren sie eine verkettete Liste die nach dem einfügen das Objekt sortiert.


----------



## Heyoka955 (24. Apr 2019)

kneitzel hat gesagt.:


> Evtl. ist das aus der Auflistung der zu testenden Fälle gekommen. Ich habe ja mehrfach aufgelistet, was für Fälle es aus meiner Sicht gibt:
> - Einfügen in leere Liste
> - Einfügen an den Anfang der Liste
> - Einfügen in die Mitte der Liste
> ...



Mein Code funktioniert bei allen drei natürlich wäre es besser wenn der akgothmus in einer Methode wäre.
Aber das Problem ist dass wenn man zahlen einfügt die kleiner als der aktuelle Head ist dann fügt er die nicht ein.

Ich hätte eine Anfrage schreiben sollen die das überprüft.


----------



## kneitzel (24. Apr 2019)

Ja, da fehlt dann eine Abfrage, wenn der Fall nicht berücksichtigt wird. Den Pseudocode, der einfach und gut lesbar ist, habe ich ja schon geliefert.


----------



## Heyoka955 (24. Apr 2019)

kneitzel hat gesagt.:


> Ja, da fehlt dann eine Abfrage, wenn der Fall nicht berücksichtigt wird. Den Pseudocode, der einfach und gut lesbar ist, habe ich ja schon geliefert.


Scheint so dass ich doch nicht so schlecht bin


----------



## kneitzel (24. Apr 2019)

Heyoka955 hat gesagt.:


> Scheint so dass ich doch nicht so schlecht bin


Deine Selbsteinschätzung dürfte nicht mit denen der Meisten hier übereinstimmen.

Wir haben dir sehr viel Informationen gegeben, von denen du nur sehr wenig umgesetzt hast.

Der Pseudocode zusammen mit den weiteren Hinweisen hätte Dich schon lange zu einer Lösung wie:


			Codiva.io Fastest Cloud IDE
		

führen müssen. 

Und den Zeitbedarf für eine Lösung, die nicht einmal richtig funktioniert muss man nicht wirklich kommentieren, oder? (Nein, es geht nicht darum, ob jemand 30 Minuten oder 2 Stunden braucht. Hier ist ja ganz offensichtlich mehr Zeit investiert worden, als unbedingt notwendig gewesen wäre und das, ohne dass zumindest ich einen Lerneffekt erkennen könnte...


----------



## mihe7 (24. Apr 2019)

@kneitzel Ich weiß gar nicht, was Du hast. Noch nicht mal 150 Kommentare und schon funktioniert so etwas kompliziertes wie eine verkettete Liste... fast...


----------



## kneitzel (24. Apr 2019)

mihe7 hat gesagt.:


> @kneitzel Ich weiß gar nicht, was Du hast. Noch nicht mal 150 Kommentare und schon funktioniert so etwas kompliziertes wie eine verkettete Liste... fast...


Ja, aber der arme Dozent, der sich seinen Code ansehen muss.... Der fällt bestimmt 2 Wochen wegen schwerer Gehirnerschütterung aus. Oder kannst Du Dir vorstellen, dass der sowas ansehen kann ohne seinen Kopf dann schnell Richtung Tischplatte zu bewegen?


----------



## mrBrown (24. Apr 2019)

Heyoka955 hat gesagt.:


> Mein Code funktioniert bei allen drei natürlich wäre es besser wenn der akgothmus in einer Methode wäre.
> Aber das Problem ist dass wenn man zahlen einfügt die kleiner als der aktuelle Head ist dann fügt er die nicht ein.


"Mein Code funktioniert bei allen drei [...] Aber das Problem ist dass [...] dann fügt er die nicht ein"

Wenn ein Satz beginnt mit "es funktioniert" und endet mit "das funktioniert nicht", dann passt da irgendwas nicht...


----------



## mrBrown (24. Apr 2019)

kneitzel hat gesagt.:


> Ja, aber der arme Dozent, der sich seinen Code ansehen muss.... Der fällt bestimmt 2 Wochen wegen schwerer Gehirnerschütterung aus. Oder kannst Du Dir vorstellen, dass der sowas ansehen kann ohne seinen Kopf dann schnell Richtung Tischplatte zu bewegen?


Aus Erfahrung kann ich sagen: Man muss nur sehr viel und sehr fluchen, das hilft.


----------



## kneitzel (24. Apr 2019)

mrBrown hat gesagt.:


> "Mein Code funktioniert bei allen drei [...] Aber das Problem ist dass [...] dann fügt er die nicht ein"
> 
> Wenn ein Satz beginnt mit "es funktioniert" und endet mit "das funktioniert nicht", dann passt da irgendwas nicht...


Du taugst auch nicht zum Politiker! Ich hoffe, Du hast da keine Ambitionen.

"Mit allen (x-1) Staaten haben wir Frieden." Bei X Staaten hat man dann halt auch Krieg ... aber muss man ja nicht sagen


----------



## mihe7 (24. Apr 2019)

kneitzel hat gesagt.:


> Ja, aber der arme Dozent, der sich seinen Code ansehen muss....


Was stellt der auch fast unlösbare Aufgaben?


----------



## Heyoka955 (24. Apr 2019)

mihe7 hat gesagt.:


> Was stellt der auch fast unlösbare Aufgaben?


habe es gelöst leute, war easy also das funz komplett nur der code ist halt beschissen...


----------



## mrBrown (24. Apr 2019)

Wenn fünf Tage Arbeit, zig Leute die dir Dinge vorsagen und beschissener Code deine Definition von „easy“ ist...

(Ich stimme Dir aber zu, die Aufgabe ist wirklich einfach...)


----------



## mihe7 (24. Apr 2019)

Heyoka955 hat gesagt.:


> habe es gelöst leute,


Dann kann ich meinen Sarkusmus-Mode wieder verlassen.



Heyoka955 hat gesagt.:


> nur der code ist halt beschissen...


Was aber am Programmierer liegt.


----------



## Heyoka955 (24. Apr 2019)

mrBrown hat gesagt.:


> Wenn fünf Tage Arbeit, zig Leute die dir Dinge vorsagen und beschissener Code deine Definition von „easy“ ist...
> 
> (Ich stimme Dir aber zu, die Aufgabe ist wirklich einfach...)


ich kann das ändern, außerdem muss der tutor fähig sein das zu verstehen xD


----------



## mihe7 (24. Apr 2019)

Heyoka955 hat gesagt.:


> außerdem muss der tutor fähig sein das zu verstehen xD


ROFL. Der Typ ist jeden Cent wert.


----------



## mrBrown (24. Apr 2019)

Heyoka955 hat gesagt.:


> ich kann das ändern, außerdem muss der tutor fähig sein das zu verstehen xD


Na dann änder es doch  und dann zeig mal, ich kann dir sagen, ob Tutoren das verstehen


----------



## Heyoka955 (24. Apr 2019)

mihe7 hat gesagt.:


> Dann kann ich meinen Sarkusmus-Mode wieder verlassen.
> 
> 
> Was aber am Programmierer liegt.


ich code sei Dezember ...


----------



## mrBrown (24. Apr 2019)

Heyoka955 hat gesagt.:


> ich code sei Dezember ...


LinkedList kommt bei euch also in der zweiten Java-Veranstaltung dran?


----------



## Heyoka955 (24. Apr 2019)

mrBrown hat gesagt.:


> LinkedList kommt bei euch also in der zweiten Java-Veranstaltung dran?


nein erste aber ganz am ende, ich hatte lange nicht mehr programmiert.

weil ich hatte ab Dezember gelernt und dann erste Klausur geschrieben und nicht bestanden weil die war schon heftiges Niveau, kann gerne zeigen aber wie die war. der prof hat die hochgeladen.

bis zur zweiten Klausur habe ich nichts gelernt mehr und bin unvorbereitet in die kalusur gegangen und bestanden. 

daher hatte ich ca mehr als 1 Monat pause.


----------



## mrBrown (24. Apr 2019)

also sind das Aufgaben aus dem letzten Semester, die du aber jetzt erst aus Lust und Laune machst?
Ganz ehrlich, das macht das ganze noch schlimmer - solche Problem mit Aufgaben aus Veranstaltungen die du schon bestanden hast...


Aber kannst die Klausur gern mal zeigen.


----------



## kneitzel (24. Apr 2019)

Hmm, irgendwie kann ich dem nicht so ganz folgen. Und ich kann mir nicht vorstellen, dass unser TE in einer Klausur eine Aufgabe zur Programmierung lösen kann.

Und "Ich hatte lange nicht mehr programmiert" ist eine Aussage, die ich auch nicht nachvollziehen kann. Man ist Student, hat eine Vorlesung, in der es um Programmieren geht und das ist kein Grund, sich damit zu beschäftigen?

Aber aus so eine Diskussion klinke ich mich aus.


----------



## Heyoka955 (24. Apr 2019)

mrBrown hat gesagt.:


> also sind das Aufgaben aus dem letzten Semester, die du aber jetzt erst aus Lust und Laune machst?
> Ganz ehrlich, das macht das ganze noch schlimmer - solche Problem mit Aufgaben aus Veranstaltungen die du schon bestanden hast...
> 
> 
> Aber kannst die Klausur gern mal zeigen.


Nein die sind aus der jetzigen Vorlesung.

Das Blatt ist freiwillig.


----------



## Heyoka955 (24. Apr 2019)

Heyoka955 hat gesagt.:


> Nein die sind aus der jetzigen Vorlesung.
> 
> Das Blatt ist freiwillig.
> 
> Aber linked list hatten wir im Winter Semester gehabt am Ende.


----------



## mrBrown (24. Apr 2019)

Na dann sag doch nicht „erste“ wenn es in Wirklichkeit die zweite ist...


„Gehabt“ heißt dann aber vermutlich nicht selbst programmiert...


----------



## mihe7 (24. Apr 2019)

kneitzel hat gesagt.:


> Und "Ich hatte lange nicht mehr programmiert" ist eine Aussage, die ich auch nicht nachvollziehen kann.


Hallo?!? Er hatte 1 Monat Pause.


----------



## mihe7 (24. Apr 2019)

Huch, jetzt sehe ich gerade, dass Du mir direkt geantwortet hast:


Heyoka955 hat gesagt.:


> ich code sei Dezember ...


Entweder kannst Du beurteilen, ob Code Mist ist oder nicht.


----------

