Un'interfaccia in Java è un po' come una classe, ma con una differenza significativa: una interface può avere solo le firme dei metodi, attributi e metodi di default. A partire da Java 8, puoi anche creare metodi di default. Nel prossimo blocco di codice puoi vedere un esempio di interfaccia:

public interface Veicolo {
    public String targa = "";
    public float maxVel;
    public void accendi();
    public void spegni();
    default void suonaClacson(){
      System.out.println("Sto suonando il clacson");
   }
}

L'interfaccia qui in alto contiene due attributi, due metodi e un metodo di default. Da sola, non è molto utile, ma di solito vengono usate insieme alle Classi. In che modo? Semplice, devi assicurarti che delle classi la implementino, usando la parola chiave implements.

public class Macchina implements Veicolo {
    public void accendi() {
        System.out.println("avvio del motore...");
    }
    public void spegni() {
        System.out.println("spegnendo il motore...");
    }
}

Ora, c'è una regola di base: la classe deve implementare tutti i metodi dell'interfaccia. I metodi devono avere la stessa identica firma (nome, parametri ed eccezioni) così com'è descritta nell'interfaccia. La classe, però, non ha bisogno di dichiarare gli attributi, solo i metodi.

Istanze di un'Interfaccia

Una volta creata una classe di Java che implementa una qualsiasi Interfaccia, l'istanza dell'oggetto deve essere referenziata come istanza dell'interfaccia. Questo concetto è simile a quello dell'istanziazione ereditaria.

// facendo seguito al nostro esempio di prima

Veicolo tesla = new Macchina();

tesla.parti(); // avvio del motore ...

Un'interfaccia non può contenere un costruttore. Per questo, non puoi creare un'istanza dell'interfaccia stessa. Devi creare un'istanza di una classe implementando un'interfaccia per poterla referenziare.

Pensa alle interfacce come a moduli di contratto vuoti, o come template.

Che cosa puoi fare con questa funzionalità? Polimorfismo! Puoi usare solo le interfacce per riferirti alle istanze dell'oggetto!

class Camion implements Veicolo {
    public void avvio() {
        System.out.println("avvio del motore del camion...");
    }
    public void spegni() {
        System.out.println("spegnimento del motore del camion...");
    }
}

class Starter {
    // metodo statico, può essere invocato senza istanziare la classe
    public static void avviaMotore(Veicolo veicolo) {
        veicolo.avvio();
    }
}

Veicolo tesla = new Macchina();
Veicolo tata = new Camion();

Starter.avviaMotore(tesla); // avvio del motore ...
Starter.avviaMotore(tata); // avvio del motore del camion ...

E per quanto riguarda molteplici interfacce?

Sì, puoi implementare molteplici interfacce in una sola classe. Mentre nell'ereditarietà tra classi sei costretto ad ereditare da una sola classe, qui puoi estendere un numero qualsiasi di interfacce. Ma non dimenticare di implementare tutti i metodi di tutte le Interfacce, altrimenti la compilazione fallirà!

public interface GPS {
    public void ottieniCoordinate();
}

public interface Radio {
    public void accendiRadio();
    public void spegniRadio();
}

public class Smartphone implements GPS,Radio {
    public void ottieniCoordinate() {
        // return delle coordinate
    }
    public void accendiRadio() {
      // accendi Radio
    }
    public void spegniRadio() {
        // spegni Radio
    }
}

Alcune caratteristiche delle Interfacce

• Puoi inserire delle variabili all'interno di un'Interfaccia, anche se non sarebbe una decisione sensata poiché le Classi non sono tenute ad avere la stessa variabile. In breve, evita di inserire delle variabili!
• Tutte le variabili e i metodi in un'Interfaccia sono pubblici, anche se non metti la parola chiave public.
• Un'Interfaccia non può specificare l'implementazione di un metodo in particolare. Sta alle Classi farlo. Anche se c'è stata una recente eccezione (vedi più avanti).
• Se una Classe implementa più Interfacce, allora c'è una remota possibilità che la firma di un metodo coincida con un'altra. Poiché Java non permette di avere più metodi con la stessa firma, questo può causare problemi. Dai un'occhiata a questa domanda per maggiori informazioni.

Metodi di Default delle Interfacce

Prima di Java 8, non c'era nessun modo per far sì che un'interfaccia avesse una specifica implementazione di un metodo. Questo porta ad un sacco di confusione ed errori di codice nel caso in cui la definizione di un'interfaccia venga cambiata.

Ipotizza di aver scritto una libreria open source, che contiene un'Interfaccia. Supponiamo che i tuoi clienti, ovvero praticamente tutti gli sviluppatori del mondo, ne stiano facendo ampio uso e siano felici. Adesso hai dovuto aggiornare la libreria aggiungendo una nuova definizione di un metodo dell'Interfaccia per supportare una nuova funzionalità. Ma questo romperebbe tutti i build, poiché tutte le Classi che implementano quell'Interfaccia devono essere cambiate. Che catastrofe!

Fortunatamente, Java 8 adesso ci mette a disposizione dei metodi default per le Interfacce. Un metodo default può contenere una sua implementazione direttamente all'interno dell'Interfaccia. Dunque, se una Classe non implementa il metodo di default, il compilatore prenderà l'implementazione menzionata nell'Interfaccia. Comodo, vero? Dunque, nella tua libreria, potrai aggiungere qualsiasi numero di metodi di default nelle interfacce senza temere di rompere nulla!

public interface GPS {
    public void ottieniCoordinate();
    default public void ottieniCoordinateApprossimative() {
        // implementazione per restituire coordinate da fonti approssimative
        // come il wifi o il telefono
        System.out.println("Prendo coordinate approssimative...");
    }
}

public interface Radio {
    public void accendiRadio();
    public void spegniRadio();
}

public class Smartphone implements GPS,Radio {
    public void ottieniCoordinate() {
        // return delle coordinate
    }
    public void accendiRadio() {
      // accendi Radio
    }
    public void spegniRadio() {
        // spegni Radio
    }

    // nessuna implementazione per ottieniCoordinateApprossimative()
}

Smartphone motoG = new Smartphone();
motog.ottieniCoordinateApprossimative(); // Prendo coordinate approssimative...

Ma cosa succede se due interfacce hanno la stessa firma di un metodo?

Ottima domanda. In quel caso, se non fornisci un'implementazione all'interno della Classe, il povero compilatore si confonderà e, semplicemente, fallirà! Devi fornire un'implementazione di metodo di default anche all'interno della Classe. C'è anche un modo elegante di farlo usando super per chiamare l'implementazione che preferisci:

public interface Radio {
    // public void accendiRadio();
    // public void spegniRadio();

    default public void prossima() {
        System.out.println("Prossima canzone dalla Radio");
    }
}

public interface LettoreMusicale {
    // public void accendi();
    // public void pausa();
    // public void spegni();

    default public void prossima() {
        System.out.println("Prossima canzone dal lettore musicale");
    }
}

public class Smartphone implements Radio, LettoreMusicale {
    public void prossima() {
        // Supponiamo che tu voglia chiamare prossima() del LettoreMusicale
        LettoreMusicale.super.prossima();
    }
}

Smartphone motoG = new Smartphone();
motoG.prossima(); // Prossima canzone dal lettore musicale

Metodi Statici nelle Interfacce

Un'altra novità in Java 8 è la possibilità di aggiungere metodi statici alle interfacce. I metodi statici delle interfacce sono quasi identici ai metodi statici delle classi concrete. L'unica grande differenza è che i metodi static non sono ereditati nelle classi che implementano l'interfaccia. Ciò significa che quando si chiama il metodo statico viene referenziata l'interfaccia, non la classe che lo implementa.

interface LettoreMusicale {
  public static void spotPubblicitario(String sponsor) {
    System.out.println("Adesso una promozione da " + sponsor);
  }
  
  public void riproduci();
}


class Smartphone implements LettoreMusicale {
	public void riproduci() {
		System.out.println("Riproduco da smartphone");
	}
}

class Main {
  public static void main(String[] args) {
    Smartphone motoG = new Smartphone();
    MusicPlayer.spotPubblicitario("Motorola"); // Chiamato dall'interfaccia, non dalla classe che la implementa
    // motoG.spotPubblicitario("Motorola"); // Questo causerebbe un errore di compilazione
  }
}

Ereditarietà nelle interfacce

È inoltre possibile, in Java, che un'interfaccia erediti un'altra interfaccia usando, come hai già immaginato, la parola chiave extends:

public interface Lettore {
    public void accendi();
    public void pausa();
    public void spegni();
}

public interface LettoreMusicale extends Lettore {
    default public void prossima() {
        System.out.println("Prossima canzone dal lettore musicale");
    }
}

Ciò significa che la Classe che implementa l'Interfaccia LettoreMusicale deve implementare tutti i metodi di LettoreMusicale così come quelli di Lettore:

public class SmartPhone implements LettoreMusicale {
    public void accendi() {
        System.out.println("Accensione");
    }
    public void spegni() {
        System.out.println("Spegnimento");
    }
    public void pausa() {
        System.out.println("Messo in pausa");
    }
}

Adesso hai una visione più chiara delle interfacce di Java! Dai un'occhiata alle Classi Astratte per vedere un altro modo in cui Java ti permette di definire contratti.

In questo articolo vedremo come convertire una stringa in un array di caratteri in Java. Ti spiegherò brevemente anche che cosa sono le stringhe, i caratteri e gli array.

Che Cos'è un Carattere in Java?

I caratteri sono tipi di dato primitivi. Un carattere è un singolo carattere racchiuso tra due apici singoli. Può essere una lettera, un numero, un segno di punteggiatura, uno spazio o qualcosa di simile. Per esempio:

char primaVocale = 'a';

Che Cos'è una Stringa in Java?

Le stringhe sono oggetti (tipo di riferimento). Una stringa è composta da una serie di caratteri. È qualsiasi cosa che si trova tra le doppie virgolette. Per esempio:

String vocali = "aeiou";

Che Cos'è un Array in Java?

Gli array sono strutture di dati fondamentali che in Java possono immagazzinare un determinato numero di elementi dello stesso tipo di dato. Per esempio, dichiariamo un array di caratteri:

char[] arrayVocali = {'a', 'e', 'i', 'o', 'u'};

Ora abbiamo una conoscenza di base di quello che sono stringhe, caratteri e array.

Convertiamo una Stringa in un Array di Caratteri

1. Usa il Metodo di Istanza toCharArray()

toCharArray() è un metodo d'istanza della classe String. Restituisce un nuovo array di caratteri basato sull'oggetto stringa corrente.

Vediamo un esempio:

// definisci una stringa
String vocali = "aeiou";

// crea un array di caratteri 
char[] arrayVocali = vocali.toCharArray();

// stampa arrayVocali
System.out.println(Arrays.toString(arrayVocali));

Output: [a, e, i, o, u]

Quando convertiamo una stringa in un array di caratteri, la lunghezza rimane la stessa. Controlliamo la lunghezza di vocali e di arrayVocali:

System.out.println("La lunghezza di \'vocali\' è " + vocali.length());
System.out.println("La lunghezza di \'arrayVocali\' è " + arrayVocali.length);

Output:

La lunghezza di 'vocali' è 5
La lunghezza di 'arrayVocali' è 5

Possiamo usare diversi modi di stampare un array. Ho usato il metodo statico toString() dalla classe di utilità Arrays.

Puoi leggere di più riguardo il metodo d'istanza toCharArray() nella documentazione di Java.

2. Usa il Metodo di Istanza charAt()

charAt() è un metodo d'istanza della classe String. Restituisce il carattere che si trova all'indice specificato della stringa corrente.

NOTA: una stringa ha indici che partono da zero, come un array.

Vediamo come possiamo convertire una stringa in un array di caratteri usando charAt() :

// definisci una stringa
String vocali = "aeiou";

// crea un array di caratteri. La lunghezza è la lunghezza di 'vocali'
char[] arrayVocali = new char[vocali.length()];

// usa un ciclo per iterare attraverso ogni carattere nella stringa 'vocali'
for (int i = 0; i < vocali.length(); i++) {
    // aggiungi ogni carattere all'array di caratteri
    arrayVocali[i] = vocali.charAt(i);
}

// stampa l'array
System.out.println(Arrays.toString(arrayVocali));

Output: [a, e, i, o, u]

Puoi leggere di più riguardo il metodo d'istanza charAt() nella documentazione di Java.

Ti ho appena mostrato un altro modo di convertire una stringa in un array di caratteri, ma possiamo usare il metodo toCharArray() per convertirla facilmente invece di creare un loop e iterare attraverso la stringa.

Sentiti libero di farmi sapere se hai suggerimenti o domande.

Foto di Alex Alvarez su Unsplash.

Supporta freeCodeCamp nella loro Raccolta Fondi del Curriculum di Scienza dei Dati.

Mettiti in contatto con me su Medium.

Grazie 😇

Buona Programmazione ❤️

Per saperne di più sulla Programmazione in Java

1. Principi di Programmazione Orientata agli Oggetti in Java: Concetti OOP per Principianti
2. Metodi degli Array in Java - Come Stampare un Array in Java
3. Da Stringa a Int in Java - Come Convertire una Stringa in un Numero Intero
4. Generatore di Numeri Casuali in Java - Come Generare Numeri Interi con Math Random

Un array è una struttura di dati usata per immagazzinare dati dello stesso tipo. Gli array immagazzinano i propri elementi in posizioni di memoria contigue.

In Java, gli array sono oggetti. Tutti i metodi della classe object possono essere chiamati su un array. Possiamo immagazzinare un numero fisso di elementi in un array.

Dichiariamo un semplice array di tipo primitivo:

int[] intArray = {2,5,46,12,34};

Adesso proviamo a stamparlo usando il metodo System.out.println():

System.out.println(intArray);
// output: [I@74a14482

Perché Java non ha stampato il nostro array? Che cosa sta succedendo dietro le quinte?

Il metodo System.out.println() converte l'oggetto che abbiamo passato in una stringa chiamando String.valueOf(). Se diamo un'occhiata all'implementazione del metodo String.valueOf() vedremo questo:

public static String valueOf(Object obj) {
    return (obj == null) ? "null" : obj.toString();
}

Se l'oggetto passato è null ci restituisce null, altrimenti chiama il metodo obj.toString() . Alla fine, System.out.println() chiama toString() per stampare l'output.

Se la classe di quell'oggetto non sovrascrive l'implementazione di Object.toString(), chiamerà il metodo Object.toString().

Object.toString() restituisce getClass().getName()+‘@’+Integer.toHexString(hashCode()) . In parole povere, restituisce: "nome della classe @ codice hash dell'oggetto".

Nel nostro precedente output [I@74a14482 , [ esprime che si tratta di un array, e I sta per int (il tipo dell'array). 74a14482 è la rappresentazione esadecimale senza segno del codice hash dell'array.

Ogni volta che creiamo le nostre classi personalizzate, è buona prassi sovrascrivere il metodo Object.toString().

Non possiamo stampare gli array in Java usando il banale metodo System.out.println(). Invece, questi sono i modi in cui possiamo stampare un array:

1. Loop: loop for e loop for-each
2. Il metodo Arrays.toString()
3. Il metodo Arrays.deepToString()
4. Il metodo Arrays.asList()
5. L'interfaccia Java Iterator
6. Java Stream API

Vediamoli uno ad uno.

1. Loop: loop for e loop for-each

Ecco un esempio di un loop for:

int[] intArray = {2,5,46,12,34};

for(int i=0; i<intArray.length; i++){
    System.out.print(intArray[i]);
    // output: 25461234
}

Tutte le classi wrapper sovrascrivono Object.toString() e restituiscono una rappresentazione del loro valore in formato di stringa.

Ed ecco un loop for-each:

int[] intArray = {2,5,46,12,34};

for(int i: intArray){
    System.out.print(i);
    // output: 25461234
}

2. Il metodo Arrays.toString()

Arrays.toString() è un metodo statico della classe array che appartiene al package java.util. Restituisce una rappresentazione dei contenuti dell'array specificato in formato di stringa. Possiamo stampare array unidimensionali usando questo metodo.

Gli elementi dell'array sono convertiti in stringhe usando il metodo String.valueOf(), in questo modo:

int[] intArray = {2,5,46,12,34};
System.out.println(Arrays.toString(intArray));
// output: [2, 5, 46, 12, 34]

Per un array di riferimenti, dobbiamo assicurarci che la classe del tipo di riferimento sovrascriva il metodo Object.toString().

Per esempio:

public class Test {
    public static void main(String[] args) {
        Studente[] studenti = {new Studente("John"), new Studente("Doe")};
        
        System.out.println(Arrays.toString(studenti));
        // output: [Studente{nome='John'}, Studente{nome='Doe'}]
    }
}

class Studente {
    private String nome;

    public Student(String nome){
        this.nome = nome;
    }

    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

    @Override
    public String toString() {
        return "Studente{" + "nome='" + nome + '\'' + '}';
    }
}

Questo metodo non è appropriato per array multidimensionali. Converte gli array multidimensionali in stringhe usando Object.toString() che descrive i loro id al posto dei loro contenuti.

Per esempio:

// creo un array multidimensionale
int[][] multiDimensionalArr = { {2,3}, {5,9} };

System.out.println(Arrays.toString(multiDimensionalArr));
// output: [[I@74a14482, [I@1540e19d]

Con l'aiuto di Arrays.deepToString(), possiamo stampare array multidimensionali.

3. Il metodo Arrays.deepToString()

Arrays.deepToString() restituisce una rappresentazione dei "contenuti profondi" dell'array specificato in formato di stringa.

Se l'elemento è un array di tipo primitivo, viene convertito in una stringa chiamando il sovraccarico appropriato di Arrays.toString() .

Ecco un esempio di un array multidimensionale di tipo primitivo:

// creo un array multidimensionale
int[][] multiDimensionalArr = { {2,3}, {5,9} };

System.out.println(Arrays.deepToString(multiDimensionalArr));
// output: [[2, 3], [5, 9]]

Se l'elemento è un array di riferimenti, viene convertito in una stringa chiamando ricorsivamente Arrays.deepToString().

Insegnante[][] insegnanti = 
{{ new Insegnante("John"), new Insegnante("David") }, {new Insegnante("Mary")} };

System.out.println(Arrays.deepToString(insegnanti));
// output: 
[[Insegnante{nome='John'}, Insegnante{nome='David'}],[Insegnante{nome='Mary'}]]

Dobbiamo sovrascrivere Object.toString() nella nostra classe Insegnante.

Se ti incuriosisce il modo in cui viene eseguita la ricorsione, ecco il codice sorgente del metodo Arrays.deepToString().

NOTA: anche gli array unidimensionali di riferimenti possono essere stampati usando questo metodo. Per esempio:

Integer[] oneDimensionalArr = {1,4,7};

System.out.println(Arrays.deepToString(oneDimensionalArr));
// output: [1, 4, 7]

4. Il metodo Arrays.asList()

Questo metodo restituisce una lista di dimensioni fisse costruita sull'array specificato.

Integer[] intArray = {2,5,46,12,34};

System.out.println(Arrays.asList(intArray));
// output: [2, 5, 46, 12, 34]

Abbiamo cambiato il tipo da int a Integer, perché List è un insieme che contiene una lista di oggetti. Quando convertiamo un array in una lista dovrebbe essere un array di riferimenti.

Java chiama Arrays.asList(intArray).toString() . Questa tecnica usa internamente il metodo toString() del tipo degli elementi all'interno della lista.

Un altro esempio con la nostra classe personalizzata Insegnante:

Insegnante[] insegnante = { new Insegnante("John"), new Insegnante("Mary") };

System.out.println(Arrays.asList(insegnante));
// output: [Insegnante{nome='John'}, Insegnante{nome='Mary'}]

NOTA: non possiamo stampare array multidimensionali usando questo metodo. Per esempio:

Insegnante[][] insegnanti = 
{{ new Insegnante("John"), new Insegnante("David") }, { new Insegnante("Mary") }};
        
System.out.println(Arrays.asList(insegnanti));

// output: [[Lcom.thano.article.printarray.Insegnante;@1540e19d, [Lcom.thano.article.printarray.Insegnante;@677327b6]

5. L'interfaccia Java Iterator

In modo simile a un loop for-each, possiamo usare l'interfaccia Iterator per iterare attraverso gli elementi dell'array e stamparli.

L'oggetto Iterator può essere creato chiamando il metodo iterator() su una Collection. Quell'oggetto verrà usato per iterare attraverso gli elementi della Collection.

Ecco un esempio di come possiamo stampare un array usando l'interfaccia Iterator:

Integer[] intArray = {2,5,46,12,34};

// creo una List di Integer
List<Integer> list = Arrays.asList(intArray);

// creo un iteratore della Integer List
Iterator<Integer> it = list.iterator();

// se la List ha elementi da iterare
while(it.hasNext()) {
    System.out.print(it.next());
    // output: 25461234
}

6. Java Stream API

La Stream API è usata per lavorare con insiemi di oggetti. Uno stream è una sequenza di oggetti. Gli stream non cambiano la struttura dei dati originaria, forniscono soltanto il risultato delle operazioni richieste.

Con l'aiuto dell'operazione terminale forEach() possiamo iterare attraverso ogni elemento dello stream.

Per esempio:

Integer[] intArray = {2,5,46,12,34};

Arrays.stream(intArray).forEach(System.out::print);
// output: 25461234

Adesso sappiamo come stampare un array in Java.

Grazie per aver letto.

Immagine di copertina di Aziz Acharki su Unsplash.

Puoi leggere gli altri miei articoli su Medium.

Buona Programmazione!

Se lavori con Java, probabilmente hai usato uno dei più famosi editor di testo come Sublime Text, VS Code, Brackets, Atom, e Notepad++, o anche IDE come Apache NetBeans e IntelliJ IDEA.

Eseguire il codice nel tuo IDE è immediato, ma spesso non riesci a vedere in che modo viene eseguito il codice (anche se ovviamente puoi controllare il comando nel terminale).

Tuttavia, è buona prassi sapere come viene eseguito effettivamente il codice e come viene prodotto l'output che ti restituisce.

Molti di voi potrebbero aver sentito che gli sviluppatori professionisti esperti usano anche il terminale per eseguire i programmi. Questo dà loro una visione più chiara e li aiuta a capire in che modo sta funzionando il codice, dove sta restituendo il valore desiderato, dove potrebbe trovarsi un bug, e così via.

Qualsiasi sia l'obiettivo, eseguire il codice Java direttamente dal terminale è un lavoro molto semplice.

In questo articolo ti mostrerò come puoi eseguire il codice Java direttamente dalla tua finestra del terminale preferita. Non temere! La procedura è abbastanza semplice, e dopo aver letto l'intero articolo dovresti essere in grado di eseguire il tuo codice Java dal terminale.

Come Eseguire il Codice Java nel Terminale

Il processo che sto per mostrarti in questo articolo si applica a qualsiasi sistema operativo, che sia Windows, MacOS o Linux.

Userò il seguente codice Java nel prossimo passaggio.

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, World!"); 
    }
}

📦 Step 1 – Vai nella cartella dove si trova il codice sorgente

Se hai già scritto il tuo codice Java in un editor, allora vai semplicemente in quella cartella. Puoi andare direttamente nella cartella usando il gestore dei file se vuoi.

Come andare nella cartella dove si trova il codice sorgente: per Windows 🪟

Supponiamo di avere il codice sorgente (Main.java) dentro la cartella This PC > Documents. Posso andare lì semplicemente usando Esplora File.

Oppure, volendo, posso anche andarci usando il mio terminale. Devo usare cd (da "change directory" in inglese) per indicare che voglio cambiare cartella .

In questo caso, posso usare cd "C:\Users\Md. Fahim Bin Amin\Documents". Poiché il mio nome utente contiene degli spazi, ho usato " " per racchiuderli.

Poi se controllo tutti i file all'interno di quella cartella, vedrò anche il file Main.java.

Ho messo il file Main.java nel mio drive D questa volta. Quindi sono andato in quella cartella usando il comando cd.

Vedo il mio file Java anche nel terminale.

Come andare nella cartella dove si trova il codice sorgente: per Linux 🐧

Puoi andare nella cartella dove si trova il tuo codice sorgente sia attraverso la GUI o dal terminale usando il comando cd anche qui.

🧑‍💻Come Compilare il Codice Java

Prima di eseguire il nostro codice Java, dobbiamo compilarlo. Per compilare un codice/programma in Java, otteniamo il file class che in seguito dovremo eseguire.

Come compilare il codice Java usando il terminale

Dobbiamo usare il comando javac nome_file_con_estensione. Per esempio, dato che voglio compilare il mio Main.java, userò il comando javac Main.java. La c in javac sta per compila.

Se il processo di compilazione avviene con successo, non otterremo nessun errore.

Questo creerà il file class di cui abbiamo bisogno nella stessa cartella.

Tieni a mente che eseguiamo il file class, non il file .java.

Lo stesso processo è applicabile per tutti i sistemi operativi disponibili.

🖥️ Come Eseguire il Codice Java

Eseguiamo il file .class per lanciare i programmi Java. Per questo, usiamo il comando java nome_file_class_senza_estensione. Per esempio, poiché il nostro file .class per questo programma è Main.class, il nostro comando sarà java Main.

Il programma Java è stato eseguito con successo!

La stessa identica procedura è applicabile anche ad altri sistemi operativi.

🏅Bonus: Come Eseguire un Programma Java con i Package

Un package sta praticamente ad indicare una cartella. Prima ti ho mostrato come usare un qualsiasi normale codice Java ricorrendo al terminale. Lì non ho usato alcun package all'interno del codice Java.

Adesso ti mostrerò come puoi eseguire qualsiasi codice Java che ha dei package dichiarati al suo interno. Questa volta, userò il seguente codice Java.

package myJavaProgram.Source;
public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, World!"); 
    }
}

Nella prima riga ho scritto il package come package myJavaProgram.Source. Questo indica che voglio creare una cartella chiamata myJavaProgram. Poi, voglio creare un'altra cartella al suo interno chiamata Source. Infine, voglio creare un file class del mio codice Java all'interno della cartella Source.

La struttura ad albero delle cartelle sarà la seguente: myJavaProgram > Source.

Per compilare questo tipo di codice Java con i package, usiamo il comando javac -d . nome_file_con_estensione.

Al momento sto usando il file Main.java, quindi userò il comando javac -d . Main.java. Questo creerà una cartella chiamata myJavaProgram, poi creerà un'altra cartella chiamata Source dentro la cartella myJavaProgram dentro la cartella dove si trova il mio file sorgente.

• La_Cartella_Dove_Ho_Il_Mio_Codice_Sorgente
• cartella myJavaProgram
• cartella Source

Crea istantaneamente la cartella myJavaProgram.

All'interno della cartella, crea la cartella Source.

Dentro la cartella Source, crea il nostro file .class. Abbiamo bisogno di questo file per eseguire il programma Java.

Adesso, se vogliamo eseguire il file .class, abbiamo bisogno di cambiare un po' il comando, poiché dobbiamo fornire la cartella del file .class nella finestra del terminale.

Usiamo il comando per eseguire il programma Java con i package, java cartella_del_file_class.il_nome_del_file_class_senza_estensione.

Poiché sto usando Main.java e ho bisogno di eseguire il file Main.class, il mio comando sarà java myJavaProgram.Source.Main. Eseguirà il codice Java come qui di seguito.

Se ti stai chiedendo perché stiamo cambiando il comando adesso, è perché prima non abbiamo dichiarato nessun package. Quindi il compilatore Java ha creato il file .class all'interno della cartella dove si trovava il nostro codice sorgente. Quindi, potremmo prendere il file .class direttamente da lì e potremmo anche eseguire il file class.

Ma se dichiariamo i package all'interno del codice sorgente in questo modo, allora stiamo dicendo al compilatore di creare il file .class in un altro posto (non all'interno della cartella dove si trova il nostro codice sorgente). Ciò significa che non prendiamo il file class direttamente da lì.

Poiché vogliamo eseguire il file class, abbiamo bisogno di dire al compilatore esplicitamente dove si trova il file class al momento, così che possa prendere il file class ed eseguirlo.

Se pensi di poter fare confusione durante questo passaggio, allora puoi copiare la cartella direttamente dal tuo codice Java.

Nella riga 1, abbiamo dichiarato la cartella del package (dove vogliamo che sia generato il file class). Dunque, se copiamo semplicemente la cartella e aggiungiamo il nome del file .class senza l'estensione (.class), preceduto da un punto (.), allora soddisfiamo la condizione per eseguire qualsiasi codice Java che ha dei package dichiarati nel codice sorgente.

Lo stesso processo è applicabile agli altri sistema operativi. Ecco qui degli screenshot da un sistema Linux:

Ottimo lavoro! 👏 Adesso puoi eseguire qualsiasi codice/programma Java direttamente usando un terminale. 🥳

Ho creato anche un video dove ho mostrato tutti i procedimenti menzionati in alto. Puoi darci un'occhiata qui. 😁

💁‍♂️ Conclusione

Spero che questo articolo ti aiuti ad eseguire i tuoi programmi Java usando solo il terminale.

➡️ Se vuoi sapere come installare un compilatore Java per il tuo sistema operativo Windows, allora puoi dare un'occhiata a questo articolo.

➡️ Se vuoi sapere come installare dei compilatori per C e C++ sul tuo sistema operativo Windows, allora puoi dare un'occhiata a questo articolo.

➡️ Se vuoi sapere come installare Python sul tuo sistema operativo Windows, allora puoi dare un'occhiata a questo articolo.

Grazie per aver letto l'intero articolo. Se ti può essere di aiuto puoi anche dare un'occhiata ai miei altri articoli su freeCodeCamp.

Se vuoi metterti in contatto con me, puoi farlo usando Twitter, LinkedIn, e GitHub.

Puoi anche ISCRIVERTI al mio canale di YouTube (Code With FahimFBA) se vuoi imparare diversi tipi di linguaggi di programmazione con molti esempi pratici pubblicati regolarmente.

