Newsgroup: it.comp.java
Titolo: Aiuto in Java su routine

Ciao a tutti, chi č che mi aiuta in questo progettino (universitario) ?
Vi invio questo codice java: non riesco a fare la routine  getMatrice()
(che la trovate qua sotto)
che dovrebbe tornare tutti gli abitanti di questo mondo immaginario inseriti
in una Vector che contiene N Abitanti.
E' in pratica una conversione da vector a matrice normale di oggetti
Abitanti
Ciao e grazie
/**
 * Insert the type's description here.
 * Creation date: (14/06/2002 13.40.38/)
 * @author: Administrator
 */
public class Flatlandia {
 private int lato = 0;
 private java.util.Vector Abitanti;
        /**
         * Flatlandia constructor comment.
         */
        public Flatlandia(int dim) {
                super();
                lato = dim;
                Abitanti = new java.util.Vector();
        }
        /**
         * Insert the method's description here.
         * Creation date: (14/06/2002 13.41.46)
         * @param n int
         */
        public void evolvi(int n) {
                if (n == 0) return;
                for (int i = 0; i < Abitanti.size(); i++) {
                        AbitanteFlatlandia abitante = (AbitanteFlatlandia)
Abitanti.elementAt(i);
                        int colonna = 0;
                        int riga = 0;
                        switch(abitante.getRappresentazione()) {
                                case 'r':
                                        colonna =
abitante.getCasella().getColonna();
                                        if ((colonna == lato - 1) ||
(colonna == 0)) abitante.cambiaDirezione();
                                        abitante.muovi();
                                        break;
                                case 'c':
                                        riga =
abitante.getCasella().getRiga();
                                        if ((riga == lato - 1) || (riga ==
0)) abitante.cambiaDirezione();
                                        abitante.muovi();
                                        break;
                                case 'd':
                                        colonna =
abitante.getCasella().getColonna();
                                        riga =
abitante.getCasella().getRiga();
                                        if (((colonna == lato - 1) ||
(colonna == 0)) || ((riga == lato - 1) || (riga == 0)))
abitante.cambiaDirezione();
                                        abitante.muovi();
                                        break;
                        }
                }
                evolvi(n - 1);
        }
        /**
         * Insert the method's description here.
         * Creation date: (14/06/2002 13.43.42)
         * @return test.Abitante
         */
        public Abitante[][] getMatrice() {
                return null;
        }
/**
 * Insert the method's description here.
 * Creation date: (14/06/2002 13.43.05)
 * @param nomeFile java.lang.String
 */
public void load(String nomeFile) {}
/**
 * Insert the method's description here.
 * Creation date: (14/06/2002 13.41.26)
 * @param comando java.lang.String
 */
public void parseComando(String comando) {
 int i1 = 0;
 int i2 = 0;
 System.out.println(comando);
 if (comando.substring(0,3).equals("put")) {
  char abitante = comando.charAt(4);
  i1 = comando.indexOf(" ", 5);
  i2 = comando.indexOf(" ", i1 + 1);
  int rigo = Integer.valueOf(comando.substring(i1 + 1, i2)).intValue();
  i1 = i2;
  i2 = comando.indexOf(" ", i1 + 1);
  int colonna = Integer.valueOf(comando.substring(i1 + 1, i2)).intValue();
  i1 = i2;
  i2 = comando.indexOf(" ", i1 + 1);
  String direzione = comando.substring(i1 + 1, comando.length());
  Abitanti.add(new AbitanteFlatlandia(abitante, new Casella(rigo, colonna),
direzione));
 } else if (comando.substring(0,4).equals("exec")) {
  i1 = comando.indexOf(" ");
  int num = Integer.valueOf(comando.substring(i1 + 1,
comando.length())).intValue();
  evolvi(num);
 } else if (comando.equals("print")) {
  System.out.println("--------------------------");
  for (int i = 0; i < Abitanti.size(); i++) {
   System.out.println(((AbitanteFlatlandia)
Abitanti.elementAt(i)).toString());
  }
 }
}
/**
 * Insert the method's description here.
 * Creation date: (14/06/2002 13.42.23)
 * @param nomeFile java.lang.String
 */
public void salva(String nomeFile) {}
/**
 * Insert the method's description here.
 * Creation date: (14/06/2002 13.42.07)
 * @return boolean
 */
public boolean tuttiEstinti() {
 return false;
}
}
/*
****************************************************************************
****
*/
/** Modella un generico abitante del mondo di Flatlandia */
abstract class Abitante {
  // CAMPI
  private char carattereAbitante; //il carattere utilizzato per
rappresentare
             //l'abitante nella rappresentazione
             //di Flatlandia. I caratteri
             //previsti sono: 'R' per
             //rappresentare un Row, 'C' per
             //rappresentare un Column, 'D' per
             //rappresentare un Diagonal.
  private Casella posizione; //la posizione attualmente occupata
dall'abitante
  private String direzione;  //la direzione in cui si sposta
//l'abitante i valori possibili sono
//"destra", "sinistra", "alto", "basso",
//"altoDestra", "altoSinistra", "bassoDestra" e
//"bassoSinistra"
// COSTRUTTORE
/* Costruisce un'istanza dell'abitante in cui il carattere che lo
 * rappresenta, la posizione di partenza e la direzione in cui si
 * muove sono specificati come parametri. */
public Abitante(char c, Casella posizioneIniziale, String dir) {
 carattereAbitante = c;
 posizione = posizioneIniziale;
 direzione = dir;
}
// METODI ASTRATTI
/* Cambia la direzione corrente dell'abitante. */
abstract public void cambiaDirezione();
/* Restituisce la casella attualmente occupata dall'abitante. */
public Casella getCasella() {
 return posizione;
}
/* Restituisce la stringa che rappresenta la direzione in cui si sta
   * attualmente muovendo l'abitante. */
public String getDirezione() {
 return direzione;
}
// METODI
/* Restituisce il carattere che rappresenta l'abitante corrente. */
public char getRappresentazione() {
 return carattereAbitante;
}
/* Muove l'abitante */
abstract public void muovi();
/**
 * Insert the method's description here.
 * Creation date: (14/06/2002 16.05.27)
 * @param newDirezion java.lang.String
 */
public void setDirezione(String newDirezione) {
 direzione = newDirezione;
}
/* Restituisce la stringa che rappresenta l'abitante. */
public String toString() {
 return "ABITANTE="
  + getRappresentazione()
  + ", POSIZIONE="
  + posizione.toString()
  + ", DIREZIONE="
  + direzione;
}
}
/*
****************************************************************************
****
*/
/**
 * Insert the type's description here.
 * Creation date: (14/06/2002 13.45.20)
 * @author: Administrator
 */
