Generische Liste

[McLovin]

gelöscht, sorry

So, danke das hat mir schon mal weitergeholfen!

Ich bekomme jetzt noch einen Fehler in der comparteTo Methode des ListElementes. Weiss da aber auch nicht woran es liegt. Tut mir leid wenn ich dumme Fragen stelle, aber ich habe noch mit Generics gearbeitet.

/**
 * Write a description of class SortedList here.
 * 
 * @author (your name) 
 * @version (a version number or a date)
 */

import java.util.Comparator;

public class SortedList<T extends Comparable<T>>
{
    // toDO:
    //- Exception bei doppelt?
    private int size;
    private ListElement<T> first;
    private ListElement<T> last;

    /**
     * Constructor for objects of class SortedList
     */
    public SortedList()
    {
        this.size = 0;
        this.first = null;
        this.last = null;
    }

    public void addSorted(T data){
        ListElement<T> element = new ListElement<T>(data, null, null);
        
        if(first == null){
           // ListElement<T> element = new ListElement<T>(data, null, null);
            first = element;
            last = element;
            size++;
        }
        else{

            if(element.compareTo(first) == -1){
                //ListElement elementNeu = new ListElement(data, first, null);
                element.setNext(first);//--------
                first.setPrevious(element);
                first = element;
                size++;
            }else{
                if(element.compareTo(last) == 1){
                    //ListElement elementNeu = new ListElement(data, null, last);
                    element.setPrevious(last);
                    last.setNext(element);
                    last = element;
                    size++;
                }else{
                    ListElement<T> elementVG = first;

                    while( element.hasNext()){

                        if(element.compareTo(elementVG) == 0 ) 
                            break;
                        if( (element.compareTo(elementVG) == 1)   && (element.compareTo( elementVG.getNext()) == -1) ){
                            //ListElement elementNeu = new ListElement(data, element.getNext(), element);
                            element.setNext(elementVG.getNext());
                            element.setPrevious(elementVG);
                            elementVG.getNext().setPrevious(element);
                            elementVG.setNext(element);
                            size++;
                            break;
                        }
                        elementVG = elementVG.getNext();
                    }
                }
            }
        }
    }


    public void remove(T data){
        if(data.equals( first.getElementData() )){
            first.getNext().setPrevious(null);
            first = first.getNext();
            size--;
        }

        if(data.equals( last.getElementData() )){
            last.getPrevious().setNext(null);
            last = last.getPrevious();
            size--;
        }

        ListElement element = first.getNext();

        while( element.hasNext()){
            if(data.equals(element.getElementData()) ){
                element.getPrevious().setNext(element.getNext());
                element.getNext().setPrevious(element.getPrevious());
                element = null;
                size--;
                break;
            }
            
            element = element.getNext();
        }
    }
    
    public String toString(){
        StringBuilder sb = new StringBuilder();
        sb.append("Personen: \n \n");
        
        ListElement element = first;

        while( element.hasNext()){
            sb.append(element).append("\n");
            element = element.getNext();
        }
        sb.append(element);
        return sb.toString();
    }
}
    
    
    
    
    
    
class ListElement<T extends Comparable<T>>
{
    // instance variables - replace the example below with your own
    private T data;
    private ListElement<T> next;
    private ListElement<T> previous;

    /**
     * Constructor for objects of class ListElement
     */
    public ListElement(T data, ListElement next, ListElement previous)
    {
        this.data = data;
        this.next = next;
        this.previous = previous;
    }
    
    public T getElementData(){
        return data;
    }

    public int compareTo(ListElement<T> element) { 
        
        if (getElementData() < element.getElementData())
            return -1;
        else if (getElementData().equals(element.getElementData()))
            return 0;
        else
            return 1;

    }
    
    public boolean hasNext(){
        if(next != null)
            return true;
        return false;
    }
    
    public ListElement<T> getNext(){
        return next;
    }
    
    public ListElement<T> getPrevious(){
        return previous;
    }
    
    public void setNext(ListElement<T> element){
        this.next = element;
    }
    
    public void setPrevious(ListElement<T> previous){
        this.previous = previous;
    }
    
    public T toString(){
        return data;
    }
}

Die Fehlermeldung ist "operator < cannot be aplied to T,T"

Hat das vielleicht etwas damit zu tun, dass T auch ein Datentyp sein kann, der nicht verglichen (compareTo) werden kann?

 

[McLovin]

Hallo,

ich bin Anfänger im Programmieren und habe folgendes Problem. Beim Compilieren bekommen ich folgende Fehlermeldung:

type parameter TypeData is not within its bound

 public class SortedList<TypeData> 
{

    private int size;
    private ListElement<TypeData> first; // Hier meckert der Compiler
    private ListElement<TypeData> last;

    /**
     * Constructor for objects of class SortedList
     */
    public SortedList()
    {
        this.size = 0;
        this.first = null;
        this.last = null;
    }

