06 - API Core di Java: String, Date e Wrapper

API Core di Java

Java fornisce un ricco set di classi core per le operazioni più comuni. In questo articolo esploreremo le più usate: String, StringBuilder, Wrapper classes e la moderna Date/Time API.

La Classe String

String e una delle classi più usate in Java. Le stringhe sono immutabili: una volta create, non possono essere modificate.

// Modi per creare String
String nome = "Mario Rossi";              // literal (consigliato)
String cognome = new String("Verdi");     // costruttore (sconsigliato)

// String vuota vs null
String vuota = "";           // stringa vuota, lunghezza 0
String nulla = null;         // riferimento nullo, nessun oggetto

// Immutabilita: i metodi restituiscono NUOVE stringhe
String originale = "Java";
String maiuscolo = originale.toUpperCase();
System.out.println(originale);   // "Java" - non modificato!
System.out.println(maiuscolo);   // "JAVA" - nuova stringa

Metodi Principali

String corso = "Programmazione Java";

// Lunghezza
int lunghezza = corso.length();  // 19

// Accesso caratteri
char primo = corso.charAt(0);    // 'P'
char ultimo = corso.charAt(corso.length() - 1);  // 'a'

// Ricerca
int posizione = corso.indexOf("Java");      // 16
int ultima = corso.lastIndexOf("a");        // 18
boolean contiene = corso.contains("Java");  // true
boolean inizia = corso.startsWith("Prog");  // true
boolean finisce = corso.endsWith("Java");   // true

// Confronto
String altro = "programmazione java";
boolean uguale = corso.equals(altro);                // false
boolean ugualeIgnoreCase = corso.equalsIgnoreCase(altro);  // true
int confronto = corso.compareTo(altro);              // negativo (P < p)

// Estrazione
String sub1 = corso.substring(0, 14);    // "Programmazione"
String sub2 = corso.substring(15);       // "Java"

// Trasformazione
String upper = corso.toUpperCase();      // "PROGRAMMAZIONE JAVA"
String lower = corso.toLowerCase();      // "programmazione java"
String trimmed = "  spazi  ".trim();     // "spazi"
String replaced = corso.replace("Java", "Python");  // "Programmazione Python"

Split e Join

// Split: divide la stringa in array
String csv = "Mario,Rossi,25,Milano";
String[] parti = csv.split(",");
// parti = ["Mario", "Rossi", "25", "Milano"]

for (String parte : parti) {
    System.out.println(parte);
}

// Join: unisce array in stringa
String[] materie = {"Java", "Python", "SQL"};
String elenco = String.join(", ", materie);  // "Java, Python, SQL"

// Split con limite
String frase = "uno-due-tre-quattro";
String[] primiDue = frase.split("-", 2);  // ["uno", "due-tre-quattro"]

StringBuilder

StringBuilder è una classe mutabile per costruire stringhe in modo efficiente, specialmente in loop.

// INEFFICIENTE con String (crea molte stringhe intermedie)
String risultato = "";
for (int i = 0; i < 1000; i++) {
    risultato += i + ", ";  // Crea una nuova String ad ogni iterazione!
}

// EFFICIENTE con StringBuilder
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append(i).append(", ");
}
String risultatoEfficiente = sb.toString();

StringBuilder sb = new StringBuilder("Hello");

// Append: aggiunge alla fine
sb.append(" ");
sb.append("World");
sb.append(123);           // "Hello World123"

// Insert: inserisce in posizione
sb.insert(5, ",");        // "Hello, World123"

// Delete: rimuove caratteri
sb.delete(11, 14);        // "Hello, World"

// Replace: sostituisce
sb.replace(0, 5, "Ciao"); // "Ciao, World"

// Reverse: inverte
sb.reverse();             // "dlroW ,oaiC"

// Conversione finale
String finale = sb.toString();

Wrapper Classes

I Wrapper sono classi che "avvolgono" i tipi primitivi, permettendo di usarli come oggetti (es. nelle collezioni).

// Autoboxing: primitivo -> wrapper (automatico)
Integer votoWrapper = 28;     // equivale a: Integer.valueOf(28)
Double media = 27.5;

