ordinamento array con metodo sort

[michela85cancro]

Ciao a tutti!

Io ho un array di Evento, che è una classe creata da me, che dovrei ordinare in base alla data usando il metodo sort... Ho necessità di utilizzare tale metodo per via della complessità computazionale dell'algoritmo di ordinamento che avevo creato per un Vector<Evento>...

Leggendo qua e là, ho letto che devo sviluppare un metodo compareTo all'interno della classe Evento, ma non ho ben capito di che cosa si tratta e come implementarlo.

Potreste darmi alcune delucidazioni in merito?

Grazie
Michela

[DonFrignolo]

Originariamente inviato da michela85cancro
Ciao a tutti!

Io ho un array di Evento, che è una classe creata da me, che dovrei ordinare in base alla data usando il metodo sort... Ho necessità di utilizzare tale metodo per via della complessità computazionale dell'algoritmo di ordinamento che avevo creato per un Vector<Evento>...

Leggendo qua e là, ho letto che devo sviluppare un metodo compareTo all'interno della classe Evento, ma non ho ben capito di che cosa si tratta e come implementarlo.

Potreste darmi alcune delucidazioni in merito?

Grazie
Michela

Comparable.
L'interfaccia contiene un metodo compareTo che dovrai implementare con la tua logica, nel tuo caso la data.
Quindi potrai utilizzare il metodo compareTo di java.util.Date in questo modo:

classe Evento implemets Comparable{
..........Tuo codice
pulic int compareTo(Evento b){
return b.getData().compareTo(this.getData());
}
}

A questo punto puoi utilizzare un qualunque oggetto java che utilizza i comparable come i TreeMap i TreeSet,SortedSet ecc. Mettendo dentro i tuoi oggetti verranno automaticamente ordinati.
TreeSet<Evento> set = new TreeSet<Evento>();
set.add(unevento);

Se invece hai bisogno di comparazione più complesse conviene creare una classe che implementa Comparator dove al suo interno metterai tutte le logiche di comparazione.

public class MioComparatore implemets Comparator{
public int compare(Evento a,Evento b){.....logica}
public boolean equals(Evento a) {....logica}

}
poi
TreeSet<Evento> set = new TreeSet<Evento>(MioComparatore);
set.add(unevento);

[michela85cancro]

Ti posto il codice che ho inserito

public class Evento implements Comparable{

    private String data;
    private String tipoEvento;
    private DataPoint dp;

    public Evento(String d, String tipo, DataPoint datapoint) {
        this.data = d;
        this.tipoEvento = tipo;
        this.dp=datapoint;
    }

//altro mio codice
    
public int compareTo(Evento b){
return b.getData().compareTo(this.getData());
}

    //questo me lo ha aggiunto in automatico NetBeans quando ho messo "implements" nella dichiarazione della classe
    public int compareTo(Object o) {
        int risultato=0;
        Calendar data=Main.stringToData((String) o, "d/M/y H:m");
        //qua devo metter l'if
        return risultato;
        
    }

}

Ho capito bene come fare? e poi l'if come lo costruisco?

[DonFrignolo]

Dovrebbe essere più o meno cosi

import java.util.*;
public class Evento implements Comparable{

    private String data;
    private String tipoEvento;
    private DataPoint dp;

    public Evento(String d, String tipo, DataPoint datapoint) {
        this.data = d;
        this.tipoEvento = tipo;
        this.dp=datapoint;
    }
    public String getData(){
       return this.data;
    }


    //questo me lo ha aggiunto in automatico NetBeans quando ho messo "implements" nella //dichiarazione della classe
    public int compareTo(Object o) {
        SimpleDateFormat formatoData = new SimpleDateFormat("dd/MM/YYYY"); //qui ci va il pattern del formato della data che utilizzi
        Date data1 = new Date();
        Data data2 = new Date();
        try {
            Evento b =(Evento)o;
            data1 = formatoData.parse(b.getData());
            
            data2=formatoData.parse(this.data);
        } catch (ParseException ex1) {
            //Tuo codice per gestire l'eccezione
        }
        return data1.compareTo(data2);
    }

}

dopo di che puoi utilizzare questo codice nel main (o nella classe che utilizzi)

TreeSet<Eventi> set = new TreeSet<Eventi>();
for(Eventi ev: tualLista){
     set.add(ev);
}
//oppure se la lista che utilizzi implementa collection (come Vector)

