Problem mit Collections.sort() mit Java 1.5

[L-ectron-X]

import java.util.*;
/**
 *
 * ProcessManager.java
 */
public class ProcessManager {
    
    /** Legt neue Instanze von ProcessManager an */
    public ProcessManager() {
        deserialize();   
    }    
    
    /**
     * Fügt einen neuen Process der Processliste hinzu..
     */
    public void addProcess(Process process) {
        processList.add(process);
    }   
    
    /**
     * Gibt den Process an der übergebenen Indexpostion
     * aus der Processliste zurück
     */
    public Process getProcess(int index) {
        return processList.get(index);
    }
    
    /** Processdaten ändern */
    public Vector<Process> setProcess(int row, Process process) {
        processList.set(row, process);
        return processList;
    }
    
    /** Löschen eines Processes aus der Processliste an bestimmter Position */
    public void removeProcess(int row) {
        processList.remove(row);
    }
    
    /** Zurückgeben der Anzahl der in der Processliste gespeicherten Processe */
    public int size() {
        return processList.size();
    }
    
    /** Sortieren der Processliste */
    private void sort() {
        Collections.sort(processList);
    }
    
    
    public void serialize() {
        Serializer.serialize(System.getProperty("user.dir"), filename, processList);
    }
    
    public void deserialize() {
        processList = (Vector)Serializer.deserialize(System.getProperty("user.dir"), filename);
        
        //wenn keine Datei ausgelesen werden konnte, leere Liste anlegen
        if(processList == null)
            processList = new Vector<Process>();
    }
    
    private Vector<Process> processList;
    private String filename;
    private static final long serialVersionUID = 1L;
    
}

Schwierigkeiten macht mir der richtige Aufruf der Collections.sort()-Methode.

Fehlerausgabe des Compilers:

symbol : method sort(java.util.Vector<Process>)
location: class java.util.Collections
Collections.sort(processList);
Note: C:\Dokumente und Einstellungen\L-ectron-X\Desktop\Java Projekte\Generics\ProcessManager.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.
1 error

 

[Bleiglanz]

puu

ich glaube es war sowas wie

Collections.<Process>sort(processList);

komisch dass bei dir hier die type-inference nicht funktioniert...

 

[L-ectron-X]

Nee, leider nicht, Bleiglanz.
Fehlermeldung die gleiche.

symbol : method sort(java.util.Vector<Process>)
location: class java.util.Collections
Collections.<Process>sort(processList);
Note: C:\Dokumente und Einstellungen\L-ectron-X\Desktop\Java Projekte\Generics\ProcessManager.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.
1 error

Process ist ein Interface, welches Klassen implmentieren, die eben einen bestimmten Vorgang repräsentieren.
Aber jede dieser Klassen implementiert eine compareTo()-Methode und soll nach jeweils eigenen Kriterien sortiert werden.

 

[Beni]

Das funktioniert dann allerdings nur, wenn du für jeden Typ Prozess einen eigenen ProzessManager machst. Wie du im Chat sagtest, du kannst die Prozesse-Typen nicht gegenseitig vergleichen, darum stelle ich mir das Sortieren auch etwas schwierig vor, wenn du nur einen Manager hast.

interface Process{
    
}

class ProcessManager<T extends Process & Comparable<? super T> > {
   
    /** Legt neue Instanze von ProcessManager an */
    public ProcessManager() {
        //deserialize();   
    }   
   
    /**
     * Fügt einen neuen Process der Processliste hinzu..
     */
    public void addProcess( T process) {
        processList.add(process);
    }   
   
    /**
     * Gibt den Process an der übergebenen Indexpostion
     * aus der Processliste zurück
     */
    public Process getProcess(int index) {
        return processList.get(index);
    }
   
    /** Processdaten ändern */
    public Vector<T> setProcess(int row, T process) {
        processList.set(row, process);
        return processList;
    }
   