// Unboxing: wrapper -> primitivo (automatico)
int votoPrimitivo = votoWrapper;  // equivale a: votoWrapper.intValue()
double mediaDouble = media;

// Parsing: String -> numero
int numero = Integer.parseInt("42");
double decimale = Double.parseDouble("3.14");
boolean flag = Boolean.parseBoolean("true");

// Conversione numero -> String
String stringa = Integer.toString(42);
String stringa2 = String.valueOf(42);

// Metodi utili
int max = Integer.MAX_VALUE;       // 2147483647
int min = Integer.MIN_VALUE;       // -2147483648
int confronto = Integer.compare(10, 20);  // negativo

// ATTENZIONE al null!
Integer nullable = null;
// int valore = nullable;  // NullPointerException!

Date and Time API (java.time)

A partire da Java 8, la nuova API java.time sostituisce le problematiche classi Date e Calendar.

LocalDate - Solo Data

import java.time.LocalDate;
import java.time.Month;

// Creazione
LocalDate oggi = LocalDate.now();
LocalDate compleanno = LocalDate.of(2000, 3, 15);
LocalDate conMonth = LocalDate.of(2000, Month.MARCH, 15);
LocalDate parsed = LocalDate.parse("2024-03-15");

// Getter
int anno = oggi.getYear();        // 2025
int mese = oggi.getMonthValue();  // 2
Month month = oggi.getMonth();    // FEBRUARY
int giorno = oggi.getDayOfMonth(); // 1
int giornoAnno = oggi.getDayOfYear(); // 32

// Manipolazione (restituisce nuova istanza)
LocalDate domani = oggi.plusDays(1);
LocalDate traUnMese = oggi.plusMonths(1);
LocalDate annoScorso = oggi.minusYears(1);

// Confronto
boolean prima = compleanno.isBefore(oggi);
boolean dopo = compleanno.isAfter(oggi);
boolean uguale = compleanno.isEqual(oggi);

// Calcolo differenza
long giorni = oggi.until(compleanno).getDays();

LocalTime - Solo Ora

import java.time.LocalTime;

// Creazione
LocalTime adesso = LocalTime.now();
LocalTime lezione = LocalTime.of(9, 30);           // 09:30
LocalTime preciso = LocalTime.of(9, 30, 45);       // 09:30:45
LocalTime parsed = LocalTime.parse("14:30:00");

// Getter
int ora = adesso.getHour();
int minuto = adesso.getMinute();
int secondo = adesso.getSecond();

// Manipolazione
LocalTime traUnOra = adesso.plusHours(1);
LocalTime mezzOraFa = adesso.minusMinutes(30);

// Costanti utili
LocalTime mezzanotte = LocalTime.MIDNIGHT;  // 00:00
LocalTime mezzogiorno = LocalTime.NOON;     // 12:00

LocalDateTime - Data e Ora

import java.time.LocalDateTime;

// Creazione
LocalDateTime oraEsatta = LocalDateTime.now();
LocalDateTime esame = LocalDateTime.of(2025, 2, 15, 9, 0);
LocalDateTime combinato = LocalDateTime.of(
    LocalDate.of(2025, 2, 15),
    LocalTime.of(9, 0)
);

// Estrarre componenti
LocalDate data = oraEsatta.toLocalDate();
LocalTime tempo = oraEsatta.toLocalTime();

// Manipolazione
LocalDateTime prossimo = oraEsatta.plusDays(7).plusHours(2);

// Formattazione
System.out.println(oraEsatta);  // 2025-02-01T11:30:00.123

Formattazione e Parsing

import java.time.format.DateTimeFormatter;
import java.util.Locale;

LocalDateTime dt = LocalDateTime.now();

// Pattern predefiniti
DateTimeFormatter isoDate = DateTimeFormatter.ISO_LOCAL_DATE;
System.out.println(dt.format(isoDate));  // 2025-02-01

