Newsgroup: it.comp.java
Titolo: Ordinare un Array..

Salve, devo creare degli oggetti Articolo (che contengono un id e un
punteggio associato all'id).
devo inserirli in un array e successivamente ordinarli in maniera
decrescente in base al punteggio.
Successivamente mi devo stampare su file gli "id punteggio" ordinati..
Però ho trovato diversi problemi nel creare l'array...
questo è il codice che ho provato ad utilizzare...
        public static void main (String [] args) throws IOException{
                String line = "";
                BufferedReader in = null;
                in = new BufferedReader(new InputStreamReader( new
FileInputStream("file.txt"));
                line= in.readLine();
                ArrayList <Articolo> al = new ArrayList <Articolo>();
                while (line!= null)
                {
                        Articolo.AssegnaArticolo(line);
                        Articolo art = new Articolo();
                        al.add(art);
                        line = in.readLine();
                }
                System.out.println(al.size());
                Object[] alArray = al.toArray();
        }
}
class Articolo implements Comparable {
        public static void AssegnaArticolo (String line){
                StringTokenizer st = new StringTokenizer(line);
                 String primo = st.nextToken();
                String secondo = st.nextToken();
                int id = Integer.parseInt(primo);
                double rank = Double.parseDouble(secondo);
         }
        public int compareTo(Object o1) {
        }
}
Tutto ciò è uscito da alcuni consigli recepiti su it.comp.java
Ovviamente il compareTo non so come scriverlo...
(posto che quello che sta sopra sia corretto!!!) 
Grazie.

usa la classe Arrays per ordinare i vettori.
Vedi i javadoc
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

         }
E nemmeno questo metodo e' corretto. Dove vanno a finire id e rank?
Ci credo che poi non sai come usare compareTo, non hai campi su cui fare 
l'ordinamento.
Saluti
CarMas

 l'ordinamento.
Questo credo che sia il problema fondamentale... non so come far
passare id e rank agli articoli che creo in modo da richiamarli una
volta creato l'oggetto Articolo.

 volta creato l'oggetto Articolo.
Ti daro' una spintarella :P
class Articolo implements Comparable {
   private int id;
   private double rank;
   public Articolo() {
      id=-1;
      double=-1;
     // inizializzali come preferisci, giusto per fare capire che non sono 
ancora assegnati
   }
   public void assegnaArticolo(String line) {
      StringTokenizer st = new StringTokenizer(line);
      String primo = st.nextToken();
      String secondo = st.nextToken();
      id = Integer.parseInt(primo);
      rank = Double.parseDouble(secondo);
    // eventuali errori vedi tu come gestirli
   }
   public int compareTo(Object o) {
     // questo ora e' tuo
   }
}
poi nel main
ArrayList <Articolo> al = new ArrayList <Articolo>();
while (line!= null) {
  Articolo art = new Articolo();
  art.AssegnaArticolo(line);
  al.add(art);
  line = in.readLine();
}
e il resto te la vedi tu.
Saluti
CarMas

> e il resto te la vedi tu.
Ok. ho provato a creare il CompareTo, ma non riesco proprio a capire
una cosa, l'oggetto che prendo come argomento lo devo confrontare con
tutto l'array già presente? Però il sort lo faccio dopo.. giusto?

Elbrethril ha scritto:

compareTo e' un metodo che devi implementare tu per fare in modo che
l'oggetto Articolo sia comparabile.
poi tu fai un sort sulla tua arraylist (arraylist.sort()). il metodo
sort usa il compareTo() del tuo oggetto per poter capire quale Articolo
viene prima (e quindi ordinarli).
Ciao Jack

 viene prima (e quindi ordinarli).
Ma ancora non capisco... nel compareTo gli faccio scorrere tutto
l'array per comparare tutti gli art.rank per vedere se è maggiore o
minore? non credo..

Elbrethril ha scritto:

No, come leggi dai javadoc, compareTo prende come argomento un altro Object. 
Quindi ti devi occupare solo di scrivere l'algoritmo se l'oggetto su cui e' 
chiamata la compareTo e' piu' "grosso" o piu' "piccolo" dell'oggetto passato 
come parametro. (L'int che ritorna compareTo e' =0 se sono uguali, <0 se 
l'oggetto su cui invochi il metodo e' piu' piccolo, >0 se e' piu grande).