Se vuoi dare un'occhiata ai miei highlights, puoi farlo sulla mia timeline Polywork.

Puoi anche visitare il mio sito per saperne di più di me e delle cose su cui sto lavorando.

Grazie mille!

Nel mio precedente articolo, ho trattato la Java Virtual Machine (JVM) e ne ho descritto l'architettura. Inoltre, ho introdotto brevemente il Java Garbage Collector (GC, letteralmente "raccoglitore della spazzatura", netturbino) come parte del componente del motore di esecuzione.

In questo articolo, approfondiremo l'argomento del Garbage Collector, il suo funzionamento e i diversi tipi di GC disponibili nell'ambiente Java, assieme ai loro vantaggi. Saranno inoltre inclusi nella spiegazione anche alcuni dei nuovi Garbage Collector sperimentali e disponibili solamente nelle più recenti release Java.

Che cos'è la Garbage Collection in Java?

La Garbage Collection (la raccolta della spazzatura) è il processo di recupero della memoria di runtime allocata ma inutilizzata che viene attuato mediante la distruzione degli oggetti inutilizzati.

In linguaggi come C e C++, è il programmatore a essere responsabile sia per la creazione che la distruzione degli oggetti. Talvolta, il programmatore può dimenticare di eliminare oggetti obsoleti e in questo modo la memoria allocata per accoglierli non viene liberata. La memoria utilizzata continua a crescere fino a quando non rimane più memoria da allocare. Applicazioni con questo comportamento soffrono di "memory leak" (falle, perdite di memoria).

Superata una certa soglia, non rimane più memoria libera in quantità sufficiente per la creazione di nuovi oggetti e l'intero programma termina in modo anomalo a causa di eccezioni di tipo OutOfMemoryError.

Si possono utilizzare metodi come free() in C e delete() in C++ per eseguire esplicitamente la Garbage Collection. In Java, la garbage collection avviene in modo automatico durante il ciclo di vita di un programma. Questa caratteristica elimina la necessità di de-allocare memoria e di conseguenza protegge dalle memory leak.

La Java Garbage Collection è il processo attraverso il quale Java esegue la gestione automatica della memoria. I programmi Java si compilano in bytecode che può essere eseguito su una Java Virtual Machine (JVM).

Quando i programmi Java sono eseguiti sulla JVM, gli oggetti sono creati sull'heap, che è un'area della memoria dedicata al programma.

Durante il ciclo di vita di un'applicazione Java, nuovi oggetti sono creati e rilasciati. Alla fine, alcuni oggetti diventeranno obsoleti. In particolare, possiamo dire che in un qualsiasi momento nel tempo, la memoria contenuta nell'heap è occupata da due tipi di oggetti:

• Vivi - questi oggetti sono utilizzati e referenziati in altre parti del programma
• Morti - questi oggetti non sono più utilizzati né referenziati in una qualunque parte del programma

Il garbage collector individua gli oggetti obsoleti non più utilizzati per poi eliminarli liberando memoria.

Come de-referenziare un oggetto in Java

L'obiettivo principale della Garbage Collection è liberare memoria dall'heap distruggendo tutti quegli oggetti che non contengono un riferimento. Quando non vi sono riferimenti a un oggetto, si assume che sia obsoleto e non più necessario. In questo modo la memoria occupata dall'oggetto può essere reclamata.

Vi sono vari modi attraverso i quali le referenze verso un oggetto possono essere rilasciate per renderlo un potenziale candidato scelto dalla Garbage Collection. Alcuni di questi sono i seguenti:

Assegnare null ad un riferimento

Student student = new Student();
student = null;

Assegnare un riferimento a un altro

Student studentOne = new Student();
Student studentTwo = new Student();
studentOne = studentTwo; // ora il primo oggetto referenziato da studentOne è disponibile per il passaggio del Garbage Collector

Utilizzare un oggetto anonimo

register(new Student());

Come funziona la Garbage Collection in Java?

La Garbage Collection in ambiente Java è un processo automatico. Il programmatore non ha l'onere di indicare esplicitamente quali oggetti destinare alla cancellazione.

L'implementazione delle garbage collection vive all'interno della JVM. Ciascuna JVM può implementare la propria versione di garbage collection. Tuttavia, deve sempre rispettare la specifica standard della JVM che richiede di lavorare con gli oggetti presenti nella porzione heap della memoria, segnalando o identificando gli oggetti divenuti irraggiungibili e distruggendoli con la compattazione.

Cosa sono le radici della Garbage Collection in Java?

I garbage collector funzionano basandosi sul concetto di radici della Garbage Collection (GC Roots) per distinguere gli oggetti vivi da quelli morti.

Esempi di tali radici son i seguenti:

• Classi caricate dal class loader di sistema (non da class loader custom)
• Thread attivi
• Variabili locali e parametri dei metodi attualmente in esecuzione
• Variabili locali e parametri dei metodi dei metodi JNI
• Riferimenti JNI globali
• Oggetti utilizzati come monitor per la sincronizzazione
• Oggetti utilizzati dalla JVM la quale li trattiene impedendo che finiscano distrutti dalla garbage collection

Il garbage collector attraversa l'intero grafo nella memoria, iniziando dalle radici e seguendo i riferimenti da queste verso gli altri oggetti.

Le fasi della Garbage Collection in Java

Un'implementazione standard di Garbage Collection comprende tre fasi:

Marcatura degli oggetti vivi

In questo step, il GC individua tutti gli oggetti vivi in memoria attraversando il grafo degli oggetti.

Quando il GC visita un oggetto, lo marca come accessibile e quindi lo classifica come vivo. Ciascun oggetto visitato dal garbage collector è considerato vivo. Analogamente, tutti gli oggetti che non sono raggiungibili a partire dalle radici sono considerati oggetti morti e potenziali candidati per la garbage collection.

Pulizia degli oggetti obsoleti

Dopo la fase di marcatura, siamo nella condizione in cui lo spazio di memoria è occupato dagli oggetti vivi (visitati) e dagli oggetti morti (non raggiungibili, non visitati). La fase di pulizia della memoria ha l'effetto di svuotare tutti i frammenti di memoria che prima erano occupati dagli oggetti morti.

Compattazione degli oggetti rimanenti in memoria

Gli oggetti morti rimossi durante la fase di pulizia potrebbero non aver occupato segmenti di memoria adiacenti. Pertanto, è probabile che si finisca per ottenere uno spazio di memoria frammentato.

La memoria può essere compattata dopo la cancellazione degli oggetti morti, in modo che gli oggetti rimanenti occupino un blocco contiguo di memoria che comincia all'inizio dell'area di heap.

Il processo di compattazione rende più facile allocare la memoria per i nuovi oggetti in modo sequenziale, assegnando indirizzi via via crescenti.

Che cosa si intende per Garbage Collection generazionale in Java?

I Java Garbage Collector implementano una strategia di garbage collection generazionale che classifica gli oggetti distinguendoli in classi di età.

Il compito di marcare e compattare tutti gli oggetti presenti in una JVM è un processo inefficiente. Con l'aumentare degli oggetti allocati, la lista degli oggetti cresce, e si allungano i tempi richiesti dalla garbage collection. L'analisi empirica delle applicazioni ha dimostrato che la maggior parte degli oggetti in Java ha vita breve.

Nell'esempio qui sopra, l'asse Y indica il numero di byte sopravvissuti o mantenuti, mentre l'asse X rappresenta il numero di byte allocati al passare del tempo. Come si può notare, in un intervallo di tempo abbastanza lungo, rimangono sempre meno oggetti allocati.

Infatti, la gran parte degli oggetti ha una vita molto breve, come dimostrato dai valori più alti vicino all'asse Y del grafico. Questo avviene perché Java classifica gli oggetti in generazioni e applica i cicli di garbage collection coerentemente con tale classificazione.

L'area di memoria riservata all'heap nella JVM è suddivisa in tre sezioni:

Generazione Giovane

I nuovi oggetti iniziano il loro ciclo di vita nella Generazione Giovane (Young Generation). A sua volta, la generazione giovane viene suddivisa in:

• Spazio Eden - tutti i nuovi oggetti partono in questo spazio quando ricevono l'allocazione di memoria iniziale
• Spazi destinati ai sopravvissuti (FromSpace e ToSpace) - gli oggetti vengono trasferiti qui dallo spazio Eden dopo essere sopravvissuti al primo ciclo di garbage collection.

Il momento in cui il garbage collector rimuove gli oggetti dall'area di Generazione Giovane, è indicato come evento di garbage collection minore.

Quando lo spazio Eden è stato popolato con gli oggetti, viene eseguito un ciclo di GC minore.  Tutti gli oggetti marcati come morti sono rimossi, mentre tutti gli oggetti marcati come vivi sono trasferiti ad uno degli spazi destinati ai sopravvissuti. L'evento di GC minore verifica anche gli oggetti presenti negli spazi dei sopravvissuti e li trasferisce da uno spazio all'altro.

Esaminiamo la seguente sequenza di esempio:

1. Tutti gli oggetti sono inseriti nello spazio Eden (sia vivi che morti)
2. Viene eseguito il ciclo di GC minore - tutti gli oggetti morti vengono estratti dallo spazio Eden. Tutti gli oggetti vivi sono trasferiti allo spazio dei sopravvissuti S1 (FromSpace). A questo punto lo spazio Eden è stato svuotato e lo spazio dei sopravvissuti S2 è vuoto.
3. I nuovi oggetti sono creati e aggiunti allo spazio Eden. Alcuni oggetti in S1 e nello spazio Eden vengono classificati come morti.
4. Viene eseguito un ciclo di GC minore - tutti gli oggetti morti sono rimossi da Eden ed S1. Tutti gli oggetti vivi sono trasferiti a S2 (ToSpace). Lo spazio Eden e lo spazio S1 adesso sono stati svuotati.

Pertanto, in qualsiasi momento, uno dei due spazi destinati agli oggetti sopravvissuti è sempre vuoto. Quando gli oggetti sopravvissuti raggiungono una certa soglia di trasferimenti da uno spazio dei sopravvissuti all'altro, vengono inviati alla Generazione Vecchia (Old Generation).

Per impostare la dimensione della Generazione Giovane è possibile usare l'apposito flag -Xmn .

Generazione Vecchia

Gli oggetti che sopravvivono più a lungo vengono ad un certo punto spostati dalla Generazione Giovane alla Generazione Vecchia. Quest'ultima è anche conosciuta come la Generazione "di ruolo" e contiene gli oggetti che sono stati mantenuti negli spazi dei sopravvissuti per un tempo relativamente lungo.

È definito un preciso valore di soglia per il mandato di ciascun oggetto che determina il numero dei cicli di garbage collection a cui l'oggetto deve sopravvivere prima che venga trasferito allo spazio della Generazione Vecchia.

Quando gli oggetti presenti nella Generazione Vecchia vengono raccolti dal garbage collector, è indicato come evento di garbage collection maggiore.

Per impostare la dimensione iniziale e quella massima raggiungibile dall'area Heap della memoria è possibile agire, rispettivamente, sugli appositi flag -Xms e -Xmx.

Dato il funzionamento della garbage collection generazionale utilizzata in Java, più è alto il numero di cicli di garbage collection a cui un evento sopravvive, più avanti in termini di indirizzo verrà spostato all'interno dell'heap. Inizia la sua vita nella Generazione Giovane e, alla fine, potrà giungere alla Generazione "di ruolo", se sopravvivrà ad un numero di cicli sufficiente.

Consideriamo l'esempio seguente per comprendere la promozione degli oggetti attraverso gli spazi e le generazioni:

Quando un oggetto viene creato, è inserito inizialmente nello Spazio Eden all'interno della Generazione Giovane. Dopo l'intervento di un ciclo di garbage collection minore, gli oggetti vivi presenti nello spazio Eden sono promossi nello spazio dei sopravvissuti FromSpace. Quando si verifica il successivo ciclo di garbage collection minore, gli oggetti vivi presenti sia nello spazio Eden che nel FromSpace sono trasferiti al ToSpace.

Questa successione di eventi è ripetuta per un numero predefinito di iterazioni, raggiunto il quale, qualora l'oggetto risultasse ancora utilizzato, viene destinato alla Generazione Vecchia a partire dal ciclo di garbage collection successivo.

Generazione Permanente

I metadati come classi e metodi sono memorizzati nella Generazione Permanente. Viene popolata dalla JVM al runtime sulla base delle classi in uso dall'applicazione. Le classi presenti nella Generazione Permanente che non risultano più in uso potrebbero essere raccolte dal garbage collector.

Per impostare le dimensioni iniziale e massima della Generazione Permanente sono previsti rispettivamente i flag  -XX:PermGen e -XX:MaxPermGen.

MetaSpace

A partire dalla versione 8 di Java, lo spazio di memoria MetaSpace sostituisce lo spazio PermGen. La nuova implementazione differisce dal PermGen e adesso questa porzione di heap viene ridimensionata in modo automatico.

Questo evita il problema dell'esaurimento di memoria da parte delle applicazioni a causa della dimensione limitata dello spazio PermGen nell'heap. La memoria MetaSpace può essere pulita tramite la garbage collection e le classi che non vengono più utilizzate possono essere rimosse automaticamente quando il MetaSpace raggiunge la dimensione massima.

Tipi di Garbage Collector nella Java Virtual Machine

La garbage collection rende la memoria Java efficiente perché rimuove gli oggetti non più referenziati dall'heap liberando spazio che diventa disponibile per l'allocazione dei nuovi oggetti.

La Java Virtual Machine dispone di otto tipi diversi di garbage collector. Vediamo di seguito i dettagli per ciascuna tipologia.

Seriale

Si tratta della più semplice implementazione di GC che è stata progettata per piccole applicazioni eseguite su ambienti in modalità mono-thread. Tutti gli eventi di garbage collection sono eseguiti sequenzialmente in un unico thread. La compattazione è eseguita dopo ciascun ciclo di collection.

Quando viene eseguito, determina un evento "stop the world" (letteralmente "arresta, interrompi il mondo") in corrispondenza del quale l'intera applicazione è posta in pausa. Dato che l'intera applicazione è congelata per la durata della garbage collection, non è consigliato per scenari del mondo reale nel quale sono generalmente richieste latenze ridotte.

L'argomento della JVM utilizzato per impostare il GC Seriale è -XX:+UseSerialGC.

Parallelo

Il collector parallelo è adatto ad applicazioni con data set di dimensioni comprese tra medie e grandi che siano eseguite su di un hardware multiprocessore in modalità multi-thread. Questa è l'implementazione di default per il GC nella JVM ed è anche conosciuto come Throughput Collector.

Sono utilizzati thread multipli per gli eventi minori di garbage collection verso la Generazione Giovane. Un singolo thread gestisce invece gli eventi maggiori di collection sulla Generazione Vecchia.

Eseguire il GC Parallelo determina comunque un evento "stop the world" e il congelamento dell'applicazione. Dato che è più adatto ad un ambiente multi-thread, può essere utilizzato quando una gran quantità di lavoro deve essere completata e pause lunghe sono ritenute accettabili, ad esempio eseguendo un job batch.

L'argomento della JVM da impostare per l'utilizzo del Garbage Collector Parallelo è  -XX:+UseParallelGC.

Vecchio GC Parallelo

Questa è la versione di default del GC Parallelo a partire dalla versione Java 7u4. Ha le medesime caratteristiche del GC Parallelo tranne per il fatto che sfrutta thread multipli sia per eseguire collection sulla Generazione Giovane che sulla Generazione Vecchia.

L'argomento da passare alla JVM per utilizzare il Garbage Collector Parallelo Vecchio è invece -XX:+UseParallelOldGC.

CMS - Concurrent Mark Sweep (Pulizia e Marcatura Concorrenti)

Anche conosciuto come il collector concorrente con pausa ridotta. Utilizza thread multipli per eventi di garbage collection minore implementando lo stesso algoritmo del Parallelo. La garbage collection maggiore è implementata in multi-thread, analogamente a quanto avveniva con il Vecchio GC Parallelo, ma nel caso del CMS, è eseguita in concorrenza con i processi dell'applicazione in modo da minimizzare le occorrenze di eventi "stop the world".

A causa di ciò, il collector CMS necessita di maggiori risorse di CPU rispetto agli altri GC. Se nel sistema vi è disponibilità per allocare una quantità maggiore di risorse CPU per ottenere performance migliori, allora il collector CMS sarà una scelta migliore rispetto al collector Parallelo. La compattazione non è invece eseguita dal collector CMS.

L'argomento per la JVM da utilizzare per impostare il GC Concurrent Mark Sweep è invece  -XX:+UseConcMarkSweepGC.

G1 - Garbage First (Prima la spazzatura)

Il G1 era stato pensato per sostituire CMS ed era progettato per applicazioni multi-thread con un ampio spazio di memoria heap (superiore a 4GB) a disposizione. Si tratta di un'implementazione parallela e concorrente come il CMS, ma che funziona diversamente se paragonata ai garbage collector più vecchi.

Nonostante anche G1 condivida l'approccio generazionale, non utilizza regioni separate per le generazioni giovane e vecchia. Invece, ciascuna generazione costituisce un insieme di regioni, le quali consentono il ridimensionamento della generazione giovane in modo flessibile.

L'heap viene partizionato in un insieme di regioni di egual dimensione (da 1MB a 32MB - a seconda della dimensione dell'heap) e utilizza thread multipli per la scansione delle stesse. Una regione potrebbe essere classificata sia come vecchia che come nuova in un momento qualsiasi durante l'esecuzione del programma.

Dopo il completamento della fase di marcatura, G1 è in grado di individuare quali regioni contengano la gran parte degli oggetti da pulire. Se l'utente è interessato a ridurre al minimo i tempi di pausa, G1 può scegliere di rimuovere solo poche regioni. Se, al contrario, l'user non ha criticità legate ai tempi di pausa oppure ha dichiarato un limite di tempo di pausa sufficientemente elevato, G1 potrebbe scegliere di includere un maggior numero di regioni.

Dato che G1 identifica la regione con il maggior numero di oggetti da rimuovere ed esegue la garbage collection proprio a partire da quella regione, viene anche detto Garbage First.

In aggiunta agli spazi Eden, Sopravvissuti e Old, in G1GC sono previsti altri due tipi di regioni:

• Enorme (Humongous) - destinato agli oggetti di grandi dimensioni (che richiedono uno spazio superiore al 50% della dimensione dell'heap)
• Disponibile (Available) - lo spazio inutilizzato o non allocato

Per impostare il garbage collector G1 il flag da passare alla JVM è  -XX:+UseG1GC.

Epsillon

Epsilon è un collector di tipo "do-nothing" (letteralmente "non fare niente") che è stato rilasciato con la JDK 11. Gestisce l'allocazione della memoria ma senza implementare alcun meccanismo di recupero dello spazio. Una volta che lo spazio disponibile per l'heap viene esaurito, la JVM si arresta.

Può essere usato per applicazioni ultrasensibili ai vincoli di latenza, nelle quali gli sviluppatori sono in grado di stabilire esattamente l'impronta di occupazione della memoria (footprint), oppure lavorano ad applicazioni ottimizzate a tal punto da essere quasi prive di oggetti obsoleti (garbage-free). L'utilizzo del GC Epsilon al di fuori di questi scenari è in genere sconsigliato.

Il flag da passare alla JVM per utilizzare il Garbage Collector Epsilon è il seguente -XX:+UnlockExperimentalVMOptions -XX:+UseEpsilonGC.

Shenandoah

Shenandoah è un nuovo GC rilasciato con la JDK 12. Il principale vantaggio di Shenandoah rispetto a G1 è che svolge una parte maggiore del ciclo della sua garbage collection in modo concorrente con i thread dell'applicazione. G1 può liberare le regioni nell'heap solamente quando l'applicazione è posta in pausa, mentre Shenandoah può trasferire gli oggetti in modo concorrente con l'applicazione.

Shenandoah può compattare oggetti vivi, rimuovere gli oggetti obsoleti e restituire RAM al Sistema Operativo quasi immediatamente dopo aver rilevato memoria libera. Come conseguenza al fatto che tutte queste attività sono condotte in concorrenza con l'applicazione, Shenandoah necessita di maggiori risorse CPU.

L'argomento da passare alla JVM per utilizzare il GC Shenandoah è infine il seguente -XX:+UnlockExperimentalVMOptions -XX:+UseShenandoahGC.

ZGC

ZGC è un altro GC che è stato inserito nella JDK 11 ed è stato poi migliorato nella JDK 12. È stato pensato per applicazioni che richiedano bassa latenza (con pause inferiori ai 10 ms) e/o che usino un heap molto esteso (dell'ordine dei Terabyte).

Gli obiettivi primari del ZGC sono latenza contenuta, scalabilità, facilità d'uso. Per raggiungere queste performance, ZGC permette a un'applicazione Java di continuare l'esecuzione mentre vengono eseguite tutte le operazioni di garbage collection. Inoltre, come comportamento di default, ZGC revoca la memoria inutilizzata e la restituisce al sistema operativo.

In questo modo, ZGC introduce un netto miglioramento rispetto ai GC tradizionali e riuscendo a offrire tempi di pausa estremamente ridotti (tipicamente inferiori ai 2 ms).

Il flag da impostare sulla JVM per attivare ZGC è invece -XX:+UnlockExperimentalVMOptions -XX:+UseZGC.

Nota: con l'introduzione della JDK 15, sia Shenandoah che ZGC sono diventati feature di produzione della JDK dopo essere stati promossi dallo stage sperimentale.

Come scegliere il Garbage Collector più adatto

Quando la tua applicazione non ha stretti vincoli sui tempi di pausa, puoi eseguire l'applicazione lasciando alla JVM la selezione del giusto collector.

Nella maggior parte degli scenari, le impostazioni di base hanno una buona resa. Se necessario, puoi regolare la dimensione dell'heap per migliorare le performance. Se le performance non sono ancora adeguate, puoi impostare il collector secondo i requisiti dell'applicazione:

• Seriale - Se l'applicazione lavora su dati di dimensione contenuta (approssimativamente fino a 100 MB) e/o sarà eseguita su di un singolo processore senza vincoli sui tempi di pausa
• Parallelo - Se il picco di performance è la priorità e non ci sono particolari vincoli per quanto riguarda i tempi di pausa e interruzioni di un secondo o maggiori sono ritenute accettabili
• CMS/G1 - Se il tempo di risposta è più importante del rendimento complessivo e le pause dovute all'intervento del garbage collection devono essere limitate approssimativamente a un secondo
• ZGC - Se il tempo di risposta è critico, e/o si sta lavorando con un heap molto esteso

Vantaggi della Garbage Collection

I vantaggi dell'azione della garbage collection in Java sono molteplici.

Prima di tutto, rende il codice più semplice. Non ci si deve preoccupare di gestire cicli di assegnamento e revoca della memoria. È sufficiente smettere di referenziare un oggetto nel codice e, a un certo punto, la memoria occupata dallo stesso oggetto verrà recuperata automaticamente.

I programmatori che lavorano con linguaggi privi di garbage collection (quali C e C++), devono implementare esplicitamente la gestione della memoria nel proprio codice.

Rende inoltre Java efficiente in termini di risorse di memoria, in quanto, il garbage collector rimuove gli oggetti non più referenziati dalla regione dell'heap. Ciò determina la creazione di spazio libero di memoria heap per accogliere i nuovi oggetti istanziati dal programma.

Mentre alcuni programmatori criticano la garbage collection in favore di una gestione più manuale della memoria, la garbage collection è diventata un componente standard per molti altri popolari linguaggi di programmazione.

Per scenari in cui la garbage collection introduce ricadute negative sulle performance, Java consente molte opzioni per impostare il garbage collector più accuratamente e in modo da migliorare la sua efficienza.

Buone Pratiche

Evitare Chiamate Manuali

Oltre al funzionamento di base della garbage collection, uno dei punti fondamentali da capire sulla garbage collection in ambiente Java riguarda il fatto che essa segue un comportamento non-deterministico. Questo si traduce nell'impossibilità di predire quando la garbage collection si verificherà durante l'esecuzione.

È possibile includere un suggerimento nel codice per eseguire il garbage collector, attraverso istruzioni quali chiamate ai metodi System.gc() o Runtime.gc(), ma è importante ricordare che questi non offrono alcuna garanzia che il GC verrà effettivamente richiamato in quel punto del programma.

Utilizzare strumenti per l'analisi

Se non si dispone di sufficiente memoria per eseguire l'applicazione, si sperimentano rallentamenti, lunghi tempi di pausa per garbage collection, frequenti eventi di "stop the world" e infine anche errori di "out of memory" (imprevisto esaurimento della memoria). Questo può indicare uno spazio di heap troppo ridotto, ma può anche significare la presenza di memory leak nell'applicazione.

Si può ottenere aiuto da un tool di monitoraggio come jstat oppure Java Flight Recorder per comprendere se l'occupazione dell'heap cresca indefinitamente, comportamento che è tipicamente un sintomo di un bug nel codice.

Le impostazioni di default sono valide

Quando si sta eseguendo una piccola applicazione Java in configurazione standalone, molto probabilmente non si avvertirà la necessità di alcuna impostazione personalizzata della garbage collection. Le impostazioni di default dovrebbero infatti funzionare correttamente nella maggior parte dei casi.

Flag JVM per cambiare le impostazioni

L'approccio più corretto per impostare la garbage collection in Java è quello di inserire i flag nella riga di comando della JVM. I Flag possono essere utilizzati per scegliere quale garbage collector applicare (Seriale, G1 e così via), la dimensione iniziale e quella massima dell'heap, la dimensione delle sezioni dell'heap (ad esempio per gli spazi della Generazione Giovane e della Generazione Vecchia) e anche altri parametri.

Scegliere il giusto collector

La natura dell'applicazione da ottimizzare è una buona guida iniziale per effettuare le impostazioni corrette. Ad esempio, il garbage collector parallelo è efficiente ma causa frequenti eventi "stop the world", rendendolo più adatto a processi backend nei quali, pause più lunghe per la garbage collection sono accettabili.

D'altro canto, il garbage collector CMS è progettato per minimizzare le pause, rendendolo ideale per applicazioni web nelle quali i tempi di risposta sono un fattore critico.

Conclusione

In questo articolo, abbiamo discusso la Garbage Collection in Java, il suo funzionamento e i diversi tipi di Garbage Collector.

Per quanto riguarda le applicazioni più semplici, la garbage collection non rientra tra i fattori principali che un programmatore deve considerare durante lo sviluppo. Tuttavia, per i programmatori che vogliono accrescere le proprie abilità in Java, è importante comprendere il funzionamento della garbage collection.

Si tratta inoltre di un argomento popolare nei colloqui tecnici, sia a livelli junior che senior, per ruoli backend.

Grazie per essere rimasto con me così a lungo. Spero ti sia piaciuto l'articolo. Puoi connetterti con me su LinkedIn dove scrivo post sulla tecnologia e sulla vita. Dai anche un'occhiata a qualche altro mio articolo e al mio canale YouTube. Buona lettura. 🙂

C'è un errore che spesso disorienta i nuovi programmatori Java. Si verifica quando una serie di prompt di input vengono raggruppati insieme e una delle chiamate del metodo scanner.nextLine() viene saltata – senza alcuna traccia di errore.

Dai un'occhiata al seguente snippet, ad esempio:

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Come ti chiami? ");
        String name = scanner.nextLine();

        System.out.printf("Ciao %s. Quanti anni hai? ", name);
        int age = scanner.nextInt();

        System.out.printf("Bene! %d anni sono un'ottima età per imparare a programmare. \nChe linguaggio preferisci? ", age);
        String language = scanner.nextLine();

        System.out.printf("Ah! %s è un linguaggio di programmazione molto valido.", language);

        scanner.close();

    }

}

La prima chiamata scanner.nextLine() chiede all'utente il suo nome. Poi la chiamata scanner.nextInt() chiede all'utente la sua età. L'ultima chiamata scanner.nextLine() chiede all'utente il suo linguaggio di programmazione preferito. Infine chiudi l'oggetto scanner e la finisci qui.

Si tratta di codice Java molto semplice, che fa uso di un oggetto scanner per prendere un input dall'utente. Proviamo a eseguire il programma e vediamo cosa accade.

Se hai eseguito il programma, probabilmente hai notato che chiede il nome, l'età e poi salta l'ultima richiesta di input per il linguaggio di programmazione preferito, terminando di colpo. Ecco quello che andremo a risolvere oggi.

Perché la chiamata scanner.nextLine() viene saltata dopo la chiamata scanner.nextInt()?

Questo comportamento non è limitato solo al metodo scanner.nextInt(). Se chiami il metodo scanner.nextLine() dopo uno qualsiasi dei metodi scanner.nextQualcosa(), il programma salterà quella chiamata.

Ciò ha a che fare con il modo in cui funzionano i due metodi. Il primo scanner.nextLine() richiede all'utente il suo nome.

Quando l'utente digita il suo nome e preme invio, scanner.nextLine() utilizza il nome e l'invio o il carattere nuova riga alla fine.

Questo vuol dire che il buffer degli input è attualmente vuoto. Quindi il metodo scanner.nextInt() chiede all'utente la sua età. L'utente la digita e preme invio.

A differenza del metodo scanner.nextLine(), il metodo scanner.nextInt() utilizza soltanto la parte intera e lascia l'invio o il carattere nuova riga nel buffer.

Quando viene chiamato lo scanner.nextLine() successivo, trova il carattere nuova riga ancora presente nel buffer degli input e lo interpreta erroneamente come l'input dell'utente.

Come puoi vedere, come molti altri problemi della vita reale, tutto ciò è causato da un'incomprensione tra l'utente e il programmatore.

Esistono due modi per risolvere il problema. Puoi utilizzare il carattere nuova riga dopo che avviene la chiamata di scanner.nextInt() oppure puoi prendere tutti gli input come stringhe per poi convertirli successivamente nei tipi di dato corretti.

