5 esercizi Java per skillarti

5 esercizi Java per skillarti

Di Giuseppe Piccininni


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.

  1. Scrivi un breve script in Java che legga un numero intero positivo e conti il numero di cifre del numero in input.
  2. Scrivi un programma in Java per convertire un oggetto di tipo String in int, long, float e double.
  3. Scrivi un programma in Java per ritornare in output il valore di una specifica chiave in un costrutto Map. (usare HashMap)
  4. Scrivi un programma in Java per ordinare un array di interi usando l’algoritmo Bubble Sort.
  5. 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.
 

  1. 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.  
  1. 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.  
  1. 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. }
  1. 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. }
  1. 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?

Impara a programmare in 3 mesi con il Corso di Coding Hackademy su Laravel PHP

Diventa Sviluppatore web in 3 mesi

Scopri il coding bootcamp Hackademy

Programma Completo