Esempi JAVA

Da Bioingegneria Elettronica e Informatica.

Pagina in lavorazione

Hello World

Esercizio introduttivo a JAVA. Il seguente codice mostra a video la stringa "Hello World !" 

  1. /* Questo è il primo programma in JAVA
  2.  * e inizia con un commento multilinea
  3.  */
  4.  
  5. // Commento su singola linea
  6.  
  7. /**
  8.  * Uso della javadoc 
  9.  * Questo programma deve stampare sullo standard output, ovvero la console,
  10.  * la stringa "Hello World !"
  11.  * 
  12.  * @author antonio
  13.  *
  14.  */
  15.  
  16. public class Principale {
  17.  
  18. 	/**
  19. 	 * Metodo di avvio del programma
  20. 	 * @param args argomenti passati dalla linea di comando
  21. 	 */
  22. 	public static void main(String[] args) {
  23.  
  24. 		// Standard output
  25. 		System.out.println("Hello World !");	
  26. 	}
  27. }

Uso delle funzioni: Doppio e Somma

Codice Java per l'introduzione alle funzioni; sono state implementate due funzioni:

  1. calcolo del doppio di un numero intero;
  2. calcolo della somma di due numeri interi. 
  1. /** Programma per mostrare il funzionamento di:
  2.  *  1. Funzione chiamante (main) e funzione chiamata;
  3.  *  2. Variabili locali e parametri (valori) attuali; 
  4.  *  3. Passaggio per Valore;
  5.  * 
  6.  * @author antonio
  7.  * 
  8.  */
  9. public class Principale {
  10.  
  11. 	public static void main(String[] args) {
  12.  
  13. 		new Principale().run();
  14. 	}
  15.  
  16. 	public void run() {
  17.                 // Dichiarazione e inizializzazione delle variabili origin, origin2 e result
  18. 		int origin = 3;
  19. 		int origin2 = 5;
  20. 		int result = 0;
  21.  
  22. 		System.out.println("Doppio di una variabile");
  23.  
  24. 		// Stampa in console del valore attuale di origin
  25. 		System.out.println("Il valore di origin è: " + origin);
  26.  
  27.                 /* Calcolo il doppio della variabile origin:
  28.                  * 1. chiamo la funzione doppio
  29.                  * 2. salvo il risultato nella variabile result
  30.                  */
  31. 		result = doppio(origin);
  32.  
  33. 		// Stampa in console il valore di result
  34. 		System.out.println("Il valore di result è: " + result);
  35.  
  36.  
  37. 		System.out.println("Somma di due variabili");
  38.  
  39. 		// Stampa in console del valore attuale di origin e origin2
  40. 		System.out.println("Il valore di origin è: " + origin);
  41. 		System.out.println("Il valore di origin2 è: " + origin2);
  42.  
  43.                 // Calcolo la somma di origin e origin2
  44. 		result = somma(origin, origin2);
  45.  
  46.                 // Stampa in console il valore di result
  47. 		System.out.println("Il valore di result è: " + result);
  48. 	}
  49.  
  50. 	/**
  51. 	 * Funzione per calcolare il doppio di un valore
  52. 	 * @param val
  53. 	 * @return
  54. 	 */
  55. 	public int doppio(int val) {
  56.                 // Dichiaro la variabile res per salvare il doppio della variabile val
  57. 		int res = 0;
  58. 		res = val * 2;
  59.  
  60.                 // Restituzione di res
  61. 		return res;
  62. 	}
  63.  
  64. 	/**
  65. 	 * Funzione per calcolare la somma di due addendi
  66. 	 * @param add1
  67. 	 * @param add2
  68. 	 * @return
  69. 	 */
  70. 	public int somma(int add1, int add2) {
  71.  
  72.                 // Codice compatto che fa la somma di add1 e add2 e restituisce il risultato
  73. 		return add1 + add2;
  74. 	}
  75. }

Scambio di due elementi all'interno di un vettore

