compareto()

[bobo24]

Devo fare il seguente esercizio :

Scrivere una classa java che legga un file di testo contenente un elenco di parole e restituisca l’elenco in ordine alfabetico utilizzando l’interfaccia comparable.

Ho creato due file java(Parole.java e TestParole.java in cui ho il main)

Nel main al momento ho messo il seguente codice

ArrayList lista = Parole.leggiFile();
        Parole.stampa(lista);

mentre nellaltro ho :

public class Parole implements Comparable{  
    public static ArrayList <String> leggiFile()
    {
        ArrayList lista = new ArrayList();
        try
        {
            Scanner sc = new Scanner(new FileReader("prova.txt"));
            while(sc.hasNext())
            {
                lista.add(sc.nextLine());
            }
        }
        catch(FileNotFoundException e)
        {
            System.out.println("File non trovato");
        }
        catch(IOException e)
        {
            System.out.println("FileCorrotto");
        }
        return lista;
    }

    public static void stampa(ArrayList <String> parole)
    {
        Iterator it = parole.iterator();
        while(it.hasNext())
        {
            String par = (String) it.next();
            System.out.println(par);
        }
    }
    public int compareTo(Object o) 
  {

}

non so cosa mettere nel compareTo perchè questo è un caso un pò diverso da quello che ho già visto

[Pastore12]

Comincia con una letta qui (informazioni generali sull'interfaccia Comparable)

http://download.oracle.com/javase/1....omparable.html

Poi dai una letta qui

http://download.oracle.com/javase/1....il/Arrays.html

Ci trovi i metodi necessari per ordinare un ArrayList

Il metodo compareTo lo devi implementare solo se usi la Classe Comparator (vedi metodi sort nella classe Arrays) oppure se ti crei un tuo oggetto "Parola", che corrisponde a ogni singola parola del tuo file di testo. Ma da quel che ho capito, "Parola" è un semplice String, che è già Comparable di suo, quindi non ti occorre riscrivere il compareTo

[valia]

secondo me il punto è proprio che deve scrivere il suo compareTo (è un esercizio in fondo).

Parti da creare bene le classi

1. Parola, contiene una stringa, getter, setter, costruttore (con stringa anche se ti va) e soprattutto questa deve essere comparable con una stringa)
2. Classe Main, che contiene
a. costruttore (anche quello di default va bene)
b. loadFromFile() che carica le info da file e fa un add ordinato in una struttura dati (anche arraylist va bene)
c. print() che stampa la struttura dinamica caricata
d. metodo main che

         Main main = new Main(); 
         main.loadFromFile(); 
         main.print();

[bobo24]

Ragazzi, ho fatto nel seguente modo e l'output mi è venuto giusto :
Secondo voi può andare questo codice perchè, come potete notare, il compareTo l'ho solo scritto senza averlo implementato(proprio come mi aveva consigliato Pastore12):
file con main :

public class TestParole {
    public static void main(String[] args) {
        ArrayList lista = Parole.leggiFile();
        Parole.stampa(lista);
        Collections.sort(lista);
        System.out.println();
        Parole.stampa(lista);
    }
}

alro file senza main

public class Parole implements Comparable{
    public static ArrayList <String> leggiFile()
    {
        ArrayList lista = new ArrayList();
        try
        {
            FileInputStream fis = new FileInputStream("prova.txt");
            InputStreamReader isr = new InputStreamReader(fis);
            BufferedReader br = new BufferedReader(isr);
            String linea = br.readLine();
            while(linea != null)
            {
                String [] lineatmp = linea.split(" ");
                for(int i=0; i<lineatmp.length;i++)
                {
                    lista.add(lineatmp[i]);
                }
                linea=br.readLine();
            }
        }
        catch(FileNotFoundException e)
        {
            System.out.println("File non trovato");
        }
        catch(IOException e)
        {
            System.out.println("FileCorrotto");
        }
        return lista;
    }

    public static void stampa(ArrayList <String> parole)
    {
        Iterator it = parole.iterator();
        while(it.hasNext())
        {
            String par = (String) it.next();
            System.out.println(par);
        }
    }

