Corso Java da Zero a Ninja

In questo breve appuntamento riprendiamo alcuni concetti fondamentali delle logica di programmazione, rivedremo assieme concetti quali:

• cos'è un algoritmo

• caratteristiche di un algoritmo

• come rappresentare gli algoritmi

• quali sono gli elementi con cui costruire gli algoritmi

Iniziamo il nostro viaggio, iniziando a spiegare i principi fondamentali della programmazione ad oggetti:

1. Classi

2. Incapsulamento

3. Ereditarietà

4. Polimorfismo

Tutti questi concetti li vedremo applicati sempre nei nostri codici Java

Scriviamo il nostro primo programma e esploriamo i diversi modi per scrivere il main e come configurare il nostro programma

Impariamo a passare parametri al main tramite la riga di comando e esploriamo una nuova forma di esecuzione per i nostri codici

Diamo all'utente di digitare i valori da fare usare al nostro programma  usando la classe Scanner

Iniziamo anche a imparare l'uso dei package e dalla clausola import

Diamo all'utente di digitare i valori da fare usare al nostro programma usando la classe JOptionPane

Diamo all'utente di digitare i valori da fare usare al nostro programma usando la classe Console

Presentazione del sistema dei tipi in Java

Un esempio pratico in cui si illustra l'uso dei tipi base in java ed alcuni aspetti legati al casting

Completa la classe Auto aggiungendo nuove funzioni ed attributi

Iniziamo ad usare il debugger, creiamo dei breakpoint ed usiamoli per verificare il comportamento del nostro programma

Iniziamo ad usare il costrutto IF e la logica condizionale

Soluzione dell'esercizio "Completa la classe"

Esaminiamo il modo in cui tramite una catena di if-else sia possibile definire scenari multipli

Iniziamo a vedere l'uso del costrutto switch come alternativa all'uso dell'if

Continuiamo ad esaminare l'uso dello switch introducendo l'uso del break

Continuiamo ad esaminare l'uso dello switch, scritture alternative degli argomenti

Completa il progetto, definendo la classe Calcolatrice ed usandone i servizi

Una possibile soluzione all'esercizio della calcolatrice

Insegnamo ai nostri programmi il modo in cui possono ripetere certe istruzioni più volte, partendo dall'suo del ciclo while

Impariamo a gestire in modo alternativo l'esecuzione dei loop mediante le istruzioni break e continue

In questo nuovo esercizio devi sviluppare il gioco della morra cinese, sfruttando tutto quelle che hai appreso fino a questo punto

In Questo video ti propongo una possibile soluzione all'esercizio della Morra Cinese

Aggiungiamo alla nostra cassetta degli attrezzi un nuovo strumento, il loop For che usiamo tutte le volte in cui sappiao in anticipo quante volte un blocco di istruzioni va ripetuto

Esaminiamo più nel dettaglio il comportamento delle operazioni di incremento e decremento in Java e di alcuni shortcut di scrittura

Un secondo esempi di uso del ciclo for in cui illustrano alcune interessanti customizzazioni relativa alla sua struttura, si continua ad eseaminare l'uso del debugger

Vediamo in che modo i loop possono essere annidati l'uno all'interno dell'altro e di come questi possono interagire tra loro, esaminando potenziali situazioni di errori. Inoltre vedremo l'uso del break in relazione alle etichette associabili ai loop stessi

Dopo i cicli While e For è il turno del ciclo do...while. Questo ciclo è particolarmente utile in tutti quei casi in cui dobbiamo garantirci che un certo blocco di si istruzioni venga eseguito almeno una volta. Il motivo di questo comportamento è legato al posizionamento della condizione di uscita che è postuma, in pratica prima eseguiamo il codice e poi verifichiamo se possiamo ripetere nuovamente lo stesso blocco. Se la condizione è falsa il loop viene interrotto in caso contrario l'operazione si ripete. In ogni caso almeno una vlta il codice è stato eseguito.

Un primo esempio di uso degli array.

