matrici

Per identificare di quale elemento si stesse parlando si è usato un indice. Pensa ora ad una tabella, ad un foglio di calcolo: per identificarne una cella occorre specificare la riga e la colonna. Per far questo si usa la coppia di parentesi quadre [][]. Nella prima si inserirà il numero di righe del vettore nella dichiarazione o il numero di riga alla quale si vuole accedere, nella seconda si inserirà il numero di colonne nella dichiarazione o il numero di colonna alla quale si vuole accedere. Per creare oggetti valgono esattamente le regole viste per il vettore.

Non rimane che risolvere qualche problema.

La tavola pitagorica (da 1 a 11)

public class Pitagorica extends Application {
   Text elementi[][];
   

   public void start(Stage primaryStage) {
      elementi = new Text[11][11];
      int riga, colonna;
      GridPane p = new GridPane();
      for(riga=0;riga<11;riga++) {             //per ogni riga da 0 a 10...
         for(colonna=0;colonna<11;colonna++) { //...per ciascuna colonna nella riga riga...
         elementi[riga][colonna] = new Text("" + ((riga+1)*(colonna+1)) ); //il valore è il n° di riga * quello di colonna
         p.add(elementi[riga][colonna], colonna, riga);
      }
      Scene scena = new Scene(p, 400, 400);
      primaryStage.setTitle("Tavola pitagorica");
      primaryStage.setScene(scena);
      primaryStage.show();
   }
}

Il massimo ed il minimo (matrice non ordinata)

Si scorrono tutti gli elementi, cioè una riga alla volta tutti gli elementi in ciascuna colonna e via via si tiene memoria di quale è il minimo ed il massimo fino a quel momento

public class MinMax extends Application {
   int matrice[][];
   TextField indicaRighe = new TextField();
   TextField indicaColonne = new TextField();
   TextField elemento = new TextField();
   Text risMin = new Text("...");
   Text risMax = new Text("...");
   int numRighe, numColonne, rCar, cCar; //Le ultime due sono il n° di righe e colonne caricate
   

   public void start(Stage primaryStage) {
      Text lIndicaRighe = new Text("N° righe");
      Text lIndicaColonne = new Text("N° colonne");
      Text lElemento = new Text("Valore cella");
      Button impostaDimensione = new Button("Prepara matrice");
      Button caricaMatrice = new Button("Inserisci elemento");
      Button eseguiCalcolo = new Button("Individua");
      Text lRisMin = new Text("Minimo");
      Text lRisMax = new Text("Massimo");
      GridPane p = new GridPane();
      p.add(lIndicaRighe, 0, 0);
      p.add(indicaRighe, 1, 0);
      p.add(lIndicaColonne, 0, 1);
      p.add(indicaColonne, 1, 1);
      p.add(impostaDimensione, 1, 2);
      p.add(lElemento, 0, 3);
      p.add(elemento, 1, 3);
      p.add(caricaMatrice, 1, 4);
      p.add(eseguiCalcolo, 1, 5);
      p.add(lRisMin, 0, 6);
      p.add(risMin, 1, 6);
      p.add(lRisMax, 0, 7);
      p.add(risMax, 1, 7);
      impostaDimensione.setOnAction(new EventHandler<ActionEvent>() {
         @Override
         public void handle(ActionEvent event) {
            dimensiona();
         }
      });
      caricaMatrice.setOnAction(new EventHandler<ActionEvent>() {
         @Override
         public void handle(ActionEvent event) {
            carica();
         }
      });
      eseguiCalcolo.setOnAction(new EventHandler<ActionEvent>() {
         @Override
         public void handle(ActionEvent event) {
            calcola();
         }
      });
      Scene scena = new Scene(p, 350, 500);
      primaryStage.setTitle("Massimo & minimo");
      primaryStage.setScene(scena);
      primaryStage.show();
   }
   

   public void dimensiona() {
      numRighe = Integer.parseInt(indicaRighe.getText());
      numColonne = Integer.parseInt(indicaColonne.getText());
      matrice = new int[numRighe][numColonne];
      rCar = cCar = 0;
   }
   

   public void carica() {
      if(rCar < numRighe) {
         if(cCar < numColonne) {
            matrice[rCar][cCar] = Integer.parseInt(elemento.getText());
            cCar++;
         } else {
            rCar++;
            cCar = 0;
         }
      } else {
         elemento.setText("Matrice piena.");
      }
   }
   