Codice Java che implementa lo scambio di due componenti in un vettore; sono stati implementati due casi:

  1. caso1: vettore di sole due componenti che vengono scambiate (funzione scambia(...));
  2. caso2: vettore di dimensione N nel quale sono scambiate le componenti con indice ind1 e ind2 (funzione scambia_componenti(...)). 
  1. public class Principale {
  2.  
  3. 	public static void main(String[] args) {
  4.  
  5. 		new Principale().run();
  6. 	}
  7.  
  8. 	public void run() {
  9. 		// Vettore formato da due elementi
  10. 		int[] v = {3,5};
  11.  
  12. 		// Stampo il valore delle due variabili prima dello scambio
  13. 		System.out.println("La prima componente del vettore vale: " + v[0]);
  14. 		System.out.println("La seconda componente del vettore vale: " + v[1]);
  15.  
  16. 		// Effettuo lo scambio
  17. 		scambia(v);
  18.  
  19. 		// Stampo il valore delle due variabili dopo lo scambio
  20. 		System.out.println("La prima componente del vettore vale: " + v[0]);
  21. 		System.out.println("La seconda componente del vettore vale: " + v[1]);
  22.  
  23.  
  24. 		// Generalizzazione a vettore formato da N elementi in cui indico le componenti da scambiare
  25. 		// Vettore formato da N elementi
  26. 		int N = 10;
  27. 		int i = 0;
  28. 		int[] vett = new int[N];
  29.  
  30. 		for(i = 0; i < N; i++)
  31. 			vett[i] = i+1;
  32.  
  33. 		int ind1 = 3;
  34. 		int ind2 = 8;
  35. 		// Stampo il vettore prima dello scambio
  36. 		for(i = 0; i < N; i++)
  37. 			System.out.print(vett[i] + " ");
  38. 		System.out.println();
  39.  
  40. 		// Effettuo lo scambio
  41. 		scambia_componenti(vett, ind1, ind2);
  42.  
  43. 		// Stampo il vettore dopo dello scambio
  44. 		for(i = 0; i < N; i++)
  45. 			System.out.print(vett[i] + " ");
  46. 		System.out.println();
  47. 	}
  48.  
  49. 	/**
  50. 	 * Funzione scambia funzionante
  51. 	 * @param V
  52. 	 */
  53. 	public void scambia(int[] V) {
  54. 		int temp;
  55. 		temp = V[0];
  56. 		V[0] = V[1];
  57. 		V[1] = temp;
  58.  
  59. 	}
  60.  
  61.         /**
  62. 	 * Funzione di scambio delle componenti in posizione c1 e c2 del vettore V 
  63. 	 * @param V
  64. 	 * @param c1
  65. 	 * @param c2
  66. 	 */
  67. 	public void scambia_componenti(int[] V, int c1, int c2) {
  68. 		int temp;
  69. 		temp = V[c1];
  70. 		V[c1] = V[c2];
  71. 		V[c2] = temp;
  72. 	}
  73. }

Prodotto tra matrici