Come svuotare il buffer degli input dopo la chiamata scanner.nextInt()

È più facile di quanto pensi. Tutto ciò che devi fare è aggiungere un'altra chiamata scanner.nextLine() dopo la chiamata scanner.nextInt().

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Come ti chiami? ");
        String name = scanner.nextLine();

        System.out.printf("Ciao %s. Quanti anni hai? ", name);
        int age = scanner.nextInt();

        // utilizza il carattere nuova riga nel buffer
        scanner.nextLine();

        System.out.printf("Bene! %d anni sono un'ottima età per imparare a programmare. \nChe linguaggio preferisci? ", age);
        String language = scanner.nextLine();

        System.out.printf("Ah! %s è un linguaggio di programmazione molto valido.", language);

        scanner.close();

    }

}

Sebbene questa soluzione funzioni, occorre aggiungere una chiamata aggiuntiva scanner.nextLine() ogni volta che chiami uno degli altri metodi. Va bene per piccoli programmi, ma per programmi più complessi può degenerare molto in fretta.

Come interpretare gli input presi usando il metodo scanner.nextLine()

Tutta la classe wrapper in Java contiene metodi per interpretare valori stringa. Ad esempio, il metodo Integer.parseInt() può interpretare un valore intero da una data stringa.

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Come ti chiami? ");
        String name = scanner.nextLine();

        System.out.printf("Ciao %s. Quanti anni hai? ", name);
        // interpreta l'intero dalla stringa
        int age = Integer.parseInt(scanner.nextLine());

        System.out.printf("Bene! %d anni sono un'ottima età per imparare a programmare. \nChe linguaggio preferisci? ", age);
        String language = scanner.nextLine();

        System.out.printf("Ah! %s è un linguaggio di programmazione molto valido.", language);

        scanner.close();

    }

}

Questo è un modo più pulito per combinare richieste di più tipi di input in Java. Finché fai attenzione a quello che l'utente sta inserendo, il parsing non dovrebbe dare problemi.

Conclusione

Grazie di cuore per interessarti a quello che scrivo. Spero che questo tutorial ti abbia aiutato in qualche modo.

Se lo hai trovato utile, condividilo con i tuoi amici. E se vuoi seguirmi, sono su Twitter e LinkedIn.

Nella maggior parte dei linguaggi di programmazione si utilizzano gli operatori per eseguire operazioni sulle variabili.

Sono divisi in diverse categorie come gli operatori aritmetici, gli operatori di assegnamento, gli operatori logici e così via.

In questo articolo parleremo dell'operatore bit a bit AND e degli operatori logici AND (&&) e OR (||).

Come usare l'operatore bit a bit AND

Il simbolo & indica l'operatore bit a bit AND. Valuta il valore binario dei numeri dati. Il risultato binario di questi numeri sarà restituito in base 10.

L'operatore & inizia la sua operazione valutando il valore dei caratteri in entrambi i numeri partendo da sinistra.

Vediamo un esempio per capire meglio:

System.out.println(10 & 12);
// ritorna 8

Analizziamo i passaggi.

Il valore binario di 10 è 1010

Il valore binario di 12 è 1100

Prima di iniziare l'operazione, è necessario tenere a mente una cosa:

• 1 and 0 => 0
• 0 and 1 => 0
• 1 and 1 => 1
• 0 and 0 => 0

Eseguiamo quindi l'operazione.

Il primo carattere per 10 è 1 e il primo carattere per 12 è anch'esso 1, quindi:

1 and 1 = 1.

Passiamo ai successivi caratteri – 0 per 10 e 1 per 12:

1 and 0 = 0.

Per i terzi caratteri – 1 per 10 e 0 per 12:

1 and 0 = 0.

Per gli ultimi caratteri – 0 per 10 e 0 per 12:

0 and 0 = 0.

Ora combiniamo tutti i caratteri restituiti. Otterremo 1000.

Il valore binario 1000 in base 10 è 8 e questo è il motivo per cui la nostra operazione ha restituito 8.

Come usare l'operatore logico AND

Gli operatori logici vengono utilizzati per valutare le condizioni. Essi restituiscono true o false in base alle condizioni date.

Il simbolo && indica l'operatore AND. Valuta due affermazioni/condizioni e restituisce true solo quando entrambe le affermazioni/condizioni sono vere.

Ecco come si presenta la sintassi:

affermazione1/condizione1 && affermazione1/condizione1

Come puoi vedere qui sopra, ci sono due affermazioni/condizioni separate dall'operatore. L'operatore valuta il valore di entrambe le affermazioni/condizioni e ci restituisce un risultato: true o false.

Ecco un esempio:

System.out.println((10 > 2) && (8 > 4));
//true

L'operatore restituirà true perché entrambe le condizioni sono vere – 10 è maggiore di 2 and 8 è maggiore di 4. Se una delle due condizioni avesse una logica non vera, otterremmo false.

Per comprendere meglio l'operatore &&, è necessario sapere che entrambe le condizioni devono essere vere per ottenere il valore true.

Ecco un altro esempio che ritorna false:

System.out.println((2 > 10) && (8 > 4));
// false

In questo caso, 2 non è maggiore di 10, ma 8 è maggiore di 4 - quindi ci viene restituito false. Questo perché una delle condizioni non è vera.

• Se entrambe le condizioni sono vere => true
• Se una delle due condizioni è falsa => false
• Se entrambe le condizioni sono false => false

Come usare l'operatore logico OR

Si utilizza il simbolo || per indicare l'operatore OR. Questo operatore restituisce false solo quando entrambe le condizioni sono false. Ciò significa che se entrambe le condizioni sono vere, si otterrà il valore true, e se una delle due condizioni è vera, si otterrà comunque il valore true.

Ecco la sintassi:

affermazione1/condizione1 || affermazione1/condizione1

Vediamo alcuni esempi.

System.out.println((6 < 1) || (4 > 2));  
// true

Restituisce true perché una delle condizioni è vera.

• Se entrambe le condizioni sono vere => true
• Se una delle condizioni è vera => true
• Se entrambe le condizioni sono false => false

Conclusioni

In questo articolo abbiamo appreso come utilizzare l'operatore bit a bit & in Java e come viene eseguita l'operazione per ottenere un risultato.

Abbiamo anche imparato a utilizzare gli operatori logici && e || in Java. Abbiamo imparato quale valore restituisce ciascuna operazione in base alle condizioni coinvolte nel calcolo.

Buona programmazione!

Che tu sia solito sviluppare programmi in Java oppure no, a un certo punto potresti aver sentito parlare di Java Virtual Machine (JVM).

La JVM è il fulcro dell'ecosistema Java e rende possibile per i programmi basati su Java di seguire l'approccio "write once, run anywhere" (ovvero scrivi una volta ed esegui ovunque). Puoi scrivere del codice Java su una macchina ed eseguirlo su qualsiasi altra macchina che utilizza la JVM.

La JVM è stata inizialmente progettata per supportare soltanto Java. Tuttavia, nel tempo, altri linguaggi come Scala, Kotlin e Groovy sono stati adottati sulla piattaforma Java. Tutti questi linguaggi sono collettivamente conosciuti come linguaggi JVM.

In questo articolo, impareremo di più a riguardo della JVM, il suo funzionamento e i vari componenti di cui è costituita.

Cos'è una macchina virtuale?

Prima di passare alla JVM, esaminiamo il concetto di macchina virtuale (virtual machine, VM).

Una macchina virtuale è una rappresentazione virtuale di un computer fisico. La macchina virtuale può essere chiamata macchina guest, e il computer fisico su cui gira la macchina virtuale può essere detto macchina host.

N.d.T.
Dall'inglese host, chi offre ospitalità, e guest, chi ne usufruisce.

Una singola macchina fisica può ospitare più macchine virtuali, ognuna con il proprio sistema operativo e le proprie applicazioni, e ognuna isolata dalle altre.

Cos'è la Java Virtual Machine?

Nei linguaggi di programmazione come C e C++, il codice viene prima compilato in codice macchina specifico per una piattaforma. Questi linguaggi sono detti compilati.

D'altro canto, nei linguaggi come JavaScript e Python, il computer esegue le istruzioni direttamente senza doverli compilare. Questi linguaggi sono detti interpretati.

Java utilizza una combinazione di entrambe le tecniche. Il codice Java viene prima compilato in bytecode per generare un file class, che viene poi interpretato dalla Java Virtual Machine per la piattaforma sottostante. Lo stesso file class può essere eseguito su qualsiasi versione della JVM in esecuzione su su qualsiasi piattaforma e sistema operativo.

Come le macchine virtuali, la JVM crea uno spazio isolato su una macchina host. Questo spazio può essere usato per eseguire i programmi Java indipendentemente dalla piattaforma o dal sistema operativo della macchina.

Architettura della Java Virtual Machine

La JVM consiste di tre componenti distinti:

1. Class Loader
2. Memoria di runtime/area dati
3. Execution Engine

Diamo un'occhiata a ognuno di loro più nel dettaglio.

Class Loader

Quando compili un file sorgente .java, questo viene convertito in bytecode come un file .class. Quando provi a utilizzare questa classe in un programma, il class loader la carica nella memoria principale.

La prima classe ad essere caricata nella memoria è solitamente la classe che contiene il metodo main().

Esistono tre fasi nel processo di caricamento della classe: caricamento (loading), collegamento (linking) e inizializzazione (initialization).

Caricamento

Il processo di caricamento comporta prendere la rappresentazione binaria (bytecode) di una classe o interfaccia con un particolare nome, e da essa generare la classe originaria o interfaccia.

Esistono tre class loader integrati disponibili in Java:

• Bootstrap Class Loader - Questo è il class loader radice. Si tratta di una superclasse dell'Extension Class Loader e carica i pacchetti standard Java come java.lang, java.net, java.util, java.io e via dicendo. Questi pacchetti sono presenti all'interno del file rt.jar e altre librerie di base presenti nella cartella $JAVA_HOME/jre/lib.
• Extension Class Loader - È una sottoclasse del Bootstrap Class Loader e superclasse dell'Application Class Loader. Si occupa del caricamento delle librerie standard Java che sono presenti nella cartella $JAVA_HOME/jre/lib/ext.
• Application Class Loader - È l'ultimo class loader e sottoclasse dell'Extension Class Loader. Carica i file presenti nel classpath. Per impostazione predefinita, il classpath è regolato sulla cartella corrente dell'applicazione. Il classpath può anche essere modificato aggiungendo le opzioni da riga di comando -classpath o -cp.

La JVM utilizza il metodo ClassLoader.loadClass() per caricare la classe nella memoria. Tenta di caricare la classe sulla base di un nome pienamente abilitato.

Se il class loader genitore non è in grado di trovare una classe, delega il lavoro al class loader figlio. Se l'ultimo class loader figlio non è in grado di caricare la classe restituisce NoClassDefFoundError o ClassNotFoundException.

Collegamento

Dopo che una classe viene caricata in memoria, viene sottoposta al processo di collegamento. Collegare una classe o un'interfaccia implica collegare insieme i diversi elementi e dipendenze del programma.

Il collegamento comprende i seguenti passaggi:

Verifica: questa fase controlla la correttezza strutturale del file .class facendo un confronto con un insieme di vincoli o regole. Se la verifica fallisce per qualche ragione, otteniamo VerifyException.

Ad esempio, se il codice è stato creato usando Java 11, ma viene eseguito su un sistema che ha installato Java 8, la fase di verifica fallirà.

Preparazione: in questa fase, la JVM alloca la memoria per i campi statici di una classe o un'interfaccia e li inizializza con dei valori predefiniti.

Ad esempio, supponi di aver già dichiarato la seguente variabile nella tua classe:

private static final boolean enabled = true;

Durante la  fase di preparazione, la JVM alloca memoria per la variabile enabled e imposta il suo valore su quello predefinito per un booleano, ovvero false.

Risoluzione: in questa fase, i riferimenti simbolici vengono sostituiti con riferimenti diretti al constant pool nel runtime.

Ad esempio, se ci sono riferimenti ad altre classi o variabili costanti presenti in altre classe, sono risolti durante questa fase e rimpiazzati con i riferimenti attuali.

Inizializzazione

L'inizializzazione comporta l'esecuzione del metodo di inizializzazione della classe o dell'interfaccia (conosciuto come <clinit>). Ciò può comprendere la chiamata del costruttore della classe, eseguendo il blocco statico e assegnando i valori a tutti le variabili statiche. Questo è il passaggio finale del caricamento di una classe.

Ad esempio, prima, quando abbiamo dichiarato il seguente codice:

private static final boolean enabled = true;

La variabile enabled era impostata al suo valore predefinito, false, durante la fase di preparazione. Nella fase di inizializzazione, alla variabile è assegnato il suo valore reale, true.

Nota: la JVM è multi-thread. Può capitare che più thread tentino di inizializzare la stessa classe allo stesso tempo. Ciò può portare a problemi di concorrenza. Occorre gestire la sicurezza del thread per assicurare che il programma funzioni in modo appropriato in un ambiente multi-thread.

Area dati di runtime

Esistono cinque componenti all'interno dell'area dati di runtime:

Analizziamoli individualmente.

Area dei metodi

Tutti i dati di livello classe come i dati di constant pool, campo e metodo, e il codice per metodi e costruttori sono conservati qui.

Se la memoria disponibile nell'area dei metodi non è sufficiente per l'avvio del programma, la JVM restituisce OutOfMemoryError.

Ad esempio, supponi di avere la seguente definizione di classe:

public class Employee {
  
  private String name;
  private int age;
  
  public Employee(String name, int age) {
  
    this.name = name;
    this.age = age;
  }
}

In questo codice di esempio, il dato al livello del campo come name e age e i dettagli del costruttore sono caricati nell'area dei metodi.

L'area dei metodi è creata all'avvio della macchina virtuale e ce n'è una sola per JVM.

Area di heap

Tutti gli oggetti e le loro corrispondenti variabili di istanza sono memorizzati qui. Questa è l'area di dati di run-time dalla quale è allocata la memoria per tutte le istanze di classe e array.

Ad esempio, supponi di dichiarare la seguente istanza:

Employee employee = new Employee();

In questo esempio di codice, viene creata un'istanza di Employee e caricata nell'area heap.

L'area di heap è creata all'avvio della macchina virtuale e ce n'è una sola per JVM.

Nota: dato che l'area dei metodi e l'heap condividono la stessa memoria per thread multipli, i dati memorizzati qui non sono thread-safe.

Stack

Ogniqualvolta un nuovo thread viene creato nella JVM, viene creato contemporaneamente uno stack di runtime separato. Tutte le variabili locali, le chiamate di metodi e i risultati parziali sono memorizzati nell'area di stack.

Se l'elaborazione fatta in un thread richiede una dimensione di stack maggiore di quella disponibile, la JVM restituisce StackOverflowError.

Per ogni chiamata di un metodo, viene creata un'entrata nella memoria di stack, chiamata frame dello stack. Quando la chiamata del metodo è completa, il frame dello stack viene eliminato.

Un frame dello stack è diviso in tre sottoparti:

• Variabili locali – Ogni frame contiene un array di variabili conosciuto come variabili locali. Tutte le variabili locali e i loro valori sono memorizzati qui. La lunghezza di questo array è determinata al tempo di compilazione.
• Stack degli operandi – Ogni frame contiene uno stack LIFO (last-in-first-out) conosciuto come stack degli operandi. Agisce come spazio di lavoro di runtime per svolgere qualsiasi operazione intermedia. La massima profondità di questo stack è determinata al tempo di compilazione.
• Frame Data – Tutti i simboli corrispondenti ai metodi sono memorizzati qui. Contiene anche le informazioni sui blocchi catch in caso di eccezioni.

Ad esempio, supponi di avere il seguente codice:

double calculateNormalisedScore(List<Answer> answers) {
  
  double score = getScore(answers);
  return normalizeScore(score);
}

double normalizeScore(double score) {
  
  return (score – minScore) / (maxScore – minScore);
}

In questo esempio di codice, le variabili come answers e score sono posizionate nell'array delle variabili locali. Lo stack degli operandi contiene le variabili e gli operatori richiesti per svolgere i calcoli matematici di sottrazione e divisione.

Nota: dato che l'area di stack non è condivisa, è totalmente thread-safe.

Registri Program Counter (PC)

La JVM supporta più thread allo stesso tempo. Ogni thread ha il suo registro PC per contenere l'indirizzo dell'istruzione JVM attualmente in esecuzione. Una volta che l'istruzione è eseguita, il registro PC viene aggiornato con l'istruzione successiva.

Stack dei metodi nativi

La JVM contiene degli stack che supportano metodi nativi. Questi metodi sono scritti in altri linguaggio diverso da Java, come C e C++. Per ogni nuovo thread, viene allocato uno stack separato per un metodo nativo.

Execution Engine

Una volta che il bytecode è stato caricato nella memoria principale e i dettagli sono disponibili nell'area dati di runtime, il passo successivo è eseguire il programma. L'execution engine si occupa di eseguire il codice presente in ogni classe.

Tuttavia, prima di eseguire il programma, il bytecode deve essere convertito in istruzioni in linguaggio macchina. La JVM può usare un interprete o un compilatore JIT per l'execution engine.

Interprete

L'interprete legge ed esegue le istruzioni del bytecode riga per riga. A causa dell'esecuzione riga per riga, l'interprete è relativamente più lento.

Un altro svantaggio dell'interprete è che quando un metodo viene chiamato più volte, è necessaria una nuova interpretazione ogni volta.

Compilatore JIT

Il compilatore JIT rimedia allo svantaggio dell'interprete. L'execution engine utilizza prima l'interprete per eseguire il bytecode, ma quando trova del codice ripetuto, utilizza il compilatore JIT.

Il compilatore JIT poi compila l'intero bytecode e lo modifica in codice macchina nativo, che viene usato direttamente per chiamate di metodi ripetute, che migliorano le prestazioni del sistema.

Il compilatore JIT ha i seguenti componenti:

1. Intermediate Code Generator - genera il codice intermedio
2. Code Optimizer - ottimizza il codice intermedio per ottenere delle prestazioni migliori
3. Target Code Generator - converte il codice intermedio in codice macchina nativo
4. Profiler - trova gli hotspot (codice che viene eseguito ripetutamente)

Per capire meglio la differenza tra l'interprete  e in compilatore JIT, supponi di avere il seguente codice:

int sum = 10;
for(int i = 0 ; i <= 10; i++) {
   sum += i;
}
System.out.println(sum);

Un interprete recupera dalla memoria il valore di sum per ogni iterazione del loop, gli aggiunge il valore di i e scrive nella memoria. Si tratta di un'operazione dispendiosa, in quanto accede alla memoria ogni volta che entra nel loop.

Tuttavia, il compilatore JIT riconosce che questo codice ha un hot spot ed esegue delle ottimizzazioni. Conserva una copia locale di sum nel registro PC per il thread e continua ad aggiungervi il valore di i nel loop. Una volta che il loop è completato, scrive il valore di sum in memoria.

Nota: un compilatore JIT impiega più tempo a compilare il codice rispetto a quello necessario all'interprete per interpretare il codice riga per riga. Se ti occorre eseguire un programma solo una volta, è meglio usare l'interprete.

Garbage Collector

Il Garbage Collector (GC) raccoglie e rimuove gli oggetti non referenziati dall'area di heap. Si tratta del processo di recuperare la memoria di runtime inutilizzata, eliminandoli.

Questo processo rende efficiente la memoria di Java, perché rimuove gli oggetti non referenziati dalla memoria heap e crea spazio per nuovi oggetti. Consta di due fasi:

1. Mark - in questo passaggio, il GC identifica gli oggetti inutilizzati in memoria
2. Sweep - in questo passaggio, il GC rimuove gli oggetti identificati durante la fase precedente

Il processo di raccolta è svolto automaticamente dalla JVM a intervalli regolari e non necessita di essere gestito separatamente. Può essere anche innescato dalla chiamata System.gc(), ma l'esecuzione non è garantita.

La JVM contiene 3 tipi differenti di garbage collector:

1. Serial GC - Questa è l'implementazione più semplice di GC ed è progettata per piccole applicazioni in esecuzione su ambienti mono-thread. Utilizza un solo thread per raccolta. Quando viene eseguito, porta a un evento "stop the world", in cui l'intera applicazione viene messa in pausa. L'argomento JVM per usare il Serial Garbage Collector è -XX:+UseSerialGC
2. Parallel GC - Questa è l'implementazione predefinita di GC nella JVM, conosciuta anche come Throughput Collector. Utilizza più thread per raccolta, ma mette comunque in pausa l'applicazione quando viene eseguito. L'argomento JVM per usare il Parallel Garbage Collector è -XX:+UseParallelGC.
3. Garbage First (G1) GC - G1GC è stato progettato per applicazioni multi-thread che hanno disponibili una grande dimensione dell'heap (più di 4 GB). Ripartisce l'heap in un set di regioni di uguale dimensione e usa thread multipli per scansionarle. G1GC identifica le regioni più ricche di elementi non più referenziati e inizia da queste a svolgere la raccolta. L'argomento JVM per usare G1GC è  -XX:+UseG1GC

Nota: esiste un altro tipo di garbage collector chiamato Concurrent Mark Sweep (CMS) GC. Tuttavia, è obsoleto fin da Java 9 e completamente rimosso in Java 14 in favore di G1GC.

Java Native Interface (JNI)

Delle volte, è necessario usare del codice nativo (non Java), ad esempio C/C++. Potrebbe essere nel caso in cui dobbiamo interagire con l'hardware, oppure per ovviare ai vincoli di Java sulla gestione della memoria e le prestazioni. Java supporta l'esecuzione del codice nativo tramite la Java Native Interface (JNI).

La JNI agisce come un ponte per consentire il supporto di pacchetti per altri linguaggi di programmazione come C, C++ e via dicendo. Ciò è particolarmente utile nei casi in cui ti occorre scrivere del codice non interamente supportato da Java, come delle specifiche funzionalità di alcune piattaforme che possono essere scritte solo in C.

Puoi usare la parola chiave native per indicare che l'implementazione del metodo sarà fornita in una libreria nativa. Avrai anche bisogno di invocare System.loadLibrary() per caricare in memoria la libreria nativa condivisa e rendere le sue funzioni disponibili in Java.

Librerie di metodi nativi

Le librerie di metodi nativi sono librerie scritte in altri linguaggi di programmazione, come C, C++ e assembly. Queste librerie sono solitamente presenti in forma di file .dll o .so, e possono essere caricateattraverso il JNI.

Errori comuni JVM

• ClassNotFoundExcecption - Si verifica quando il class loader sta cercando di caricare delle classi usando Class.forName(), ClassLoader.loadClass() o ClassLoader.findSystemClass() ma non viene trovata nessuna definizione per il nome della classe specificato.
• NoClassDefFoundError - Si verifica quando un compilatore compila con successo la classe, ma il class loader non è in grado di individuare il file class durante il runtime.
• OutOfMemoryError - Si verifica quando la JVM non può allocare un oggetto perché non c'è memoria, e non è possibile liberare altra memoria tramite il garbage collector.
• StackOverflowError - Si verifica quando la JVM esaurisce la memoria creando un nuovo frame dello stack processando un thread.

Conclusione

In questo articolo, abbiamo discusso l'architettura della Java Virtual Machine e i suoi diversi componenti. Spesso non scaviamo a fondo nella meccanica interna della JVM o non ci interessiamo a come funziona mentre il nostro codice è all'opera.

È soltanto quando qualcosa va storto e abbiamo bisogno di ottimizzare la JVM o sistemare un problema di memoria che proviamo a capire la sua meccanica interna.

Questa è anche una domanda molto comune durante i colloqui di lavoro, sia al livello junior che senior per le posizioni backend. Una conoscenza approfondita della JVM ti aiuta a scrivere del codice migliore e a evitare le insidie collegate agli errori di stack e di memoria.

Grazie per essere rimasto con me fino a questo punto. Spero che questo articolo ti sia piaciuto. Puoi connetterti con me su LinkedIn, dove discuto abitualmente di vita e tecnologia. Dai anche un'occhiata ai miei altri articoli e al mio canale YouTube (risorse in lingua originale inglese). Buona lettura. 🙂

Java è in circolazione dagli anni '90 e nonostante il suo grande successo in molti settori, questo linguaggio di programmazione multi-piattaforma e orientato agli oggetti, è spesso criticato.

Indipendentemente da ciò che le persone pensano riguardo a Java, per la mia esperienza, posso dirti che è un eccellente linguaggio di programmazione. La sua prima apparizione risale al 1995, ed è ancora ampiamente usato – ed è probabile che questo non cambi a breve.

Puoi usare Java per costruire server, creare applicazioni desktop, giochi, applicazioni mobile e molto altro. Esistono anche altri linguaggi JVM (discuteremo a breve di cosa vuol dire) come Kotlin, Groovy, Scala e Clojure che puoi usare per diversi scopi.

Java è multi-piattaforma, che vuol dire che il codice che scrivi e compili su una piattaforma può essere eseguito su qualsiasi altra piattaforma che ha Java installato. Discuteremo questo tema in maggiore dettaglio più avanti.

Per ora, posso dirti che sebbene Java abbia i suoi difetti, ha anche tanto da offrire.

Sommario

1. Prerequisiti
2. Hello World
   1. Cosa succede nel codice?
   2. JVM
   3. JRE e JDK
3. Configurare Java
4. Installare un IDE
5. Creare un nuovo progetto su IntelliJ IDEA
6. Variabili
   1. Regole per dichiarare le variabili
   2. Variabili final
7. Tipi di dati primitivi
   1. Conversione di tipo
   2. Classi wrapper
8. Operatori
   1. Operatori aritmetici
   2. Operatori di assegnazione
   3. Operatori di confronto
   4. Operatori logici
   5. Operatori unari
9. Stringhe
   1. Formattare una stringa
   2. Ottenere la lunghezza di una stringa e verificare se è vuota
   3. Dividere e unire stringhe
   4. Convertire una stringa in maiuscolo o minuscolo
   5. Confrontare due stringhe
   6. Sostituire caratteri e sottostringhe
   7. Verificare se una stringa contiene una sottostringa
10. Input e output
11. Istruzioni condizionali
12. Istruzione switch-case
13. Visibilità delle variabili
14. Valori predefiniti delle variabili
15. Array
    1. Ordinare un array
    2. Ricerca binaria su un array
    3. Riempire un array
    4. Copiare un array
    5. Confrontare due array
16. Loop
    1. Loop for
    2. Loop for-each
    3. Loop while
    4. Loop do-while
17. ArrayList
    1. Aggiungere o rimuovere elementi multipli
    2. Rimuovere elementi in base a una condizione
    3. Clonare e confrontare ArrayList
    4. Verificare le presenza di un elemento e se un ArrayList è vuoto
    5. Ordinare un ArrayList
    6. Tenere gli elementi comuni in due ArrayList
    7. Eseguire un'azione su tutti gli elementi di un ArrayList
18. HashMap
    1. Inserire e sostituire elementi multipli
    2. Verificare se un elemento è presente e se una HashMap è vuota
    3. Eseguire un'azione su tutti gli elementi di una HashMap
19. Classi e oggetti
    1. Metodi
    2. Overloading dei metodi
20. Costruttori
21. Modificatori di accesso
22. Getter e setter
23. Ereditarietà
24. Sovrascrivere un metodo
25. Conclusione

Prerequisiti

L'unico requisito per questo corso è avere familiarità con un qualsiasi altro linguaggio di programmazione come Python, JavaScript e via dicendo.

Anche se spiegherò concetti di programmazione fondamentali nel contesto di Java, non parlerò di cose come cos'è una variabile nell'ambito della programmazione in generale.

Come scrivere Hello World in Java

Idealmente, il primo passo dovrebbe essere impostare Java sul tuo computer, ma non voglio annoiarti con il download e l'installazione di un mucchio di software proprio all'inizio. Per questo esempio, userai la piattaforma https://replit.com/.

Prima di tutto, vai su https://replit.com/ e crea un nuovo account se non ne hai già uno. Puoi usare il tuo account Google/GitHub/Facebook esistente per accedere. Una volta fatto il login, ti troverai nella tua home. Da qui, usa il pulsante Create sotto My Repls per creare un nuovo repl.

Nella finestra Create a Repl, scegli Java com Template, imposta un titolo descrittivo (nel campo Title) come Hello World e premi il pulsante Create Repl.

Ti verrà mostrato un editor di codice con un terminale integrato, come il seguente:

Sul lato sinistro c'è la lista dei file di questo progetto, al centro c'è l'editor di codice e sulla destra il terminale.

Il template contiene già del codice predefinito. Puoi eseguire il codice premendo il pulsante Run. Prosegui pure eseguendo il programma.

Se tutto funziona a dovere, dovresti vedere le parole "Hello world!" stampate sul lato destro. Congratulazioni, hai eseguito con successo il tuo primo programma in Java.

Cosa succede nel codice?

Il programma hello world è probabilmente il programma eseguibile Java più semplice che tu possa scrivere – e capirlo è cruciale.

class Main {
  public static void main(String[] args) {
    System.out.println("Hello world!");
  }
}

Partiamo dalla prima riga:

class Main {
  //...
}

Questa riga crea una classe Main. Una classe raggruppa insieme una porzione di codice correlato in una singola unità.

