La conoscenza della programmazione Object-Oriented passa attraverso uno dei linguaggi di programmazione più famosi al mondo, ormai da anni, ovvero il linguaggio Java.
Imparare Java consente ad un aspirante programmatore informatico di apprendere a pieno il paradigma di programmazione ad oggetti, in quanto il linguaggio Java è uno dei precursori di questo paradigma, nonché uno dei linguaggi attraverso cui è più facile impararlo.
A cosa serve Java?
Il linguaggio Java a tantissime applicazioni, tra cui sviluppo di videogiochi (basti pensare a Minecraft), creazione di applicazioni Android, Cloud Computing e IoT (Internet of Things). Più raro vederlo applicato a contesti come l’intelligenza artificiale o lo sviluppo web (tramite framework).
Programmare in Java aiuta molto uno sviluppatore alle prime armi a comprendere la programmazione informatica e la logica che c’è dietro ad essa. Per questo, esercitarsi diventa fondamentale per apprendere il linguaggio Java nella sintassi e nella semantica.
Per esercitarci andremo a vedere 5 esercizi Java da risolvere, di difficoltà graduale, così da comprendere sia i concetti più basilari che quelli più avanzati di questo linguaggio di programmazione.
- Scrivi un breve script in Java che legga un numero intero positivo e conti il numero di cifre del numero in input.
- Scrivi un programma in Java per convertire un oggetto di tipo String in int, long, float e double.
- Scrivi un programma in Java per ritornare in output il valore di una specifica chiave in un costrutto Map. (usare HashMap)
- Scrivi un programma in Java per ordinare un array di interi usando l’algoritmo Bubble Sort.
- Scrivi un programma in Java per stampare tutti gli elementi di un ArrayList usando le posizioni (indici) degli elementi.
In Java ci sono tanti costrutti da dover imparare, utilizzare e sfruttare per modellare i dati. La tipizzazione è molto preponderante in Java, perciò con questi 5 esercizi potrai subito capire quanto è cruciale imparare la sintassi e saper modellare non solo i dati, ma anche i tipi di dato, convertendoli e gestendoli attraverso una struttura dati.
Prova a risolvere questi esercizi senza sbirciare la soluzione, che sarà presente alla fine dell’articolo.
- La soluzione di questo esercizio prevede un solido utilizzo dello statement condizionale if-else-if per assicurarsi che una condizione, esplicitata nel codice Java, sia vera o falsa e ottenere l’output desiderato.
1. import java.util.Scanner;
2. public class Exercise1 {
3.
4. public static void main(String[] args)
5. {
6. Scanner in = new Scanner(System.in);
7. System.out.print("Inserisci in input un intero minore di dieci miliardi: ");
8.
9. if (in.hasNextLong())
10. {
11.
12. long n = in.nextLong();
13.
14. if (n < 0)
15. {
16. n *= -1;
17. }
18. if (n >= 10000000000L)
19. {
20. System.out.println("Il numero è uguale o più grande di 10,000,000,000!");
21. }
22. else
23. {
24. int digits = 1;
25. if (n >= 10 && n < 100)
26. {
27. digits = 2;
28. }
29. else if (n >= 100 && n < 1000)
30. {
31. digits = 3;
32. }
33. else if (n >= 1000 && n < 10000)
34. {
35. digits = 4;
36. }
37. else if (n >= 10000 && n < 100000)
38. {
39. digits = 5;
40. }
41. else if (n >= 100000 && n < 1000000)
42. {
43. digits = 6;
44. }
45. else if (n >= 1000000 && n < 10000000)
46. {
47. digits = 7;
48. }
49. else if (n >= 10000000 && n < 100000000)
50. {
51. digits = 8;
52. }
53. else if (n >= 100000000 && n < 1000000000)
54. {
55. digits = 9;
56. }
57. else if (n >= 1000000000 && n < 10000000000L)
58. {
59. digits = 10;
60. }
61. System.out.println("Cifre nel numero intero: " + digits);
62. }
63. }
64. else
65. {
66. System.out.println("Il numero non è un intero");
67. }
68. }
69. }
70. - La tipizzazione nel linguaggio Java è molto forte. Saper convertire i vari tipi di dato in modo tale da modellarli a seconda delle proprie esigenze è una pratica molto utile. String, int, float, booleani, sono tutti tipi di dato che vanno esplicitati nel momento di una dichiarazione di una variabile o ritorno di un valore di una specifica funzione.
1. public class Main {
2. public static void main(String[] args) {
3. String STR_TO_INT = "1323";
4. String STR_TO_LONG = "13625478965325";
5. String STR_TO_FLOAT = "25.135F";
6. String STR_TO_DOUBLE = "21.25478254D";
7.
8. System.out.println("Converti String in int/Integer:");
9. Integer toInt1 = Integer.valueOf(STR_TO_INT);
10. int toInt2 = Integer.parseInt(STR_TO_INT);
11. System.out.println("\"" + STR_TO_INT + "\"" + " come int corrisponde a "
12. + toInt1 + " e come Integer corrisponde a " + toInt2);
13.
14. System.out.println("\n Converti String in long/Long:");
15. Long toLong1 = Long.valueOf(STR_TO_LONG);
16. long toLong2 = Long.parseLong(STR_TO_LONG);
17. System.out.println("\"" + STR_TO_LONG + "\"" + " come long corrisponde a "
18. + toLong1 + " e come Long corrisponde a " + toLong2);
19. System.out.println("\n Converti String in float/Float:");
20. Float toFloat1 = Float.valueOf(STR_TO_FLOAT);
21. float toFloat2 = Float.parseFloat(STR_TO_FLOAT);
22. System.out.println("\"" + STR_TO_FLOAT + "\"" + " come float corrisponde a "
23. + toFloat1 + " e come Float corrisponde a " + toFloat2);
24.
25. System.out.println("\n Converti String in double/Double:");
26. Double toDouble1 = Double.valueOf(STR_TO_DOUBLE);
27. double toDouble2 = Double.parseDouble(STR_TO_DOUBLE);
28. System.out.println("\"" + STR_TO_DOUBLE + "\"" + " come double corrisponde a "
29. + toDouble1 + " e come Double corrisponde a " + toDouble2);
30. }
31. }
32. - Java possiede tanti costrutti e collezioni per gestire i dati. Queste sono necessarie quando si devono svolgere specifici compiti o gestire dati di diversi tipo attraverso un’unica struttura. In questo esercizio puoi apprendere e capire l’utilizzo dell’HashMap.
1. import java.util.*;
2. public class Exercise3 {
3. public static void main(String args[]){
4. HashMap<Integer,String> hash_map= new HashMap<Integer,String>();
5. hash_map.put(1,"Red");
6. hash_map.put(2,"Green");
7. hash_map.put(3,"Black");
8. hash_map.put(4,"White");
9. hash_map.put(5,"Blue");
10. // get value of key 3
11. String val=(String)hash_map.get(3);
12. // check the value
13. System.out.println("Il valore per la chiave 3 è: " + val);
14. }
15. }- Il Bubble Sort è un famoso algoritmo di ordinamento. I numeri salvati in una lista vengono scansionati, ogni coppia di elementi adiacenti viene comparata ed i due elementi vengono invertiti di posizioni se non sono ordinati. Questo processo iterativo viene svolto finché l’intera lista di dati non è ordinata secondo la condizione esplicitata. Avendo Java tante collezioni, array e modi per creare liste di dati, allenarsi sugli algoritmi di ordinamento è un good habit per avere confidenza non solo con la logica della programmazione, ma anche con la scrittura di un codice un po’ più articolato.
1. import java.util.Arrays;
2. class BubbleSort
3. {
4. void bubbleSort(int nums[])
5. {
6. int n = nums.length;
7. for (int i = 0; i < n-1; i++)
8. for (int j = 0; j < n-i-1; j++)
9. if (nums[j] > nums[j+1])
10. {
11. // swap temp and nums[i]
12. int temp = nums[j];
13. nums[j] = nums[j+1];
14. nums[j+1] = temp;
15. }
16. }
17.
18. // Method to test above
19. public static void main(String args[])
20. {
21. BubbleSort ob = new BubbleSort();
22. int nums[] = {7, -5, 3, 2, 1, 0, 45};
23. System.out.println("Array originale:");
24. System.out.println(Arrays.toString(nums));
25. ob.bubbleSort(nums);
26. System.out.println("Array ordinato: ");
27. System.out.println(Arrays.toString(nums));
28. }
29. }- Un’altra collezione estremamente utile in Java è l’ArrayList. La classe ArrayList corrisponde ad un array ridimensionabile, che può essere trovato nel pacchetto java.util. La differenza tra un array built-in e un ArrayList in linguaggio Java è che la dimensione di un array non può essere modificata (se si desidera aggiungere o rimuovere elementi a/da un array, è necessario crearne uno nuovo). Si tratta sostanzialmente di un array molto più versatile.
1. import java.util.ArrayList;
2. public class Exercise5 {
3. public static void main(String[] args) {
4. ArrayList <String> c1 = new ArrayList <String> ();
5. c1.add("Red");
6. c1.add("Green");
7. c1.add("Black");
8. c1.add("White");
9. c1.add("Pink");
10. System.out.println("\n ArrayList originale: " + c1);
11. System.out.println("\n Stampa usando l’indice di un elemento: ");
12. int no_of_elements = c1.size();
13. for (int index = 0; index < no_of_elements; index++)
14. System.out.println(c1.get(index));
15. }
16. }
Trascurare la pratica nella programmazione informatica è un grosso sbaglio. Servirsi di esercizi online di coding rappresenta il giusto approccio per prendere confidenza con la scrittura del codice, la comprensione della sintassi e semantica, che si distingue, ovviamente, per ogni linguaggio. Esercitarsi sulle cose più semplici, comprendendo la logica che c’è dietro, renderà meno arduo il cammino per assimilare i concetti più complessi di un linguaggio di programmazione o di un paradigma di programmazione. Pronto a cominciare?