Un semplice codice che generato un vettore di numeri interi casuali, ne stampa il contenuto e ne calcola la media

Completa la classe MathArray aggiungendo metodi di ricerca per estrarre:

• minimo

• massimo

• posizione di un elemento all'interno del vettore

Ecco qui la soluzione per l'esercizio assegnato

Continuiamo ad esaminare l'uso dei vettori, in questa nuova lezione, vedremo come utilizzare classi custom per costruire un carrello della spesa, il cui contenuto è salvato all'interno di un array

Continuiamo a lavora sul progetto del carrello, andandoci a concentrare sulle operazioni di cancellazione e calcolo del totale.

In questo esercizio ti chiedo di modificare la classe Cart in modo che non sia più necessario utilizzare una variabile per conoscere la posizione della prossima cella vuota nel vettore in cui inserire un nuovo prodotto.

L'inserimento dovrà sfruttare la prima posizione libera e la cancellazione dovrà solamente svuotare la cella senza modificare la posizione degli altri elementi.

Attenzione dovrai modificare anche i metodi di stampa e per il calcolo del totale

Buon Lavoro!

Ecco qui la soluzione dell'esercizio

Ecco qui la soluzione all'esercizio del distributore

In questo video andremo a creare un vettore circolare in cui gli elementi potranno essere inseriti all'infinto sovrascrivendo di volta gli elementi più vecchi. Il tutto giocando in modo opportuno con il valore dell'indice del vettore e l'operazione modulo

Vediamo in questo video, come superare i limite dei vettori come struttre statiche creando una lista dinamica

In questa lezione vedremo come aggiugere una seconda dimensione ai nostri vettori e come questa aggiunta modifichi in parte il modo di interagire con la struttura.

In questa prima parte della soluzione vedremo come costruire le dodici serie di 5 numeri, garantendo che in nessuna serie lo stesso valore compaia più di una volta

In questa seconda completiamo il nostro esercizio, definendo le classi che simulano il comoprtamento del giocatore che sceglie i propri numeri e di cun controllore che confronta i valori estratti con i numeri scelti da giocatore

In questa nuova lezione imparerai in che modo distribuire i tuoi programmi, sia nel caso in cui fossero degli "eseguibili" sia nel caso in cui fossero delle librerie da poter includere in altri progetti

In questo nuovo appuntamento vedremo come creare una stringa e come gestire l'operazione di confronto, Scopriremo come le stringhe siano una classe a cui in Java è stato fornito un trattamento di favore, riservandogli ben due aree di memoria, il che ci porterà a dover esaminare come particolare scrupolo l'operazione di confronto, proprio perchè il concetto dell'essere uguali nelle stringhe quasi mai coincide con quello che immaginiamo.

Dopo aver visto come creare una stringa e come gestire le operazioni confronto, oggi rispondiamo ad un'altra domanda "come si effettuano le ricerche su una stringa?". Scopriremo assieme l'uso dei metodi index e di come la trasformazione di una stringa in un vettore ci possa fornire un metodo di ricerca alternativo e flessibile.

In questo primo appuntamento con le espressioni regolari, scopriremo come scrivere regole basate su intervalli di caratteri e di come questi possano essere utilizzati per testare la correttezza di strinhe di lunghezza arbitraria.

In questo secondo incontro con le espressioni regolari, scopriamo l'uso:

• del simbolo ^ per gestire negazioni e prefissi

• del simbolo $ per la gestione dei suffissi

• del simoblo | per la gestione delle alternative

• delle parentesi per modificare l'ordine di valutazione/associazione di una espressione

In questo ultimo appuntamento dedicato alle espressioni regolari, esploreremo una serie di shortcut utili per semplificare pattern complessi. Faremo la conoscenza delle classi Pattern e Matcher, strumenti fondamentali per gestire le regex in Java, e scopriremo come rendere le nostre espressioni indipendenti dalla forma con cui il testo è stato scritto — che sia maiuscolo, minuscolo o misto.

In questo nuovo appuntamento torniamo a parlare di stringhe. Lo fermo esaminando i metodi con cui è possibile:

• concatenare due o più stringhe

• estrarre porzioni di testo

• effettuare operazioni di sostiturzioni

• e rivedremo alcune operazioni di ricerca

Valuteremo anche l'impatto che le stringhe, in quanto immutabili, hanno sull'uso delle risorse di sistema

Iniziamo con il descrivere il primo dei tra pilastri della programmazione OOP

Cerchiamo di capirne il significato e le implicazioni a livello di definizione ed uso all'interno ed all'esterno della classe

Continuiamo l'esame del concetto di incapsulamento in ralazione all'uso dei modificatori

private, public e default

In questa lezione vedremo un esempio concreto di uso dei modificatori analizzati fino a questo punto.

In paritcolare creeremo un progetto per un piccolo negozio, in cui gli attori saranno:

• il negozio

• i prodotti

• i clienti

Vedremo in che modo è possibile farli interagire e come i modificatori influenzino il modo di progettare la soluzione

Inoltre vedremo una nuova forma per formattare gli output e come l'operazione di assegnazione può essere utilizzata all'interno di un if.

In questa nuova lezione si parla di "Overloading" ossia la possibilità offertaci da Java di definire metodi con lo stesso nome, ma che si diffenziano l'uno dall'altro per le informazioni che ricevono in input

Si conitnua a parlare di "Overloading", ma questa volta applicato ai costruttori, vedremo come utilizzare le invocazioni a catena e come il loro uso sia cambiato dalla versione 22 di Java in avanti

I tipi base sono fondamentali in moltissimi scenari, ma alle volte la loro natura potrebbe limitare le operazioni che possiamo invocare, per questo in java esistono i cosidetti tipi wrapper, si tratta di classi che incapsulano al loro interno valori di tipo base e che ne ampliano notevolmente le capacità operative, possono essere estremamente utili, ma possono portare a problemi di ambiguita in relazione al principio dell'overloading.

In questa lezione vedremo di capire meglio come funzionano.

In questo nuovo appuntamento, impareremo l'uso dei varags, ossia una notazione alternativa per fornire ad un metodo una lista di lunghezza arbitraria di informazioni senza dover necessariamente ricorrere ai vettori

In questo nuovo appuntamento esploreremo l'uso del modificatore static e le sue conseguenze nella dichiarazione degli attributi e dei metodi

In questa nuova lezione vedremo in che modo adottare i metodi statici per poter creare degli oggetti impedendo l'uso diretto del costruttore al fine di evitare di creare oggetti parziali o incongruenti

Continua il nostro studio del modificatore static e del modo in cui possa essere utilizzato per definire al meglio i servizi di una classe.

Vedrai anche un prio uso della parola chiave var per definire le variabili locali ai metodi

Questa volta ti chiedo di completare il progetto scuola in base alle specifiche che vengono descritte nel video e nel pdf.

Buona programmazione  e buon divertimento

In questa prima parte dell'esercizio andiamo a risovlere alcune delle specifiche di progetto, in particolare il calcolo della media, la possibilità di aggiungere voti all'infinito, il check sulla congruenza tra il registro dei voti ed il corso di cui si vuole calcolare le media

Completiamo il nostro esercizio, aggiungendo nuovi metodi e rivedendo quanto fatto nella lezione precedente

In questa lezione imparerai convertire il contenuto di un oggetto in una stringa attraverso il metodo toString ed a usare il risultato per verificare se il comporamento del tuo progetto è valido

In questa lezione apprenderai l'uso della parola chiave var, nella dichiarazione delle variabili all'interno delle classi,

Ne esaminaeremo i possibili contesti d'uso e le possibili limitazioni

Iniziamo ad approfondire i concetti legati all'ereditarietà, in particolare vedremo come definire delle genealogie di classi, come utilizzare la clausola super e come sfruttare l'override dei metodi

Si continua ad esaminare il contetto l'ereditarietà in relazione alla forma assunta dai costruttore e di come la presenza della clausola super divenga opzionale in specifici scenari