Questa è una classe public, che vuol dire che la classe è accessibile ovunque nel codebase. Un file sorgente Java (un file con l'estensione .java) può contenere al suo interno soltanto una classe public di livello più alto.

Questa classe pubblica con il livello più alto deve avere esattamente lo stesso nome del file con il codice sorgente. Ecco perché il file denominato Main.java contiene la classe Main in questo progetto.

Per capirne il motivo, clicca sui tre puntini nella lista dei file e clicca sull'opzione Show hidden files.

Così facendo vedrai alcuni nuovi file all'interno del progetto, tra cui il file Main.class. È ciò che viene chiamato bytecode. Quando premi il pulsante Run, il compilatore Java compila il tuo codice dal file Main.java in questo bytecode.

Adesso, modifica il codice Hello World esistente come segue:

class Main {
  public static void main(String[] args) {
    System.out.println("Hello world!");
  }
}

class NotMain {
  public static void main(String[] args) {
    System.out.println("Not hello world!");
  }
}

Come puoi vedere, una nuova classe chiamata NotMain è stata aggiunta. Prosegui e premi ancora il pulsante Run tenendo d'occhio il menu Files.

È apparso un nuovo bytecode chiamato NotMain.class. Questo significa che per ogni classe presente nell'intero codebase, il compilatore creerà un bytecode separato.

Ciò crea confusione riguardo a quale classe sia il punto d'ingresso (entry-point) di questo programma. Per risolvere questo problema, Java usa la classe che corrispondente al nome del file con il codice sorgente come punto d'ingresso del programma.

Ma basta parlare della classe, adesso diamo un'occhiata alla funzione al suo interno:

class Main {
  public static void main(String[] args) {
    System.out.println("Hello world!");
  }
}

La funzione public static void main (String[] args) ha un significato speciale in Java. Se hai esperienza con linguaggi come C, C++ o Go, dovresti già sapere che ogni programma in questi linguaggi possiede una funzione main. L'esecuzione del programma parte da questa funzione main.

In Java, devi scrivere questa funzione esattamente come public static void main (String[] args) altrimenti non funzionerà. Infatti, se la cambi anche di poco, Java inizierà a lamentarsi.

Il tipo del valore di ritorno è cambiato da void a int e la funzione adesso restituisce 0 alla fine. Come puoi vedere nella console, dice:

Error: Main method must return a value of type void in class Main, please 
define the main method as:
   public static void main(String[] args)

Ascolta il suggerimento e riporta il programma al suo stato precedente.

class Main {
  public static void main(String[] args) {
    System.out.println("Hello world!");
  }
}

Il metodo main è un metodo public e static vuol dire che puoi chiamarlo senza istanziare la sua classe.

void significa che la funzione non restituisce nessun valore e String[] args vuol dire che la funzione prende un array di stringhe come argomento. Questo array contiene argomenti da riga di comando passati al programma durante l'esecuzione.

System.out.println stampa delle stringhe sul terminale. Nell'esempio precedente, "Hello world!" è stata passata alla funzione, quindi otteniamo Hello world! stampato sul terminale.

In Java, ogni istruzione termina con un punto e virgola. A differenza di JavaScript o Python, il punto e virgola in Java è obbligatorio. Saltarne uno farà fallire la compilazione.

Sostanzialmente è tutto per questo programma. Se non hai capito ogni aspetto dei questa sezione parola per parola, non preoccuparti. Diventerà tutto più chiaro andando avanti.

Per ora, ricorda che la classe public di livello più alto in un file sorgente Java deve corrispondere al nome del file e che la funzione main di ogni programma Java deve essere definita come public static void main(String[] args).

Cos'è la JVM?

Nella sezione precedente, ho già usato un paio di volte la parola "bytecode". Ho anche detto che Java è "multi-piattaforma", che vuol dire che il codice scritto e compilato su una piattaforma può girare su qualsiasi piattaforma che ha Java installato.

Il tuo processore non comprende l'italiano o l'inglese. Infatti, l'unica cosa che comprende sono gli zero e gli uno, ovvero il linguaggio binario.

Quando scrivi e compili un programma in C++, il risultato è un file binario. Il processore lo comprende e, in base alla piattaforma designata del programma, questo file può essere diverso.

Ad esempio, prendiamo dei processori AMD64 e ARMv8-A. Questi processori hanno un set di istruzioni differenti. Quindi, per eseguire un programma su queste due diverse piattaforme, dobbiamo compilarlo separatamente.

Ma un programma Java può essere scritto una volta ed eseguito ovunque. Spero ti ricordi dei bytecode di cui abbiamo parlato nella sezione precedente. Quando compili del codice Java il risultato non è in binario ma in bytecode.

Il bytecode non è interamente binario, ma è comunque non leggibile da una persona, e nemmeno dal tuo processore.

Quindi invece di dare questo bytecode alla CPU, lo eseguiamo attraverso la Java Virtual Machine (o JVM in breve) che legge e interpreta il bytecode per la CPU.

Se vuoi comprendere l'architettura della JVM nel dettaglio, ti suggerisco questo articolo di Siben Nayak sull'argomento.

Cosa sono JRE e JDK?

JRE sta per Java Runtime Environment e JDK sta per Java Development Kit.

Il JRE o Java Runtime Environment racchiude un'implementazione della JVM insieme a un set di librerie richieste per eseguire i programmi Java.

Il JDK, d'altro canto, contiene il JRE insieme a tutte le librerie necessarie per sviluppare programmi in Java.

Quindi, se vuoi eseguire programmi Java sul tuo computer, dovrai installare il JRE. Mentre se vuoi sviluppare dei programmi Java, dovrai installare il JDK, di cui esistono diverse implementazioni.

Tra di esse, Java SE (Standard Edition) Development Kit di Oracle, OpenJDK, un'implementazione ufficiale di riferimento di Java SE (Standard Edition) Development Kit.

Come puoi immaginare dal suo nome, OpenJDK è open-source, quindi ne esistono svariate versioni. Se hai una macchina Linux e usi il tuo gestore di pacchetti di distro per installare JDK, è molto probabile che installerai una versione OpenJDK come Adoptium, Microsoft Build di OpenJDK e così via.

Spero che tu abbia capito che il JRE è un sovrainsieme della JVM e che il JDK è un sovrainsieme del JRE. Per ora, non preoccuparti delle diverse implementazioni o versioni, lo farai a tempo debito.

Come configurare Java sul tuo computer

Prima di tutto, vai su https://www.oracle.com/java/technologies/downloads/ e scarica l'ultima versione di Java SE Development Kit in base alla piattaforma su cui ti trovi:

Una volta terminato il download, avvia l'installazione e segui il processo di installazione premendo i pulsanti Avanti. Termina premendo il pulsante Chiudi nell'ultima pagina.

Il processo di installazione può variare su macOS e Linux ma dovresti essere in grado di venirne a capo.

Una volta che l'installazione è terminata, esegui il seguente comando sul tuo terminale:

java --version

# java 18.0.2 2022-07-19
# Java(TM) SE Runtime Environment (build 18.0.2+9-61)
# Java HotSpot(TM) 64-Bit Server VM (build 18.0.2+9-61, mixed mode, sharing)

Se funziona, hai installato con successo Java SE Development Kit sul tuo computer. Se invece vuoi usare OpenJDK, scarica pure Microsoft Build di OpenJDK o Adoptium e segui il processo di installazione.

Per i semplici programmi di esempio che scriveremo in questo articolo, non importa quale JDK utilizzi, ma per un utilizzo pratico, assicurati che la tua versione di JDK sia adatta al tipo di progetto su cui lavori.

Come installare un IDE Java sul tuo computer

Quando si tratta di Java, IntelliJ IDEA è senza dubbio il migliore ambiente di sviluppo integrato (IDE) in circolazione. Persino Google lo utilizza come base per Android Studio.

L'ultima versione dell'IDE può costare fino a € 169.00 all'anno. Ma se sei uno studente, puoi ottenere gratuitamente una licenza per studenti per tutti i prodotti JetBrains.

Esiste anche una edizione community open-source, completamente gratuita, che utilizzerò per tutto il manuale.

Vai sulla pagina di download di IntelliJ IDEA e scarica l'edizione community per la tua piattaforma.

Una volta finito il download, installa IntelliJ IDEA come qualsiasi altro software.

Come creare un nuovo progetto su IntelliJ IDEA

Usa la scorciatoia dal menu start per avviare IntelliJ IDEA. Ti apparirà la seguente finestra:

Usa il pulsante New Project e vedrai una finestra New Project:

Dai un nome descrittivo al tuo progetto. Lascia le altre opzioni come sono e premi il pulsante Create.

La creazione del progetto non dovrebbe richiedere più di qualche secondo e, fatto questo, ti apparirà la finestra qui sotto:

A sinistra trovi la finestra degli strumenti del progetto. Tutti il codice sorgente sarà all'interno di questa cartella src.

Clicca con il tasto destro sulla cartella src e vai su New > Java Class.

Per il prossimo passaggio, dai un nome come Main alla classe e assicurati che il tipo sottolineato sia Class.

Una nuova classe sarà creata con poche righe di codice.

Aggiorna il codice come segue:

public class Main {
    public static void main (String[] args) {
        System.out.println("Hello World!");
    }
}

Per eseguire questo codice, usa il pulsante verde sul lato destro della barra superiore.

Il codice sarà eseguito e l'output verrà mostrato nel terminale integrato nella parte inferiore della finestra.

Congratulazioni, hai ricreato con successo in IntelliJ IDEA il programma Hello World precedentemente discusso.

Come lavorare con le variabili in Java

Per lavorare con diversi tipi di dati in Java, puoi creare variabili di vario tipo. Ad esempio, se vuoi memorizzare la tua età in una nuova variabile, puoi farlo in questo modo:

public class Main {

	public static void main(String[] args) {
		// <tipo> <nome>
		int eta;

	}

}

Inizia a scrivere il tipo di dato o variabile. Visto che eta è un numero intero, il suo tipo sarà un intero, o int, seguito dal nome della variabile eta e da un punto e virgola.

Per ora, hai dichiarato la variabile ma non l'hai ancora inizializzata. In altre parole, la variabile non ha nessun valore. Puoi inizializzare la variabile come segue:

public class Main {

	public static void main(String[] args) {
		// <tipo> <nome>
		int eta;
		
		// <nome> = <valore>
		eta = 27;
        
		// stampa sul terminale "Ho 27 anni."
		System.out.println("Ho " + eta + " anni.");

	}

}

Per assegnare un valore, inizia a scrivere il nome della variabile che desideri inizializzare, seguito dal segno uguale (=, chiamato operatore di assegnazione) e dal valore che vuoi assegnare alla variabile. Non dimenticare il punto e virgola alla fine.

La chiamata della funzione System.out.println(); stamperà la frase Ho 27 anni. sulla console. Nel caso te lo stessi chiedendo, usare il segno più è uno dei tanti modi per stampare delle variabili in modo dinamico in mezzo a una frase.

Una cosa che devi tenere a mente è che non puoi usare una variabile non inizializzata in Java. Quindi se trasformi la riga eta = 27 in un commento, anteponendovi due barre oblique e provi a compilare il codice, il compilatore ti darà il seguente messaggio di errore:

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	The local variable eta may not have been initialized

	at variables.Main.main(Main.java:13)

La riga The local variable eta may not have been initialized indica che la variabile non è stata inizializzata.

Invece di dichiarare e inizializzare la variabile su righe diverse, puoi farlo in un colpo solo, in questo modo:

public class Main {

	public static void main(String[] args) {
		// <tipo> <nome> = <valore>
		int eta = 27;
        
		// stampa sul terminale "Ho 27 anni."
		System.out.println("Ho " + eta + " anni.");

	}

}

Il codice dovrebbe essere tornato alla normalità. Puoi anche cambiare il valore di una variabile quante volte desideri nel tuo codice.

public class Main {

	public static void main(String[] args) {
		int eta = 27;
        
		// aggiorna il valore a 28 invece di 27
		eta = 28;
        
		System.out.println("Ho " + eta + " anni.");

	}

}

In questo codice, il valore di eta cambia da 27 a 28 perché lo stiamo sovrascrivendo prima di stamparlo.

Tieni a mente che mentre puoi assegnare un valore a una variabile quante volte desideri, non puoi dichiarare la stessa variabile due volte.

public class Main {

	public static void main(String[] args) {
		// <tipo> <nome> = <valore>
		int eta = 27;
        
		int eta = 28;
        
		// stampa sul terminale
		System.out.println("Ho " + eta + " anni.");

	}

}

Se provi a compilare questo codice, il compilatore ti restituirà il seguente errore:

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	Duplicate local variable eta

	at variables.Main.main(Main.java:9)

La riga Duplicate local variable eta indica che la variabile è già stata dichiarata.

Oltre alle variabili, su internet potresti trovare il termine "letterale". I letterali sono variabili con valori con codifica fissa.

Ad esempio, in questo caso, eta = 27 non è calcolato dinamicamente. Il valore è scritto direttamente nel codice sorgente, quindi eta è un intero letterale.

Quali sono le regole per dichiarare le variabili?

Esistono alcune regole che riguardano la nomenclatura delle variabili in Java. Puoi utilizzare qualsiasi nome, a patto che non inizi con un numero e non contenga spazi.

Nonostante sia possibile iniziare il nome di una variabile con un trattino basso (_) o il simbolo del dollaro ($), non essere consapevole del loro utilizzo può rendere il codice difficile da leggere. I nomi delle variabili sono anche case sensitive, quindi eta e ETA sono due variabili diverse.

Un'altra cosa importante da ricordare è che non puoi usare nessuna delle parole chiave riservate in Java. Al momento, ne esistono circa 50. Puoi conoscere queste parole chiave grazie alla documentazione ufficiale, ma non preoccuparti di memorizzarle.

Man mano che continui a fare pratica, quelle importanti si annideranno nel tuo cervello automaticamente. E se stai ancora facendo confusione con la dichiarazione di una variabile, il compilatore sarà lì a ricordarti che c'è qualcosa di sbagliato.

Oltre alle regole, ci sono alcune convenzioni che dovresti seguire:

• Il nome di una variabile dovrebbe iniziare con una lettera minuscola e non con un carattere speciale (come un trattino basso o il simbolo del dollaro).
• Se il nome della variabile contiene più parole, usa il camel case: primaVariabile, secondaVariabile
• Non usare lettere singole come nome: f, l

Finché segui queste regole e convenzioni, sei a posto. Se vuoi imparare di più sulle convenzioni di nomenclatura in generale, dai un'occhiata a questo mio articolo sull'argomento.

Cosa sono le variabili final?

Una variabile final in Java può essere assegnata solo una volta. Quindi se inizializzi una variabile come final, non puoi riassegnarla.

public class Main {

	public static void main(String[] args) {
		// final <tipo> <nome> = <valore>
		final int eta = 27;
		
		eta = 28;
        
		System.out.println("Ho " + eta + " anni.");

	}

}

Dato che la variabile eta è stata dichiarata come final, otterrai il seguente messaggio di errore:

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	The final local variable eta cannot be assigned. It must be blank and not using a compound assignment

	at variables.Main.main(Main.java:9)

Tuttavia, se lasci la variabile non inizializzata quando la dichiari, il codice funzionerà:

public class Main {

	public static void main(String[] args) {
		// final <tipo> <nome>
		final int eta;
		
		eta = 28;
        
		// stampa sul terminale "Ho 28 anni."
		System.out.println("Ho " + eta + " anni.");

	}

}

Quindi, dichiarare una variabile come final limiterà l'abilità di riassegnarle un valore. Se la lasci non inizializzata, poi sarai in grado di inizializzarla normalmente.

Quali sono i tipi di dati primitivi in Java?

A un livello elevato, ci sono due tipi di dati in Java: "primitivi" e "non primitivi" o "riferimenti" (reference).

I tipi primitivi contengono valori. Ad esempio, int è un tipo primitivo e contiene un valore intero.

Un tipo riferimento, d'altro canto, contiene il riferimento a una posizione in memoria in cui viene conservato un oggetto dinamico.

Esistono otto tipi di dati primitivi in Java.

Sì, lo so che questa tabella spaventa ma non stressarti. Non devi memorizzarli.

Non hai bisogno di pensare a questi intervalli molto di frequente, e anche se lo fai, ci sono modi per visualizzarli nel tuo codice Java.

In ogni caso, se non sai cosa è un bit, ti consiglio questo breve articolo riguardo al linguaggio binario.

Hai già imparato come dichiarare un intero nella sezione precedente. Puoi dichiarare byte, short o long allo stesso modo.

Anche dichiarare un double funziona allo stesso modo, eccetto per il fatto che puoi assegnare un numero con un punto decimale invece di un intero:

public class Main {

	public static void main(String[] args) {
		double gpa = 4.8;
		
		System.out.println("Il mio GPA è " + gpa + ".");

	}
}

Se assegni un int a un double, come 4 invece di 4.8, l'output sarà 4.0 invece di 4, perché un double ha sempre il punto decimale.

Dato che double e float sono simili, potresti pensare che sostituire la parola chiave double con float convertirà la variabile in un numero in virgola mobile – ma non è corretto. Dovrai aggiungere una f o F dopo il valore:

public class Main {

	public static void main(String[] args) {
		float gpa = 4.8f;
		
		System.out.println("Il mio GPA è " + gpa + ".");

	}
}

Ciò accade perché, di default, ogni numero con un punto decimale è trattato come un double in Java. Se non aggiungi la f, il compilatore penserà che stai cercando di assegnare un valore double a una variabile float.

I dati di tipo boolean possono essere i valori true o false.

public class Main {

	public static void main(String[] args) {
		boolean fineSettimana = false;
		
		System.out.println(fineSettimana); // false

	}
}

Come puoi immaginare, false può essere trattato come no e true può essere trattato come sì.

I booleani diventeranno molto più utili una volta che imparerai le istruzioni condizionali. Per ora, ricorda soltanto che valori possono contenere.

Il tipo char può contenere qualsiasi carattere Unicode in un certo intervallo.

public class Main {

	public static void main(String[] args) {
		char segnoPercentuale = '%';
		
		System.out.println(segnoPercentuale); // %

	}
}

In questo esempio, abbiamo salvato il segno della percentuale in una variabile char per poi stamparla sul terminale.

Puoi usare anche delle sequenze Unicode di escape per stampare determinati simboli.

public class Main {

	public static void main(String[] args) {
		char simboloCopyright = '\u00A9';
		
		System.out.println(simboloCopyright); // ©

	}
}

La sequenza di escape Unicode per il simbolo del copyright, ad esempio, è \u00A9 e puoi trovare altre sequenze Unicode di escape in questo sito.

Tra questi 8 tipi di dati, quelli che userai più di frequente sono int, double, boolean e char.

Cos'è una conversione di tipo o casting?

Una conversione di tipo in Java può essere "implicita" o "esplicita". Quando il compilatore converte un tipo di dato con un intervallo più ristretto in uno più ampio automaticamente, si parla di conversione di tipo implicita o di widening.

public class Main {

	public static void main(String[] args) {
		int numero1 = 8;
		double numero2 = numero1;
		
		System.out.println(numero2); // 8.0
	}

}

Visto che un double è più grande di un intero, il compilatore può facilmente eseguire la conversione. Invece, se provi a fare il contrario, otterrai questo errore dal compilatore:

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	Type mismatch: cannot convert from double to int

	at operators.Main.main(Main.java:7)

Quando esegui una conversione implicita, il flusso di conversione dovrebbe essere il seguente:

Naturalmente, puoi passare da short a double, ad esempio, saltando gli altri nel mezzo.

Puoi anche passare da dati con intervallo più ampio a dati con intervallo più ristretto. In questo caso, parliamo di conversione di tipo esplicita o di narrowing.

package datatypes;

public class Main {

	public static void main(String[] args) {
		double numero1 = 8.5;
		int numero2 = (int) numero1;
		
		System.out.println(numero2); // 8
	}

}

Precedentemente, abbiamo visto che se provi a convertire un tipo di dato più grande in uno più piccolo il compilatore si lamenta. Ma quando aggiungi l'operatore di cast (int) esplicitamente, fai vedere al compilatore chi è che comanda.

Facendo ciò, perdi una parte dei dati. Se cambi il numero double iniziale da 8.5 in 8, perdi delle informazioni. Quindi ogni volta che fai una conversione esplicita, fai attenzione.

Puoi anche convertire un char in un int come segue:

public class Main {

	public static void main(String[] args) {
		char carattere = 'F';
		int numero = carattere;
		
		System.out.println(numero); // 70
	}

}

70 è il codice ASCII per il carattere F – ecco il perché di questo output. Se vuoi saperne di più sui codici ASCII, il mio collega Kris Koishigawa ha scritto un eccellente articolo sull'argomento.

Il flusso di conversione in questo caso sarà opposto a quello visto in precedenza.

Ti suggerisco di sperimentare convertendo diversi valori da un tipo all'altro e vedere cosa accade. In questo modo, approfondirai la tua comprensione e acquisirai sicurezza.

Cosa sono le classi wrapper in Java?

Le classi wrapper (o involucro) possono contenere i tipi di dati primitivi e trasformarli in riferimenti. Le classi wrapper sono disponibili per tutti gli otto tipi di dati primitivi.

Puoi usare le classi wrapper come segue:

public class Main {
    public static void main (String[] args) {
        Integer eta = 27;
        Double gpa = 4.8;

        System.out.println(eta); // 27
        System.out.println(gpa); // 4.8
    }
}

Tutto ciò che devi fare è sostituire il tipo di dato primitivo con la classe wrapper equivalente. Questi riferimenti hanno anche metodi per estrarre da essi il tipo primitivo.

Ad esempio, eta.intValue() restituirà l'età come un intero primitivo e  gpa.doubleValue() restituirà il GPA come un primitivo double.

Esistono metodi del genere per tutti gli otto tipi di dati. Sebbene vedrai dati primitivi per la maggior parte del tempo, le classi wrapper torneranno utili in alcuni casi che discuteremo in una sezione successiva.

Come usare gli operatori in Java

Nell'ambito della programmazione, gli operatori sono determinati simboli che comunicano al compilatore di svolgere specifiche operazioni, come operazioni aritmetiche, di confronto o logiche.

Anche se in Java esistono sei tipi di operatori, qui non parlerò degli operatori bitwise. Parlare degli operatori bitwise in una guida per principianti potrebbe essere scoraggiante.

Cosa sono gli operatori aritmetici?

Gli operatori aritmetici sono quelli che puoi usare per svolgere operazioni aritmetiche. Ne esistono cinque:

Le operazioni di addizione, sottrazione, moltiplicazione e divisione sono piuttosto intuitive. Dai un'occhiata all'esempio di codice qui sotto per capire:

public class Main {

	public static void main(String[] args) {
		int numero1 = 10;
		int numero2 = 5;
		
		System.out.println(numero1 + numero2); // 15
		System.out.println(numero1 - numero2); // 5
		System.out.println(numero1 * numero2); // 50
		System.out.println(numero1 / numero2); // 2
		System.out.println(numero1 % numero2); // 0

	}

}

Gli output delle prime quattro operazioni non hanno bisogno di spiegazioni. Nell'ultima operazione, abbiamo svolto un'operazione di modulo usando il simbolo %. Il risultato è 0 perché dividendo 10 per 2, il resto è nullo.

Addizione e moltiplicazione sono piuttosto semplici. Per la sottrazione, se il primo operando è minore del secondo, il risultato sarà un numero negativo, come nella vita reale.

Il tipo di dato con cui stai lavorando fa la differenza nel risultato delle operazioni di divisione e modulo.

public class Main {

	public static void main(String[] args) {
		int numero1 = 8;
		int numero2 = 5;
		
		System.out.println(numero1 / numero2); // 1
	}

}

Anche se il risultato di questa operazione dovrebbe essere 1.6, ciò non accade. In Java, se dividi un intero per un altro intero, il risultato sarà un intero. Ma se cambi entrambi o uno dei due in un float/double, tutto torna alla normalità.

public class Main {

	public static void main(String[] args) {
		double numero1 = 8;
		double numero2 = 5;
		
		System.out.println(numero1 / numero2); // 1.6
	}

}

Questo principio si applica anche all'operatore modulo. Se uno o entrambi gli operandi sono float/double, il risultato sarà un float/double.

Cosa sono gli operatori di assegnazione?

Abbiamo già usato l'operatore di assegnazione in una sezione precedente.

public class Main {

	public static void main(String[] args) {
		// <tipo> <nome> = <valore>
		int eta = 27;
        
		// stampa il valore di eta sul terminale
		System.out.println(eta);

	}

}

Quando usi il simbolo = per assegnare un valore a una variabile, funziona come un operatore di assegnazione. Ma questa non è l'unica forma di questo operatore.

Combinando il normale operatore di assegnazione con gli operatori aritmetici, puoi ottenere risultati differenti.

Il seguente esempio di codice dovrebbe rendere le cose più chiare:

package operators;

public class Main {

	public static void main(String[] args) {
		double numero1 = 10;
		double numero2 = 5;
		
		numero1 += numero2;
		
		System.out.println(numero1); // 15
	}

}

Gli altri operatori funzionano allo stesso modo. Svolgono l'operazione e poi ne assegnano il risultato all'operando di sinistra.

Potrei darti una dimostrazione degli altri ma credo che se li provi tu stesso li capirai meglio. Dopotutto, l'esercizio e la pratica sono i soli modi per consolidare le tue conoscenze.

Cosa sono gli operatori di confronto?

Gli operatori di confronto sono utilizzati per verificare la relazione tra due operandi. Ad esempio, se un operando è uguale a un altro oppure no.

Gli operatori di confronto restituiscono true o false a seconda dell'operazione svolta.

In Java, esistono sei operatori di confronto.

Il seguente esempio di codice mostra l'utilizzo di questi operatori:

public class Main {

	public static void main(String[] args) {
		double numero1 = 10;
		double numero2 = 5;
		
		System.out.println(numero1 == numero2); // false
		System.out.println(numero1 != numero2); // true
		System.out.println(numero1 > numero2); // true
		System.out.println(numero1 < numero2); // false
		System.out.println(numero1 >= numero2); // true
		System.out.println(numero1 <= numero2); // false
	}

}

L'utilizzo pratico di questi operatori diventerà più chiaro una volta che imparerai a conoscere le istruzioni condizionali in una sezione successiva.

Puoi usare questi operatori anche con i caratteri.

public class Main {

	public static void main(String[] args) {
		char letteraMinuscola = 'a';
		char letteraMaiuscola = 'A';
		
		System.out.println(letteraMinuscola > letteraMaiuscola); // ???
	}

}

Quale credi che sarà l'output di questo codice? Ti invito a scoprirlo da solo. Ricordi il valore ASCII dei caratteri? Hanno un ruolo importante nell'output di questo programma.

Cosa sono gli operatori logici?

Immagina il caso in cui un programma che hai scritto può essere usato solo da persone che hanno più di 18 anni ma meno di 40. La logica dovrebbe essere la seguente:

puoi eseguire il programma se ->
	eta >= 18 e eta <= 40

Oppure il caso in cui un utente deve essere uno studente della tua scuola o un membro della libreria per prendere libri in prestito. In questa situazione, la logica sarebbe:

può prendere libri in prestito se ->
	studenteDellaScuola o membroDellaLibreria

Queste decisioni logiche possono essere prese usando operatori logici. Esistono tre operatori del genere in Java.

Vediamo del codice con questi operatori, partendo dall'operatore logico and (&&):

public class Main {

	public static void main(String[] args) {
		int eta = 20;
		
		System.out.println(eta >= 18 && eta <= 40); // true
	}

}

In questo caso, ci sono due condizioni ai lati dell'operatore &&. Se e soltanto se entrambe le condizioni sono valutate come true, l'operazione and risulta essere true.

Se la prima condizione è false, il computer non valuterà l'altra condizione e restituirà false, perché se la prima è false, non c'è modo che l'intera operazione sia true.

L'operatore logico or (||) funziona in modo simile, ma in questo caso, se una delle due condizioni è vera, lo sarà anche il risultato dell'operazione:

public class Main {

	public static void main(String[] args) {
		boolean studenteDellaScuola = true;
		boolean membroDellaLibreria = false;
		
		System.out.println(studenteDellaScuola || membroDellaLibreria); // true
	}

}

Se la prima condizione di un'operazione logica or è true, il computer non valuterà l'altra condizione è restituirà true, perché se la prima condizione viene valutata come true il risultato dell'operazione sarà true indipendentemente dall'altra condizione.

Infine, l'operatore not (!) valuta l'opposto della condizione. Dai un'occhiata all'esempio di codice qui sotto:

public class Main {

	public static void main(String[] args) {
		boolean membroDellaLibreria = true;
		
		System.out.println(membroDellaLibreria); // true
		System.out.println(!membroDellaLibreria); // false
	}

}

Come puoi vedere, l'operatore not restituisce l'opposto di un dato valore booleano. L'operatore ! è un operatore unario, che vuol dire che opera su un singolo operando.

public class Main {

	public static void main(String[] args) {
		boolean membroDellaLibreria = true;
		boolean studenteDellaScuola = false;
		
		System.out.println(!studenteDellaScuola || membroDellaLibreria); // true
	}

}

In questo esempio, l'operatore not trasforma studenteDellaScuola in true, e l'operazione viene valutata true. Ma se modifichi il codice in questo modo:

public class Main {

	public static void main(String[] args) {
		boolean membroDellaLibreria = true;
		boolean studenteDellaScuola = false;
		
		System.out.println(!(studenteDellaScuola || membroDellaLibreria)); // false
	}

}

L'operazione logica or avverrà prima e sarà true. L'operatore not ne trasformerà il risultato in false.

Anche se abbiamo usato due operandi per ogni operatore, puoi usarne quanti ne desideri. Puoi anche usare diversi operatori insieme.

public class Main {

	public static void main(String[] args) {
		boolean studenteDellaScuola = true;
		boolean membroDellaLibreria = false;
		int eta = 10;
		
		System.out.println(studenteDellaScuola || membroDellaLibreria && eta > 18); // ???
	}

}

Quale pensi che sarà l'output di questo codice? Ti suggerisco di scoprirlo da solo. :)

Cosa sono gli operatori unari?

Esistono alcuni operatori che sono usati con un operando alla volta e vengono chiamati operatori unari. Nonostante ne esistano cinque, parlerò soltanto di due di loro.

Il seguente codice ne mostra bene il funzionamento:

public class Main {

	public static void main(String[] args) {
		int punteggio = 95;
		int turni = 11;
		
		punteggio++;
		turni--;
		
		System.out.println(punteggio); // 96
		System.out.println(turni); // 10
	}

}

Puoi anche usare questi operatori come prefissi:

public class Main {

	public static void main(String[] args) {
		int punteggio = 95;
		int turni = 11;
		
		++punteggio;
		--turni;
		
		System.out.println(punteggio); // 96
		System.out.println(turni); // 10
	}

}

Per ora, tutto semplice. Ma ci sono alcune leggere differenze tra la sintassi con suffisso e prefisso che devi conoscere. Guarda il codice qui sotto:

package operators;

public class Main {

	public static void main(String[] args) {
		int punteggio = 95;
		
		
		System.out.println(++punteggio); // 96
		System.out.println(punteggio); // 96
	}

}

Questo è il risultato atteso. L'operatore decremento usato come prefisso funziona allo stesso modo. Ma guarda cosa accade se passiamo alla sintassi con suffisso:

package operators;

public class Main {

	public static void main(String[] args) {
		int punteggio = 95;
		
		
		System.out.println(punteggio++); // 95
		System.out.println(punteggio); // 96
	}

}

Disorientante, vero? Quale credi che sia il valore reale della variabile adesso? È 96, vediamo perché.

Quando usiamo la sintassi con il suffisso all'interno della funzione print, la funzione incontra prima la variabile e poi la incrementa. Ed ecco perché nella seconda riga stampa il nuovo valore aggiornato.

Nel caso della sintassi con il prefisso, la funzione incontra l'operatore di incremento e svolge l'operazione. Poi prosegue stampando il valore aggiornato.

Stai attento perché questa piccola differenza può prenderti alla sprovvista. Oppure prova a evitare di incrementare o decrementare all'interno di chiamate di funzione.

Come usare le stringhe in Java

In Java, il tipo String è uno dei rifermenti usati più di frequente. È un insieme di caratteri che puoi usare per formare righe di testo in un programma.

Esistono due modi per creare nuove stringhe in Java. Il primo è quello letterale:

public class Main {
	public static void main(String[] args) {
		String nome = "Farhan";
        
		System.out.println("Il mio nome è " + nome + ".");
	}

}

Come puoi vedere, dichiarare e usare una variabile di tipo String in questo modo non è molto diverso da dichiarare tipi primitivi in Java.

Il secondo modo per creare una variabile di tipo String è usare l'operatore new.

public class Main {
	public static void main(String[] args) {
		// <tipo> <nome> = new <tipo>(<valore>)
		String nome = new String("Farhan");
        
		System.out.println("Il mio nome è " + nome + ".");
	}

}

Questo programma funziona come il precedente ma con una leggera differenza.

La JVM mantiene una porzione della memoria del computer per memorizzare le stringhe. Questa porzione è detta string pool (o pool di stringhe).

Ogni volta che crei una nuova String nel modo letterale, il JVM controlla prima se la stringa esiste già nel pool. Se esiste, il JVM la riusa, altrimenti la crea.

D'altro canto, quando utilizzi l'operatore new, il JVM crea sempre un nuovo oggetto String. Il seguente programma dimostra chiaramente questo concetto:

public class Main {

	public static void main(String[] args) {
		String stringaLetterale1 = "abc";
		String stringaLetterale2 = "abc";
		
		String oggettoStringa1 = new String("abc");
		String oggettoStringa2 = new String("abc");
		
		System.out.println(stringaLetterale1 == stringaLetterale2);
		System.out.println(oggettoStringa1 == oggettoStringa2);

	}

}

Come potresti già sapere, l'operatore == è usato per verificare l'uguaglianza. L'output del programma sarà:

true
false

Dato che abc era già nello string pool, la variabile stringaLetterale2 la riutilizza. Nel caso di oggetti stringa invece, si tratta di due entità diverse.

Come formattare una stringa

Abbiamo già visto l'utilizzo dell'operatore + per concatenare stringhe o formattarle in un modo specifico.

Questo approccio funziona finché non hai tante aggiunte a una stringa. È facile fare confusione con la posizione delle virgolette.

Un modo migliore di formattare una stringa è il metodo String.format().

public class Main {
	public static void main(String[] args) {
		String nome = "Farhan";
		int eta = 27;
		
		String stringaFormattata = String.format("Il mio nome è %s e ho %d anni.", nome, eta);
        
		System.out.println(stringaFormattata);
	}

}

Il metodo prende una stringa con degli specificatori di formato come primo argomento e gli argomenti per sostituire gli specificatori come argomenti successivi.

Nel codice qui sopra, i caratteri %s e %d sono specificatori di formato. Sono responsabili di comunicare al compilatore che quella parte della stringa deve essere sostituita con qualcosa.

Poi il compilatore sostituirà %s con nome e %d con eta. L'ordine degli specificatori deve corrispondere all'ordine degli argomenti e gli argomenti devono corrispondere al tipo indicato dallo specificatore.

I caratteri %s e %d non sono a caso. Sono specifici per stringhe e per interi decimali (in base dieci). Ecco una tabella degli specificatori usati comunemente:

Ci sono anche %o per gli interi in base otto, %x o %X per i numeri esadecimali e %e o %E per le notazioni scientifiche, ma dato che non ne parlerò in questo manuale non li ho inseriti.

Proprio come gli specificatori %s e %d che hai visto, puoi usare gli altri specificatori per il tipo di dato corrispondente. E, nel caso te lo stessi chiedendo, lo specificatore %f funziona sia per i float che per i double.

Come ottenere la lunghezza di una stringa e verificare se una stringa è vuota

Controllare la lunghezza di una stringa o verificare se una stringa è vuota prima di svolgere delle operazioni è piuttosto comune.

Ogni oggetto stringa ha un metodo length() che ne restituisce la lunghezza. È come la proprietà length per gli array.

public class Main {
	public static void main(String[] args) {
		String nome = "Farhan";
        
		System.out.println(String.format("La lunghezza di questa stringa è: %d.", nome.length())); // 6
	}

}

Il metodo restituisce la lunghezza come un intero, che puoi usare insieme allo specificatore di formato per gli interi.

Per verificare se una stringa è vuota o meno, puoi usare il metodo isEmpty(). Proprio come il metodo length(), può essere usato per ogni oggetto stringa.

public class Main {
	public static void main(String[] args) {
		String nome = "Farhan";
		
		if (nome.isEmpty()) {
			System.out.println("Non c'è nessun nome qui");
		} else {
			System.out.println(String.format("Okay, ci penso io a %s.", nome));
		}
	}

}

Il metodo restituisce un valore booleano che puoi usare direttamente in una istruzione if. Il programma controlla se il nome è vuoto oppure no e stampa risposte diverse nei due casi.

Come dividere e unire delle stringhe

Il metodo split() può essere usato per dividere una stringa sulla base di un'espressione regolare.

import java.util.Arrays;

public class Main {
	public static void main(String[] args) {
		String nome = "Farhan Hasin Chowdhury";

		System.out.println(Arrays.toString(nome.split(" ")));
	}

}

Il metodo restituisce un array di stringhe. Ogni stringa nell'array è una sottostringa della stringa originale. Qui, ad esempio, abbiamo diviso la stringa Farhan Hasin Chowdhury in corrispondenza di ogni spazio, quindi l'output sarà [Farhan, Hasin, Chowdhury].

Come promemoria: un array è un insieme di più dati dello stesso tipo.

Dato che il metodo prende un'espressione regolare come argomento, possiamo sfruttarle per svolgere operazioni di suddivisione più complicate.

Puoi anche riunire insieme l'array per riformare la stringa, in questo modo:

public class Main {
	public static void main(String[] args) {
		String nome = "Farhan Hasin Chowdhury";
		
		String sottostringhe[] = nome.split(" ");
		
		String nomeUnito = String.join(" ", sottostringhe);

		System.out.println(nomeUnito); // Farhan Hasin Chowdhury
	}

}

Il metodo join() può anche aiutarti a unire più stringhe insieme fuori da un array.

public class Main {
	public static void main(String[] args) {
		System.out.println(String.join(" ", "Farhan", "Hasin", "Chowdhury")); // Farhan Hasin Chowdhury
	}

}

Come convertire una stringa in maiuscolo o minuscolo

Convertire una stringa in maiuscolo o minuscolo è un'operazione molto diretta in Java, che puoi svolgere rispettivamente con i metodi toUpperCase() e toLowerCase():

public class Main {
	public static void main(String[] args) {
		String nome = "Farhan Hasin Chowdhury";

		System.out.println(name.toUpperCase()); // FARHAN HASIN CHOWDHURY
		
		System.out.println(name.toLowerCase()); // farhan hasin chowdhury
	}

}

Come confrontare due stringhe

Dato che le stringhe sono di tipo riferimento, non puoi confrontarle con l'operatore ==.

Il metodo equals() controlla se due stringhe sono uguali o meno e il metodo equalsIgnoreCase() fa la stessa cosa ignorando le differenze nelle maiuscole/minuscole.

public class Main {
	public static void main(String[] args) {
		String nome = "Farhan Hasin Chowdhury";
		String nomeMaiuscolo = nome.toUpperCase();

		System.out.println(nome.equals(nomeMaiuscolo)); // false
		
		System.out.println(nome.equalsIgnoreCase(nomeMaiuscolo)); // true
	}

}

Come sostituire caratteri o sottostringhe in una stringa

Il metodo replace() può essere usato per sostituire caratteri o intere sottostringhe di una data stringa.

package strings;

public class Main {
	public static void main(String[] args) {
		String loremIpsumStd = "Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam, eaque ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo.";

		System.out.println(String.format("Standard lorem ipsum text: %s", loremIpsumStd));
		
		String loremIpsumHalfTranslated = loremIpsumStd.replace("Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium", "But I must explain to you how all this mistaken idea of denouncing pleasure and praising pain was born and I will give you a complete account of the system");
		
		System.out.println(String.format("Translated lorem ipsum text: %s", loremIpsumHalfTranslated));
	}

}

Qui, la stringa loremIpsumStd contiene una porzione del testo lorem ipsum originale. In seguito, la prima riga della stringa viene sostituita e la nuova stringa viene salvata nella variabile loremIpsumHalfTranslated.

Come verificare se una stringa contiene una sottostringa

Il metodo contains() può verificare se una data stringa contiene una certa sottostringa oppure no.

public class Main {
	public static void main(String[] args) {
		String testo = "Le rose sono rosse, le viole sono blu";

		if (testo.contains("blu")) {
			System.out.println("Il testo contiene la parola blu.");
		} else {
			System.out.println("Il testo non contiene la parola blu.");
		}
	}

}

Il metodo restituisce un valore booleano, quindi puoi utilizzarlo in una qualsiasi istruzione condizionale.

Questi erano alcuni dei più comuni metodi per stringhe. Se ne vuoi conoscere altri, consulta la documentazione ufficiale.

Quali sono i diversi modi di inserire input e ottenere output di dati?

Finora abbiamo imparato il metodo System.out.println() per stampare informazioni sul terminale. Abbiamo anche usato il metodo String.format() in una sezione precedente.

In questa sezione, imparerai a conoscere alcuni metodi parenti di System.out.println() e anche come prendere un input da un utente.

Prendere un input da un utente è estremamente semplice in linguaggi come Python. Tuttavia, in Java richiede qualche riga di codice in più.

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		
		System.out.print("Come ti chiami? ");
		String nome = scanner.nextLine();
		
		System.out.printf("Ciao %s. Quanti anni hai? ", nome);
		int eta = scanner.nextInt();
		
		System.out.printf("Grande! %d anni sono un'ottima età per iniziare a programmare.", eta);
		
		scanner.close();

	}

}