set.addAll(tuaLista);

A questo punto set è la tua lista ordinata per data

[andbin]

Originariamente inviato da michela85cancro
Ti posto il codice che ho inserito

Ho capito bene come fare?

Più o meno ..... Ma ci sono alcune questioni tecniche e concettuali da chiarire.

Sarebbe meglio se usassi i generics, cioè nel tuo caso vuol dire che dovresti dichiarare di implementare Comparable<Evento> e a quel punto devi definire int compareTo(Evento altro)

Se non usi i generics (solo Comparable), allora la "firma" del metodo deve essere int compareTo(Object altro) ed è generalmente compito del programmatore fare nel metodo un "cast" al tipo specifico, nel tuo caso ad Evento.

In ogni caso hai un "altro" Evento e devi compararlo con l'evento "this" (l'oggetto su cui è stato invocato compareTo).

Nella tua classe Evento sarebbe molto meglio se il campo interno per la data fosse di tipo Date o Calendar .... non certo String. La rappresentazione testuale di una data dovrebbe essere una cosa "esterna", solo per l'utente.
Se hai un Date esso ha compareTo() (da Java 1.2) e se avessi Calendar ha lo stesso il compareTo().
Se devi solo comparare per la data a quel punto sarebbe banale perché basta invocare appunto il compareTo().

[DonFrignolo]

Se non usi i generics (solo Comparable), allora la "firma" del metodo deve essere int compareTo(Object altro) ed è generalmente compito del programmatore fare nel metodo un "cast" al tipo specifico, nel tuo caso ad Evento.

Hai perfettemente ragione infatti me ne ero accorto e lo stavo correggendo

[michela85cancro]

scusate la mia "zucca dura", ma ho dovuto imparare java da sola in 2 settimane ed è la prima volta che programmo ad oggetti...
Allora, così come mi ha detto andbin ho modificato la data da String a Calendar... i metodi di conversione stringToData e dataToString li avevo già implementati....
Non ho capito se, avendo fatto ciò, non c'è più bisogno che implementi il compareTo oppure se lo devo fare così:

public int compareTo(Object o) {
        Evento e = (Evento) o;
        return this.compareTo(e); 
    }

A questo punto nel main devo mettere:

Vector<Evento> eventiOrdinati= set.addAll(eventiNonOrdinati);

Ho capito bene?

[andbin]

Originariamente inviato da michela85cancro
lo devo fare così:

public int compareTo(Object o) {
        Evento e = (Evento) o;
        return this.compareTo(e); 
    }

Ho capito bene?

No. Se, detto in generale, implementi Comparable nella tua classe Evento, è perché vuoi ovviamente poter stabilire un ordinamento degli oggetti Evento. Ma l'ordinamento sarà basato su qualcosa ... no? Ci deve essere cioè almeno 1 campo su cui fai l'ordinamento. Quale è? La data? Allora nel compareTo() che tu implementi in Evento devi andare a confrontare le due date, quella in 'this' e quella nell'altro Evento passato.
E il risultato di questo confronto è concettualmente il risultato complessivo del confronto tra 2 Evento.

Il codice che hai postato non solo non ha senso ... ma se lo provi .... vai in stack overflow ... perché richiama sempre sé stesso!!!

[michela85cancro]

Si, devo confrontare le date.... quindi va bene così?

public int compareTo(Object o) {
        Evento e = (Evento) o;
        Calendar data1=e.getData();
        Calendar data2=this.getData();
        return data2.compareTo(data1); 
    }

[DonFrignolo]

public int compareTo(Object o) {
        Evento e = (Evento) o;
        Calendar data1=e.getData();

        return this.compareTo(e); 
    }

No nemmeno ora....
Richiamarlo cosi ricorsivamente il compareTo va in un ciclo infinito!!!

Se hai cambiato da string a calendar allora il compare to dentro eventi diventerà

public int compareTo(Object o) {
        Evento e = (Evento) o;
        return this.data.compareTo(e.getData()); 
    }

Questo perchè puoi sfruttare il metodo di comparazione che è contenuto nella classe Calendar che fa già tutti i controlli necessari e non devi implementare altro.

Vector<Evento> eventiOrdinati= set.addAll(eventiNonOrdinati);

Questo non ti serve perchè le classi Vector e TreeSet sono entrambe Collection, quindi puoi utilizzare il TreeSet senza fare assegnazioni.