Codice Java che implementa il prodotto, righe per colonne, tra due matrici. 

  1. public class Principale {
  2.  
  3. 	public static void main(String[] args) {
  4.  
  5. 		new Principale().run();
  6. 	}
  7.  
  8. 	public void run() {
  9. 		int r1, c1;
  10. 		int r2, c2;
  11. 		int k;
  12.  
  13. 		// Affinchè il prodotto tra matrici possa essere eseguito è necessario che c1 = r2;
  14.  
  15. 		// Dimensioni prima matrice
  16. 		r1 = 2;
  17. 		c1 = 3;
  18.  
  19. 		// Dimensioni della seconda matrice
  20. 		r2 = 3;
  21. 		c2 = 5;
  22.  
  23. 		// Valorizzazzione matrice1 con numeri interi da 0 (r1*c1)-1
  24. 		k = 0;
  25.  
  26. 		int[][] mat1 = new int[r1][c1];
  27.  
  28. 		for (int i  = 0; i < r1; i++) {
  29. 			for (int j = 0; j < c1; j++) {
  30. 				mat1[i][j] = k;
  31. 				k++;
  32. 			}
  33. 		}
  34.  
  35. 		// Valorizzazzione matrice1 con numeri interi da 0 (r2*c2)-1
  36. 		k = 0;
  37.  
  38. 		int[][] mat2 = new int[r2][c2];
  39. 		for (int i  = 0; i < r2; i++) {
  40. 			for (int j = 0; j < c2; j++) {
  41. 				mat2[i][j] = k;
  42. 				k++;
  43. 			}
  44. 		}
  45.  
  46. 		// Stampa delle matrici mat1 e mat2
  47. 		System.out.println("La prima matrice vale: ");
  48. 		stampaMatrice(mat1, r1, c1);
  49. 		System.out.println("La seconda matrice vale: ");
  50. 		stampaMatrice(mat2, r2, c2);
  51.  
  52. 		/* Controllo che le dimensioni delle matrici rispettano r2 == c1 
  53. 		 * affinchè sia possibile effettuare il prodotto tra le due matrici 
  54. 		 */
  55. 		if (r2 != c1) {
  56. 			System.out.println("Non è possibile fare il prodotto tra matrici");
  57. 		}
  58. 		else {
  59. 			// Dichiarazione della matrice prodotto mat3 di dimensioni r1*c2
  60. 			int[][] mat3 = new int[r1][c2];
  61.  
  62. 			// Il prodotto tra le matrici è effettuato nella relativa funzione
  63. 			prodottoMatrici(mat1, r1, c1, mat2, r2, c2, mat3);
  64.  
  65. 			// Stampa della matrice prodotto mat3
  66. 			System.out.println("La matrice prodotto vale: ");
  67. 			stampaMatrice(mat3, r1, c2);
  68. 		}
  69. 	}
  70.  
  71. 	/**
  72. 	 * Funzione per la stampa della matrice mat note le sue dimensioni r e c
  73. 	 * @param mat
  74. 	 * @param r
  75. 	 * @param c
  76. 	 */
  77. 	public void stampaMatrice(int[][] mat, int r, int c) {
  78. 		int i = 0;
  79. 		int j = 0;
  80.  
  81. 		for (i = 0; i < r; i++) {
  82. 			for (j = 0; j < c; j++) {
  83. 				System.out.print(mat[i][j] + "\t");
  84. 			}
  85. 			System.out.println();
  86. 		}
  87. 	}
  88.  
  89. 	/**
  90. 	 * Funzione che effettua il prodotto tra matrici
  91. 	 * @param A prima matrice
  92. 	 * @param r1 numero di righe della prima matrice
  93. 	 * @param c1 numero di colonne della prima matrice
  94. 	 * @param B seconda matrice
  95. 	 * @param r2 numero di righe della seconda matrice
  96. 	 * @param c2 numero di colonne della seconda matrice
  97. 	 * @param C matrice prodotto
  98. 	 */
  99. 	public void prodottoMatrici(int[][] A, int r1, int c1, int[][] B, int r2, int c2, int[][] C) {
  100. 		int i = 0;
  101. 		int j = 0;
  102. 		int k = 0;
  103.  
  104. 		// Algoritmo per il prodotto tra matrici
  105. 		for (i = 0; i < r1; i++) {
  106. 			for (k = 0; k < c2; k++) {
  107. 				C[i][k] = 0;
  108. 				for (j = 0; j < c1; j++) {
  109. 					C[i][k] = C[i][k] + A[i][j] * B[j][k];
  110. 				}
  111. 			}
  112. 		}
  113. 	}
  114. }

Algoritmo di ordinamento Selection Sort