    /** Löschen eines Processes aus der Processliste an bestimmter Position */
    public void removeProcess(int row) {
        processList.remove(row);
    }
   
    /** Zurückgeben der Anzahl der in der Processliste gespeicherten Processe */
    public int size() {
        return processList.size();
    }
   
    /** Sortieren der Processliste */
    private void sort() {
        Collections.sort(processList);
    }
   

    private Vector<T> processList;
    private String filename;
    private static final long serialVersionUID = 1L;
   
}

 

[L-ectron-X]

Ach, mir dämmerts. :roll:
Wie Beni im Chat sagte, ist es schwierig solche Klassen miteinander zu vergleichen.
Da habe ich mir wohl noch nicht genug Gedanken gemacht. OK, danke für das Geraderücken meiner schrägen Vorstellungen. :wink:

 

[Bleiglanz]

trotzdem ist das Problem doch eine reine Warnung, wenn du eine Liste von Prozessen übergibst, dann sollte eigentlich per Inferenz die richtige methode aufgerufen werden

Note: Recompile with -Xlint:unchecked for details. (schon gemacht?)

Collections.sort ist doch extra so gebaut, dass es auch mit den Oberklassen noch zurechtkommt....

<T extends Comparable<? super T>>

 

[L-ectron-X]

Mit -Xlint kompiliert meint der Compiler:

Compiliere C:\Dokumente und Einstellungen\L-ectron-X\Desktop\Java Projekte\Generics\ProcessManager.java mit Java-Compiler
ProcessManager.java:46: warning: [unchecked] unchecked method invocation: <T>sort(java.util.List<T>) in java.util.Collections is applied to (java.util.Vector<Process>)
Collections.sort(processList);
^

<T extends Comparable<? super T>>

Ich kann leider damit nicht viel anfangen. Ich habe das Konzept von Generics leider noch nicht ganz verstanden.

 

[Bleiglanz]

class ProcessManager<T extends Process & Comparable<? super T>>

eine echte Implementierung müsste also eine Processklasse haben, die sowohl das Interface "Process" und auch Comparable für irgendeinen supertyp implementiert: ist das bei dir der Fall?

// nur ein kleiner Test...
// übersetzt ohne Fehler!

public class Coll<T extends Process & Comparable<? super T>>
{
    public java.util.Vector<T> liste = new java.util.Vector<T>();
                                                                                
    public static void main(String[] a){
        Coll<ProcessImpl> c = new Coll<ProcessImpl>();
        java.util.Collections.sort(c.liste);
    }
}
                                                                                
interface Process {}
                                                                                
class ProcessImpl implements Process, Comparable<Process>{
    public int compareTo(Process o){return 0;}
}

 

[L-ectron-X]

@Bleiglanz. Danke für deine Mühe. Ich habe mir jetzt erst mal ein Generics-Tutorial heruntergeladen, damit ich irgendwann mal verstehe, was hier deine Klassendefinition aussagt.
Bisher habe ich immer nur an der Generics-Oberfläche gekratzt, aber was du hier gepostet hast, übersteigt bei weeeiiitem mein Wissen über Generics.

Ich den Thread mal verschoben, weil sich aus ihm ja etwas entwickelt hat, was vielleicht noch mehr Leute interessiert.

 

[Beni]

class ProcessManager<T extends Process & Comparable<? super T> >

Ist nicht so schlimm, wie es aussieht. Das ganze zerfällt erstmals in zwei Teile:
T extends Process UND T extends Comparable<? super T>

Die linke Seite ist klar: T muss das Interface Process implementieren.
Die rechte Seite hat die Form T extends Comparable

, also T muss Comparable

implentieren. In diesem Fall ist

durch <? super T> ersetzt worden. Das bedeutet, dass man hier nur Klassen (bzw. Interfaces) eintragen darf, welche eine Superklasse/-Interface von T sind, oder gleich T (z.B. Object, als Superklasse von T, würde auf jeden Fall funktionieren.)