Comprator con List<File>

[fermat]

vorrei imparare ad usare Comparator.
questa è la mia classe:

import java.io.*;
import java.util.*;

public class ListDir implements Comparator {

    public static void main(String args[]) throws FileNotFoundException {
        File dir = new File("/Volumes/MATTE/Dir");
        String lista = ListDir.sortList(dir);
        System.out.println(lista);
    }

    public static List<File> listingDir(File dir) {
        List<File> file = new ArrayList<File>();
        File[] elementi = dir.listFiles();
        for (File files : elementi) {
            file.add(files);
            if (files.isDirectory()) {
                List<File> otherDir = listingDir(files);
                file.addAll(otherDir);
            }
        }
        return file;
    }

    public static String sortList(File dir) throws FileNotFoundException {
        validateDir(dir);
        List<File> file = listingDir(dir);
        String result = "";
        Collections.sort(file);
        for (File files : file) {
            result += files.getAbsolutePath() + "\n";
        }
        return result;
    }

    private static void validateDir(File dir) throws FileNotFoundException {
        if (dir == null) {
            throw new IllegalArgumentException("Directory should not be null.");
        }
        if (!dir.exists()) {
            throw new FileNotFoundException("Directory does not exist: " + dir);
        }
        if (!dir.isDirectory()) {
            throw new IllegalArgumentException("Is not a directory: " + dir);
        }
        if (!dir.canRead()) {
            throw new IllegalArgumentException("Directory cannot be read: " + dir);
        }
    }
}

so che devo implementare uno dei due metodi di comparator.
ho visto un pò in giro l'uso di compare.
ad esempio (dovrebbe ordinare dei numeri ma nn è il mio caso, lo prendo solo come esempio):

    public int compare(Object obj1, Object obj2) {

        ListDir c1 = (ListDir) obj1;
        ListDir c2 = (ListDir) obj2;

        int s1 = c1.getA() + c1.getB();
        int s2 = c2.getA() + c2.getB();

        return s1 - s2;
    }

ho alcuni problemi.
innanzitutto mi conviene usare compare sul metodo listingDir che ritorna una List<File> o su sortDir che ritorna una String?
io ho pensato fosse meglio su sortDir in quanto andrei a sotituire Collections.sort().
e poi come vado a sostituire gli int con le String?

[andbin]

Generalmente Comparator si implementa in una classe a parte, non in una classe che fa già altre cose. E visto che in generale stai usando i generics nel codice, puoi usarli anche con Comparator.

Gli oggetti che il tuo comparatore dovrà confrontare NON sono ListDir ma File. Userai poi la forma:

Collections.sort(lista, new UnComparatore());

Ed è chiaro che nel tuo caso la lista contiene oggetti java.io.File e quindi il comparatore tratterà e confronterà File.

public class OrdinePerNomeComparator implements Comparator<File> {
    public int compare(File f1, File f2) {
        ..........
    }
}

[fermat]

diciamo che ho ottenuto quello che vorrei:

/Volumes/MATTE/Dir/SecondaDir
/Volumes/MATTE/Dir/SecondaDir/Quarta dir
/Volumes/MATTE/Dir/SecondaDir/Quarta dir/c1.txt
/Volumes/MATTE/Dir/SecondaDir/Quarta dir/c2.txt
/Volumes/MATTE/Dir/SecondaDir/b1.txt
/Volumes/MATTE/Dir/a1.txt
/Volumes/MATTE/Dir/a2.txt

import java.io.*;
import java.util.*;

public class myComparator implements Comparator<File> {

    public int compare(File f1, File f2) {
        String file1 = f1.getAbsolutePath();
        String file2 = f2.getAbsolutePath();
        return file1.compareTo(file2);
    }
}

certo in una textarea nn rende benissimo.

[andbin]

Originariamente inviato da fermat
certo in una textarea nn rende benissimo.

Beh, effettivamente fatto così diventa un po' "prolisso". Ma dipende per chi e cosa fai la lista. Potresti anche pensare di mostrare nella textarea una struttura simile ad albero.

Se invece ti riferisci al fatto che "S" viene prima di "a" è ovviamente perché in ASCII le maiuscole hanno codice inferiore alle minuscole.