class AbitanteFlatlandia extends Abitante {
/**
 * AbitanteFlatlandia constructor comment.
 * @param c char
 * @param posizioneIniziale test.Casella
 * @param dir java.lang.String
 */
public AbitanteFlatlandia(char c, Casella posizioneIniziale, String dir) {
 super(c, posizioneIniziale, dir);
}
/* Cambia la direzione corrente dell'abitante. */
public void cambiaDirezione() {
 if (getDirezione().equals("alto"))
  setDirezione("basso");
 else
  if (getDirezione().equals("basso"))
   setDirezione("alto");
  else
   if (getDirezione().equals("destra"))
    setDirezione("sinistra");
   else
    if (getDirezione().equals("sinistra"))
     setDirezione("destra");
    else
                                        if
(getDirezione().equals("suDestra"))
      setDirezione("bassoSinistra");
     else
                                                if
(getDirezione().equals("giuSinistra"))
       setDirezione("altoDestra");
      else
                                                        if
(getDirezione().equals("suSinistra"))
        setDirezione("bassoDestra");
       else
                                                                if
(getDirezione().equals("giuDestra"))
         setDirezione("altoSinistra");
}
/* Muove l'abitante */
public void muovi() {
 if (getDirezione().equals("alto"))
  getCasella().setRiga(getCasella().getRiga() - 1);
 else
  if (getDirezione().equals("basso"))
   getCasella().setRiga(getCasella().getRiga() + 1);
  else
   if (getDirezione().equals("destra"))
    getCasella().setColonna(getCasella().getColonna() + 1);
   else
    if (getDirezione().equals("sinistra"))
     getCasella().setColonna(getCasella().getColonna() - 1);
    else
     if (getDirezione().equals("altoDestra")) {
      getCasella().setRiga(getCasella().getRiga() - 1);
      getCasella().setColonna(getCasella().getColonna() + 1);
     } else
      if (getDirezione().equals("altoSinistra")) {
       getCasella().setRiga(getCasella().getRiga() - 1);
       getCasella().setColonna(getCasella().getColonna() - 1);
      } else
       if (getDirezione().equals("bassoDestra")) {
        getCasella().setRiga(getCasella().getRiga() + 1);
        getCasella().setColonna(getCasella().getColonna() + 1);
       } else
        if (getDirezione().equals("bassoSinistra")) {
         getCasella().setRiga(getCasella().getRiga() + 1);
         getCasella().setColonna(getCasella().getColonna() - 1);
        }
}
}
/*
****************************************************************************
****
*/
/* Rappresenta una casella del mondo di Flatlandia */
class Casella {
  private int riga;
  private int colonna;
/* Costruisce la casella di coordinate (riga,colonna) */
public Casella(int riga, int colonna) {
 this.riga = riga;
 this.colonna = colonna;
}
/* Restituisce true se l'istanza passata come argomento rappresenta la
   * casella di quella corrente */
public boolean equals(Object o) {
 if (o instanceof Casella)
  return (
   this.riga == ((Casella) o).riga & this.colonna == ((Casella) o).colonna);
 else
  return false;
}
/* Restituisce la coordinata colonna */
public int getColonna() {
 return colonna;
}
/* Restituisce la coordinata riga */
public int getRiga() {
 return riga;
}
/**
 * Insert the method's description here.
 * Creation date: (14/06/2002 15.59.20)
 * @param newColonna int
 */
public void setColonna(int newColonna) {
 colonna = newColonna;
}
/**
 * Insert the method's description here.
 * Creation date: (14/06/2002 15.59.35)
 * @param newRiga int
 */
public void setRiga(int newRiga) {
 riga = newRiga;
}
public String toString() {
 return "(" + riga + "," + colonna + ")";
}
}

ma che hai fatto ???
[][] lo fai in c o altri linguaggi di tipo tradizionale.
Riscrivi i pezzi di codice con due Vector(s) ed usa gli Iterartor(s) ed 
il mondo ti sorriderà di nuovo. Non essere preoccupato della libertà dei 
vettori, la libertà non fa mai male, impara da Perl e Lisp.
Caio,
	kiuma

 ha scritto nel messaggio
news:3D26AAC3...@usa.net...