Codice Java che implementa l'algoritmo di ordinamento Selection Sort. 

  1. public class Principale {
  2.  
  3. 	public static void main(String[] args) {
  4.  
  5. 		new Principale().run();
  6. 	}
  7.  
  8. 	public void run() {
  9. 		int i = 0;
  10.  
  11. 		// Vettore formato da N elementi
  12. 		int N = 10;
  13. 		int[] vett = {15, 25, 18, 6, 4, 9, 110, 200, 0, 201};
  14.  
  15. 		// Stampo il vettore prima dell'ordinamento
  16. 		for(i = 0; i < N; i++)
  17. 			System.out.print(vett[i] + " ");
  18. 		System.out.println();
  19.  
  20. 		// Effettuo l'ordinamento
  21. 		ordinamentoSelectionSort(vett, N);
  22.  
  23. 		// Stampo il vettore dopo l'ordinamento
  24. 		for(i = 0; i < N; i++)
  25. 			System.out.print(vett[i] + " ");
  26. 		System.out.println();
  27. 	}
  28.  
  29.         /**
  30. 	 * Funzione che implementa l'algoritmo di ordinamento Selection Sort noti il vettore e la sua dimensione
  31. 	 * @param V
  32. 	 * @param dim
  33. 	 */
  34. 	public void ordinamentoSelectionSort(int[] V, int dim) {
  35. 		int i = 0;
  36. 		int j = 0;
  37. 		int i_min = 0;
  38.  
  39. 		for (i = 0; i < dim -1; i++) {
  40. 			i_min = i;
  41. 			for (j = i+1; j < dim; j++ ) {
  42. 				if (V[j] < V[i_min])
  43. 					i_min = j;
  44. 			}
  45.  
  46. 			scambia_componenti(V, i, i_min);
  47. 		}
  48. 	}
  49.  
  50.         /**
  51. 	 * Funzione di scambio delle componenti in posizione c1 e c2 del vettore V 
  52. 	 * @param V
  53. 	 * @param c1
  54. 	 * @param c2
  55. 	 */
  56. 	public void scambia_componenti(int[] V, int c1, int c2) {
  57. 		int temp = V[c1];
  58. 		V[c1] = V[c2];
  59. 		V[c2] = temp;
  60. 	}
  61. }

Algoritmo di fusione Merge Sort