La classe java.util.Scanner è necessaria per ricevere input utente. Puoi importarla nel tuo programma usando la parola chiave import.

Poi, dovrai creare una nuova istanza della classe Scanner usando la parola chiave new. Quando crei una nuova istanza, dovrai esplicitare il flusso di input desiderato.

Potresti voler prendere un input da un utente o da un file. In ogni caso, devi comunicarlo al compilatore. System.in è il flusso standard di input e output.

L'oggetto scanner ha metodi come nextLine() per prendere degli input stringa, nextInt() per prendere input interi, nextDouble() per input double e così via.

Nel codice precedente, il metodo scanner.nextLine() chiederà una stringa all'utente e restituirà l'input inserito con un carattere nuova riga dopo di esso.

Poi, il metodo scanner.nextInt() chiederà un intero e restituirà l'input dato dall'utente.

Potrebbe essere la prima volta che vedi il metodo System.out.printf(). Oltre al metodo System.out.println(), esiste anche il metodo System.out.print() che stampa una data stringa senza aggiungere un carattere nuova a riga al suo termine.

System.out.printf() è una sorta di combinazione dei metodi System.out.print() e String.format(). Puoi usare gli specificatori di formato discussi precedente anche in questo metodo.

Una volta che l'input è stato accettato, è necessario chiudere l'oggetto scanner. Puoi farlo semplicemente chiamando il metodo scanner.close().

Semplice, vero? Complichiamo un po' le cose.

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Come ti chiami? ");
        String nome = scanner.nextLine();

        System.out.printf("Ciao %s. Quanti anni hai? ", nome);
        int eta = scanner.nextInt();

        System.out.printf("Grande! %d anni sono un'ottima età per iniziare a programmare. \nChe linguaggio preferisci? ", eta);
        String linguaggio = scanner.nextLine();

        System.out.printf("Ah! %s è un linguaggio di programmazione molto valido.", linguaggio);

        scanner.close();

    }

}

Ho aggiunto un'istruzione scanner.nextLine() dopo la chiamata del metodo scanner.nextInt(). Funzionerà?

La risposta è no. Il programma salterà semplicemente l'ultimo prompt di input e stamperà l'ultima riga. Questo comportamento non è esclusivo di scanner.nextInt(). Se usi scanner.nextLine() dopo gli altri metodi nextQualcosa(), dovrai fare i conti con questo problema.

In breve, questo accade perché premi Invio per il metodo scanner.nextInt(), che prende l'intero e lascia il carattere nuova riga nel buffer dell'input.

Quindi, quando viene invocato scanner.nextLine(), consuma quel carattere nuova riga alla fine dell'input. La soluzione più semplice a questo problema è scrivere una chiamata aggiuntiva di scanner.nextLine() dopo le altre chiamate di un metodo scanner.

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Come ti chiami? ");
        String nome = scanner.nextLine();

        System.out.printf("Ciao %s. Quanti anni hai? ", nome);
        int eta = scanner.nextInt();

        // consuma il carattere nuova riga
        scanner.nextLine();

        System.out.printf("Grande! %d anni sono un'ottima età per iniziare a programmare. \nChe linguaggio preferisci? ", eta);
        String linguaggio = scanner.nextLine();

        System.out.printf("Ah! %s è un linguaggio di programmazione molto valido.", linguaggio);

        scanner.close();

    }

}

Esiste un altro modo per risolvere questo problema, ma non ne parlerò qui. Se sei interessato, dai un'occhiata a questo mio articolo sull'argomento.

Come usare le istruzioni condizionali in Java

Puoi usare le istruzioni condizionali per prendere delle decisioni sulla base di condizioni specifiche.

Per questo, utilizziamo l'istruzione if come mostrato qui sotto:

public class Main {

	public static void main(String[] args) {
		int eta = 20;
		
		// if (condizione) {...}
		if (eta >= 18 && eta <= 40) {
			System.out.println("Puoi usare il programma");
		}
		
	}

}

L'istruzione inizia con un if, seguito dalla condizione all'interno di parentesi. Se la condizione viene valutata come true, il codice all'interno delle parentesi graffe sarà eseguito.

Il codice racchiuso all'interno di parentesi graffe è detto blocco di codice.

Se cambi il valore di eta in 50, l'istruzione print non sarà eseguita e non ci sarà alcun output sulla console. Per questo tipo di situazioni in cui la condizione viene valutata come false, puoi aggiungere un blocco else:

public class Main {

	public static void main(String[] args) {
		int eta = 20;
		
		if (eta >= 18 && age <= 40) {
			System.out.println("Puoi usare il programma");
		} else {
			System.out.println("Non puoi usare il programma");
		}
		
	}

}

Ora, se la condizione viene valutata come false, sarà eseguito il codice nel blocco else e vedrai Non puoi usare il programma stampato sul terminale.

Puoi anche avere condizioni multiple all'interno di una scaletta if-else if-else:

public class Main {

	public static void main(String[] args) {
		int eta = 50;
		boolean studenteDellaScuola = true;
		boolean membroDellaLibreria = false;
		
		// if (condizione) {...}
		if (eta >= 18 && eta <= 40) {
			System.out.println("Puoi usare il programma");
		} else if (studenteDellaScuola || membroDellaLibreria) {
			System.out.println("Puoi usare il programma per un tempo limitato");
		} else {
			System.out.println("Non puoi usare il programma");
		}
		
	}

}

Se la prima condizione viene valutata come false, viene testata la seconda condizione. Se la seconda condizione viene valutata come true, allora sarà eseguito il codice nelle parentesi graffe corrispondenti. Se le condizioni relative alle istruzioni if ed else if sono entrambe false, allora sarà eseguito il blocco else.

Puoi anche annidare delle istruzioni if all'interno di altre istruzioni if come segue:

package operators;

public class Main {

	public static void main(String[] args) {
		int eta = 20;
		
		if (eta >= 18 && eta <= 40) {
			boolean studenteDellaScuola = true;
			boolean membroDellaLibreria = false;
			
			if (studenteDellaScuola || membroDellaLibreria) {
				System.out.println("Puoi usare il programma");
			}
		} else {
			System.out.println("Non puoi usare il programma");
		}
		
	}

}

In questo caso, l'istruzione if interna sarà testata solo se la prima istruzione if sarà valutata come true.

Cos'è un'istruzione switch-case?

Oltre ai blocchi if-else, esistono altri casi in cui è possibile definire condizioni multiple in una struttura che funge da interruttore.

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Qual è il primo operando? ");
        int a =scanner.nextInt();

        // consuma il carattere nuova riga
        scanner.nextLine();

        System.out.print("Qual è il secondo operando? ");
        int b = scanner.nextInt();

        // consuma il carattere nuova riga
        scanner.nextLine();

        System.out.print("Quale operazione vuoi svolgere? ");
        String operazione = scanner.nextLine();

        switch (operazione) {
            case "addizione":
                System.out.printf("%d + %d = %d", a, b, a+b);
                break;
            case "sottrazione":
                System.out.printf("%d - %d = %d", a, b, a-b);
                break;
            case "moltiplicazione":
                System.out.printf("%d * %d = %d", a, b, a*b);
                break;
            case "divisione":
                if (b == 0) {
                    System.out.print("Non puoi dividere per zero!");
                } else {
                    System.out.printf("%d / %d = %d", a, b, a / b);
                }
                break;
            default:
                System.out.printf("Operazione invalida!");
        }

        scanner.close();

    }

}

Questo è un programma per fare calcoli estremamente semplice. Il programma richiede due numeri all'utente e poi chiede che operazione eseguire.

Ogni istruzione switch-case ha uno switch e case multipli. Quando dici "addizione", il programma verifica se il valore dello switch o della variabile operazione è o meno addizione.

Se corrisponde, il corpo del case sarà eseguito. Se nessuno dei casi corrisponde, viene eseguito il default.

Per quanto riguarda l'istruzione break, fa esattamente quello che sembra: ferma il programma dall'eseguire i casi successivi.

Se rimuovi le istruzioni break, tutti i casi vengono eseguiti uno dopo l'altro fino al caso default.

Cos'è la visibilità di una variabile in Java?

La visibilità rappresenta il tempo di vita e l'accessibilità di una variabile. A seconda di dove dichiari una variabile potresti essere o non essere in grado di accedervi da altre posizioni.

Prendi come esempio il codice qui sotto:

public class Main {

	public static void main(String[] args) {
		int eta = 20;
		
		if (eta >= 18 && eta <= 40) {
			// la variabile eta è accessibile qui
			// i booleani non sono accessibili qui

			boolean studenteDellaScuola = true;
			boolean membroDellaLibreria = false;
			
			if (studenteDellaScuola || membroDellaLibreria) {
				// i booleani sono accessibili qui
				// la variabile eta è accessibile qui

				System.out.println("Puoi usare il programma");
			}
		} else {
			// la variabile eta è accessibile qui
			// i booleani non sono accessibili qui
            
			System.out.println("Non puoi usare il programma");
		}
		
	}

}

Qui, la variabile eta è dichiarata all'interno del blocco di codice di class. Ciò vuol dire che puoi accedere a questa variabile all'interno di tutto il blocco class senza alcun problema. Dato che la variabile è accessibile nell'intera istanza di classe, è una variabile d'istanza.

Invece, le variabili studenteDellaScuola e membroDellaLibreria sono state dichiarate nel blocco di codice della prima istruzione if, quindi non sono accessibili fuori da quel blocco di codice.

Ma possono essere raggiunte da qualsiasi blocco di codice annidato nel primo blocco if. Le variabili così dichiarate sono dette variabili locali.

Esistono anche variabili di classe dichiarate con la parola chiave static ma avrai modo di saperne di più nelle sezioni dedicate alla programmazione orientata agli oggetti.

Per ora, la regola generale è che è possibile accedere a una variabile all'interno del blocco di codice in cui è stata dichiarata o dai blocchi in esso annidati.

Quali sono i valori di default di una variabile in Java?

Hai imparato che in Java hai bisogno di inizializzare una variabile dopo averla dichiarata, altrimenti non sarai in grado di usarla. Beh, non è vero in tutti i casi.

Se dichiari una variabile nel livello di classe, le verrà assegnato un valore predefinito dal compilatore.

public class Main {
	
	// impostata a 0 come valore predefinito
	static int eta;

	public static void main(String[] args) {
		System.out.println(eta); // 0
	}
}

Dato che il metodo main è static, può accedere solo a variabili static nel livello di classe. Parleremo di static molto dettagliatamente nella sezione relativa alla programmazione orientata agli oggetti.

Ma se sposti la dichiarazione della variabile all'interno del metodo main, diventa locale e non ottiene alcun valore predefinito.

public class Main {
	public static void main(String[] args) {
		// resta non inizializzata
		int eta;
    
		System.out.println(eta); // errore di compilazione
	}
}

Questo codice restituirà l'errore di compilazione The local variable eta may not have been initialized.

Alle variabili viene assegnato un valore di default in base al loro tipo. Nella maggior parte dei casi, sarà 0 o null. Ecco una lista dei valori predefiniti dei tipi primitivi:

Ad ogni variabile di tipo riferimento sarà assegnato il valore null di default. Discuteremo di tipi, classi e oggetti di tipo riferimento nelle sezioni dedicate alla programmazione orientata agli oggetti.

Come lavorare con gli array in Java

Hai già imparato come dichiarare variabili singole e usarle in un programma. Qui entrano in scena gli array.

Gli array sono strutture di dati che contengono valori multipli dello stesso tipo in posizioni di memoria sequenziali. Gli array possono essere formati da qualsiasi tipo di dati primitivi e non.

Puoi creare un array in Java in questo modo:

public class Main {

	public static void main(String[] args) {
		// <tipo> <nome>[] = new <tipo>[<lunghezza>]
		char vocali[] = new char[5];

	}
}

Occorre scrivere il tipo di dato che l'array deve contenere, in questo caso char, scrivendo poi il nome dell'array, vocali, seguito da parentesi quadre. Le parentesi quadre comunicano a Java che stai dichiarando un array di caratteri e non una variabile carattere regolare.

Poi, bisogna aggiungere il simbolo uguale seguito dall'operatore new, usato per creare nuovi oggetti in Java. Dato che gli array sono di tipo riferimento in Java, new è necessario per creare nuove istanze.

La dichiarazione termina scrivendo di nuovo il tipo e delle parentesi quadre contenenti la lunghezza dell'array. Qui, 5 significa che l'array conterrà non più di cinque elementi.

Lavorando con una variabile singola, possiamo farvi riferimento semplicemente con il suo nome. Ma nel caso degli array, ogni elemento possiede un indicee gli array hanno indice a base zero. Questo vuol dire che il primo elemento di un array ha indice 0 e non 1.

Per accedere a un elemento di un array, puoi scrivere il nome dell'array – in questo caso vocali –  seguito dalle parentesi quadre con l'indice desiderato. Quindi se vuoi accedere al primo elemento nell'array, puoi farlo in questo modo:

public class Main {

	public static void main(String[] args) {
		char vocali[] = new char[5];
		
		vocali[0] = 'a';
	}
}

A questo punto, vocali[0] è simile a una normale variabile carattere. Puoi stamparla, assegnarle un nuovo valore, svolgere calcoli nel caso di variabili di tipo numerico e così via.

Visto che l'array è vuoto al momento, assegno il carattere a al primo indice. Puoi assegnare il resto delle vocali agli altri indici come segue:

public class Main {

	public static void main(String[] args) {
		char vocali[] = new char[5];
		
		vocali[0] = 'a';
		vocali[1] = 'e';
		vocali[2] = 'i';
		vocali[3] = 'o';
		vocali[4] = 'u';

	}
}

Dato che gli indici partono da 0, l'ultimo sarà uguale alla lunghezza dell'array -1, in questo caso 4. Se provi a assegnare altri elementi all'array, ad esempio vocali[5] = 'x';, il compilatore ti darà il seguente errore:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
	at arrays.Main.main(Main.java:18)

Gli array non possono essere stampati come le variabili normali. Occorre usare un loop oppure convertire l'array in una stringa. Visto che non abbiamo ancora parlato dei loop, userò il secondo metodo.

import java.util.Arrays;

public class Main {

	public static void main(String[] args) {
		char vocali[] = new char[5];
		
		vocali[0] = 'a';
		vocali[1] = 'e';
		vocali[2] = 'i';
		vocali[3] = 'o';
		vocali[4] = 'u';
		
		System.out.println("Le vocali sono: " + Arrays.toString(vocali));

	}
}

Dovrai prima importare java.util.Arrays; e usare il metodo Arrays.toString() per convertire l'array in una stringa. Questa classe possiede altri metodi interessanti, ma prima di parlane, vorrei mostrarti come dichiarare e inizializzare un array in un colpo solo.

import java.util.Arrays;

public class Main {

	public static void main(String[] args) {
		char vocali[] = {'a', 'e', 'i', 'o', 'u'};
		
		System.out.println("Le vocali sono: " + Arrays.toString(vocali));

	}
}

La parte sinistra della dichiarazione resta invariata, mentre, dopo l'operatore di assegnazione, invece di usare new dovrai scrivere i singoli elementi dell'array separati da una virgola all'interno delle parentesi graffe.

In questo caso il compilatore conterà gli elementi dell'array e utilizzerà questo conteggio come lunghezza dell'array.

Se non conosci la lunghezza di un array, puoi usare la proprietà length.

In questo caso, vocali.length sarà 5, visto che ci sono cinque elementi nell'array. La proprietà length dà un intero ed è utilizzabile per ogni array in Java.

Gli array possono anche essere multidimensionali. Finora abbiamo lavorato con array come questo:

Gli array monodimensionali sono ideali per contenere una serie di valori. Ma immagina un piano terapeutico giornaliero in forma di una tabella:

La prima riga rappresenta i sette giorni della settimana e le colonne rappresentano quante volte un paziente deve prendere un farmaco durante tre momenti della giornata. 0 vuol dire no e 1 vuol dire sì.

Puoi descrivere questa routine giornaliera usando un array multidimensionale:

import java.util.Arrays;

public class Main {

	public static void main(String[] args) {		
		int pianoTerapeutico[][] = {
				{1, 2, 3, 4, 5, 6, 7},
				{0, 1, 1, 0, 1, 1, 0},
				{1, 0, 1, 0, 1, 0, 0},
				{0, 0, 1, 1, 0, 1, 0},
		};
		
		System.out.println(Arrays.deepToString(pianoTerapeutico)); // [[1, 2, 3, 4, 5, 6, 7], [0, 1, 1, 0, 1, 1, 0], [1, 0, 1, 0, 1, 0, 0], [0, 0, 1, 1, 0, 1, 0]]

	}
}

Gli array multidimensionali non possono essere stampati con il normale metodo Arrays.toString(), devi scavare più a fondo.

Anche se l'output non sembra proprio una tabella, puoi renderlo simile a una tabella con un po' di codice:

import java.util.Arrays;

public class Main {

	public static void main(String[] args) {		
		int pianoTerapeutico[][] = {
				{1, 2, 3, 4, 5, 6, 7},
				{0, 1, 1, 0, 1, 1, 0},
				{1, 0, 1, 0, 1, 0, 0},
				{0, 0, 1, 1, 0, 1, 0},
		};
		
		System.out.println(Arrays.deepToString(pianoTerapeutico).replace("], ", "]\n"));
	}
}

// [[1, 2, 3, 4, 5, 6, 7]
// [0, 1, 1, 0, 1, 1, 0]
// [1, 0, 1, 0, 1, 0, 0]
// [0, 0, 1, 1, 0, 1, 0]]

Hai già imparato a usare il metodo replace() per le stringhe. Qui, stiamo semplicemente sostituendo la parentesi finale in ogni riga con una parentesi e il carattere nuova riga.

La prima riga rappresenta i 7 giorni della settimana e il resto delle righe le medicina da prendere ogni giorno. Ogni riga della tabella è un array.

Per accedere a un singolo valore di un array multidimensionale ti servono due indici. Il primo indice determina la riga e il secondo la colonna.

Quindi pianoTerapeutico[2][3] selezionerà l'elemento di indice 3 del terzo array, che sarà 0. Lavorare con array multidimensionali può sembrare un po' complesso ma con la pratica diventa più semplice.

Visto che in Java puoi creare array di ogni tipo, perché non provi a creare altri tipi di array da solo?

Come ordinare un array

Una delle operazioni più comuni che puoi eseguire su un array è ordinarlo. java.utils.Arrays con il metodo Arrays.sort() è qui proprio per questo:

import java.util.Arrays;

public class Main {

	public static void main(String[] args) {		
		char vocali[] = {'e', 'u', 'o', 'i', 'a'};
		
		Arrays.sort(vocali);
		
		System.out.println("L'array ordinato è: " + Arrays.toString(vocali)); // [a, e, i, o , u]

	}
}

Il metodo Arrays.sort() accetta un array non ordinato come argomento e lo riordina. Quindi invece di ottenere un nuovo array ordinato, l'array originale viene ordinato in ordine ascendente.

Di default, il metodo tratta il primo indice dell'array come indice di partenza e la lunghezza dell'array come indice finale.

Puoi specificare i due indici manualmente. Ad esempio, se vuoi ordinare soltanto u, o, i in ordine ascendente e lasciare e, a come sono, puoi farlo in questo modo:

import java.util.Arrays;

public class Main {

	public static void main(String[] args) {		
		char vocali[] = {'e', 'u', 'o', 'i', 'a'};
		
		int indicePartenza = 1;
		int indiceFine = 4;
		
		Arrays.sort(vocali, indicePartenza, indiceFine);
		
		System.out.println("L'array ordinato è: " + Arrays.toString(vocali)); // [e, i, o, u , a]

	}
}

Stavolta, il metodo prende l'array come primo parametro, l'indice di partenza come secondo parametro e quello di fine come terzo parametro. Il resto rimane invariato.

Come eseguire una ricerca binaria su un array

Cercare dei valori in un array ordinato è un'operazione comune. Il metodo Arrays.binarySearch() ti permette di cercare degli elementi all'interno di un array ordinato usando l'algoritmo di ricerca binaria.

public class Main {

	public static void main(String[] args) {
		char vocali[] = {'a', 'e', 'i', 'o', 'u'};
        
        char chiave = 'i';
		
		int trovaIndiceElemento = Arrays.binarySearch(vocali, chiave);
		
		System.out.println("La vocale 'i' è all'indice: " + trovaIndiceElemento); // 2

	}
}

