Java Academy · Lezione

Pattern annidati per record

Corrispondere dati profondamente annidati

Pattern annidati per record è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Pattern di record annidati

I pattern di record possono essere annidati: un componente che è a sua volta un record può essere destrutturato all'interno del pattern esterno. In questo modo è possibile gestire dati profondamente strutturati con un'unica espressione.

Un modello di dati annidato

Si consideri un Line composto da due record Point. I record interni sono candidati naturali all'annidamento.

public class Main {
    record Point(int x, int y) {}
    record Line(Point start, Point end) {}

    public static void main(String[] args) {
        Line line = new Line(new Point(0, 0), new Point(3, 4));
        System.out.println(line);
    }
}

Destrutturazione a un livello

Un pattern semplice associa i due componenti Point, lasciandoli però integri.

public class Main {
    record Point(int x, int y) {}
    record Line(Point start, Point end) {}

    public static void main(String[] args) {
        Object obj = new Line(new Point(0, 0), new Point(3, 4));
        if (obj instanceof Line(Point s, Point e)) {
            System.out.println(s + " -> " + e);
        }
    }
}

Andare più in profondità

Sostituisca i Point s interni con il relativo pattern di record per raggiungere direttamente le coordinate: Line(Point(int x1, int y1), Point(int x2, int y2)).

public class Main {
    record Point(int x, int y) {}
    record Line(Point start, Point end) {}

    public static void main(String[] args) {
        Object obj = new Line(new Point(0, 0), new Point(3, 4));
        if (obj instanceof Line(Point(int x1, int y1), Point(int x2, int y2))) {
            double len = Math.hypot(x2 - x1, y2 - y1);
            System.out.println("Length: " + len);
        }
    }
}

A qualsiasi profondità

L'annidamento può raggiungere la profondità dei dati. Ogni livello associa un componente intero oppure lo destruttura ulteriormente, rispecchiando esattamente la struttura dei dati.

public class Main {
    record Point(int x, int y) {}
    record Line(Point start, Point end) {}
    record Drawing(Line first, String label) {}

    public static void main(String[] args) {
        Object obj = new Drawing(new Line(new Point(1, 2), new Point(3, 4)), "diag");
        if (obj instanceof Drawing(Line(Point(var ax, var ay), var end), var label)) {
            System.out.println(label + " starts at " + ax + "," + ay);
            System.out.println("ends near " + end);
        }
    }
}

Combinare var e tipi

All'interno di un pattern annidato può combinare liberamente tipi espliciti e var. Usi var per i componenti che deve solo trasferire e tipi espliciti dove la chiarezza è utile.

Annidamento in switch

I pattern annidati sono particolarmente espressivi in switch, perché consentono a ogni case di descrivere una forma precisa dei dati.

public class Main {
    record Point(int x, int y) {}
    record Line(Point start, Point end) {}

    static String describe(Object o) {
        return switch (o) {
            case Line(Point(var x1, var y1), Point(var x2, var y2)) when x1 == x2 -> "vertical";
            case Line(Point p1, Point p2) -> "general line";
            default -> "not a line";
        };
    }

    public static void main(String[] args) {
        System.out.println(describe(new Line(new Point(2, 0), new Point(2, 9))));
        System.out.println(describe(new Line(new Point(0, 0), new Point(5, 5))));
    }
}

L'intera corrispondenza deve riuscire

Un pattern annidato corrisponde solo se ogni livello corrisponde. Se un componente ha un tipo diverso da quello previsto dal relativo sottopattern, la corrispondenza complessiva fallisce e non viene associata alcuna variabile.

Compromesso sulla leggibilità

L'annidamento profondo è potente, ma può diventare difficile da leggere. Se un pattern diventa troppo grande, consideri la possibilità di destrutturare un solo livello e gestire il resto con una logica separata.

Guard sulle associazioni annidate

Poiché i pattern annidati espongono i valori interni come variabili locali, una singola guard when può fare riferimento a campi appartenenti a più livelli contemporaneamente.

public class Main {
    record Point(int x, int y) {}
    record Line(Point start, Point end) {}

    static boolean isUnitStep(Object o) {
        return o instanceof Line(Point(int x1, int y1), Point(int x2, int y2))
            && x2 - x1 == 1 && y2 - y1 == 1;
    }

    public static void main(String[] args) {
        System.out.println(isUnitStep(new Line(new Point(0, 0), new Point(1, 1))));
        System.out.println(isUnitStep(new Line(new Point(0, 0), new Point(2, 2))));
    }
}

Un esempio completo

Calcoli il punto medio di una linea destrutturando entrambi gli estremi.

public class Main {
    record Point(int x, int y) {}
    record Line(Point start, Point end) {}

    static Point midpoint(Object o) {
        if (o instanceof Line(Point(int x1, int y1), Point(int x2, int y2))) {
            return new Point((x1 + x2) / 2, (y1 + y2) / 2);
        }
        return null;
    }

    public static void main(String[] args) {
        System.out.println(midpoint(new Line(new Point(0, 0), new Point(4, 6))));
    }
}

Verifica rapida

Verifichi la Sua comprensione dei pattern di record annidati.

Riepilogo

Ha imparato i pattern di record annidati.

Un componente di record che è a sua volta un record può essere destrutturato direttamente nel pattern.
L'annidamento può raggiungere qualsiasi profondità e combinare tipi espliciti con var.
La corrispondenza riesce solo se ogni livello corrisponde.
Le associazioni interne possono essere usate nelle guard e insieme al corpo.

Domande Frequenti

La lezione «Pattern annidati per record» è gratuita?

Sì — il testo completo di «Pattern annidati per record» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «Pattern annidati per record»?

Corrispondere dati profondamente annidati Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Pattern annidati per record»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Java Academy