Consideriamo due vettori (U e V) già ordinati con lo stesso criterio e nelle ipotesi che la loro lunghezza non coincida, che ogni vettore non contenga elementi uguali e che non ci sono elementi comuni tra i due vettori. L'algoritmo merge sort crea un terzo vettore ordinato (W) dato dalla fusione dei primi due. La logica alla base dell'algoritmo è quella di far lavorare in un ciclo due indici (i e j), ciascuno su un vettore, scorrendo i quali si aggiunge al vettore fusione volta per volta l'elemento minore a cui fanno riferimento i due indici. Quando uno dei due vettori termina, si aggiungono al vettore fusione i restanti elementi dell'altro vettore. 

  1. public class MergeSort {
  2.  
  3. 	public static void main(String[] args) {
  4.  
  5. 		new MergeSort().run();
  6. 	}
  7.  
  8. 	public void run() {
  9.  
  10. 		// Dimensioni dei Vettori U e V
  11. 		int n = 10;
  12. 		int m = 20;
  13.  
  14. 		// I vettori su cui applicare il merge sort
  15. 		int[] U = {21, 30, 15, 6, 0, 1, 78, 99, 100, 200};
  16. 		int[] V = {3, 251, 20, 5, 9, 101, 45, 67, 80, 71, 98, 2, 7, 125, 156, 24, 1010, 4, 8, 2000};
  17.  
  18. 		// Applico l'ordinamento su entrambi i vettori con l'algoritmo Selection SOrt
  19. 		ordinamentoSelectionSort(U, n);
  20. 		ordinamentoSelectionSort(V, m);
  21.  
  22. 		// Ora che i vettori sono entrambi ordinati posso fare il merge sort
  23. 		int[] W = new int[n+m];
  24. 		mergeSort(U, n, V, m, W);
  25.  
  26.                 // Stampa i tre vettori U,V e W
  27. 		stampaVettore(U,n);
  28. 		stampaVettore(V,m);
  29. 		stampaVettore(W,n+m);
  30.  
  31. 	}
  32.  
  33. 		/**
  34. 	 * Funzione che implementa l'algoritmo di Merge Sort
  35. 	 * @param v1
  36. 	 * @param dim1
  37. 	 * @param v2
  38. 	 * @param dim2
  39. 	 * @param v3
  40. 	 */
  41. 	public void mergeSort(int[] v1, int dim1, int[] v2, int dim2, int[] v3) {
  42.  
  43. 		int i = 0;
  44. 		int j = 0;
  45. 		int k = 0;
  46.  
  47. 		// Utilizzo gli indici i e j che scorrono sui vettori v1 e v2 rispettivamente.
  48. 		while (i < dim1 && j < dim2) {
  49. 			if(v1[i] < v2[j]) {
  50. 				v3[k] = v1[i];
  51. 				i++;
  52. 			}
  53. 			else {
  54. 				v3[k] = v2[j];
  55. 				j++;
  56. 			}
  57. 			k++;
  58. 		}
  59.  
  60. 		/* Il blocco condizionale if serve a capire qual è il vettore non terminato
  61. 		 * in modo da inserire i sui rimanenti elementi nel vettore fusione v3
  62. 		 */
  63. 		if (i < dim1) {
  64. 			for (i = i; i < dim1; i++) {
  65. 				v3[k] = v1[i];
  66. 				k++;
  67. 			}
  68. 		}
  69. 		else {
  70. 			for (; j < dim2; j++) {
  71. 				v3[k] = v2[j];
  72. 				k++;
  73. 			}
  74. 		}
  75. 	}
  76.  
  77.  
  78. 	/**
  79. 	 * Funzione di ordinamento con algoritmo Selection Sort
  80. 	 * @param vett
  81. 	 * @param dim
  82. 	 */
  83. 	public void ordinamentoSelectionSort(int[] vett, int dim) {
  84. 		int i, j, i_min;
  85.  
  86. 		for(i = 0; i < dim-1; i++) {
  87. 			i_min = i;
  88. 			for (j = i+1; j < dim; j++) {
  89. 				if(vett[j] < vett[i_min])
  90. 					i_min = j;
  91. 			}
  92.  
  93. 			scambiaElementi(vett, i_min, i);
  94. 		}
  95. 	}
  96.  
  97.         /**
  98. 	 * Funzione di scambio delle componenti in posizione A e B del vettore vett
  99. 	 * @param vett
  100. 	 * @param A
  101. 	 * @param B
  102. 	 */
  103. 	public void scambiaElementi(int[] vett, int A, int B) {
  104. 		int temp = vett[A];
  105. 		vett[A] = vett[B];
  106. 		vett[B] = temp;
  107. 	}
  108.  
  109.         /**
  110. 	 * Funzione di stampa degli elementi del vettore vett
  111. 	 * @param vett
  112. 	 * @param dim
  113. 	 */
  114. 	public void stampaVettore(int[] vett, int dim) {
  115. 		int i = 0;
  116. 		for (i = 0; i < dim; i++)
  117. 			System.out.print(vett[i] + "  ");
  118. 		System.out.println();
  119. 	}
  120. }


Algoritmo di Ricerca Dicotomica