Vediamo come l'uso dei setter possa influenzare il processo di estensione delle classi e come possa incidere positivamente sul fenomeno dell'accoppiamento

In questa nuova lezione si continua l'esame dell'ereditarietà nelle sue varie sfaccettature, sia in relazione ai metodi di set, sia con gli altri tipi di metodi

In questo nuovo appuntamento vedremo insieme cosa significa il polimorfismo applicato alla programmazione

In questo esempio sfrutteremo i principi di ereditarietà e polimorfismo per implementare un sistema di gestione per il noleggio di Auto e Moto

In questo eserciio ti chiedo di realizzare un sistema per la gestione dei prestiti in una biblioteca

In questo primo video iniziamo a definire la genealogia delle risorse che saranno gestite dalla biblioteca

Continuiamo lo sviluppo della nostra soluzione.

In questo video implementiamo i servizi per l'aggiunta, la rimozione e la ricerca di una risorsa ed salveremo i prestiti, in più definiamo una classe specifica per registrare i dati del prestito

Concludiamo la scrittura del nostro esercizio.

Oltre ad aggiunere nuovi metodi vedremo anche un nuovo ed interessantissimo uso dello switch che evita l'uso della combinazione if - instanceof per determinare il tipo di un oggetto

In questo nuovo video imparerai l'uso dell'insanceof e di come questo risulti necessario nelle operazioni di casting/conversione tra tipi classe

In questo nuovo appuntamente esamineremo il concetto dell'uguaglianza tra due oggetti e di come questa operazione possa essere valutata a diversi gradi di dettagli.

In questa nuova lezione introduciamo l'uso del modifcatore protected e di come questo influsca sul processo di ereditarietà e sulla visibilità del metodo tra classi appartenenti a package differenti

In questa nuova lezione vedremo il modo in cui il modificatore final incida sulla estendibilità di una classe o sulla possibilità di effettre l'override dei singoli metodi

Vediamo come l'uso di costruittori private in abbinamento a metodi builder statici incide sull'ereditarietà

In questa nuova lezione vedremo l'uso delle sealed class e di come queste consentano un controllo estremamente fine sulla possibile discendenza di una classe

Un modo smart per definire classi immutabili, evitando la verbosità di Java

In questa lezione apprenderemo l'uso degli enumerati, ossia un particolare tipo di classe in cui si indicano in modo esplicito i valori presenti nel dominio

In questo video impariamo a commentare il nostro codice, usando i commenti a riga singola e multi riga

In questo secondo video approfondiamo le strategie per aggiungere commenti ai nostri codici usando i Javadoc, in questo modo impareremo anche come costruire il manuale d'uso per i nostri progetti

In questo video illustreremo l'uso della composizione per definire classi complesse. Questo approccio vede le classe non in termini di discendenza, ma di elementi che le compongono.

Questo permette di suddividere in modo diverso le responsabilità tra i diversi soggetti utilizzati nella costruzione.

La composizione non esclude l'uso dell'ereditarietà ed infatti nel codice che ti propongo i due approcci vengono utilizzati assieme

In questo nuovo appuntamento imparerai l'uso delle inner class, si tratta della possibilità di dichiarare classi all'interno di altre classi, si definisce in questo modo un principio di subordinazione tra la classe interna e la classe contenitrice che quindi governerà la possibilità di interagire con i metodi definiti nella classe interna

In questo nuovo video esaminiamo un uso concreto delle inner class, in particolare simuliamo il comportamento di un ascensore

Iniziamo ad apprendere l'uso delle classi astratte mediante un esempio concreto, ossia la gestione dei ruoli in una scuola

In questo secondo video si continua lo studio delle classi astratte e di come queste ri relazionano con il modificatore sealed e le altre strategie per gestire l'ereditarietà

In questa lezione apprenderemo l'uso dei metodi astratti e di come questi permettano di definire un set di servizi comuni che una o poiù classi concrete devono garantire