> quindi ordinarli).
E> Ma ancora non capisco... nel compareTo gli faccio scorrere tutto
E> l'array per comparare tutti gli art.rank per vedere se è maggiore o
E> minore? non credo..
Letta fu la  documentazione ??? (domanda fatta da  *dietro* una lupara
:) )
compareTo()  viene richiamata  ogni volta  che nel  sort  è necessario
sapere se l'elemento A è maggiore/minore/uguale dell'elemento B.
Quindi la tua compareTo deve rimodellare le regole con cui il tuo cli-
ente dice che l'articolo A è maggiore/minore/uguale dell'articolo B.
Quindi se hai definito rank come intero (esempio) allora fai una cosa del genere
class Articolo implements Comparable {
   // bla bla bla
   int rank;
   // bla bla bla
   public int compareTo(Object altro) {
      if ( ! altro instanceOf Articolo ) 
         throw new 
          ClassCastException("Ohi, ti ghe da darme un articolo, MONA!");
 
      // return sgn(rank.altro - rank) mi suona più efficente.
      else if (rank == altro.rank) 
           return 0;
      else if (rank < altro.rank) 
           return -1;
      else
           return 1;
 
   }
   // bla bla bla e ancora bla
}
Spero che sia d'aiuto...
-- 
 /\           ___
/___/\_|_|\_|__|___Gian Uberto Lauri_____
  //--\| | \|  |   Integralista GNUslamico
\/                 e coltivatore diretto di Software

> Spero che sia d'aiuto...
si, però nel main faccio una cosa del genere...
		BufferedReader in = null;
		in = new BufferedReader(new InputStreamReader( new file.txt);
		line= in.readLine();
		ArrayList <Articolo> al = new ArrayList <Articolo>();
		while (line!= null) {
			Articolo art = new Articolo();
			art.AssegnaArticolo(line);
			al.add(art);
a questo punto posso fare il sort tranquillamente? però ArrayList non
me lo permette giusto?

Elbrethril ha scritto:

a questo punto e' chiaro che non hai letto la documentazione...
vai a leggere la doc di Comparable e di ArrayList, e poi se hai ancora
problemi riposta...

 writes:
E> a questo punto posso fare il sort tranquillamente? però ArrayList
E> non me lo permette giusto?
Usa un contenitore diverso per avere l'ordinamento (Java ne ha! Lo hai
fatto il bookmark ai JavaDoc della versione che stai usando, veroooo?)
in automatico,  oppure uno  che ti generi  un array da  manipolare coi
metodi della classe Arrays.
/* scusa la domanda, come stiamo a inglese ? */


 /* scusa la domanda, come stiamo a inglese ? */
diciamo che la conoscenza molto scolastica mi permette di capire
molto... ma non tutto, perchè?

 /* scusa la domanda, come stiamo a inglese ? */
a furia di leggere le API l'inglese lo imparera'.
Altrimenti e' meglio che lascia perdere la programmazione...
-- 
Yoda of Borg am I! Assimilated shall you be! Futile resistance is, hmm?

 
Perche' il 99.9periodico% della documentazione e' in inglese. Senza inglese in 
questo mondo vai poco lontano.
Ciao, Co

 writes:
CA> Se usi ArrayList, va benissimo. Allora il discorso e' questo, se
CA> sbaglio mi corrigerete:
Crazie CorratoPaolo Primo per afer skritto ottima spiekazione (:) solo
per la forma del post)


 
E andatevene tutti in pace! :) Cioe'? la forma e' corretta ma il contenuto no?

> 
CA> E andatevene tutti  in pace! :) Cioe'? la forma  e' corretta ma il
CA> contenuto no?
Il contenuto č corretto e serissimo, la forma mi ha fatto sbellicare :)


 
Ah ok! sai a volte mi capita di tirare qualche castroneria.. siam qui tutti per 
imparare!

> Ti e' piu chiaro?
ok. mi è molto più chiaro. Però non mi torna una cosa...
io una volta riempito l'ArrayList <Articolo> al = new ArrayList
<Articolo>();
lo devo passare in Array per fare l'ordinamento...
ho provato con
Object [] articoli = al.toArray();
però in questo modo perdo i tipi Articolo? perchè così facendo
quando eseguo Arrays.sort(articoli);
per l'ordinamento non mi riconosce "articoli" di tipo Articolo e quindi
non trova articoli.rank per effettuare l'ordinamento...
Sbaglio qualcosa nel ragionamento?
Grazie mille a tutti...