// Pattern personalizzati
DateTimeFormatter italiano = DateTimeFormatter.ofPattern("dd/MM/yyyy");
DateTimeFormatter completo = DateTimeFormatter.ofPattern("dd MMMM yyyy, HH:mm", Locale.ITALIAN);
DateTimeFormatter americano = DateTimeFormatter.ofPattern("MM-dd-yyyy hh:mm a", Locale.US);

System.out.println(dt.format(italiano));  // 01/02/2025
System.out.println(dt.format(completo));  // 01 febbraio 2025, 11:30
System.out.println(dt.format(americano)); // 02-01-2025 11:30 AM

// Parsing con formato
String dataStringa = "15/03/2025";
LocalDate dataParsed = LocalDate.parse(dataStringa, italiano);

ZonedDateTime - Fusi Orari

import java.time.ZonedDateTime;
import java.time.ZoneId;

// Ora corrente nel fuso locale
ZonedDateTime quiOra = ZonedDateTime.now();

// Ora in fusi specifici
ZonedDateTime roma = ZonedDateTime.now(ZoneId.of("Europe/Rome"));
ZonedDateTime newYork = ZonedDateTime.now(ZoneId.of("America/New_York"));
ZonedDateTime tokyo = ZonedDateTime.now(ZoneId.of("Asia/Tokyo"));

System.out.println("Roma: " + roma);
System.out.println("New York: " + newYork);
System.out.println("Tokyo: " + tokyo);

// Conversione tra fusi
ZonedDateTime romaOra = ZonedDateTime.now(ZoneId.of("Europe/Rome"));
ZonedDateTime stessaMomentoNY = romaOra.withZoneSameInstant(ZoneId.of("America/New_York"));

// Lista fusi disponibili
Set<String> fusi = ZoneId.getAvailableZoneIds();

Esempio Completo: Gestione Calendario Esami

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.Locale;

public class CalendarioEsami {

    private static final DateTimeFormatter FORMATO_ITALIANO =
        DateTimeFormatter.ofPattern("EEEE d MMMM yyyy", Locale.ITALIAN);

    private static final DateTimeFormatter FORMATO_ORA =
        DateTimeFormatter.ofPattern("HH:mm");

    public static void main(String[] args) {
        // Dati esame
        String corso = "Programmazione Java";
        LocalDate dataEsame = LocalDate.of(2025, Month.FEBRUARY, 15);
        LocalTime oraInizio = LocalTime.of(9, 0);
        LocalTime oraFine = LocalTime.of(12, 0);

        // Calcolo giorni mancanti
        LocalDate oggi = LocalDate.now();
        Period differenza = Period.between(oggi, dataEsame);
        long giorniMancanti = oggi.until(dataEsame).getDays();

        // Stampa informazioni
        StringBuilder sb = new StringBuilder();
        sb.append("╔════════════════════════════════════════╗\n");
        sb.append("║         PROSSIMO ESAME                 ║\n");
        sb.append("╠════════════════════════════════════════╣\n");
        sb.append(String.format("║ Corso: %-31s ║%n", corso));
        sb.append(String.format("║ Data:  %-31s ║%n",
            dataEsame.format(FORMATO_ITALIANO)));
        sb.append(String.format("║ Ora:   %s - %s                     ║%n",
            oraInizio.format(FORMATO_ORA),
            oraFine.format(FORMATO_ORA)));
        sb.append("╠════════════════════════════════════════╣\n");

        if (giorniMancanti > 0) {
            sb.append(String.format("║ Mancano: %d giorni                     ║%n", giorniMancanti));
        } else if (giorniMancanti == 0) {
            sb.append("║ L'ESAME E OGGI!                        ║\n");
        } else {
            sb.append("║ Esame già sostenuto                    ║\n");
        }

        sb.append("╚════════════════════════════════════════╝");

        System.out.println(sb.toString());
    }
}

Conclusione

In questo articolo abbiamo esplorato le API core di Java: String e StringBuilder per la manipolazione del testo, i Wrapper per i tipi primitivi, e la moderna Date/Time API per la gestione di date e orari.

Nel prossimo articolo vedremo il Collections Framework: List, Set, Map e le diverse implementazioni.