Nota importante: al minuto 22:10 viene detto erroneamente che la classe Concreta non eredita i metodi Astratti, si tratta di un lapsus, si voleva dire che le classi qualunque ne sia il tipo non ereditano mai i metodi statici, o più in generale tutto quello che viene dichiarato come static

Esercizio in cui dovrai applicare i concetti legati alle classi astratte per modellare veicoli di tipo diverso con costi di gestione e di utilizzo differenti.

Buon Lavoro!

Iniziamo ad esaminare le interfacce cercandone di capire subito i vantaggi.

Vedremo come si dichiarano e come influiscono nella dichiarazione di una classe e nell'uso degli oggetti

In questa lezione esploriamo il modo in cui una classe abbia la possibilità di implmentare contemporaneamente più interfacce e quali sono alcuni possibili scenari in cui ci si prò trovare nel momento in cui si implementeranno i metodi astratti

Questa nuova lezione ci porta ad affrontare i problemi legati al modo in cui le interfacce gestiscono l'ereditarietà singola e multipla e di quelli che sono alcuni dei possibili scenari in cui ci si può trovare

Questa volta devi sviluppare un sistema per la gestione dei pagamenti, da poter integrare in un progetto per un sito di e-Commerce

In questo primo video vedremo come implementare i due sistemi di pagamenti che non permettono la restituzione del denaro e ragioneremo quali scelte fare in relazione ad ognuna delle implementazioni

Continua lo sviluppo della nostra soluzione, questa volta implementeremo l'interfaccia per i sistemi che consentono la restituzione della somma versata

In questo nuovo appuntamento vedremo come centralizzare il meccanismo per la generazione dei messaggi, in modo da rendere la nostra soluzione più elegante e manutenibile

In questo video concludiamo la relazionnazione del nostro gestore di pagamenti, andando a definire la classe con cui gestire i diversi tipi di transazione, vedremo come il concetto del polimorfismo sia fondamentale al fine di ottenere soluzioni snelle ed elaganti

In questo video vedremo un utile miglioramento che rende la nostra soluzione più manutenibile e meno ambigua

In questa lezione vedremo come creare un programma che possa adattare il testo dei messaggi a seconda della lingua di sistema.

Quando si parla di classi anonime ci si riferisce spesso ad implementazioni spot di un'interfaccia che vengono dichiarate e sviluppate all'interno di un metodo e che hanno un ciclo vitale limitato al solo contesto in cui sono definite, in questa lezione cerchiamo di fare chiarezza circa la scrittura da utilizzare per poterne sfruttare le caratteristiche.

In questo nuovo appuntamento vediamo come usare l'implementazione anonima di un'interfaccia per creare una semplice calcolatrice

In questa lezione iniziamo lo studio avuto dalle interfacce a partire da Java 8 e proseguito nelle successive versioni. La nostra attenzione si rivolgerà alla definizione ed all'uso dei metodi di default, ossia metodi definiti all'iinterno di un'interfaccia, ma che a differenza dei metodi astratti presentano una definizione concreta esattamente come avviene con i metodi concreti delle classi concrete e non.

In questa lezione imparerai come i metodi di defualt possano essere inseriti con successo all'intenro di un progetto già comlpeto. Riprenderemo l'esempio del Sistema dei pagamenti ed aggiungeremo due nuovi metodi di default e studieremo come questi impattano nella definizione generale del progetto

In questo nuovo appuntamento andiamo ad esplorare il modo in cui i metodi di default abbiamo modificato il modo di intendere l'ereditarietà singola e multipla all'intenro delle interfacce e di quali possibili scenari di errore si possono venire a creare

I metodi di default non erano sufficienti, pertanto ora abbiamo la possibilità di creare anche metodi static e private all'interno delle interfacce, questo ci permette di incapsulare diversamente il codice che avrebbe rischiato di essere concentrato solo all'interno dei metodi di default con il rischio di esporre funzionalità importanti che invece andavano protette

In questa lezione inizieremo a prendere confidenza con le espressioni lambda e capiremo come il loro uso possa semplificare la scrittura del nostro codice