    public int compareTo(Object o) {
        throw new UnsupportedOperationException("Not supported yet.");
    }
}

[valia]

allora, per modellizzare la classe per benino Parola deve contenere solo

1. stringa (che è la word)
2. costruttori opportuni (almeno quello di default)
3. getter, setter e implementazione di compareTo.

Quello che tu compari sono oggetti di tipo Parola, non Stringhe (che sono quelli che butti nel tuo arrayList).

Prova a fare come ti ho detto, mettendo nel main

private List<Parola> listaParole = new ArrayList<Parola>();

....

//metti il metodo load

private void load(){
//fai tutto il caricamento, supponi di avere in tmp una parola letta dal file

Parola p = new Parola(tmp); 
listaParole.add(p); 
}
....
//metti il metodo print

private void print(){

//come lo hai fatto tu, ma sull'array che ti ho definito io
}

//main

public static void main(String arg[]){
Main main = new Main(); 
main.load();
main.print();
}

in quel caso hai sfruttato sapientemente quello che è stato fatto per la classe String, il punto è che qui, anche se lo fai sulla stringa, devi farlo tu (per esercizio)

[Pastore12]

Boh, se quello che ha già scritto funziona, rispetta già la consegna.
Se si voleva proprio creare una classe che implementi l'interfaccia Comparable, la cosa poteva essere esplicitata meglio nel testo...

[bobo24]

Allora ne approfitto per farmi spiegare al volo queste poche rigo del prossimo esercizio che devo andare a fare, perchè non mi è molto chiaro :

Data una lista L contenente istanze dell'interfaccia Comparable, scrivere un metodo per costruire una nuova lista che contenga tutti i massimi locali di L, dove un massimo locale è un elemento x di L tale che il suo predecessore e il suo successore sono entrambi minori di x.
Testare il metodo con un semplice programma di verifica.

Intanto, Vi ringrazio per l'aiuto datomi riguardo l'esercizio precedente.

[Pastore12]

Originariamente inviato da bobo24
Data una lista L contenente istanze dell'interfaccia Comparable, scrivere un metodo per costruire una nuova lista che contenga tutti i massimi locali di L, dove un massimo locale è un elemento x di L tale che il suo predecessore e il suo successore sono entrambi minori di x.
Testare il metodo con un semplice programma di verifica.

Stai abusando del thread

Comunque, come esercizio è proprio carino.
I minimi e i massimi e locali sono roba da analisi matematica. Forse dovresti conoscerli già da lì.
Si tratta solo di scorrere la lista e verificare per ciasun elemento se la condizione di cui sopra è verificata per predecessore e successore.

[valia]

Originariamente inviato da Pastore12
Boh, se quello che ha già scritto funziona, rispetta già la consegna.
Se si voleva proprio creare una classe che implementi l'interfaccia Comparable, la cosa poteva essere esplicitata meglio nel testo...

il punto è che si deve esercitare sul compare e lo deve scrivere lui, lo ha fatto utilizzando la sort (di Collection) su String che ha già il compareTo implementato.
In pratica (e lo vedi dal codice) non ha fatto quello che chiedeva l'esercizio (cioè io lo taglierei) perché il compareTo se vedi ha

throw new UnsupportedOperation(....)

quindi in pratica non lo ha fatto.

Il secondo punto, si basa sempre sul creare una classe con le caratteristiche e implementare la logica di compare

[Pastore12]

Originariamente inviato da valia
il punto è che si deve esercitare sul compare e lo deve scrivere lui, lo ha fatto utilizzando la sort (di Collection) su String che ha già il compareTo implementato.
In pratica (e lo vedi dal codice) non ha fatto quello che chiedeva l'esercizio (cioè io lo taglierei) perché il compareTo se vedi ha

throw new UnsupportedOperation(....)

quindi in pratica non lo ha fatto.

Il secondo punto, si basa sempre sul creare una classe con le caratteristiche e implementare la logica di compare

Beh, che Parole implementi Comparable è un non-senso, d'accordo. E quella eccezione dimostra che non ha ancora troppo chiaro il concetto.
Per il resto è difficile capire esattamente cosa debba fare. Si chiede che usi l'interfaccia Comparable, e questo lo fa, delegando la cosa al metodo sort di Arrays.

Ora.. se trattandosi di un esercizio deve creare una classe Comparable, forse dovrebbe anche scrivere il suo metodo di ordinamento che la usi...
Se il file fosse stato più complesso di un elenco di parole, dall'interpretazione che dai tu non si scappava.