   public void calcola() {
      int massimo, minimo, riga, colonna;
      for(riga = 0; riga < rCar; riga++) {
         for(colonna = 0, minimo = massimo = matrice[riga][0]; colonna < cCar; colonna++) {
            if(massimo < matrice[riga][colonna]) {
               massimo = matrice[riga][colonna];
            }
            if(minimo > matrice[riga][colonna]) {
               minimo = matrice[riga][colonna];
            }
         }
      }
      risMin.setText(minimo + "");
      risMax.setText(massimo + "");
   }
}

Il re mangia?

Viene data una normale scacchiera di 8 righe ed 8 colonne, si dispone il re in una certa posizione e 4 pezzi avversari in altrettante posizioni. Ci si chiede se, una volta individuato il re, questi possa mangiare un pezzo avversario. Anche se è possibile risolvere questo problema in modo meno costoso, si userà una matrice nella quale per convenzione indichiamo il contenuto della cella 0 se questa è vuota; 1 se questa contiene il re in questione ed il 2 se contiene uno dei 4 avversari.

Sebbene la posizione del re si conosca, per risolvere questo esercizio facciamo a meno di tale informazione; andremo quindi a curiosare in ciascuna cella della matrice fino a trovare il re o arrivare alla fine della scacchiera.

public class ReMangia extends Application {
   int scacchiera[][] = new int[8][8];
   TextField reX = new TextField(); //Contiene il numero di colonna del re
   TextField reY = new TextField(); //Contiene il numero di riga del re
   TextField avversarioX = new TextField(); //Contiene il numero di colonna di ciascun avversario (uno alla volta)
   TextField avversarioY = new TextField(); //Contiene il numero di riga di ciascun avversario (uno alla volta)
   Text lAvversarioX = new Text("Colonna dell'avversario 1");
   Text lAvversarioY = new Text("Riga dell'avversario 1");
   Button impostaAvversario = new Button("Posiziona l'avversario 1");
   Text ris = new Text("...");
   int numAvversario;
   

   public void start(Stage primaryStage) {
      Text lReX = new Text("Colonna del re");
      Text lReY = new Text("Riga del re");
      Button impostaRe = new Button("Posiziona il re");
      Button siMangia = new Button("Verifica se mangia");
      numAvversario = 5;
      impostaRe.setOnAction(new EventHandler<ActionEvent>() {
         @Override
         public void handle(ActionEvent event) {
            reXY();
         }
      });
      impostaAvversario.setOnAction(new EventHandler<ActionEvent>() {
         @Override
         public void handle(ActionEvent event) {
            avversarioXY();
         }
      });
      siMangia.setOnAction(new EventHandler<ActionEvent>() {
         @Override
         public void handle(ActionEvent event) {
            mangia();
         }
      });
      GridPane p = new GridPane();
      p.add(lReX, 0, 0);
      p.add(reX, 1, 0);
      p.add(lReY, 0, 1);
      p.add(reY, 1, 1);
      p.add(impostaRe, 1, 2);
      p.add(lAvversarioX, 0, 3);
      p.add(avversarioX, 1, 3);
      p.add(lAvversarioY, 0, 4);
      p.add(avversarioY, 1, 4);
      p.add(impostaAvversario, 1, 5);
      p.add(siMangia, 1, 6);
      p.add(ris, 0, 7, 2, 1);
      Scene scena = new Scene(p, 400, 400);
      primaryStage.setTitle("Il re mangia?");
      primaryStage.setScene(scena);
      primaryStage.show();
   }
   

   public void reXY() {   //Quando posiziono il re pulisco prima tutta la matrice da eventuali impostazioni precedenti
      int riga, colonna;
      for(riga = 0; riga < 8; riga++) {
         for(colonna = 0; colonna < 8; colonna++) {
            scacchiera[riga][colonna] = 0;
         }
      }
      numAvversario = 1;
      lAvversarioX.setText("Colonna dell'avversario 1");
      lAvversarioY.setText("Riga dell'avversario 1");
      impostaAvversario.setText("Posiziona l'avversario 1");
      riga = Integer.parseInt(reX.getText());
      colonna = Integer.parseInt(reY.getText());
      scacchiera[riga][colonna] = 1;
   }
   

   public void avversarioXY() {
      int riga, colonna;
      riga = Integer.parseInt(avversarioX.getText());
      colonna = Integer.parseInt(avversarioY.getText());
      if(numAvversario <= 4) {
         if(scacchiera[riga][colonna] == 0) {
            scacchiera[riga][colonna] = 2;
            numAvversario++;
            lAvversarioX.setText("Colonna dell'avversario " + numAvversario);
            lAvversarioY.setText("Riga dell'avversario " + numAvversario);
            impostaAvversario.setText("Posiziona l'avversario " + numAvversario);
         } else {
            avversarioX.setText("Posizione");
            avversarioY.setText("impegnata");
         }
      } else {
            avversarioX.setText("Avversari");
            avversarioY.setText("posizionati");
         }
   }
   

   public void mangia() {
      int riga, colonna, conta, i, j;
      for(conta = riga = 0; riga < 8; riga++) {
         for(colonna = 0; colonna < 8; colonna++) {
            if(scacchiera[riga][colonna] == 1) {
               if(riga == 0) {
                  i = 0;
               } else {
                  i = -1;
               }
               for(; i < 2 && riga+i < 8; i++) {
                  if(colonna == 0) {
                     j = 0;
                  } else {
                     j = -1;
                  for(; j < 2 && colonna+j < 8; j++) {
                     if(scacchiera[riga+i][colonna+j] == 2) {
                        conta++;
                  }
               }
            }
         }
      }
      if(conta > 0) {
         ris.setText("Hai " + conta + " possibilità di mangiare.");
      } else {
         ris.setText("Non hai possibilità di mangiare.");
      }
   }
}

Giunto ormai è il momento di provare da soli.

Prova ad implementare le due varianti di caricamento di una matrice: tramite matrice di TextField e tramite un'unica TextField.