Continuiamo la nostra introduzione alle espressioni lambda, in questa nuova lezione andremo ad esaminare in che modo questa forma di scrittura si relaziona agli attributi ed alle variabili locali.

Dopo questo vedremo come usare le lambda come argomenti dei metodi.

In questo primo appuntamento iniziamo a muover i primi passi nel mondo delle collections. In particolare faremo la conoscenza della classe ArrayList e di come questa abbia molti punti in comune con i vettori risolvendone però alcuni dei problemi tipici: dimensione finita, valori non necessariamente adiacenti, dimensioni statiche

La possibilità di inserire oggetti di qualunque tipo all'interno di una collecion è sicuramente un vantaggio, ma dall'altro crea il problema di non sapere mai il tipo dell'informaioni e che si sta per utilizzare se non dopo aver utilizzato una serie di test. tutto questo crea un codice fortemente ridondante e verboso, per questo a partire da Java 5 sono stati introdotti i generics. In questa lezione vedremo cosa sono e come possono essere utilizzare per "raffinare" il tipo delle informazioni memorizabili all'interno delle collection. Inizieremo la nostra analisi partendo dalle liste.

In questo nuovo appuntamento rivediamo il progetto del carrello della spesa utilizzando le liste ed effettuando diverse operazioni di ottimizzazione al codice

In questa nuova lezione oltre ad esaminare i metodi di ricerca, impareremo ad interagire meglio con i metodi di cancellazione ed alcuni metodi di conversione, spiegando anche perchè può essere conveniente trasformare una lista in un vettore.

In questo nuovo appuntamento vedremo in che modo le espressioni lambda possono entrare in gioco quando dobbiamo interagire con i valori di una lista.

Studieremo come usare i metodi removeIf ed il metodo forEach e vedremo come gestire situazioni particolari legate all'uso del foreach ed alcune limitazioni al suo uso

In questo nuovo apputamento vediamo altri due esempi di uso delle espresisoni lambda in abbinamento ai metodi delle liste, nello specifico il metodo replace permette la sostituzione/aggiornamento di tutti gli oggetti che verificano una specifica condizione, il metodo sort consente di definire un criterio per l'ordinamento dei dati.

In questo esercizio ti chiedo di modificare il codice del progetto del carrello in modo tale che in fase di inserimento di un nuovo prodotto non se ne crei una nuova copia nel carrello, ma si vada a modificare un contatore associato.

Vediamo assieme come poteva essere modificato il carrello per garantire l'inserimento senza copie,

Ti mostro due approcci, uno basato su algoritmo di ricerca a forza bruta ed uno più raffinato basato sull'uso dell'algoritmo di ricerca con sentinella

In questa nuova lezione parliamo di linkedlist o liste doppiamente e di come questa struttura estenda semanticamente le funzionalità già esaminate con le liste.

Iniziamo oggi ad esaminare l'uso dei dizionari, in particolare la nostra attenzione si concentrerà sugli Hashmap.

In questo primo appuntamento dopo una breve introduzione, inizieremo ad esaminare i metodi che ci consentono di leggere e scrivere all'interno del dizionario

In questo secondo appuntamento con gli hashmap la nostra attenzione si rivolge ai metodi che consentono la cancellazione e la sostituzioni di intere sezioni della struttura, saranno inoltre esaminati altri metodi di utilità da poter impiegare nella scrittura dei nostri codici

In questo nuovo appuntamento vedremo in che modo è possibile scandire l'intero contenuto di un hashmap. Imparerai l'uso dei metodi keySet, values e entrySet e vedrai come sfrutarli per poter leggere l'intero contenuto di un hashmap

In questo nuovo esercizio ti chiedo di realizzare un progetto per la gestione di una serie di to-do list associate ad un gruppo di persone

In questo primo video iniziamo a creare i mattoni con cui poi assembleremo il nostro progetto finale.

In particolare scriveremo le classi:

• Persona

• Task

• Stati Task

• Manager Task - Solo il metodo per l'assegnazione di un task ad una persona

Ti spiegherò anche alcune scelte di progetto che ho deciso di seguire per cercare di organizzare al meglio i dati e semplificare le diverse operazioni