[fermat]

no no mi riferivo al primo punto.
è possibile mostrare una struttura ad albero dentro una textarea?
potresti farmi un esempio?

[andbin]

Originariamente inviato da fermat
è possibile mostrare una struttura ad albero dentro una textarea?
potresti farmi un esempio?

Innanzitutto non metti più i path completi. Poi comunque nella parte dove scansioni il file-system con tecnica ricorsiva, vai a collezionare stringhe dove, magari, come esempio, per ogni livello di annidamento aggiungi degli spazi davanti ai nomi.

Volumes
   MATTE
      Dir
         SecondaDir
            Quarta dir
               c1.txt
               c2.txt
            b1.txt
         a1.txt
         a2.txt

Se poi vuoi "abbellire" ancora di più con segni es. + o mettendo delle barrette | si può fare ma richiede della "logica" in più.

[fermat]

io pensavo di fare una cosa del genere:

    public static List<File> listingDir(File dir, int livello) {
        String spazio = "";
        List<File> file = new ArrayList<File>();
        File[] elementi = dir.listFiles();
        for (int l = 0; l < livello; l++) {
            spazio += "   ";
        }
        for (File files : elementi) {
            file.add(files);
            if (files.isDirectory()) {
                List<File> otherDir = listingDir(files, 0);
                file.addAll(otherDir);
            }
        }
        return file;
    }

    public static String sortList(File dir) throws FileNotFoundException {
        validateDir(dir);
        List<File> file = listingDir(dir, 0);
        String result = "";
        Collections.sort(file, new myComparator());
        for (File files : file) {
            result += files.getName() + "\n";
        }
        return result;
    }

ma il problema è che listDir ritorna una List<File>.
dove lo stampo lo spazio?
cambio di tipo di ritorno o il livello va messo altrove?

[andbin]

Originariamente inviato da fermat
ma il problema è che listDir ritorna una List<File>.

Innanzitutto nessuno ti vieta di avere quel/i metodo/i di scansione del file-system come "privati" e fare in modo che il metodo ricorsivo riceva anche un StringBuffer o StringBuilder così da appendere facilmente un nome di file "indentato" (con spazi proporzionali al "livello" di annidamento). E il metodo ricorsivo non dovrebbe più restituire qualcosa.

[fermat]

dici qualcosa del genere o ho sbagliato completamente?
nn ho mai usato StringBuilder (anche se è molto interessante):

    private static void listingDir(File dir, int livello) {
        String spazio = "";
        StringBuilder sb = new StringBuilder("");
        List<File> file = new ArrayList<File>();
        File[] elementi = dir.listFiles();
        for (int l = 0; l < livello; l++) {
            spazio += "   ";
        }
        for (File files : elementi) {
            file.add(files);
            if (files.isDirectory()) {
                listingDir(files, 0);
                StringBuilder append = sb.append(spazio).append(files);
            }
        }
    }

    public static String sortList(File dir) throws FileNotFoundException {
        validateDir(dir);
        List<File> file = listingDir(dir, 0);
        String result = "";
        Collections.sort(file, new myComparator());
        for (File files : file) {
            result += files.getName() + "\n";
        }
        return result;
    }

inoltre avendo messo questo metodo come void ho un problema su sort in quanto giustamente quando rihiama listDir si aspetta un void, e invece la gli do un List<File>.

[andbin]

Originariamente inviato da fermat
dici qualcosa del genere o ho sbagliato completamente?

La .... seconda che hai detto. Se ora non restituisce nulla (void) e non gli passi nemmeno lo StringBuffer/Builder .... come fai?

Il metodo listingDir dovrebbe ricevere il buffer! Che istanzi 1 volta sola quando invochi la prima volta listingDir con livello 0 che fa "partire" tutta la scansione.

E inoltre, mi pare pure chiaro che se scegli questa soluzione, l'ordinamento non puoi più farlo alla fine di tutto nel sortList, perché avresti solamente una lunga stringona (nel buffer) con già tutto concatenato e indentato.

Quindi l'ordinamento devi già farlo nel listingDir ad ogni livello di annidamento.