Codice Java che implementa l'algoritmo di ricerca dicotomica. 

  1. public class RicercaDicotomica {
  2.  
  3. 	public static void main(String[] args) {
  4.  
  5. 		new RicercaDicotomica().run();
  6. 	}
  7.  
  8. 	public void run() {
  9.  
  10. 		// Il vettore e la sua dimensione
  11. 		int n = 20;
  12. 		int[] V = {3, 251, 20, 5, 9, 101, 45, 67, 80, 71, 98, 2, 7, 125, 156, 24, 1010, 4, 8, 2000};
  13.  
  14. 		// Ordinamento del vettore con algoritmo Selection Sort
  15. 		ordinamentoSelectionSort(V, n);
  16.  
  17. 		// Stampa del vettore
  18. 		System.out.print("Il vettore ordinato è il seguente: ");
  19. 		stampaVettore(V, n);
  20.  
  21.  
  22. 		// Effettuiamo la ricerca dell'elemento x
  23. 		int x = 20;
  24.  
  25. 		// Chiamata alla funzione di ricerca
  26. 		int ind = ricercaBinaria(V, n, x);
  27.  
  28. 		// Stampa dei risultati
  29. 		if(ind == -1)
  30. 			System.out.println("L'elemento non è stato trovato");
  31. 		else
  32. 			System.out.println("L'elemento " + x + " è stato trovato in posizione " + ind);
  33.  
  34. 	}
  35.  
  36. 	/**
  37. 	 * Funzione che implementa la ricerca dicotomica
  38. 	 * @param vett Il vettore in cui effettuare la ricerca
  39. 	 * @param dim La dimensione del vettore
  40. 	 * @param ele L'elemento da cercare all'interno del vettore
  41. 	 * @return L'indice dell'elemento ricercato, oppure -1 se l'elemento non è stato trovato
  42. 	 */
  43. 	public int ricercaBinaria(int[] vett, int dim, int ele) {
  44. 		int low = 0;
  45. 		int high = dim -1;
  46.  
  47. 		while(low <= high) {
  48. 			int mid = (low+high) / 2;
  49.  
  50. 			if(vett[mid] == ele) {
  51. 				return mid;
  52. 			}
  53. 			else if(vett[mid] < ele) {
  54. 				low = mid + 1;
  55. 			}
  56. 			else {
  57. 				high = mid -1;
  58. 			}
  59. 		}
  60. 		return -1;
  61.  
  62. 	}
  63.  
  64. 	/**
  65. 	 * Funzione di ordinamento Selection Sort
  66. 	 * @param vett
  67. 	 * @param dim
  68. 	 */
  69. 	public void ordinamentoSelectionSort(int[] vett, int dim) {
  70. 		int i, j, i_min;
  71.  
  72. 		for(i = 0; i < dim-1; i++) {
  73. 			i_min = i;
  74. 			for (j = i+1; j < dim; j++) {
  75. 				if(vett[j] < vett[i_min])
  76. 					i_min = j;
  77. 			}
  78.  
  79. 			scambiaElementi(vett, i_min, i);
  80. 		}
  81. 	}
  82.  
  83. 	/**
  84. 	 * Funzione di scambio
  85. 	 * @param vett
  86. 	 * @param A
  87. 	 * @param B
  88. 	 */
  89. 	public void scambiaElementi(int[] vett, int A, int B) {
  90. 		int temp = vett[A];
  91. 		vett[A] = vett[B];
  92. 		vett[B] = temp;
  93. 	}
  94.  
  95. 	/**
  96. 	 * Funzione di stampa del vettore
  97. 	 * @param vett
  98. 	 * @param dim
  99. 	 */
  100. 	public void stampaVettore(int[] vett, int dim) {
  101. 		int i = 0;
  102. 		for (i = 0; i < dim; i++)
  103. 			System.out.print(vett[i] + "  ");
  104. 		System.out.println();
  105. 	}
  106. }

Altro Esercizio 1