Il metodo Arrays.binarySearch() prende come primo parametro un array e la chiave di ricerca (l'elemento che stiamo cercando) come secondo parametro, per poi restituire l'indice dell'elemento desiderato come un intero.

Puoi memorizzare l'indice in un int e usarlo per accedere all'elemento dell'array con vocali[trovaIndiceElemento].

Nota che l'array è stato ordinato in modo ascendente. Se non sei sicuro dell'ordine dell'array, usa prima il metodo Arrays.sort() per ordinarlo.

Di default, il metodo tratta il primo indice dell'array come punto di partenza e la lunghezza dell'array come termine, ma puoi specificare gli indici manualmente.

Ad esempio, se vuoi che la ricerca avvenga dall'indice 2 all'indice 4, puoi farlo così:

import java.util.Arrays;

public class Main {

	public static void main(String[] args) {
		char vocali[] = {'a', 'e', 'i', 'o', 'u'};
        
        char chiave = 'i';
		int indicePartenza = 2;
		int indiceFine = 4;
		
		int trovaIndiceElemento = Arrays.binarySearch(vocali, indicePartenza, indiceFine, chiave);
		
		System.out.println("La vocale 'i' è all'indice: " + trovaIndiceElemento); // 2

	}
}

Stavolta il metodo prende l'array su cui vuoi effettuare la ricerca come primo parametro, l'indice di partenza come secondo, l'indice finale come terzo e la chiave di ricerca come quarto parametro.

Ora, la ricerca avverrà tra i, o e u.  Quindi, se cerchi la a, non la troverai. In casi in cui l'elemento dato non viene trovato, otterrai un indice negativo, variabile a seconda di una serie di fattori che non discuterò qui. Se sei interessato a saperne di più, dai un'occhiata a questo articolo sull'argomento.

Come riempire un array

Hai già imparato come inizializzare un array con dei valori, ma a volte potresti aver bisogno di riempire un intero array con lo stesso valore. Il metodo Arrays.fill() può farlo per te:

import java.util.Arrays;

public class Main {

	public static void main(String[] args) {		
		char vocali[] = {'e', 'u', 'o', 'i', 'a'};
		
		Arrays.fill(vocali, 'x');
		
		System.out.println("L'array riempito: " + Arrays.toString(vocali)); // [x, x, x, x, x]

	}
}

Come il metodo Arrays.sort(), Arrays.fill() può eseguire altre operazioni. Prende l'array come primo parametro, il valore che vuoi inserire come secondo parametro e aggiorna l'array originale in loco.

Anche questo metodo tratta il primo indice come punto di partenza e la lunghezza come indice finale. Puoi specificare questi indici manualmente come segue:

import java.util.Arrays;

public class Main {

	public static void main(String[] args) {		
		char vocali[] = {'e', 'u', 'o', 'i', 'a'};
		
		int indicePartenza = 1;
		int indiceFine = 4;
		
		Arrays.fill(vocali, indicePartenza, indiceFine, 'x');
		
		System.out.println("L'array riempito: " + Arrays.toString(vocali)); // [e, x, x, x, a]

	}
}

In questo caso, il metodo prende l'array come primo argomento, l'indice di partenza come secondo, l'indice finale come terzo e il valore da inserire come quarto argomento.

Come fare una copia di un array

Dato che in Java gli array sono di tipo riferimento, copiarli usando l'operatore di assegnazione può causare qualche comportamento inatteso.

import java.util.Arrays;

public class Main {

	public static void main(String[] args) {
		int numeriDispari[] = {1, 3, 5};
		int copiaNumeriDispari[] = numeriDispari;
		
		Arrays.fill(numeriDispari, 0);
		
		System.out.println("L'array copiato: " + Arrays.toString(copiaNumeriDispari)); // [0, 0, 0]

	}
}

I cambiamenti apportati all'array sorgente si riflettono anche sulla copia. Questo accade perché  quando usiamo l'operatore di assegnazione per copiare l'array, la copia fa riferimento all'array originale in memoria.

Per copiare un array in modo appropriato, puoi usare il metodo Arrays.copyOf() come segue:

import java.util.Arrays;

public class Main {

	public static void main(String[] args) {
		int numeriDispari[] = {1, 3, 5};
		int copiaNumeriDispari[] = Arrays.copyOf(numeriDispari, numeriDispari.length);
		
		Arrays.fill(numeriDispari, 0);
		
		System.out.println("L'array copiato: " + Arrays.toString(copiaNumeriDispari)); // [1, 3, 5]

	}
}

Il metodo prende l'array sorgente come primo argomento e la lunghezza del nuovo array come secondo argomento. Se vuoi che la lunghezza sia la stessa, passa semplicemente la lunghezza dell'array originale usando la proprietà length.

Se inserisci una lunghezza minore, ogni valore successivo sarà escluso e se inserisci una lunghezza maggiore, i nuovi indici saranno popolati con il valore di default per il tipo di dato nell'array.

Esiste anche  il metodo Arrays.copyOfRange() che può copiare una porzione di un array in un nuovo array:

import java.util.Arrays;

public class Main {

	public static void main(String[] args) {
		int numeriDispari[] = {1, 3, 5, 7, 9, 11, 13, 15};
		
		int indicePartenza = 2;
		int indiceFine = 7;
		
		int copiaNumeriDispari[] = Arrays.copyOfRange(numeriDispari, indicePartenza, indiceFine);
		
		System.out.println("L'array copiato: " + Arrays.toString(copiaNumeriDispari)); // [5, 7, 9, 11, 13]

	}
}

Questo metodo prende l'array sorgente come primo argomento, seguito dall'indice di partenza e di fine.

Tieni a mente che l'indice finale non è incluso. Ecco perché il 15 non è presente nel nuovo array. Ma se vuoi includere l'ultimo indice dell'array, usa la lunghezza dell'array originale come indice finale.

import java.util.Arrays;

public class Main {

	public static void main(String[] args) {
		int numeriDispari[] = {1, 3, 5, 7, 9, 11, 13, 15};
		
		int indicePartenza = 2;
		int indiceFine = numeriDispari.length;
		
		int copiaNumeriDispari[] = Arrays.copyOfRange(numeriDispari, indicePartenza, indiceFine);
		
		System.out.println("L'array copiato: " + Arrays.toString(copiaNumeriDispari)); // [5, 7, 9, 11, 13, 15]

	}
}

Ora il nuovo array includerà anche il 15. Puoi anche inserire un numero può grande della lunghezza dell'array sorgente. In questo caso, i nuovi indici aggiunti conterranno il valore di default del tipo di dato nell'array.

Come confrontare due array

Se propri a verificare se due array sono uguali o meno in Java usando l'operatore di uguaglianza relazionale, otterrai dei risultati inaspettati.

public class Main {

	public static void main(String[] args) {		
		int numeriDispari1[] = {1, 3, 5, 7, 9, 11, 13, 15};
		int numeriDispari2[] = {1, 3, 5, 7, 9, 11, 13, 15};
		
		System.out.println(numeriDispari1 == numeriDispari2); // false
	}
}

Anche se i due array sono identici, l'output del programma è false. Visto che gli array sono di tipo riferimento, l'operatore di confronto verificherà se sono la stessa istanza o no.

Per confrontare due array in Java, puoi usare il metodo Arrays.equals():

import java.util.Arrays;

public class Main {

	public static void main(String[] args) {		
		int numeriDispari1[] = {1, 3, 5, 7, 9, 11, 13, 15};
		int numeriDispari2[] = {1, 3, 5, 7, 9, 11, 13, 15};
		
		System.out.println(Arrays.equals(numeriDispari1, numeriDispari2)); // true
	}
}

Tuttavia, se cambi anche un solo elemento in questi array, l'output sarà false dato gli array non saranno più uguali.

Puoi anche confrontare array multidimensionali, ma per quello devi utilizzare il metodo Arrays.deepEquals() invece del metodo usuale.

import java.util.Arrays;

public class Main {

	public static void main(String[] args) {		
		int pianoTerapeutico1[][] = {
				{1, 2, 3, 4, 5, 6, 7},
				{0, 1, 1, 0, 1, 1, 0},
				{1, 0, 1, 0, 1, 0, 0},
				{0, 0, 1, 1, 0, 1, 0},
		};
		
		int pianoTerapeutico2[][] = {
				{1, 2, 3, 4, 5, 6, 7},
				{0, 1, 1, 0, 1, 1, 0},
				{1, 0, 1, 0, 1, 0, 0},
				{0, 0, 1, 1, 0, 1, 0},
		};
		
		System.out.println(Arrays.deepEquals(pianoTerapeutico1, pianoTerapeutico2)); // true
	}
}

Questo metodo chiama sé stesso ogni volta che incontra un nuovo array all'interno dell'array genitore.

Questi erano i metodi più comuni all'interno della classe java.util.Arrays. Se vuoi impararne altri, consulta la documentazione ufficiale.

Come usare i loop in Java

Se hai bisogno di ripetere un'operazione per un certo numero di volte, puoi usare un loop. I loop possono essere di tre tipi: loop for, loop for...each e loop while.

Loop for

I loop for sono probabilmente il tipo di loop più comune che troverai su internet.

Ogni loop for è formato da tre parti. L'inizializzazione, la condizione e un'espressione di aggiornamento. Le iterazioni avvengono in più passaggi.

Se vuoi stampare i numeri da 0 a 10 usando un loop for, puoi farlo in questo modo:

public class Main {

	public static void main(String[] args) {
		for (int number = 0; number <= 10; number++) {
			System.out.println(number);
		}
	}
}

// 0
// 1
// 2
// 3
// 4
// 5
// 6
// 7
// 8
// 9
// 10

Il diagramma a flusso di questo loop sarà il seguente:

1. All'inizio del loop, inizializziamo un nuovo intero chiamato number con il valore iniziale 0.
2. Poi, viene verificato se number è minore o uguale a 10 oppure no.
3. Se è minore o uguale a 10, l'istruzione all'interno del blocco del loop viene eseguita e il valore della variabile stampato sul terminale.
4. Poi, la variabile è aggiornata, incrementandone il valore di 1.
5. Il loop torna indietro per verificare se il valore di number è ancora minore o uguale a 10 oppure no.

Finché il valore di number resta minore o uguale a 10, il loop prosegue. Nel momento in cui il suo valore diventa 11, il loop termina.

Puoi usare un loop for per iterare su un array, in questo modo:

public class Main {

	public static void main(String[] args) {
		int serieFibonacci[] = {0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55};
		
		for(int index = 0; index < serieFibonacci.length; index++) {
			System.out.println(serieFibonacci[index]);
		}
	}
}

Il diagramma di flusso di questo loop sarà:

Dato che l'ultimo indice dell'array è minore della sua lunghezza, il loop viene eseguito per tutti gli elementi dell'array. Nel momento in cui il valore di index diventa uguale alla lunghezza dell'array, usciamo dal loop.

Una delle cose simpatiche che puoi fare con i loop è stampare tabelline di moltiplicazione. Ad esempio, la tabellina del 5:

public class Main {

	public static void main(String[] args) {
		int numero = 5;
		
		for (int moltiplicatore = 1; moltiplicatore <= 10; moltiplicatore++) {
			System.out.println(String.format("%d x %d = %d", numero, moltiplicatore, numero * moltiplicatore));
		}
	}
}

// 5 x 1 = 5
// 5 x 2 = 10
// 5 x 3 = 15
// 5 x 4 = 20
// 5 x 5 = 25
// 5 x 6 = 30
// 5 x 7 = 35
// 5 x 8 = 40
// 5 x 9 = 45
// 5 x 10 = 50

I loop possono anche essere annidati. Ciò vuol dire che puoi inserire un loop in un altro loop. Possiamo stampare le tabelline dei numeri da 1 a 10 usando dei loop annidati:

public class Main {

	public static void main(String[] args) {
		for (int numero = 1; numero <= 10; numero++) {
			System.out.println(String.format("\ntabellina del %d", numero));
			for (int moltiplicatore = 1; moltiplicatore <= 10; moltiplicatore++) {
				System.out.println(String.format("%d x %d = %d", numero, moltiplicatore, numero * moltiplicatore));
			}
		}
	}
}

Non aggiungo l'output di questo codice. Provalo tu stesso e scrivi le iterazioni del loop su carta in modo da capire meglio cosa accade in ogni passaggio.

Loop for-each

Se vuoi iterare su un insieme come un array e svolgere delle operazioni su ogni elemento dell'insieme, puoi usare un loop for-each.

public class Main {

	public static void main(String[] args) {
		int serieFibonacci[] = {0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55};
		
		for(int numero : serieFibonacci) {
			System.out.println(numero);
		}
	}
}

Nel caso di un loop for-each, il tipo di elemento deve corrispondere al tipo di elementi dell'insieme con cui stai lavorando. Qui, l'array è di tipo int e quindi anche l'elemento del loop è un intero.

Questo loop svolge esattamente le stesse operazioni viste in precedenza, ma stavolta, non devi tenere traccia dell'indice o usare le parentesi quadre per accedere agli elementi. Ha un aspetto più pulito ed è meno favorevole alla generazione di errori.

Loop while

Se vuoi eseguire un gruppo di codice finché una determinata condizione è verificata, puoi usare un loop while.

Non ci sono passaggi di inizializzazione o aggiornamento in un loop while. Accade tutto nel corpo del loop. Se riscriviamo il programma per stampare la tabellina del 5 usando un loop while in questo modo:

public class Main {

	public static void main(String[] args) {
		int numero = 5;
		int moltiplicatore = 1;
		
		while (moltiplicatore <= 10) {
			System.out.println(String.format("%d x %d = %d", numero, moltiplicatore, numero*moltiplicatore));
			
			moltiplicatore++;
		}
	}
}

// 5 x 1 = 5
// 5 x 2 = 10
// 5 x 3 = 15
// 5 x 4 = 20
// 5 x 5 = 25
// 5 x 6 = 30
// 5 x 7 = 35
// 5 x 8 = 40
// 5 x 9 = 45
// 5 x 10 = 50

Anche se i loop while sono meno comuni dei loop for, è bene imparare a utilizzarli.

Loop do-while

L'ultimo tipo di loop di cui parleremo è il loop do-while. Inverte il normale ordine delle operazioni di un loop while – quindi invece di controllare prima la condizione e poi eseguire il corpo del loop, esegue prima il corpo del loop e poi verifica la condizione.

Il codice per stampare la tabellina del 5 implementato con un loop do-while sarà:

public class Main {

	public static void main(String[] args) {
		int numero = 5;
		int moltiplicatore = 1;
		
		do {
			System.out.println(String.format("%d x %d = %d", numero, moltiplicatore, numero*moltiplicatore));
			
			moltiplicatore++;
		} while (moltiplicatore <= 10);
	}
}

// 5 x 1 = 5
// 5 x 2 = 10
// 5 x 3 = 15
// 5 x 4 = 20
// 5 x 5 = 25
// 5 x 6 = 30
// 5 x 7 = 35
// 5 x 8 = 40
// 5 x 9 = 45
// 5 x 10 = 50

Questo tipo di loop è molto utile quando hai bisogno di svolgere alcune operazioni finché un utente non ti dà un input specifico. Come mostrare un menu finché l'utente preme il tasto "x".

Come lavorare con gli ArrayList in Java

In Java, gli array non sono ridimensionabili. Una volta che hai impostato una lunghezza per un array non puoi cambiarla in nessun modo. In Java, la classe ArrayList rimedia a questa limitazione.

import java.util.ArrayList;

public class Main {
    public static void main (String[] args) {
        ArrayList<Integer> numeriDispari = new ArrayList<>();

        numeriDispari.add(1);
        numeriDispari.add(3);
        numeriDispari.add(5);
        numeriDispari.add(7);
        numeriDispari.add(9);

        System.out.println(numeriDispari.toString()); // [1, 3, 5, 7, 9]
    }
}

Per creare un ArrayList, devi importare la classe java.util.ArrayList in cima al tuo file sorgente.

Poi, devi scrivere ArrayList, il tipo di dato degli elementi all'interno di parentesi angolate, aggiungere il numero dell'ArrayList seguito dall'operatore di assegnazione e new ArrayList<>().

Non puoi creare ArrayList di tipo primitivo, quindi dovrai usare le classi wrapper corrispondenti.

Anche se questi elementi hanno indice a base zero come gli array, non puoi utilizzare la notazione con parentesi quadre per accedervi. Invece, occorre usare il metodo get():

import java.util.ArrayList;

public class Main {
    public static void main (String[] args) {
        ArrayList<Integer> numeriDispari = new ArrayList<>();

        numeriDispari.add(1);
        numeriDispari.add(3);
        numeriDispari.add(5);
        numeriDispari.add(7);
        numeriDispari.add(9);

        System.out.println(numeriDispari.get(2)); // 5
    }
}

Il metodo get() ti darà il valore presente all'indice dato. Allo stesso modo di get(), puoi usare il metodo set() per aggiornare il valore di un elemento.

import java.time.LocalDate;
import java.util.ArrayList;

public class Main {
    public static void main (String[] args) {
        ArrayList<Integer> numeriDispari = new ArrayList<>();

        numeriDispari.add(1);
        numeriDispari.add(3);
        numeriDispari.add(5);
        numeriDispari.add(7);
        numeriDispari.add(9);

        numeriDispari.set(2, 55);

        System.out.println(numeriDispari.get(2)); // 55
    }
}

Il primo parametro del metodo set() è l'indice e il secondo è il valore aggiornato.

Non esiste una proprietà length come per gli array ma puoi usare il metodo size() su qualsiasi ArrayList per trovarne la lunghezza.

import java.util.ArrayList;

public class Main {
    public static void main (String[] args) {
        ArrayList<Integer> numeriDispari = new ArrayList<>();

        numeriDispari.add(1);
        numeriDispari.add(3);
        numeriDispari.add(5);
        numeriDispari.add(7);
        numeriDispari.add(9);

        System.out.println(numeriDispari.size()); // 5
    }
}

Puoi rimuovere elementi da un ArrayList usando il metodo remove():

import java.util.ArrayList;

public class Main {
    public static void main (String[] args) {
        ArrayList<Integer> numeriDispari = new ArrayList<>();

        numeriDispari.add(1);
        numeriDispari.add(3);
        numeriDispari.add(5);
        numeriDispari.add(7);
        numeriDispari.add(9);

        numeriDispari.remove(Integer.valueOf(7));
        numeriDispari.remove(Integer.valueOf(9));

        System.out.println(numeriDispari.toString()); // [1, 3, 5]
    }
}

Il metodo remove() può rimuovere un elemento in base al suo valore o al suo indice. Se passi al metodo un valore intero primitivo, rimuoverà l'elemento corrispondente a quell'indice.

Ma se passi un oggetto, come in questo codice, il metodo troverà e cancellerà l'elemento dato. Il metodo valueOf() è presente in tutte le classi wrapper e può convertire un valore primitivo in un tipo riferimento.

Come aggiungere o rimuovere elementi multipli

Abbiamo già visto esempi dei metodi add() e remove(), ma esistono anche i metodi addAll() e removeAll() per lavorare con elementi multipli.

import java.util.ArrayList;

public class Main {
    public static void main (String[] args) {
        ArrayList<Integer> numeriDispari = new ArrayList<>();

        numeriDispari.add(1);
        numeriDispari.add(3);
        numeriDispari.add(5);

        ArrayList<Integer> altriNumeriDispari = new ArrayList<>();

        altriNumeriDispari.add(7);
        altriNumeriDispari.add(9);
        altriNumeriDispari.add(11);

        numeriDispari.addAll(altriNumeriDispari); // [1, 3, 5, 7, 9, 11]

        System.out.println(numeriDispari.toString());

        numeriDispari.removeAll(altriNumeriDispari);

        System.out.println(numeriDispari.toString()); // [1, 3, 5]
    }
}

Entrambi i metodi accettano delle collezioni come parametri. Nel codice qui sopra, abbiamo creato due ArrayList separati per poi unirli con il metodo addAll().

In seguito abbiamo rimosso gli elementi del secondo ArrayList usando il metodo removeAll() per far tornare l'ArrayList nel suo stato originario.

Puoi anche eliminare tutti gli elementi di un ArrayList con il metodo clear():

import java.util.ArrayList;

public class Main {
    public static void main (String[] args) {
        ArrayList<Integer> numeriDispari = new ArrayList<>();

        numeriDispari.add(1);
        numeriDispari.add(3);
        numeriDispari.add(5);

        numeriDispari.clear();
        
        System.out.println(numeriDispari.toString()); // []
    }
}

Il metodo non richiede nessun parametro e non restituisce nessun valore. Svuota semplicemente l'ArrayList con una sola chiamata.

Come rimuovere elementi in base a una condizione

Il metodo removeIf() può essere usato per rimuovere elementi da un ArrayList in base a una condizione:

import java.util.ArrayList;

public class Main {
    public static void main (String[] args) {
        ArrayList<Integer> numeri = new ArrayList<>();

        for (int i = 0; i <= 10; i++) {
            numeri.add(i);
        }

        System.out.println(numeri.toString()); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

        numeri.removeIf(numero -> numero % 2 == 1);

        System.out.println(numeri.toString()); // [0, 2, 4, 6, 8, 10]
    }
}

Il metodo accetta un'espressione lambda come parametro. Le espressioni lambda sono dei metodi senza nome, che ricevono dei parametri e svolgono delle operazioni su di essi.

In questo caso, il metodo removeIf() itera sull'ArrayList e passa ogni elemento all'espressione lambda come valore della variabile numero.

Poi l'espressione lambda verifica se il numero dato è divisibile per 2 oppure no e restituisce true o false in base al risultato.

Se l'espressione lambda restituisce true, il metodo removeIf() conserverà il valore, altrimenti lo cancellerà.

Come clonare e confrontare degli ArrayList

Per duplicare un ArrayList puoi usare il metodo clone():

import java.util.ArrayList;

public class Main {
    public static void main (String[] args) {
        ArrayList<Integer> numeri = new ArrayList<>();

        for (int i = 0; i <= 10; i++) {
            numeri.add(i);
        }

        ArrayList<Integer> numeriClonato = (ArrayList<Integer>)numeri.clone();

        System.out.println(numeriClonato.equals(numeri)); // true
    }
}

Il metodo clone() restituisce un oggetto, quindi occorre definire correttamente il tipo dell'ArrayList manualmente. Puoi confrontare due ArrayList con il metodo equals(), proprio come per gli array.

Come verificare la presenza di un elemento e se un ArrayList è vuoto

Puoi usare il metodo contains() per controllare se un ArrayList contiene o meno un dato elemento:

import java.util.ArrayList;

public class Main {
    public static void main (String[] args) {
        ArrayList<Integer> numeriDispari = new ArrayList<>();

        numeriDispari.add(1);
        numeriDispari.add(3);
        numeriDispari.add(5);
        numeriDispari.add(7);
        numeriDispari.add(9);

        System.out.println(numeriDispari.isEmpty()); // false
        System.out.println(numeriDispari.contains(5)); // true
    }
}

Se vuoi verificare se un ArrayList è vuoto oppure no, chiama semplicemente il metodo isEmpty() e otterrai un booleano come valore di ritorno.

Come ordinare un ArrayList

Puoi ordinare un ArrayList in diversi modi usando il metodo sort():

import java.util.ArrayList;
import java.util.Comparator;

public class Main {
    public static void main (String[] args) {
        ArrayList<Integer> numeriDispari = new ArrayList<>();

        numeriDispari.add(5);
        numeriDispari.add(7);
        numeriDispari.add(1);
        numeriDispari.add(9);
        numeriDispari.add(3);

        System.out.println(numeriDispari.toString()); [5, 7, 1, 9, 3]

        numeriDispari.sort(Comparator.naturalOrder());

        System.out.println(numeriDispari.toString()); [1, 3, 5, 7, 9]
    }
}

Il metodo sort() prende come parametro un comparator che impone l'ordine sull'ArrayList.

Puoi riordinare l'ArrayList in ordine inverso cambiando il comparator passato:

import java.util.ArrayList;
import java.util.Comparator;

public class Main {
    public static void main (String[] args) {
        ArrayList<Integer> numeriDispari = new ArrayList<>();

        numeriDispari.add(5);
        numeriDispari.add(7);
        numeriDispari.add(1);
        numeriDispari.add(9);
        numeriDispari.add(3);

        System.out.println(numeriDispari.toString()); // [5, 7, 1, 9, 3]

        numeriDispari.sort(Comparator.reverseOrder());

        System.out.println(numeriDispari.toString()); // [9, 7, 5, 3, 1]
    }
}

I comparator hanno anche altri utilizzi, ma questi vanno oltre lo scopo di questo manuale.

Come tenere gli elementi comuni in due ArrayList

Immagina di avere due ArrayList e di dover trovare quali elementi sono presenti in entrambi, rimuovendo gli altri dal primo ArrayList.

import java.util.ArrayList;

public class Main {
    public static void main (String[] args) {
        ArrayList<Integer> numeriDispari = new ArrayList<>();

        numeriDispari.add(1);
        numeriDispari.add(3);
        numeriDispari.add(5);

        ArrayList<Integer> altriNumeriDispari = new ArrayList<Integer>();

        altriNumeriDispari.add(5);
        altriNumeriDispari.add(7);
        altriNumeriDispari.add(9);

        numeriDispari.retainAll(altriNumeriDispari);

        System.out.println(numeriDispari.toString()); // [5]
    }
}

Il metodo retainAll() può sbarazzarsi per te degli elementi non comuni ai due ArrayList. Dovrai chiamare il metodo sull'ArrayList su cui vuoi operare e passare l'altro ArrayList come parametro.

Come eseguire un'azione su tutti gli elementi di un ArrayList

Hai già imparato come usare i loop nelle sezioni precedenti. Bene, gli ArrayList possiedono già un metodo forEach() che accetta un'espressione lambda come parametro e può svolgere un'azione su tutti gli elementi dell'ArrayList.

import java.util.ArrayList;

public class Main {
    public static void main (String[] args) {
        ArrayList<Integer> numeriDispari = new ArrayList<>();

        numeriDispari.add(1);
        numeriDispari.add(3);
        numeriDispari.add(5);
        numeriDispari.add(7);
        numeriDispari.add(9);

        numeriDispari.forEach(numero -> {
            numero = numero * 2;
            System.out.printf("%d ", numero); // 2 6 10 14 18
        });

        System.out.println(numeriDispari.toString()); // [1, 3, 5, 7, 9]
    }
}

L'ultima volta, l'espressione lambda che abbiamo visto era su una singola riga – ma ce ne possono essere di più grandi. Qui, il metodo forEach() itererà sull'ArrayList passando ogni elemento all'espressione lambda come valore della variabile numero.

L'espressione lambda moltiplicherà il valore fornito per 2 e lo stamperà sul terminale. Tuttavia, l'ArrayList originario resterà invariato.

Come lavorare con le HashMap in Java

In Java, le HashMap possono contenere elementi in coppie chiave-valore. Questo tipo di collezioni è comparabile ai dizionari in Python o agli oggetti in JavaScript.

import java.util.HashMap;

public class Main {
    public static void main (String[] args) {
        HashMap<String, Double> prezzi = new HashMap<>();

        prezzi.put("mela", 2.0);
        prezzi.put("arancia", 1.8);
        prezzi.put("guava", 1.5);
        prezzi.put("mirtillo", 2.5);
        prezzi.put("banana", 1.0);

        System.out.printf(prezzi.toString()); // {arancia=1.8, banana=1.0, mela=2.0, mirtillo=2.5, guava=1.5}
    }
}

Per creare una HashMap, devi prima importare la classe java.util.HashMap in cima al tuo file sorgente.

Poi, devi scrivere HashMap seguito dal tipo di dati della chiave e del valore all'interno di parentesi angolate e separati da una virgola.

In questo caso, le chiavi sono stringhe e i valori dei double. Dopo di ciò, aggiungi l'operatore di assegnazione seguito da new HashMap<>().

Per inserire dei dati nell'HashMap puoi usare il metodo put(), che accetta la chiave come primo parametro e il valore corrispondente come secondo parametro.

Esiste anche il metodo putIfAbsent(), che aggiunge un determinato elemento solo se non è già presente nell'HashMap.

import java.util.HashMap;

public class Main {
    public static void main (String[] args) {
        HashMap<String, Double> prezzi = new HashMap<>();

        prezzi.put("mela", 2.0);
        prezzi.put("arancia", 1.8);
        prezzi.put("guava", 1.5);
        prezzi.put("mirtillo", 2.5);
        prezzi.put("banana", 1.0);

        prezzi.putIfAbsent("guava", 2.9);

        System.out.println(prezzi.toString()); // {arancia=1.8, banana=1.0, mela=2.0, mirtillo=2.5, guava=1.5}
    }
}

Puoi usare il metodo get() per ottenere un valore da una HashMap. Il metodo prende la chiave come parametro.

import java.util.HashMap;

public class Main {
    public static void main (String[] args) {
        HashMap<String, Double> prezzi = new HashMap<>();

        prezzi.put("mela", 2.0);
        prezzi.put("arancia", 1.8);
        prezzi.put("guava", 1.5);
        prezzi.put("mirtillo", 2.5);
        prezzi.put("banana", 1.0);

        System.out.println(prezzi.get("banana")); // 1.000000
    }
}

Esiste anche una variante di questo metodo. Il metodo getOrDefault() funziona come get() ma se la chiave data non viene trovata, restituisce un valore di default specificato.

import java.util.HashMap;

public class Main {
    public static void main (String[] args) {
        HashMap<String, Double> prezzi = new HashMap<>();

        prezzi.put("mela", 2.0);
        prezzi.put("arancia", 1.8);
        prezzi.put("guava", 1.5);
        prezzi.put("mirtillo", 2.5);
        prezzi.put("banana", 1.0);

        System.out.println(prezzi.getOrDefault("jackfruit", 0.0)); // 0.0
    }
}

Il valore di default deve corrispondere al tipo di valori nell'HashMap. Puoi aggiornare un valore in una HashMap usando il metodo replace():

import java.util.HashMap;

public class Main {
    public static void main (String[] args) {
        HashMap<String, Double> prezzi = new HashMap<>();

        prezzi.put("mela", 2.0);
        prezzi.put("arancia", 1.8);
        prezzi.put("guava", 1.5);
        prezzi.put("mirtillo", 2.5);
        prezzi.put("banana", 1.0);

        prezzi.replace("mirtillo", 2.8);

        System.out.printf(prezzi.toString()); // {arancia=1.8, banana=1.0, mela=2.0, mirtillo=2.8, guava=1.5}
    }
}

Per rimuovere elementi da una HashMap, puoi usare il metodo remove():

import java.util.HashMap;

public class Main {
    public static void main (String[] args) {
        HashMap<String, Double> prezzi = new HashMap<>();

        prezzi.put("mela", 2.0);
        prezzi.put("arancia", 1.8);
        prezzi.put("guava", 1.5);
        prezzi.put("mirtillo", 2.5);
        prezzi.put("banana", 1.0);

        prezzi.remove("guava");

        System.out.printf(prezzi.toString()); // {arancia=1.8, banana=1.0, mela=2.0, mirtillo=2.5}
    }
}

Nel caso avessi bisogno di conoscere quanti dati sono presenti all'interno di una HashMap, puoi saperlo usando il metodo size():

import java.util.HashMap;

public class Main {
    public static void main (String[] args) {
        HashMap<String, Double> prezzi = new HashMap<>();

        prezzi.put("mela", 2.0);
        prezzi.put("arancia", 1.8);
        prezzi.put("guava", 1.5);
        prezzi.put("mirtillo", 2.5);
        prezzi.put("banana", 1.0);

        System.out.println(prezzi.size()); // 5
    }
}

Infine, se desideri svuotare una HashMap, puoi farlo grazie al metodo clear().

import java.util.HashMap;

public class Main {
    public static void main (String[] args) {
        HashMap<String, Double> prices = new HashMap<>();

        prices.put("apple", 2.0);
        prices.put("orange", 1.8);
        prices.put("guava", 1.5);
        prices.put("berry", 2.5);
        prices.put("banana", 1.0);

        prices.clear();

        System.out.println(prices.toString()); // {}
    }
}

Proprio come per gli ArrayList, il metodo non prende argomenti né restituisce valori.

Come inserire o sostituire elementi multipli in una HashMap

Se vuoi inserire più elementi in una HashMap in un colpo solo, puoi farlo usando il metodo putAll():

import java.util.HashMap;

public class Main {
    public static void main (String[] args) {
        HashMap<String, Double> prezzi = new HashMap<>();

        prezzi.put("mela", 2.0);
        prezzi.put("arancia", 1.8);
        prezzi.put("guava", 1.5);
        prezzi.put("mirtillo", 2.5);
        prezzi.put("banana", 1.0);

        HashMap<String, Double> altriPrezzi = new HashMap<>();

        altriPrezzi.put("jackfruit", 2.9);
        altriPrezzi.put("ananas", 1.1);
        altriPrezzi.put("pomodoro", 0.8);

        prezzi.putAll(altriPrezzi);

        System.out.println(prezzi.toString()); // {arancia=1.8, banana=1.0, mela=2.0, mirtillo=2.5, ananas=1.1, pomodoro=0.8, guava=1.5, jackfruit=2.9}
    }
}

Il metodo prende un'altra HashMap come parametro e aggiunge i suoi elementi all'HashMap su cui è stato chiamato.

Puoi anche usare il metodo replaceAll() per aggiornare valori multipli in una HashMap.

import java.util.HashMap;

public class Main {
    public static void main (String[] args) {
        HashMap<String, Double> prezzi = new HashMap<>();

        prezzi.put("mela", 2.0);
        prezzi.put("arancia", 1.8);
        prezzi.put("guava", 1.5);
        prezzi.put("mirtillo", 2.5);
        prezzi.put("banana", 1.0);

        prezzi.replaceAll((frutto, prezzo) -> prezzo * 2);

        System.out.println(prezzi.toString()); // {arancia=3.6, banana=2.0, mela=4.0, mirtillo=5.0, guava=3.0}
    }
}

Il metodo replaceAll() itera sull'HashMap e passa ogni coppia chiave-valore all'espressione lambda.

Il primo parametro dell'espressione lambda è la chiave e il secondo è il valore. All'interno dell'espressione lambda puoi eseguire le azioni che desideri.

Come verificare se una Hash Map contiene un elemento o è vuota

Puoi usare i metodi containsKey() e containsValue() per controllare se una HashMap contiene un elemento oppure no.

import java.util.HashMap;

public class Main {
    public static void main (String[] args) {
        HashMap<String, Double> prezzi = new HashMap<>();

        prezzi.put("mela", 2.0);
        prezzi.put("arancia", 1.8);
        prezzi.put("guava", 1.5);
        prezzi.put("mirtillo", 2.5);
        prezzi.put("banana", 1.0);

        System.out.println(prezzi.containsKey("banana")); // true
        System.out.println(prezzi.containsValue(2.5)); // true
    }
}

La differenza tra i due  metodi è che il metodo containsKey() verifica se una data chiave è presente o meno, mentre il metodo containsValue() verifica se un dato valore è presente o meno.

Se vuoi sapere se una HashMap è vuota oppure no, puoi usare il metodo isEmpty():

import java.util.HashMap;

public class Main {
    public static void main (String[] args) {
        HashMap<String, Double> prezzi = new HashMap<>();

        prezzi.put("mela", 2.0);
        prezzi.put("arancia", 1.8);
        prezzi.put("guava", 1.5);
        prezzi.put("mirtillo", 2.5);
        prezzi.put("banana", 1.0);

        System.out.println(prezzi.isEmpty()); // false
    }
}

Dato che il metodo restituisce un valore booleano, puoi utilizzarlo in istruzioni if-else.

Come eseguire un'azione su tutti gli elementi di una HashMap

Proprio come gli ArrayList, anche le HashMap possiedono un metodo forEach() che puoi usare per iterare sull'HashMap e ripetere determinate azioni su ogni dato.

import java.util.HashMap;

public class Main {
    public static void main (String[] args) {
        HashMap<String, Double> prezzi = new HashMap<>();

        prezzi.put("mela", 2.0);
        prezzi.put("arancia", 1.8);
        prezzi.put("guava", 1.5);
        prezzi.put("mirtillo", 2.5);
        prezzi.put("banana", 1.0);

        System.out.println("prezzi scontati");

        prices.forEach((frutto, prezzo) -> {
            System.out.println(frutto + " - " + (prezzo - 0.5));
        });
    }
}

// prezzi scontati
// arancia - 1.3
// banana - 0.5
// mela - 1.5
// mirtillo - 2.0
// guava - 1.0

Il metodo itera su ogni dato e passa la chiave e il valore all'espressione lambda. All'interno del corpo dell'espressioni lambda, puoi fare ciò che desideri.

Classi e Oggetti in Java

Ecco un'utile definizione di programmazione orientata agli oggetti:

La programmazione orientata agli oggetti (OOP, Object-oriented programming) è un paradigma di programmazione basato sul concetto di "oggetti", che possono contenere dati e codice: dati in forma di campi (spesso chiamati attributi o proprietà) e codice in forma di procedure (spesso chiamate metodi).

Immagina il sistema di gestione di una libreria, dove i membri della libreria possono accedere e vedere i libri che hanno già preso in prestito, richiederne nuovi e così via.

In questo sistema, gli utenti e i libri possono essere tutti oggetti. Questi oggetti avranno le loro proprietà come nome e data di nascita, nel caso di un utente, e titolo e autore, nel caso dei libri.

Le classi nella programmazione orientata agli oggetti sono i modelli per gli oggetti precedentemente menzionati. Abbiamo già parlato delle possibili proprietà degli oggetti utente e libro.

Per creare una nuova classe Utente, clicca ancora con il tasto destro sulla cartella src. Poi vai su New > Java Class, chiamala Utente e premi invio.

Tenendo a mente le proprietà discusse in precedenza, il codice della classe Utente dovrebbe essere come segue:

import java.time.LocalDate;

public class Utente {
    String nome;
    LocalDate dataDiNascita;
}

LocalDate è un tipo di dato riferimento che rappresenta una data. Ora torna al file Main.java e crea una nuova istanza di questa classe:

import java.time.LocalDate;

public class Main {
    public static void main (String[] args) {
        Utente utente = new Utente();

        utente.nome = "Farhan";
        utente.dataDiNascita = LocalDate.parse("1996-07-15");

        System.out.printf("%s è nato il %s.", utente.nome, utente.dataDiNascita.toString()); // Farhan è nato il 1996-07-15.
    }
}

Creare un nuovo utente non è molto diverso da creare una nuova stringa o un array. Inizi scrivendo il nome della classe, poi il nome dell'istanza o dell'oggetto.

Aggiungi l'operatore di assegnazione seguito dalla parola chiave new e dalla chiamata del costruttore. Il costruttore è un metodo speciale che inizializza l'oggetto.

Il costruttore inizializza le proprietà dell'oggetto con dei valori predefiniti, e cioè null per tutti i tipi riferimento.

Puoi accedere alle proprietà di un oggetto scrivendo il nome dell'oggetto seguito da un punto e dal nome della proprietà.

Il metodo LocalDate.parse() interpreta la data dalla stringa specificata. Dato che dataDiNascita è un riferimento, occorre usare il metodo toString() per stamparla sulla console.

Cos'è un metodo?

Le variabili o le proprietà di una classe descrivono lo stato dei suoi oggetti. I metodi invece, ne descrivono il comportamento.

Ad esempio, nella classe Utente possiamo avere un metodo che calcola l'età dell'utente.

import java.time.Period;
import java.time.LocalDate;

public class Utente {
    String nome;
    LocalDate dataDiNascita;

    int eta() {
        return Period.between(this.dataDiNascita, LocalDate.now()).getYears();
    }
}

Qui, la parola chiave this rappresenta l'istanza attuale della classe. Iniziamo scrivendo il tipo del valore di ritorno del metodo. Dato che l'età di un utente è un intero, il valore restituito da questo metodo sarà di tipo int.

Poi scriviamo il nome del metodo, seguito dalle parentesi.

È il momento di scrivere il corpo del metodo, all'interno di parentesi graffe. La classe Period in Java esprime un periodo di tempo secondo il sistema del calendario ISO-8601. Il metodo LocalDate.now() restituisce la data corrente.

Quindi la chiamata Period.between(this.dataDiNascita, LocalDate.now()).getYears() restituisce la differenza tra la data corrente e la data di nascita in anni.

Ora torniamo al file Main.java file e chiamiamo il metodo come segue:

import java.time.LocalDate;

public class Main {
    public static void main (String[] args) {
        Utente utente = new Utente();

        utente.nome = "Farhan";
        utente.dataDiNascita = LocalDate.parse( "1996-07-15");

        System.out.printf("%s ha %s anni.", utente.nome, utente.eta()); // Farhan ha 26 anni.
    }
}

I metodi possono anche accettare dei parametri. Ad esempio, se vuoi creare un metodo prestito() per inserire nuovi libri nella lista dei libri presi in prestito da un utente, puoi farlo in questo modo:

import java.time.LocalDate;
import java.time.Period;
import java.util.ArrayList;

public class Utente {
    String nome;
    LocalDate dataDiNascita;
    
    ArrayList<String> libriPresiInPrestito = new ArrayList<String>();

    int eta() {
        return Period.between(this.dataDiNascita, LocalDate.now()).getYears();
    }

    void prestito(String titoloLibro) {
        this.libriPresiInPrestito.add(titoloLibro);
    }
}

Tornando al file Main.java, possiamo chiamare il metodo in questo modo:

public class Main {
    public static void main (String[] args) {
        Utente utente = new Utente();

        utente.nome = "Farhan";

        utente.prestito("Carmilla");
        utente.prestito("Hard West");

        System.out.printf("%s ha preso in prestito questi libri: %s", utente.nome, utente.libriPresiInPrestito.toString()); // Farhan ha preso in prestito questi libri: [Carmilla, Hard West]
    }
}

Allo stesso modo, creiamo una classe per i libri:

import java.util.ArrayList;

public class Libro {
    String titolo;
    ArrayList<String> autori = new ArrayList<String>();
}

Spesso i libri hanno più di un autore. Adesso creiamo una nuova istanza di Libro nel file Main.java.

import java.time.LocalDate;

public class Main {
    public static void main (String[] args){
        Utente utente = new Utente();
        utente.nome = "Farhan";
        utente.dataDiNascita = LocalDate.parse("1996-07-15");

        Libro libro = new Libro();
        libro.titolo = "Carmilla";
        libro.autori.add("Sheridan Le Fanu");

        System.out.printf("%s è stato scritto da %s", libro.titolo, libro.autori.toString()); // Carmilla è stato scritto da [Sheridan Le Fanu]
    }
}

Ora torniamo al file Utente.java e creiamo una relazione tra gli utenti e i libri:

import java.time.LocalDate;
import java.time.Period;
import java.util.ArrayList;

public class Utente {
    String nome;
    LocalDate dataDiNascita;

    ArrayList<Libro> libriPresiInPrestito = new ArrayList<Libro>();

    int eta() {
        return Period.between(this.dataDiNascita, LocalDate.now()).getYears();
    }

    void prestito(Libro libro) {
        this.libriPresiInPrestito.add(libro);
    }
}

Invece di usare un ArrayList di stringhe, adesso stiamo usando un ArrayList di libri per conservare i libri presi in prestito da un utente.

Dato che il tipo dell'argomento del metodo è cambiato, di conseguenza dovrai aggiornare il codice nel file Main.java:

import java.time.LocalDate;

public class Main {
    public static void main (String[] args){
        Utente utente = new Utente();
        utente.nome = "Farhan";
        utente.dataDiNascita = LocalDate.parse("1996-07-15");

        Libro libro = new Libro();
        libro.titolo = "Carmilla";
        libro.autori.add("Sheridan Le Fanu");

        utente.prestito(libro);

        System.out.printf("%s ha preso in prestito questi libri: %s", utente.nome, utente.libriPresiInPrestito.toString()); // Farhan ha preso in prestito questi libri: [Libro@30dae81]
    }

Tutto funziona a dovere, eccetto il fatto che le informazioni sui libri non vengono stampate in modo appropriato.

Spero che ti ricordi del metodo toString(). Quando chiamiamo utente.libriPresiInPrestito.toString() il compilatore realizza che gli elementi contenuti nell'ArrayList  sono oggetti o riferimenti. Quindi inizia a chiamare il metodo toString() in questi elementi.

Il problema è che non esiste un'implementazione appropriata di toString() nella classe Libro. Apri Libro.java e aggiorna il suo codice come segue:

import java.util.ArrayList;

public class Libro {
    String titolo;
    ArrayList<String> autori = new ArrayList<String>();

    public String toString() {
        return String.format("%s di %s", this.titolo, this.autori.toString());
    }
}

Adesso, il metodo toString() restituisce una stringa ben formattata invece del riferimento all'oggetto. Esegui ancora il codice e questa volta l'output dovrebbe essere Farhan ha preso in prestito questi libri: [Carmilla di [Sheridan Le Fanu]].

Come puoi vedere, essere in grado di progettare il tuo software con delle entità reali lo rende molto più comprensibile. Anche se è tutto incentrato su un ArrayList e qualche stringa, è come se l'operazione di prestito del libro avvenga davvero.

Cos'è l'overloading dei metodi?

In Java, più metodi possono avere lo stesso nome se i loro parametro sono diversi. Ciò viene detto overloading dei metodi.

Un esempio può essere il metodo prestito() nella classe Utente(). Adesso accetta un singolo libro come parametro. Creiamo una versione di overload che invece accetta un array di libri.

import java.time.LocalDate;
import java.time.Period;
import java.util.ArrayList;
import java.util.Arrays;

public class Utente {
    private String nome;
    private LocalDate dataDiNascita;

    private ArrayList<Libro> libriPresiInPrestito = new ArrayList<Libro>();

    public String getNome() {
        return this.nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

    public String getLibriPresiInPrestito() {
        return this.libriPresiInPrestito.toString();
    }

    Utente (String nome, String dataDiNascita) {
        this.nome = nome;
        this.dataDiNascita = LocalDate.parse(dataDiNascita);
    }

    int eta() {
        return Period.between(this.dataDiNascita, LocalDate.now()).getYears();
    }

    void prestito(Libro libro) {
        this.libriPresiInPrestito.add(libro);
    }

    void prestito(Libro[] libri) {
        libriPresiInPrestito.addAll(Arrays.asList(libri));
    }
}

Il tipo del valore di ritorno del nuovo metodo è identico al precedente, ma questo accetta un array di oggetti Libro invece di un singolo oggetto.

Aggiorniamo il file Main.java per poter usare questo metodo di overload.

public class Main {
    public static void main(String[] args) {
        Utente utente = new Utente("Farhan", "1996-07-15");

        Libro libro1 = new Libro("Carmilla", new String[]{"Sheridan Le Fanu"});
        Libro libro2 = new Libro("Frankenstein", new String[]{"Mary Shelley"});
        Libro libro3 = new Libro("Dracula", new String[]{"Bram Stoker"});

        utente.prestito(new Libro[]{libro1, libro2});

        utente.prestito(libro3);

        System.out.printf("%s ha preso in prestito questi libri: %s", utente.getNome(), utente.getLibriPresiInPrestito());
    }
}

Come puoi vedere, adesso il metodo prestito() accetta un array di libri o un singolo oggetto libro senza problemi.

Cosa sono i costruttori in Java?

Un costruttore è un tipo particolare di metodo presente in ogni classe e che viene chiamato dal compilatore ogni volta che crei un nuovo oggetto da una classe.

Dato che il metodo è chiamato durante la costruzione di un oggetto, prende il nome di costruttore. Di default, un costruttore assegna dei valori predefiniti a tutte le sue proprietà.

Per sovrascrivere il costruttore predefinito, devi creare un nuovo metodo in una classe con lo stesso nome della classe.

import java.time.LocalDate;
import java.time.Period;
import java.util.ArrayList;

public class Utente {
    public String nome;
    public LocalDate dataDiNascita;
    public ArrayList<Libro> libriPresiInPrestito = new ArrayList<Libro>();

    Utente (String nome, String dataDiNascita) {
        this.nome = nome;
        this.dataDiNascita = LocalDate.parse(dataDiNascita);
    }

    int eta() {
        return Period.between(this.dataDiNascita, LocalDate.now()).getYears();
    }

    void prestito(Libro libro) {
        this.libriPresiInPrestito.add(libro);
    }
}

Ora che abbiamo il costruttore, invece di prendere la data da una stringa nel file Main.java, possiamo farlo qui.

Questo perché il formato della data di nascita interessa la classe Utente e la classe Main non ha bisogno di preoccuparsene.

Stesso trattamento per la classe Libro:

import java.util.ArrayList;
import java.util.Arrays;

public class Libro {
    public String titolo;
    public ArrayList<String> autori = new ArrayList<String>();

    Libro(String titolo, String[] autori) {
        this.titolo = titolo;
        this.autori = new ArrayList<String>(Arrays.asList(autori));
    }

    public String toString() {
        return String.format("%s di %s", this.titolo, this.autori.toString());
    }
}

Di nuovo, il tipo della collezione autori non è una preoccupazione della classe Main. Il modo più semplice per lavorare con un gruppo di valori in Java è usare un array.

Quindi, otteniamo i nomi degli autori come un array dalla classe Main e da esso creiamo un ArrayList nella classe Libro.

Ora dobbiamo passare questi parametri al costruttore quando creiamo un nuovo oggetto utente o libro nel file Main.java.

import java.util.ArrayList;

public class Main {
    public static void main (String[] args) {
        Utente utente = new Utente("Farhan", "1996-07-15");

        Libro libro = new Libro("Carmilla", new String[]{"Sheridan Le Fanu"});

        utente.prestito(libro);

        System.out.printf("%s ha preso in prestito questi libri: %s", utente.nome, utente.libriPresiInPrestito.toString()); // Farhan ha preso in prestito questi libri: [Carmilla, Hard West]
    }
}

Guarda come sembra già tutto più pulito, e presto sarà ancora meglio.

Cosa sono i modificatori di accesso in Java?

Hai già visto più volte la parola chiave public. Si tratta di uno dei modificatori di accesso di Java.

Esistono quattro modificatori di accesso in Java:

Per ora, parleremo dei modificatori di accesso default, public e private. protected sarà discusso in una sezione successiva.

Hai già imparato cosa sono le classi. I pacchetti sono collezioni di più classi separate secondo le loro funzionalità.

Ad esempio, se stai creando un gioco, puoi mettere tutte le classi relative alla fisica in un pacchetto e quelle relative alla grafica in un altro pacchetto.

I pacchetti vanno oltre lo scopo di questo manuale, ma man mano che continui a lavorare su progetti più grandi ci prenderai la mano.

Il modificatore di accesso public è abbastanza autoesplicativo. Variabili, metodi o classi public sono accessibili da ogni altra classe o pacchetto nel tuo progetto.

Quelli private, d'altro canto, sono disponibili soltanto nella loro classe.

Prendiamo come esempio la classe Utente. Il nome e la data di nascita di un utente non dovrebbero essere accessibili dall'esterno.

import java.time.LocalDate;
import java.time.Period;
import java.util.ArrayList;

public class Utente {
    private String nome;
    private LocalDate dataDiNascita;
    private ArrayList<Libro> libriPresiInPrestito = new ArrayList<Libro>();

    Utente (String nome, String dataDiNascita) {
        this.nome = nome;
        this.dataDiNascita = LocalDate.parse(dataDiNascita);
    }

    int eta() {
        return Period.between(this.dataDiNascita, LocalDate.now()).getYears();
    }

    void prestito(Libro libro) {
        this.libriPresiInPrestito.add(libro);
    }
}

Così va meglio. Aggiorniamo anche la classe Libro per rendere le informazioni relative a titolo e autore nascoste dall'esterno.

import java.util.ArrayList;
import java.util.Arrays;

public class Libro {
    private String titolo;
    private ArrayList<String> autori = new ArrayList<String>();

    Libro(String titolo, String[] autori) {
        this.titolo = titolo;
        this.autori = new ArrayList<String>(Arrays.asList(autori));
    }

    public String toString() {
        return String.format("%s di %s", this.titolo, this.autori.toString());
    }
}

Visto che le proprietà ora sono private, la riga System.out.println() nel file Main.java fallirà nell'accedervi direttamente e otterremo un errore.

La soluzione a questo problema è scrivere metodi pubblici che le altre classi possono usare per accedere a queste proprietà.

Cosa sono i metodi getter e setter in Java?

Getter e setter sono metodi pubblici usati per leggere e scrivere delle proprietà private.

import java.time.LocalDate;
import java.time.Period;
import java.util.ArrayList;
import java.util.Arrays;

public class Utente {
    private String nome;
    private LocalDate dataDiNascita;
    private ArrayList<Libro> libriPresiInPrestito = new ArrayList<Libro>();

    public String getNome() {
        return this.nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

    public String getLibriPresiInPrestito() {
        return this.libriPresiInPrestito.toString();
    }

    Utente (String nome, String dataDiNascita) {
        this.nome = nome;
        this.dataDiNascita = LocalDate.parse(dataDiNascita);
    }

    int eta() {
        return Period.between(this.dataDiNascita, LocalDate.now()).getYears();
    }

    void prestito(Libro libro) {
        this.libriPresiInPrestito.add(libro);
    }
}

I metodi getNome() e getLibriPresiInPrestito() sono responsabili di restituire il valore delle variabili nome e libriPresiInPrestito.

Non accediamo mai alla varabile dataDiNascita al di fuori dal metodo eta(), quindi un getter non è necessario.

Dato che il tipo della variabile libriPresiInPrestito non riguarda la classe Main, il getter ci assicura di restituire il valore nel formato appropriato.

Adesso aggiorniamo il codice nel file Main.java in modo che usi questi metodi:

public class Main {
    public static void main (String[] args) {
        Utente utente = new Utente("Farhan", "1996-07-15");

        Libro libro = new Libro("Carmilla", new String[]{"Sheridan Le Fanu"});

        utente.prestito(libro);

        System.out.printf("%s ha preso in prestito questi libri: %s", utente.getNome(), utente.getLibriPresiInPrestito());
    }
}

Ottimo. Ora il codice è addirittura più pulito e facile da leggere. Analogamente ai getter, i setter vengono usati per scrivere i valori di proprietà private.

Ad esempio, potresti desiderare di permettere all'utente di cambiare la sua data di nascita. Il metodo prestito() funziona già come un setter per l'ArrayList libriPresiInPrestito.

import java.time.LocalDate;
import java.time.Period;
import java.util.ArrayList;
import java.util.Arrays;

public class Utente {
    private String nome;
    private LocalDate dataDiNascita;
    private ArrayList<Libro> libriPresiInPrestito = new ArrayList<Libro>();

    public String getNome() {
        return this.nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

    public void setDataDiNascita(String dataDiNascita) {
        this.dataDiNascita = LocalDate.parse(dataDiNascita);
    }
    
    public String getLibriPresiInPrestito() {
        return this.libriPresiInPrestito.toString();
    }

    Utente (String nome, String dataDiNascita) {
        this.nome = nome;
        this.dataDiNascita = LocalDate.parse(dataDiNascita);
    }

    int eta() {
        return Period.between(this.dataDiNascita, LocalDate.now()).getYears();
    }

    void prestito(Libro libro) {
        this.libriPresiInPrestito.add(libro);
    }
}

Ora possiamo chiamare il metodo setNome() con qualsiasi nome vogliamo impostare all'utente. Analogamente, possiamo usare setDataDiNascita() per impostare la data di nascita.

Implementiamo dei getter e dei setter anche nella classe Libro.

import java.util.ArrayList;
import java.util.Arrays;

public class Libro {
    private String titolo;
    private ArrayList<String> autori = new ArrayList<String>();

    public String getTitolo() {
        return this.titolo;
    }

    public void setTitolo(String titolo) {
        this.titolo = titolo;
    }

    public String getAutori() {
        return this.autori.toString();
    }

    public void setAutori(String[] autori) {
        this.autori = new ArrayList<String>(Arrays.asList(autori));
    }
    
    Libro(String titolo, String[] autori) {
        this.titolo = titolo;
        this.autori = new ArrayList<String>(Arrays.asList(autori));
    }

    public String toString() {
        return String.format("%s di %s", this.titolo, this.autori.toString());
    }
}

Ora non puoi accedere direttamente a queste proprietà, ma devi utilizzare i getter e setter appropriati.

Cos'è l'ereditarietà in Java?

L'ereditarietà è un'altra importante caratteristica della programmazione orientata agli oggetti. Immagina di avere tre tipi di libri. Quelli normali, gli e-book e gli audiolibri.

Anche se hanno delle somiglianze, visto che hanno un titolo e un autore, hanno anche alcune differenze. Ad esempio, i libri normali e gli e-book hanno delle pagine mentre gli audiolibri hanno un tempo di esecuzione. Gli e-book possono essere in formato PDF e EPUB.

Quindi usare la stessa classe per tutti e tre non è un'opzione, ma questo non vuol dire che dobbiamo creare tre classi separate con piccole differenze. Possiamo creare classi separate per e-book e audiolibri e far ereditare loro le proprietà e i metodi della classe Libro.

Iniziamo aggiungendo il numero delle pagine alla classe Libro:

import java.util.ArrayList;
import java.util.Arrays;

public class Libro {
    private String titolo;
    private int pagine;
    private ArrayList<String> autori = new ArrayList<String>();

    Libro(String titolo, int pagine, String[] autori) {
        this.titolo = titolo;
        this.pagine = pagine;
        this.autori = new ArrayList<String>(Arrays.asList(autori));
    }

    public String length() {
        return String.format("%s ha %d pagine.", this.titolo, this.pagine);
    }

    public String toString() {
        return String.format("%s di %s", this.titolo, this.autori.toString());
    }
}

Visto che non useremo getter e setter in questi esempi, mi è sembrata una buona idea fare un po' di pulizia. Il metodo length() restituisce la lunghezza del libro come una stringa.

Ora creiamo una nuova classe Java chiamata AudioLibro con il seguente codice:

public class AudioLibro extends Libro{
    private int durata;

    AudioLibro(String titolo, String[] autori, int durata) {
        super(titolo, 0, autori);

        this.durata = durata;
    }
}

La parola chiave extends fa sapere al compilatore che questa classe è una sottoclasse della classe Libro. Ciò significa che questa classe eredita tutte le proprietà e i metodi della classe genitore.

All'interno del metodo costruttore AudioLibro, impostiamo la durata dell'audiolibro – ma occorre anche chiamare manualmente il costruttore della classe genitore.

La parola chiave super in Java fa riferimento alla classe genitore, quindi super(titolo, 0, autori) chiama essenzialmente il metodo costruttore genitore con i parametri necessari.

Visto che gli audiolibri non hanno pagine, impostare il numero di pagine a zero può essere una buona soluzione.

Oppure possiamo creare una versione di overload del metodo costruttore Libro che non richiede il numero di pagine.

Come prossimo passo, creiamo un'altra classe Java chiamata Ebook con il seguente codice:

public class Ebook extends Libro{
    private String formato;

    Ebook(String titolo, int pagine, String[] autori, String formato) {
        super(titolo, pagine, autori);

        this.formato = formato;
    }
}

Questa classe è praticamente identica alla classe Libro eccetto per il fatto che possiede una proprietà formato.

public class Main {
    public static void main (String[] args) {
        Libro libro = new Libro("Carmilla", 200, new String[]{"Sheridan Le Fanu"});
        Ebook ebook = new Ebook("Frankenstein", 220, new String[]{"Mary Shelley"}, "EPUB");
        AudioLibro audioLibro = new AudioLibro("Dracula", new String[]{"Bram Stoker"}, 160);

        System.out.println(libro.toString()); // Carmilla di [Sheridan Le Fanu]
        System.out.println(ebook.toString()); // Frankenstein di [Mary Shelley]
        System.out.println(audioLibro.toString()); // Dracula di [Bram Stoker]
    }
}

Per ora va tutto bene. Ma ricordi il metodo length() che abbiamo scritto nella classe Libro? Funzionerà per i libri ma non per gli e-book.

Questo perché la proprietà pagine è private e nessuna altra classe eccetto Libro può accedervi. Anche il titolo è una proprietà private.

Apriamo il file Book.java e segniamo le proprietà titolo e pagine come protected.

import java.util.ArrayList;
import java.util.Arrays;

public class Libro {
    protected String titolo;
    protected int pagine;
    private ArrayList<String> autori = new ArrayList<String>();

    Libro(String titolo, int pagine, String[] autori) {
        this.titolo = titolo;
        this.pagine = pagine;
        this.autori = new ArrayList<String>(Arrays.asList(autori));
    }

    public String length() {
        return String.format("%s ha %d pagine.", this.titolo, this.pagine);
    }

    public String toString() {
        return String.format("%s di %s", this.titolo, this.autori.toString());
    }
}

In questo modo saranno accessibili dalle sottoclassi. Gli audiolibri hanno un altro problema con il metodo length().

Gli audiolibri non hanno pagine, ma hanno una durata e questa differenza non farà funzionare il metodo length().

Un modo per risolvere questo problema è sovrascrivere il metodo.

Come sovrascrivere un metodo in Java

Come suggerisce il nome, sovrascrivere vuol dire cancellare gli effetti di un metodo sostituendolo con qualcos'altro.

public class AudioLibro extends Libro{
    private int durata;

    AudioLibro(String titolo, String[] autori, int durata) {
        super(titolo, 0, autori);

        this.durata = durata;
    }
    
    @Override
    public String length() {
        return String.format("%s dura %d minuti.", this.titolo, this.durata);
    }
}

Sovrascriviamo un metodo della classe genitore riscrivendolo nella sottoclasse. La parola chiave @Override è un'annotazione. In Java, le annotazioni sono metadati.

Non è obbligatorio annotare il metodo in questo modo, ma se lo fai il compilatore saprà che il metodo annotato sovrascrive un metodo genitore e farà in modo che vengano seguite tutte le regole di sovrascrittura.

Ad esempio, se fai un errore nel nome del metodo, così che non corrisponda più a nessun metodo del genitore, il compilatore ti farà sapere che il metodo non sta sovrascrivendo nulla.

public class Main {
    public static void main (String[] args) {
        AudioLibro audioLibro = new AudioLibro("Dracula", new String[]{"Bram Stoker"}, 160);

        System.out.println(audioLibro.length()); // Dracula dura 160 minuti.
    }
}

Fantastico, non è vero? Ogni volta che sovrascrivi un metodo in Java, tieni a mente che sia il metodo originale che quello che lo sovrascrive devono avere lo stesso tipo di valore di ritorno, stesso nome e stessi parametri.

Conclusione

Ti ringrazio di cuore per aver speso il tuo tempo leggendo questo manuale. Spero che tu ti sia divertito e che tu abbia imparato i concetti fondamentali di Java.

Questo manuale non è congelato nel tempo. Continuerò a lavorarci su e aggiornarlo con miglioramenti, nuovi contenuti e altro. Puoi darmi opinioni e suggerimenti sul manuale in forma anonima con questo form.

Oltre a questo, ho scritto altri manuali completi su altri argomenti complicati che sono disponibili gratuitamente su freeCodeCamp.

Questi manuali sono parte della mia missione di semplificare per tutti l'apprendimento di tecnologie difficili da comprendere. La stesura di ognuno di questi manuali richiede molto tempo e impegno.

Se ti è piaciuto leggere questo manuale e vuoi motivarmi, considera di lasciarmi delle stelle su GitHub e sostienimi per le mie competenze su LinkedIn.

Sono sempre aperto a suggerimenti e discussioni su Twitter o LinkedIn. Contattami con un messaggio privato.

Infine, considera di condividere queste risorse con altri, perché:

Nell'open source, sentiamo fortemente che per fare ben qualcosa, devi coinvolgere tante persone. — Linus Torvalds

Buono studio, ci vediamo alla prossima.

In questo articolo, ti mostrerò come utilizzare il metodo Arrays.binarySearch() in Java.

Cos'è Arrays.binarySearch() in Java?

Secondo la documentazione ufficiale sul metodo Arrays.binarySearch():

Ricerca nell'array di byte specificato il valore indicato usando l'algoritmo di ricerca binaria.

L'array deve essere ordinato (ad esempio con il metodo sort(byte[])) prima della chiamata. Se non è ordinato, il risultato non è definito.

Se l'array contiene più elementi con il valore specificato, non è garantito quale di essi sarà trovato.

In parole povere, il metodo Arrays.binarySearch() può cercare un dato elemento in un array ordinato e restituire il suo indice se la ricerca ha successo.

import java.util.Arrays;

public class Main {

	public static void main(String[] args) {
		char vocali[] = {'a', 'e', 'i', 'o', 'u'};
		
		char chiave = 'i';
		
		int trovaIndiceElemento = Arrays.binarySearch(vocali, chiave);
		
		System.out.println("La vocale indicata ha indice: " + trovaIndiceElemento);

	}
}

Il metodo Arrays.binarySearch() prende come primo argomento l'array su cui effettuare la ricerca e la chiave di ricerca come secondo argomento. L'output di questo programma sarà:

La vocale indicata ha indice: 2

Ricorda, il metodo restituisce l'indice dell'elemento trovato e non l'elemento stesso. Quindi puoi conservare l'indice in un intero come quello usato in questo esempio.

Come impostazione predefinita, il metodo usa il primo indice dell'array come punto di partenza della ricerca e la lunghezza dell'array come termine. Quindi in questo caso l'indice di partenza è 0 e quello di fine è 6.

Invece di usare gli indici predefiniti, puoi definirli tu stesso. Ad esempio, se vuoi svolgere la ricerca dall'indice 2 all'indice 4, puoi farlo in questo modo:

import java.util.Arrays;

public class Main {

	public static void main(String[] args) {
		char vocali[] = {'a', 'e', 'i', 'o', 'u'};
		
		char chiave = 'i';
		int indicePartenza = 2;
		int indiceFine = 4;
		
		int trovaIndiceElemento = Arrays.binarySearch(vocali, indicePartenza, indiceFine, chiave);
		
		System.out.println("La vocale indicata ha indice: " + trovaIndiceElemento);

	}
}

In questo caso, il metodo Arrays.binarySearch() prende l'array su cui vuoi effettuare la ricerca come primo argomento, l'indice di partenza come secondo argomento, l'indice finale come terzo argomento e la chiave di ricerca come quarto argomento.

Finché mantieni l'indice finale entro la lunghezza dell'array, il metodo dovrebbe funzionare senza problemi. Se usi un indice maggiore, otterrai l'eccezione Array index out of range.

Semplice, vero? Il metodo restituisce l'indice dell'elemento, se questo viene trovato. Ma cosa succede se non trova l'elemento indicato?

Cosa succede quando Arrays.binarySearch() non trova l'elemento dato?

Ancora, secondo la documentazione ufficiale sul metodo Arrays.binarySearch():

Il metodo restituisce l'indice della chiave di ricerca, se contenuto nell'array all'interno dell'intervallo specificato; altrimenti (-(insertion point) - 1).

"Insertion point" è definito come il punto in cui la chiave dovrebbe essere inserita nell'array: l'indice del primo elemento nell'intervallo maggiore della chiave, o toIndex (indice finale) se tutti gli elementi nell'intervallo sono minori della chiave specificata.

Nota che questo garantisce che il valore di ritorno sarà >= 0 se e solo se la chiave è trovata.

Non molto chiaro, vero? Provo a spiegare. La prima riga afferma che il metodo restituisce l'indice della chiave di ricerca se la chiave viene trovata nell'array.

Se non viene trovata, l'output sarà uguale al valore di (-(insertion point) - 1). Qui, in base alla chiave di ricerca, insertion point può avere diversi valori.

Ipotizziamo di avere l'array [5, 6, 7, 8, 9, 10] e la chiave di ricerca 0, che è chiaramente non presente nell'array. In questo caso, la chiave di ricerca è minore di tutti gli elementi dell'array. Ma il primo elemento maggiore della chiave di ricerca è 5, quindi in questo caso il valore di insertion point sarà:

(-(indice del primo elemento maggiore della chiave) - 1) = (0 - 1) = -1

Possiamo verificarlo nello snippet di codice seguente:

package arrays;

import java.util.Arrays;

public class Main {

	public static void main(String[] args) {		
		int numeri[] = {5, 6, 7, 8, 9, 10};
		
		System.out.println(Arrays.binarySearch(numeri, 0)); // -1
	}
}

Di nuovo, ipotizziamo di avere l'array [5, 6, 7, 8, 9, 10] e la chiave di ricerca 12, chiaramente non presente nell'array. In questo caso, la chiave di ricerca è maggiore di tutti gli elementi dell'array e il valore di insertion point sarà:

(-(l'indice finale (-(6) - 1) = (-6 - 1) = -7

Ricorda, quando non definisci manualmente un indice finale, il metodo usa la lunghezza dell'array come indice finale, che in questo caso è 6.

Possiamo verificarlo nello snippet di codice seguente:

import java.util.Arrays;

public class Main {

	public static void main(String[] args) {		
		int numeri[] = {5, 6, 7, 8, 9, 10};
		
		System.out.println(Arrays.binarySearch(numeri, 12)); // -7
	}
}

Tuttavia, i risultati cambieranno se definisci gli indici di partenza e di fine manualmente, in questo modo:

import java.util.Arrays;

public class Main {

	public static void main(String[] args) {
		int numeri[] = {5, 6, 7, 8, 9, 10};
		
		int indicePartenza = 1;
		int indiceFine = 3;
		
		System.out.println(Arrays.binarySearch(numeri, indicePartenza, indiceFine, 5)); // -2
		System.out.println(Arrays.binarySearch(numeri, indicePartenza, indiceFine, 10)); // -4

	}
}

Prova tu stesso a calcolare i valori. Puoi anche usare il metodo Arrays.binarySearch() con dei caratteri, in questo modo:

import java.util.Arrays;

public class Main {

	public static void main(String[] args) {
		char vocali[] = {'a', 'e', 'i', 'o', 'u'};
		
		char chiave = 'i';
		int indicePartenza = 2;
		int indiceFine = 4;
		
		System.out.println(Arrays.binarySearch(vocali, indicePartenza, indiceFine, chiave));

	}
}

Lo stesso principio si applica in questo caso, quando la chiave di ricerca fornita non viene trovata. Ma per il confronto di un carattere nell'array e una data chiave di ricerca, sarà utilizzato il codice ASCII corrispondente al carattere. Quindi A (65) sarà minore di a (97). Tienilo a mente quando controlli gli output del tuo programma.

In conclusione

Questo era praticamente tutto per questo metodo. Spero che adesso tu sia in grado di capire come funziona Arrays.binarySearch().

Buona programmazione!

I getter e i setter vengono usati per proteggere dati, in particolar modo quando si creano delle classi.

Per ogni variabile di istanza, un metodo getter restituisce il suo valore, mentre un metodo setter ne imposta o ne aggiorna il valore. Per questo motivo, getter e setter sono anche conosciuti rispettivamente come accessor e mutator.

Per convenzione, i getter iniziano con la parola "get" e i setter iniziano con la parola "set", seguita dal nome della variabile. In entrambi i casi la prima lettera del nome della variabile è maiuscola:

public class Vehicle {
  private String color;
  
  // Getter
  public String getColor() {
    return color;
  }
  
  // Setter
  public void setColor(String c) {
    this.color = c;
  }
}

Il metodo getter restituisce il valore dell'attributo. Il metodo setter prende un parametro e lo assegna all'attributo.

Una volta che il getter e il setter sono stati definiti, li possiamo usare nel main:

public static void main(String[] args) {
  Vehicle v1 = new Vehicle();
  v1.setColor("Red");
  System.out.println(v1.getColor());
}

// l'output è "Red"

Getter e setter permettono di avere controllo su dei valori. Potresti anche validare il valore dato nel setter prima di impostarlo effettivamente.

Perché usare getter e setter?

Getter e setter ti permettono di controllare il modo in cui le variabili nel tuo codice sono consultate e aggiornate. Ad esempio, considera questo metodo setter:

public void setNumber(int number) {
  if (number < 1 || number > 10) {
    throw new IllegalArgumentException();
  }
  this.number = num;
}

Usando il metodo setNumber, puoi essere sicuro che il valore di number sia sempre tra 1 e 10. Molto più conveniente rispetto ad aggiornare direttamente la variabile number:

obj.number = 13;

Se aggiorni direttamente number, è possibile che si verifichino dei possibili effetti indesiderati da qualche parte nel codice. In quest'esempio, impostare number su 13 viola il vincolo che volevamo stabilire, per cui il suo valore deve essere compreso tra 1 e 10.

Rendere number una variabile privata e usare il metodo setNumber impedisce che questo accada.

D'altra parte, l'unico modo per leggere il valore di number è l'uso di un metodo getter:

public int getNumber() {
  return this.number;
}

Il cifrario di Cesare è una famosa attuazione della crittografia risalente ai suoi primordi. Prende una frase e la riorganizza, basandosi su una chiave che viene adoperata sull'alfabeto. Ad esempio, considera la chiave 3 e la frase

Mi piace indossare i cappelli.

Quando la frase viene codificata usando la chiave 3, diventa:

Pl sldfh lqgrvvduh l fdsshool.

In questo modo, è difficile leggere il messaggio, che può passare inosservato.

Mentre questo è un esempio di codifica m0lto semplice, è un progetto perfetto su cui far pratica per chi sta imparando a programmare.

Comprendere il cifrario

Per implementare questo codice, almeno in Java, avrai bisogno di riflettere a fondo su ciò che è stato fatto. Quindi, vediamo quali sono i passaggi fondamentali da considerare per questo codice.

Step 1: identifica il carattere nella frase.

Step 2: trova la posizione del carattere nell'alfabeto.

Step 3: identifica la somma di posizione del carattere + posizione della chiave nell'alfabeto.

Note* se la posizione del carattere + chiave > 26, torna indietro e ricomincia a contare da 1.

Step 4: costruisci una nuova frase usando i nuovi caratteri al posto di quelli originali.

Step 5: ripeti fino a raggiungere la lunghezza della frase (loop for).

Step 6: restituisci il risultato.

Codificare il cifrario

Questi sono dei buoni step da seguire, ma dovremmo pensare a cosa ci serve fare in termini di codice.

Step 0: crea una funzione che accetta un messaggio e una chiave.

Qualcosa del genere:

public String Encrypt(String message, int key) {

}

Step 1: identifica il carattere nella frase.

Per farlo, avremo bisogno di stabilire un alfabeto a cui fare riferimento.

Crea una variabile alphabet che contiene le 26 lettere dell'alfabeto.

String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
String alphabet2 = alphabet.toLowerCase();

Step 2: trova la posizione del carattere nell'alfabeto.

Poi crea un loop for che itera su ogni carattere del messaggio. Sarà più semplice svolgere quest'operazione se creiamo uno StringBuilder.

StringBuilder encrypted = new StringBuilder(message);
for (int q = 0; q < encrypted.length(); q++) {
    char currchar = encrypted.charAt(q);
    int index = alphabet.indexOf(currchar);
}

A questo punto, dovremmo assicurarci che la posizione corrisponda a una lettera.

if (index != -1) {}

Step 3:  identifica la somma di posizione del carattere + posizione della chiave nell'alfabeto.

Se è una lettera, allora dobbiamo trovare la posizione nell'alfabeto modificato, Non abbiamo ancora creato una variabile per l'alfabeto modificato, quindi dovremmo farlo adesso.

Step 4: costruisci una nuova frase usando i nuovi caratteri al posto di quelli originali.

Una volta trovato il valore nell'alfabeto modificato, dovremmo impostarlo sulla stessa posizione nello StringBuilder che abbiamo creato.

public String Encryption(String input, int key) {
        StringBuilder encrypted = new StringBuilder(input);
        String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        String alphabet2 = alphabet.toLowerCase();
        String keyedalphabet = alphabet.substring(key) + alphabet.substring(0, key);
        for (int q = 0; q < encrypted.length(); q++) {
            char currChar = encrypted.charAt(q);
            int index = alphabet.indexOf(currChar);
            if (index != -1) {
                char newChar = keyedalphabet.charAt(index);
                encrypted.setCharAt(q, newChar);
            }

Step 5: ripeti fino a raggiungere la lunghezza della frase (loop for).

Ora, abbiamo controllato se il carattere è maiuscolo, ma dobbiamo controllare anche se è minuscolo. Per farlo, dobbiamo accedere a alphabet2 che abbiamo creato precedentemente.

index = alphabet2.indexOf(currChar);
if (index != -1) {
    String keyedalphabet2 = keyedalphabet.toLowerCase();
    char newChar = keyedalphabet2.charAt(index);
    encrypted.setCharAt(q, newChar);
}

Step 6: restituisci il risultato.

Una volta completato il loop for, tutto ciò che ci resta da fare è restituire la stringa.

public String Encryption(String input, int key) {
    StringBuilder encrypted = new StringBuilder(input);
    String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    String alphabet2 = alphabet.toLowerCase();
    String keyedalphabet = alphabet.substring(key) + alphabet.Asubstring(0, key);
    for (int q = 0; q < encrypted.length(); q++) {
        char currChar = encrypted.charAt(q);
        int index = alphabet.indexOf(currChar);
        if (index != -1) {
            char newChar = keyedalphabet.charAt(index);
            encrypted.setCharAt(q, newChar);
        }
        index = alphabet2.indexOf(currChar);
        if (index != -1) {
            String keyedalphabet2 = keyedalphabet.toLowerCase();
            char newChar = keyedalphabet2.charAt(index);
            encrypted.setCharAt(q, newChar);
        }
    }
    return encrypted
}

Step 7: Debug.

Un momento! Così non funzionerà! encrypted non è una stringa, ma uno StringBuilder e questa funzione richiede specificatamente che venga restituita una stringa.

Fortunatamente, esiste una funzione molto semplice per rimediare a  questa svista.

public String Encryption(String input, int key) {
    StringBuilder encrypted = new StringBuilder(input);
    String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    String alphabet2 = alphabet.toLowerCase();
    String keyedalphabet = alphabet.substring(key) + alphabet.substring(0, key);
    for (int q = 0; q < encrypted.length(); q++) {
        char currChar = encrypted.charAt(q);
        int index = alphabet.indexOf(currChar);
        if (index != -1) {
            char newChar = keyedalphabet.charAt(index);
            encrypted.setCharAt(q, newChar);
        }
        index = alphabet2.indexOf(currChar);
        if (index != -1) {
            String keyedalphabet2 = keyedalphabet.toLowerCase();
            char newChar = keyedalphabet2.charAt(index);
            encrypted.setCharAt(q, newChar);
        }
    }
    return encrypted.toString();
}

Ecco come puoi ottenere la versione codificata della tua frase originale. Prova tu stesso!

Grazie per aver letto quest'articolo.

I numeri casuali generati da computer sono divisi in due categorie: numeri casuali veri e numeri pseudo-casuali.

I numeri casuali veri vengono generati sulla base di fattori esterni. Ad esempio, ottenendo la casualità usando i rumori circostanti.

Ma generare numeri casuali veri in questo modo, richiede molto tempo. Quindi, possiamo utilizzare dei numeri pseudo-casuali che vengono generati usando un algoritmo e un valore iniziale.

I numeri pseudo-casuali sono adeguati per la maggior parte degli scopi. Ad esempio, puoi usarli in crittografia, per realizzare giochi con dadi o carte e per creare numeri OTP (one-time password).

In quest'articolo, impareremo come generare numeri pseudo-casuali usando Math.random() in Java.

1. Usare Math.random() per generare interi

Math.random() restituisce un numero pseudo-casuale di tipo double, maggiore di o uguale a zero e minore di uno.

Proviamolo in questo blocco di codice:

    public static void main(String[] args) {
        double randomNumber = Math.random();
        System.out.println(randomNumber);
    }
    // output #1 = 0.5600740702032417
    // output #2 = 0.04906751303932033

randomNumber ti darà numeri casuali diversi a ogni esecuzione.

Diciamo di voler generare numeri casuali in un range specifico, per esempio, da zero a quattro.

    // genera numeri casuali tra 0 e 4
    public static void main(String[] args) {
        // Math.random() genera un numero casuale tra 0.0 e 0.999
        // Quindi, Math.random()*5 è un numero tra 0.0 e 4.999
        double doubleRandomNumber = Math.random() * 5;
        System.out.println("doubleRandomNumber = " + doubleRandomNumber);
        // converti il double in numero intero
        int randomNumber = (int)doubleRandomNumber;
        System.out.println("randomNumber = " + randomNumber);
    }
    /* Output #1
    doubleRandomNumber = 2.431392914284627
    randomNumber = 2
    */

Quando convertiamo un double a int, il valore int mantiene soltanto la parte intera del numero.

Ad esempio, nel codice qui sopra, doubleRandomNumber è 2.431392914284627. La parte intera di doubleRandomNumber è 2 e la parte decimale (i numeri dopo il punto) è 431392914284627. Quindi, randomNumber manterrà soltanto la parte intera del numero 2.

Puoi leggere di più sul metodo Math.random() nella documentazione Java.

Usare Math.random() non è l'unico modo per generare numeri casuali in Java. Adesso, considereremo come generare numeri casuali usando la classe Random.

2. Usare la classe Random per generare interi

Nella classe Random, abbiamo molte metodi d'istanza che forniscono numeri casuali. In questa sezione, vedremo due metodi d'istanza: nextInt(int bound) e nextDouble().

Come usare il metodo nextInt(int bound)

nextInt(int bound) restituisce un numero pseudo-casuale di tipo int, maggiore di o uguale a zero e minore del valore bound.

Il parametro bound specifica il range. Ad esempio, se specifichiamo il bound come 4, nextInt(4) restituirà un valore di tipo int, maggiore o uguale a zero e minore di quattro. 0,1,2,3 sono i possibili risultati di nextInt(4) .

Dato che questo è un metodo d'istanza, dovremmo creare un oggetto random per utilizzarlo. Proviamo.

    public static void main(String[] args) {
        // crea oggetto Random
        Random random = new Random();
        // genera numero casuale tra 0 e 3
        int number = random.nextInt(4);
        System.out.println(number);
    }

Come usare il metodo nextDouble()

Analogamente a Math.random(), nextDouble() restituisce un numero pseudo-casuale di tipo double, maggiore di o uguale a zero e minore di uno.

    public static void main(String[] args) {
        // crea oggetto Random
        Random random = new Random();
        // genera numero random maggiore o uguale a 0.0 e minore di 1.0
        double number = random.nextDouble();
        System.out.println(number);
    }

Per altre informazioni, puoi leggere la documentazione Java.

Quale metodo scegliere?

Math.random() utilizza la classe random. Se nella nostra applicazione vogliamo solo numeri pseudo-casuali di tipo double, allora possiamo usare Math.random().

Altrimenti, possiamo usare la classe random dato che offre svariati metodi per generare numeri pseudo-casuali in tipi diversi come nextInt(), nextLong(), nextFloat() e nextDouble().

Grazie per aver letto quest'articolo.

Photo image by Brett Jordan on Unsplash

Buona programmazione!

Gli oggetti stringa sono rappresentati come stringhe di caratteri.

Se hai lavorato in Java Swing, sai che ha componenti come JTextField e JTextArea che usiamo per ottenere i nostri input dall'interfaccia grafica. Inoltre, prende il nostro input come una stringa.

Se vogliamo fare una semplice calcolatrice usando Swing, dobbiamo scoprire come convertire una stringa in un numero intero. Questo ci porta alla domanda, come facciamo a convertire una stringa in un numero intero?

In Java, possiamo usare Integer.valueOf() e Integer.parseInt() per convertire una stringa in un numero intero.

1. Usare Integer.parseInt() per convertire una stringa in un numero intero

Questo metodo restituisce la stringa come un tipo primitivo int. Se la stringa non contiene un numero intero valido allora dà una eccezione NumberFormatException.

Quindi, ogni volta che convertiamo una stringa in un numero intero, dobbiamo gestire questa eccezione mettendo il codice dentro un blocco try-catch.

Consideriamo un esempio di conversione da una stringa ad un numero intero usando Integer.parseInt():

        String str = "25";
        try{
            int number = Integer.parseInt(str);
            System.out.println(number); // output = 25
        }
        catch (NumberFormatException ex){
            ex.printStackTrace();
        }

Cerchiamo di rompere questo codice scrivendo un numero intero non valido:

     	String str = "25T";
        try{
            int number = Integer.parseInt(str);
            System.out.println(number);
        }
        catch (NumberFormatException ex){
            ex.printStackTrace();
        }

Come puoi vedere nel codice sopra, abbiamo provato a convertire 25T in un numero intero. Questo non è un input valido, quindi dà un errore NumberFormatException.

Ecco l'output del codice sopra:

java.lang.NumberFormatException: For input string: "25T"
	at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
	at java.lang.Integer.parseInt(Integer.java:580)
	at java.lang.Integer.parseInt(Integer.java:615)
	at OOP.StringTest.main(StringTest.java:51)

Come passo successivo, consideriamo come convertire una stringa in un numero intero, usando il metodo Integer.valueOf() method.

2. Usare Integer.valueOf() per convertire una stringa in un numero intero

Questo metodo restituisce la stringa come oggetto numero intero. Se guardi sulla documentazione di Java, Integer.valueOf() restituisce un oggetto numero intero che è equivalente a new Integer(Integer.parseInt(s)).

Metteremo il nostro codice in un blocco try-catch quando usiamo questo metodo. Consideriamo un esempio usando il metodo Integer.valueOf():

        String str = "25";
        try{
            Integer number = Integer.valueOf(str);
            System.out.println(number); // output = 25
        }
        catch (NumberFormatException ex){
            ex.printStackTrace();
        }

Ora, proviamo a romperlo inserendo un numero intero non valido:

        String str = "25TA";
        try{
            Integer number = Integer.valueOf(str);
            System.out.println(number); 
        }
        catch (NumberFormatException ex){
            ex.printStackTrace();
        }

Come l'esempio precedente, il codice sopra darà un errore.

Ecco l'output del codice sopra:

java.lang.NumberFormatException: For input string: "25TA"
	at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
	at java.lang.Integer.parseInt(Integer.java:580)
	at java.lang.Integer.valueOf(Integer.java:766)
	at OOP.StringTest.main(StringTest.java:42)

Prima di usare il metodo sopra menzionato, possiamo anche creare un metodo per controllare se la stringa input è numerica o meno.

Ho creato un semplice metodo per controllare se la stringa inserita è numerica o no:

public class StringTest {
    public static void main(String[] args) {
        String str = "25";
        String str1 = "25.06";
        System.out.println(isNumeric(str));
        System.out.println(isNumeric(str1));
    }

    private static boolean isNumeric(String str){
        return str != null && str.matches("[0-9.]+");
    }
}

L'output è:

true
true

Il metodo isNumeric() prende una stringa come argomento. Prima controlla se è null o meno. Poi usa il metodo matches() per vedere se contiene le cifre da 0 a 9 e il carattere punto.

Questo è un semplice modo per controllare se è un valore numerico. Puoi scrivere tu stesso o cercare su Google espressioni regolari più complesse a seconda del tuo caso di utilizzo.

È buona pratica controllare se la stringa input è numerica o no prima di provare a trasformarla in un numero intero.

Grazie per aver letto quest'articolo.

Immagine di 🇸🇮 Janko Ferlič su Unsplash

Buona programmazione!