In questa seconda parte della soluzione completiamo la definizione della classe che gestisce i task aggiungendo i metodi con cui gestire il ciclo vitale di ogni task assegnato ad ogni persona

Verifichiamo il funzionamento del nostro progetto e correggiamo una potenziale anomalia nel comportamento di uno dei metodi

In questo nuovo appuntamento andremo ad esaminare un'interessante "specializzazione" delle HashMap, le EnumMap. La particolarità di questa struttura è che l'insieme delle chiavi viene definito tramite un enum il che limita quelli che sono i possibili valori utilizzabili.

Esaminiamo un'altra interessante specializzazione dei dizionari, questa volta parliamo di TreeMap, si tratta di strutture in cui le chiavi risultano ordinate rispetto ad un criterio di confronto che consente di dire quando una chiave è più grande di un'altra ed in funzione di questa posizionarla alla destra o alla sinistra della "radice" della struttura, il tutto con notevoli vantaggi nelle operazioni di ricerca che possono sfruttare l'ordinamento delle chiavi per limitare di volta in volta la scansione su una porzione limitata della struttura

In questo nuovo appuntamento vedremo assieme come anche le mappe offrano metodi che fanno uso delle espressioni lambda.

In particoalre imparerai l'uso dei metodi:

• computeIfAbsent

• computeIfPresent

• merge

Si tratta di metodi di scrittura che puoi utilizzare in alternativa ai metodo put e putIfAbsent e che ti permettono un controllo molto più accurato sulle operazioni di inserimento ed aggiornamento dei dati.

In questo uovo apputamento impararai l'uso dei metodi forEach e replaceAll. Il primo lo usi quando vuoi leggere tutti i valori all'interno della mappa estraendo ogni volta sia la chiave sia il valore, il secondo invece lo usi quando devi fare degli aggiornamenti.

In questa lezione vedremo cosa sono i set e quali implementazioni sono definite all'interno del framework Collection

Gli iteratori hanno la possibilità di essere definite su tutte le strutture appartenenti al framework collection, sono particolamente utiliti quando si tratta di scandire strutture dati in ambienti con ridotte capacità elaborative o in sistemi legacy che usano versioni di java antecedenti a java 8. Ti stratta di strutture estremamente soli e robuste e posseggono uno stile dichiarativo esplicito. Possono essere usate sia in modalità lettura che scrittura consentendo la cancellazione diretta degli elmenti che "puntano"

In questo nuovo appuntamento iniziamo a parlare di stream associati alle Collections, in particolare vedremo un primo esempio in cui si fa uso del metodo filter per filtrare i dati presenti in una lista prima di andarli ad utilizzare

In questo nuovo appuntamento vedreo come, attraverso i metodi di mapping definiti sugli stream, sia possibile combiare la natura dello stream e di conseguenza operare in modo diverso sugli stessi dati in funzione del mapping definito

In questo nuovo apputamento imparerai l'uso delle tecnica nota con il nome di Method Reference, ossia la possibilità di usare metodi "compatibili" definiti altrove come implementazione dei metodi dichiarati nelle interfacce funzionali.

In questo nuovo appuntamento iniziamo a studiare l'uso del metodo collect. Si tratta probabilmente del metodo più interessante che si possa applicare ad uno stream, il suo uso ci consente di definire strutture completamente diverse su cui lo stream originale era stato definito, consentendo di sviluppare dinamiche analoghe a quelle di una select sql in cui possiamo indicare cosa estrarre e nel caso come raggruppare i dati per ottenere dati di sintesi

Conitnua il nostro studio del metodo collect, in questo nuovo appuntamento vedremo in che modo è possibile filtrare i dati che dovranno essere inseriti all'interno del risultato finale.

In questo nuovo appuntamento vedremo in che modo il metodo collect debba essere modificato per carantire la compatibilità con Java 8, inoltre apprenderai l'uso del metodo collectingAndThen utile per effettuare operazioni postume al processo di aggragazione prima di restituire il risultato complessivo.