Traccia: Algoritmo che, data una matrice A con elementi causali e non ordinati, crea la matrice B con gli stessi elementi della matrice A, ma ordinati in ordine crescente per righe, e infine stampa gli elementi della matrice B in console. 

  1. public class Esercizio1 {
  2.  
  3. 	public static void main(String[] args) {
  4.  
  5. 		new Esercizio1().run();
  6.  
  7. 	}
  8.  
  9. 	public void run() {
  10.  
  11. 		// Dichiarazione e inizializzazione della matrice
  12. 		int[][] mat = {{15, 25, 3, 0, 24}, 
  13. 				{40, 5, 61, 2, 90}, 
  14. 				{16, 26, 4, 99, 100}, 
  15. 				{45, 6, 64, 9, 98}, 
  16. 				{44, 1, 69, 7, 21}};
  17.  
  18. 		int n = 5;
  19.  
  20. 		// Stampa della matrice non ordinata
  21. 		System.out.println("La matrice non ordinata è la seguente: ");
  22. 		stampaMatrice(mat, n);
  23.  
  24. 		// Chiamo la funzione di ordinamento della matrice
  25. 		ordinaMatrice(mat, n);
  26.  
  27. 		// Stampo la matrice ordinata
  28. 		System.out.println("La matrice ordinata è la seguente: ");
  29. 		stampaMatrice(mat, n);
  30.  
  31. 	}
  32.  
  33. 	/**
  34. 	 * Funzione di ordinamento della matrice
  35. 	 * @param mat
  36. 	 * @param dim
  37. 	 */
  38. 	public void ordinaMatrice(int[][] mat, int dim) {
  39.  
  40. 		/* E' utilizzato un vettore temporaneo il cui scopo e quello
  41. 		 * di contenere tutti gli elementi della matrice
  42. 		 */
  43. 		int[] vettTemp = new int[dim*dim];
  44. 		int k = 0;
  45. 		int i = 0;
  46. 		int j = 0;
  47.  
  48. 		// Ciclo per inserire tutti gli elementi della matrice nel vettore.
  49. 		for (i = 0; i < dim; i++) {
  50. 			for(j = 0; j < dim; j++) {
  51. 				vettTemp[k] = mat[i][j];
  52. 				k++;
  53. 			}
  54. 		}
  55.  
  56. 		// Chiamo la funzione di ordinamento del vettore
  57. 		ordinaVettore(vettTemp, dim*dim);
  58.  
  59. 		// Chiamo la funzione per ricostruire la matrice a partire dal vettore
  60. 		matriceDaVettore(mat, vettTemp, dim);
  61. 	}
  62.  
  63. 	/** 
  64. 	 * Funzione che crea una amtrice a partire da un vettore
  65. 	 * @param mat
  66. 	 * @param vett
  67. 	 * @param dim
  68. 	 */
  69. 	public void matriceDaVettore(int[][] mat, int[] vett, int dim) {
  70. 		int i = 0;
  71. 		int j = 0;
  72. 		int k = 0;
  73.  
  74. 		for (i = 0; i < dim; i++) {
  75. 			for (j = 0; j < dim; j++) {
  76. 				mat[i][j] = vett[k];
  77. 				k++;
  78. 			}
  79. 		}
  80. 	}
  81.  
  82. 	/**
  83. 	 * Funzione di ordinamento del vettore con algoritmo Selection Sort
  84. 	 * @param vett
  85. 	 * @param dim
  86. 	 */
  87. 	public void ordinaVettore(int[] vett, int dim) {
  88. 		int i, j, i_min;
  89.  
  90. 		for(i = 0; i < dim-1; i++) {
  91. 			i_min = i;
  92. 			for (j = i+1; j < dim; j++) {
  93. 				if(vett[j] < vett[i_min])
  94. 					i_min = j;
  95. 			}
  96.  
  97. 			scambiaElementi(vett, i_min, i);
  98. 		}
  99. 	}
  100.  
  101. 	/**
  102. 	 * Funzione di scambio degli elementi di un vettore
  103. 	 * @param vett
  104. 	 * @param A
  105. 	 * @param B
  106. 	 */
  107. 	public void scambiaElementi(int[] vett, int A, int B) {
  108. 		int temp = vett[A];
  109. 		vett[A] = vett[B];
  110. 		vett[B] = temp;
  111. 	}
  112.  
  113. 	/**
  114. 	 * Funzione di stampa della matrice
  115. 	 * @param mat
  116. 	 * @param dim
  117. 	 */
  118. 	public void stampaMatrice(int[][] mat, int dim) {
  119. 		int i = 0; 
  120. 		int j = 0;
  121.  
  122. 		for (i = 0; i < dim; i++) {
  123. 			for (j = 0; j < dim; j++)
  124. 				System.out.print(mat[i][j] + "\t");
  125. 			System.out.println();
  126. 		}
  127. 	}
  128. }