> Object [] articoli = al.toArray();
Articoli articoli[] = (Articoli [])al.toArray()
per caso non funziona ? (non č ironia, non ho il tempo di testare :) )


 per caso non funziona ? (non è ironia, non ho il tempo di testare :) )
java.lang.ClassCastException...

Elbrethril ha scritto:

Ma allora non hai letto bene quello che ho scritto. Se hai ArrayList, puoi usare 
la classe Collections, metodo sort() invece di convertirlo in array e usare 
Arrays. In ogni caso, passarlo in array con la toArray non ti fa di certo 
perdere il senso di Articolo. Prova a fare
ArrayList<Articolo> al = new ArrayList<Articolo>();
// Riempi
Object[] articoli = al.toArray();
if (articoli[0] instanceof Articolo)
     System.out.println("In verita' ti dico, e' un Articolo");
Quando lo passi al sort, stai tranquillo funziona lo stesso.
Leggiti qualche capitolo sulla teoria dell'ereditarieta' e binding dinamico.

> :) )
E> java.lang.ClassCastException...
Giusto, č un array di Object popolato di Articoli...


 per caso non funziona ? (non è ironia, non ho il tempo di testare :) )
Articoli[] articoli=al.toArray(new Articoli[al.size()]);
Questo funziona?
Saluti
CarMas

      System.out.println("In verita' ti dico, e' un Articolo");
Ok, ed infatti il problema non era qui perchè effettivamente
articoli[] è di tipo Articolo..
però non riesco a farmi tornare il compareTo...
questi sono gli errori che mi da...
Exception in thread "main" java.lang.Error: Unresolved compilation
problems:
	art.rank cannot be resolved or is not a field
	art.rank cannot be resolved or is not a field
	at OrdinaArticoli.compareTo(CiteSeerOrdinaArticoli.java:27)
	at java.util.Arrays.mergeSort(Unknown Source)
	at java.util.Arrays.sort(Unknown Source)
	at java.util.Collections.sort(Unknown Source)
	at OrdinaArticoli.main(CiteSeerOrdinaArticoli.java:60)
art.rank è quello all'interno del compareTo appunto...
	public int compareTo(Object art) {
			if (rank == art.rank)
		           return 0;
		      else if (rank < art.rank)
		           return -1;
		      else
		           return 1;
	}	
ho letto la documentazione... ma non capisco...

 ho letto la documentazione... ma non capisco...
ma rank non e' private? se e' cosi non puoi leggere cosa contiene rank
tramite art.rank, ma devi fare un art.getRank() (chiaramente devi aver
definito il getRank()).
Ciao Jack


 definito il getRank()).
si, rank è private....
ti posto tutto il codice...
public class Articoli implements Comparable{
	private int id;
	private double rank;
	public void Articolo() {
		id=-1;
		rank = -1;
	}
	public void AssegnaArticolo(String line) {
		StringTokenizer st = new StringTokenizer(line);
		String primo = st.nextToken();
		String secondo = st.nextToken();
		id = Integer.parseInt(primo);
		rank = Double.parseDouble(secondo);
	}
	public int compareTo(Object art) {
		if (art instanceof Articoli)
		{
			if (rank == art.rank)
		           return 0;
		      else if (rank < art.rank)
		           return -1;
		      else
		           return 1;
		}
	}
	public static void main (String [] args) throws IOException
	{
		String line = "";
		BufferedReader in = null;
		in = new BufferedReader(new InputStreamReader( new
FileInputStream("file.txt"), "UTF-8"));
		line= in.readLine();
		ArrayList <Articoli> al = new ArrayList <Articoli>();
		while (line!= null) {
			Articoli art = new Articoli();
			art.AssegnaArticolo(line);
			al.add(art);
			line = in.readLine();
		}
		Collections.sort(al);
	}
}

 if (rank == art.rank)
probabilmente glielo devi castare.
public int compareTo(Object o) {
  if(o instanceof Articolo) {
    Articolo art=(Articolo)o;
    if(rank == o.ranl) { ... eccetera }
    ....
  }
  else {
     // caso non articolo
  }
}
Saluti
CarMas

    if(rank == o.ranl) { ... eccetera }
Questa ovviamente diventa
if(rank == art.rank) { }
Saluti
CarMas

 if(rank == art.rank) { }
ok!!! FUNZIONA!!!
è stato un parto... davvero!!!



 è stato un parto... davvero!!!
Chiaro che funziona ^^
Non so se ti abbiamo imboccato troppo o poco, l'importante e' che hai capito 
quello che hai fatto!!
Saluti
CarMas