Esempi JAVA: differenze tra le versioni

Da Bioingegneria Elettronica e Informatica.
(→‎Prodotto tra matrici)
Riga 193: Riga 193:
  
 
== Prodotto tra matrici ==
 
== Prodotto tra matrici ==
 +
<syntaxhighlight lang="java" line>
 +
public class Principale {
 +
 +
public static void main(String[] args) {
 +
 +
new Principale().run();
 +
}
 +
 +
public void run() {
 +
int r1, c1;
 +
int r2, c2;
 +
int k;
 +
 +
// Affinchè il prodotto tra matrici possa essere eseguito è necessario che c1 = r2;
 +
 +
// Dimensioni prima matrice
 +
r1 = 2;
 +
c1 = 3;
 +
 +
// Dimensioni della seconda matrice
 +
r2 = 3;
 +
c2 = 5;
 +
 +
// Valorizzazzione matrice1 con numeri interi da 0 (r1*c1)-1
 +
k = 0;
 +
 +
int[][] mat1 = new int[r1][c1];
 +
 +
for (int i  = 0; i < r1; i++) {
 +
for (int j = 0; j < c1; j++) {
 +
mat1[i][j] = k;
 +
k++;
 +
}
 +
}
 +
 +
// Valorizzazzione matrice1 con numeri interi da 0 (r2*c2)-1
 +
k = 0;
 +
 +
int[][] mat2 = new int[r2][c2];
 +
for (int i  = 0; i < r2; i++) {
 +
for (int j = 0; j < c2; j++) {
 +
mat2[i][j] = k;
 +
k++;
 +
}
 +
}
 +
 +
// Stampa delle matrici mat1 e mat2
 +
System.out.println("La prima matrice vale: ");
 +
stampaMatrice(mat1, r1, c1);
 +
System.out.println("La seconda matrice vale: ");
 +
stampaMatrice(mat2, r2, c2);
 +
 +
/* Controllo che le dimensioni delle matrici rispettano r2 == c1
 +
* affinchè sia possibile effettuare il prodotto tra le due matrici
 +
*/
 +
if (r2 != c1) {
 +
System.out.println("Non è possibile fare il prodotto tra matrici");
 +
}
 +
else {
 +
// Dichiarazione della matrice prodotto mat3 di dimensioni r1*c2
 +
int[][] mat3 = new int[r1][c2];
 +
 +
// Il prodotto tra le matrici è effettuato nella relativa funzione
 +
prodottoMatrici(mat1, r1, c1, mat2, r2, c2, mat3);
 +
 +
// Stampa della matrice prodotto mat3
 +
System.out.println("La matrice prodotto vale: ");
 +
stampaMatrice(mat3, r1, c2);
 +
}
 +
}
 +
 +
/**
 +
* Funzione per la stampa della matrice mat note le sue dimensioni r e c
 +
* @param mat
 +
* @param r
 +
* @param c
 +
*/
 +
public void stampaMatrice(int[][] mat, int r, int c) {
 +
int i = 0;
 +
int j = 0;
 +
 +
for (i = 0; i < r; i++) {
 +
for (j = 0; j < c; j++) {
 +
System.out.print(mat[i][j] + "\t");
 +
}
 +
System.out.println();
 +
}
 +
}
 +
 +
/**
 +
* Funzione che effettua il prodotto tra matrici
 +
* @param A prima matrice
 +
* @param r1 numero di righe della prima matrice
 +
* @param c1 numero di colonne della prima matrice
 +
* @param B seconda matrice
 +
* @param r2 numero di righe della seconda matrice
 +
* @param c2 numero di colonne della seconda matrice
 +
* @param C matrice prodotto
 +
*/
 +
public void prodottoMatrici(int[][] A, int r1, int c1, int[][] B, int r2, int c2, int[][] C) {
 +
int i = 0;
 +
int j = 0;
 +
int k = 0;
 +
 +
// Algoritmo per il prodotto tra matrici
 +
for (i = 0; i < r1; i++) {
 +
for (k = 0; k < c2; k++) {
 +
C[i][k] = 0;
 +
for (j = 0; j < c1; j++) {
 +
C[i][k] = C[i][k] + A[i][j] * B[j][k];
 +
}
 +
}
 +
}
 +
}
 +
}
 +
</syntaxhighlight>

Versione delle 10:52, 22 mar 2017

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

  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

  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

  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. }
Estratto da "http://www.vitoantoniobevilacqua.it/wiki/index.php?title=Esempi_JAVA&oldid=417"