Altro Esercizio 2

Traccia: Dato un vettore di N elementi (con N di valore pari a un numero quadrato perfetto non inferiore a 16 e non superiore a 100), con elementi tali che ciascuno di essi non sia inferiore al precedente; creare una matrice quadrata in cui gli stessi elementi sono inseriti consecutivamente per righe evitando le ripetizioni e aggiungendo negli ultimi elementi della matrice tutti elementi nulli; infine, stampare la matrice finale in console. 

  1. public class Esercizio2 {
  2.  
  3. 	public static void main(String[] args) {
  4.  
  5. 		new Esercizio2().run();
  6. 	}
  7.  
  8. 	public void run() {
  9.  
  10. 		int dim = 4;
  11. 		int[] v = {1, 2, 3, 3, 4, 5, 6, 6, 15, 20, 20, 25, 26, 26, 26, 27};
  12.  
  13. 		// Prova anche con i due vettori commentati
  14. 		//int[] v = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
  15. 		//int[] v = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
  16.  
  17. 		int[][] mat = new int[dim][dim];
  18.  
  19. 		/* Funzione che crea la matrice a partire dal vettore 
  20. 		 * evitando le ripetizioni e inserendo 0 nei rimanenti elementi
  21. 		 */
  22. 		creaMatrice(mat, v, dim);
  23.  
  24. 		System.out.println("La matrice richesta è la seguente: ");
  25. 		stampaMatrice(mat, dim);
  26. 	}
  27.  
  28. 	/**
  29. 	 * Funzione che crea la matrice secondo la richiesta della traccia
  30. 	 * @param mat
  31. 	 * @param vett
  32. 	 * @param dim
  33. 	 */
  34. 	public void creaMatrice(int[][] mat, int[] vett, int dim){
  35.  
  36. 		int i = 0;
  37. 		int j = 0;
  38. 		int k = 0;
  39.  
  40. 		for (i = 0; i < dim; i++) {
  41. 			for (j = 0; j < dim; j++) {
  42. 				/* Incremento l'indice fino a quando non trovo un elemento 
  43. 				 * diverso dal successivo, oppure non arrivo alla fine del vettore 
  44. 				 */
  45. 				while ( k < (dim*dim)-1 && vett[k] == vett[k+1]) {
  46. 					k++;
  47. 				}
  48.  
  49. 				/* Se l'indice è inferiore alla dimensione
  50. 				 * del vettore, allora inserisco il relativo
  51. 				 * elemento nella matrice. Altrimenti inserisco 0
  52. 				 */
  53. 				if (k < dim*dim) {
  54. 					mat[i][j] = vett[k];
  55. 					k++;
  56. 				}
  57. 				else {
  58. 					mat[i][j] = 0;
  59. 				}
  60. 			}
  61. 		}
  62. 	}
  63.  
  64. 	/**
  65. 	 * Funzione di stampa della matrice
  66. 	 * @param mat
  67. 	 * @param dim
  68. 	 */
  69. 	public void stampaMatrice(int[][] mat, int dim) {
  70. 		int i = 0; 
  71. 		int j = 0;
  72.  
  73. 		for (i = 0; i < dim; i++) {
  74. 			for (j = 0; j < dim; j++)
  75. 				System.out.print(mat[i][j] + "\t");
  76. 			System.out.println();
  77. 		}
  78. 	}
  79. }
Estratto da "http://www.vitoantoniobevilacqua.it/wiki/index.php?title=Esempi_JAVA&oldid=453"