    public void addSorted(TypeData data){
        ListElement<TypeData> element = new ListElement<TypeData>(data, null, null);
        
        if(first == null){
            first = element;
            last = element;
            size++;
        }
        else{

            if(element.compareTo(first) == -1){
                element.setNext(first);//--------
                first.setPrevious(element);
                first = element;
                size++;
            }else{
                if(element.compareTo(last) == 1){
                    //ListElement elementNeu = new ListElement(data, null, last);
                    element.setPrevious(last);
                    last.setNext(element);
                    last = element;
                    size++;
                }else{
                    ListElement<TypeData> elementVG = first;

                    while( element.hasNext()){

                        if(element.compareTo(elementVG) == 0 ) 
                            break;
                        if( (element.compareTo(elementVG) == 1)   && (element.compareTo( elementVG.getNext()) == -1) ){
                            element.setNext(elementVG.getNext());
                            element.setPrevious(elementVG);
                            elementVG.getNext().setPrevious(element);
                            elementVG.setNext(element);
                            size++;
                            break;
                        }
                        elementVG = elementVG.getNext();
                    }
                }
            }
        }
    }


    public void remove(TypeData data){
        if(data.equals( first.getElementData() )){
            first.getNext().setPrevious(null);
            first = first.getNext();
            size--;
        }

        if(data.equals( last.getElementData() )){
            last.getPrevious().setNext(null);
            last = last.getPrevious();
            size--;
        }

        ListElement element = first.getNext();

        while( element.hasNext()){
            if(data.equals(element.getElementData()) ){
                element.getPrevious().setNext(element.getNext());
                element.getNext().setPrevious(element.getPrevious());
                element = null;
                size--;
                break;
            }
            
            element = element.getNext();
        }
    }
    
    public String toString(){
        StringBuilder sb = new StringBuilder();
        sb.append("Personen: \n \n");
        
        ListElement element = first;

        while( element.hasNext()){
            sb.append(element).append("\n");
            element = element.getNext();
        }
        sb.append(element);
        return sb.toString();
    }
}
    
    
    
    
    
    
class ListElement<TypeData extends Comparable<TypeData>>
{
    // instance variables - replace the example below with your own
    private TypeData data;
    private ListElement<TypeData> next;
    private ListElement<TypeData> previous;

    /**
     * Constructor for objects of class ListElement
     */
    public ListElement(TypeData data, ListElement next, ListElement previous)
    {
        this.data = data;
        this.next = next;
        this.previous = previous;
    }
    
    public TypeData getElementData(){
        return data;
    }

    public int compareTo(ListElement<TypeData> element) { 
        
        if (getElementData() < element.getElementData())
            return -1;
        else if (getElementData().equals(element.getElementData()))
            return 0;
        else
            return 1;

    }
    
    public boolean hasNext(){
        if(next != null)
            return true;
        return false;
    }
    
    public ListElement<TypeData> getNext(){
        return next;
    }
    
    public ListElement<TypeData> getPrevious(){
        return previous;
    }
    
    public void setNext(ListElement<TypeData> element){
        this.next = element;
    }
    
    public void setPrevious(ListElement<TypeData> previous){
        this.previous = previous;
    }
    
    public TypeData toString(){
        return data;
    }
}

Die Aufgabe ist es eine sortierte doppelt verkettete List zu schreiben.

Danke im Vorraus!

 

[SlaterB]

generische Parameter solltest du nur dem Standard nach T, U, V usw. nennen, sonst verwechselt man das mit normalen Klassen/ Interfacen,
vielleicht noch alles Großbuchstaben, evtl. mit Unterstrich als Trenner, falls erlaubt, akzeptabel

in ListElement ist der Parameter eingeschränkt auf bestimmte Comparable-Klassen,
in SortedList dagegen nicht, so dass dort auch Klassen, die nicht Comparable sind, etwa SortedList selber, als Parameter genutzt werden könnten,
du musst dort schon "extends Comparable<TypeData>" wiederholt definieren

 

[Landei]

Mal ein stilistischer Hinweis:

[c]addSorted[/c] und [c]remove[/c] sind viel zu lang und verschachtelt, sollten also in sinnvolle Einheiten zerlegt werden. Ich denke allerdings, dass sie vor allem deshalb so kompliziert sind, weil sie im falschen Kontext, nämlich [c]SortedList[/c] operieren. Du hast doch schon eine eigene Klasse [c]ListElement[/c], nur ist die wirklich strohdoof. Überlege dir also, welche Aufgaben du von den genannten Methoden besser nach [c]ListElement[/c] delegieren solltest. Du kannst dich z.B. viel leichter von [c]ListElement[/c] zu [c]ListElement[/c] hangeln, bis du die richtige Stelle zum Einfügen gefunden hast, als das von "außen" zu tun.

 

[McLovin]

Habs herausgefunden!

    public int compareTo(ListElement<T> element) { 

        return getElementData().compareTo(element.getElementData());

    }