Chiudiamo il cerchio con il metodo collect imparando a definirne uno completamente personalizzato che non si appoggia a Collectors già esistenti, ma definendo uno tutto nostro in cui indichiamo il tipo del risultato da produrre, come organizzare i dati e combinare strutture già esistenti con quella prodotta dalla nostra collect.

In questo nuovo appuntamento vedremo una specializzazione del concetto di raggruppamento, usando il metodo partitioningBy, la particolarità è che questo divide i risultati in due gruppi, associati rispettivamente ai valori true e false, questo perchè la suddivisione è basata su di una condizione logica

In questo nuovo appuntamento esamineremo l'uso del metodo reduce e di come questo possa estrarre un unico dato di sintesi da uno stream

In questo nuovo appuntamento studieremo l'uso del metodo flatMap e di come questo possa essere utilizzare per "appiattire" stream di stream in stream semplice.

Analizzeremo anche la possibilità di creare stream sulle mappe

In questo nuovo appuntamento ti propongo di realizzare un nuovo progetto che ha come argomento la gestione di una biblioteca.

In particolare dovrai implementare i servizi relativi a:

• prestiti

• acquisti

• cancellazione

• generazione di statistiche varie

Ne avrai di cose da fare, per questo ti auguro buona programmazione

Iniziamo a muovere i primi passi verso la soluzione del nostro problema, in questo video vedremo verranno creati i primi mattoni della nostra soluzione, inoltre faremo delle prime valutazioni in merito ad alcune scelte di progetto che influenzeranno il resto dello sviluppo.

In questo nuovo appuntamento sviluppiamo le funzionalità di base della biblioteca con cui sarà possibile inserire un nuovo volume, sostituirlo, rimuoverlo ed avere una serie di informazioni sul patrimonio complessivo della struttura

Iniziamo a costruire il gestore dei prestiti, dopo aver completato la classe Biblioteca costruiiamo la classe che ci permette di registrare i nuovi prestiti e gestire le restituizioni.

In questo nuovo appuntamento vediamo come poter definire una classe a partire dalla quale si possano definire i metodi per generare le statistiche di cui si può avere bisogno nella nostra biblioteca, per gestire il patrimonio bibliografico ed i prestiti.

In questo nuovo appuntamento imparerai ad usare l'ereditarietà applicata ai tipi parametri

In questa nuova lezione imparerai l'uso del simbolo ? come marker universale per i generics e come sfruttare la parola chiave super nella definzione di strutture da utilizzare. Infatti ? e super non permettono di dichiarare classi, ma di "consumare" i tipi generici

In questa nuova lezione vedremo come utilizzare le interfacce per limitare i tipi accettanti in classi generiche, esaminaeramo anche tutta una serie di casi particolari legati all'uso dei generics, in relazione anche all'estensione ed all'implementazione

Iniziamo con un pò di teoria.

Cosa sono le eccezioni, come le possiamo gestire, cosa non è un'eccezione.

Possiamo evitarle? La risposta è no, ma le possiamo "catturare" e risolvere

In questa lezione iniziamo ed esplorare l'impatto che le eccezioni possono avere nella stesura del nostro codice, in particolare vedremo come possono essere integrate all'interno della definizione dei costruttori e ci come possono essere utilizzate in metodi Factory

In questo nuovo appuntamento vedremo come l'uso dei metodi può influenzare la definizione e la gestione dei metodi proponendo modi alternativi e non convenzionali per sfruttare le eccezioni

Oggi scopriremo come creare le nosrte eccezioni e come sfruttarle al meglio all'interno del nostro codice, vedremo anche un modo poco ortodosso per usare le eccezioni quando non ci sono stati problemi di esecuzioni.

In questa nuova lezione vediamo in che modo l'uso delle eccezioni possa essere influenzato e come influenzi la definizione dei costruittori quando di definiscono delle genealogie di classi

In questo nuovo appuntamento vedremo in che modo l'override dei metodi possa essere influenzato dalla presenza delle eccezioni