Ciao, questo è che non vuoi fare anche tu.
Ben tornato.
Diamo un'occhiata a questa caratteristica molto interessante chiamata stream che è stata introdotta in Java
otto insieme ad altre funzionalità come i riferimenti ai metodi di lambast su interfacce di funzione standard.
In effetti, lo streaming è considerato di vitale importanza se i migliori casi d'uso di riferimenti alla materia Ramdass su
interfacce di funzione standard.
Streams è un'API e viene introdotto come parte di un nuovo pacchetto chiamato Java o dot dot strip.
Onstream è un'interfaccia e ha molti metodi su molti dei suoi metodi che usano interfacce di funzione
standard come Metapad sui tubi sporchi.
Quindi quando abbiamo a che fare con flussi anche noi.
In che modo i riferimenti al metodo sulle interfacce di funzione standard entrano in gioco.
Soby come tutte queste principali funzionalità Java entrano in azione quando abbiamo a che fare con i flussi.
OK, quindi sono tutti strettamente legati e questo è tutto ciò che devi ricordare sui flussi.
Si tratta di eseguire sequela come operazioni su collezioni.
Quindi possiamo eseguire alcune operazioni complesse su raccolte che non erano possibili prima dell'8
luglio.
OK, questo è tutto ciò che devi ricordare.
E offre anche il vantaggio di scrivere codice in uno stile dichiarativo.
Ne discuteremo tra un po '.
Non sono mai stato discusso nell'introduzione, ma qui non devono essere solo raccolte.
Possono anche essere gli array Comus in cima all'elenco dei valori o persino gli incendi quando si esegue l'output in ingresso.
Può anche essere altri tipi di fonti, ma in genere si tratta di implementazioni di raccolta come senza ordine.
Quindi abbiamo questo nel nostro mondo di database, quindi abbiamo un database e come le query Escorial che ci aiutano
a manipolare i dati nei loro database.
Sotto-esegui tutti i tipi di operazioni complesse come il filtraggio usando la clausola WHERE.
Le condizioni nella clausola WHERE sono i dati di raggruppamento stanno ordinando alcuni dati.
Siamo l'ordine di come l'arte perduta possiamo anche danneggiare.
Le operazioni di riepilogo come contiamo alcune in media, così possiamo fare tutto questo usando Escorial.
Ma quando si tratta di collezioni nel mondo Java 8, potremmo naturalmente aggiungere qualcosa alla collezione o
possiamo ottenere qualcosa dalla collezione o possiamo anche cercare di andare avanti con altri
tipi di operazioni che sono supportate usando vari metodi ma noi non potrei fare nulla di tutto questo
Non ci sono metodi di un tour che supportano questo tipo di operazioni.
Ducrot possibile negli Stati Uniti.
Come l'ordinamento e la somma di raggruppamento di elementi flitter.
In media, in caso di ricognizione di ordinamento, l'ordinamento esterno utilizzando la classe di raccolte è nel Sautner.
Ma all'interno dell'interfaccia di raccolta stessa o dell'interfaccia listener stessa non esisteva alcun metodo
come il socket e quando si trattava di ricapitolare Ishan potevamo ovviamente fare codice usando il metodo size size method e
la collection ma non potevamo fare un po 'di media in Per fare questo tipo di operazioni dovevamo scrivere
il nostro quarto.
Abbiamo dovuto prendere una capra personalizzata in modo che uno dei limiti nella scrittura di tale codice personalizzato non sia leggibile.
Il codice non è leggibile sul secondo numero in quanto non è facilmente parallelizzabile.
Quindi dobbiamo riscrivere il codice per renderlo appetibile.
È un sapone molto noioso per affrontarlo.
Java 8 ha introdotto l'API di streaming che fa parte di questo nuovo pacchetto chiamato punto punto punto punto punto.
Possiamo fare tutte queste operazioni come filtrare il raggruppamento e l'ordinamento e anche le operazioni di riepilogo.
Quindi i metodi di Stream White API per fare questo in modo che.
Tutti i limiti non sono i benefici sono quelli di subire benefici quindi gli sviluppatori non hanno bisogno di scrivere
quel tribunale personalizzato in modo che possano semplicemente esprimere ciò che vogliono nel lavorare con i diversi metodi.
Questa è una metafora in corso, c'è una questione di raggruppamento.
Sto selezionando questo tipo di cose e puoi cambiare questi metodi, così facendo stiamo scrivendo
dichiarativo e non leccare semplicemente esprimendo ciò che lui o lei vuole.
Quindi il risultato di questo è quanto il codice più pulito sul campo è anche facilmente parallelizzabile.
Ora abbiamo visto questo esempio e l'engro conferenza per motivarci a studiare i flussi.
Quindi qui l'obiettivo è categorizzare i libri in modo da avere un elenco di libri nel frigo
per commentare, vogliamo categorizzarli per categoria.
E vogliamo anche classificare solo quei libri che possono descrivere l'OP con la valutazione del libro è almeno
quattro punti cinque sul risultato finale di questo sarà memorizzato in questa mappa di hash chiamato libri
per categoria.
Ma la chiave è la categoria e il valore è un elenco di libri che rientrano in quella categoria.
Quindi questo si chiama come in me, ma io programma e questo è ciò che abbiamo fatto attraverso il nostro discorso.
No, come ho appena detto, è facile scrivere questo, ma non è così difficile, ma leggerlo è un
po 'difficile è un po' illeggibile.
E come ho appena detto, la discordia è impegnata a lavorare in modo sequenziale e in un singolo ambiente thread.
Quindi se vogliamo una battaglia come questa, dobbiamo riscriverla e questo è molto doloroso.
Quindi su Internet abbiamo anche affermato che la stessa logica può essere espressa in un modo molto più
pulito in questo modo usando l'API degli stream.
Quindi, ancora una volta qui abbiamo i libri sulla lista sono benedetti e stiamo invocando un metodo chiamato
stream onstream è essenzialmente un metodo nell'interfaccia di raccolta stessa.
Quindi è stata introdotta nell'interfaccia di connessione in Java 8 sotto le tende un'istanza fuori dall'interfaccia di streaming
e l'interfaccia di vapore ha questi metodi come tale unclick.
Quindi stiamo invocando il metodo del filtro e l'importo che stiamo passando per la Lamda, che non è altro che la
valutazione del libro che deve essere maggiore di un file.
Quindi è abbastanza buono.
E il filtro restituisce anche un'altra istanza dell'interfaccia di flusso in modo che siamo in grado di raccogliere il metodo in
modo da filtrare e raccogliere i nostri due metodi nell'interfaccia del flusso.
E abbiamo anche il raggruppamento per metrica e ne discuteremo più tardi.
Ma come puoi vedere il filtro e il raggruppamento e fare clic insieme stanno eseguendo la stessa
operazione che stiamo eseguendo grette la programmazione imperativa chiamata.
Quindi questa è la programmazione decrementale.
E come puoi vedere è molto pulito ed è anche molto efficiente.
E ciò che sta accadendo qui è che stiamo facendo un'iterazione interna così lo sviluppatore sta semplicemente specificando ciò che
lui o lei vuole che vogliono un filtro o qualcosa e vogliono raggruppare.
Ma l'iterazione e il raggruppamento effettivi sono fatti internamente all'interno di questi metodi.
Quindi questo è ciò che sta accadendo anche in segreto.
Quindi in sequenza abbiamo queste query per il filtraggio abbiamo la croce rossa e per il raggruppamento abbiamo la
clausola group by.
Ma esattamente come l'hanno fatto, sotto il raggruppamento, si è preso cura internamente dei dati.
Allo stesso modo anche qui l'iterazione è gestita internamente dall'API del flusso.
Quindi quello che otteniamo qui è una migliore astrazione.
Quindi otteniamo la migliore astrazione, semplicemente specifichiamo ciò di cui abbiamo bisogno e il modo in cui deve essere fatto è
un dettaglio dell'implementazione che viene inserito in questi metodi.
Ora sogna il flusso di McPartland, l'intera competizione è paralizzata.
Quindi Gibeah sarebbe in grado di sfruttare il diverso corso nel sistema sotto per essere in grado di
paralizzare la concorrenza e renderla molto più efficiente.
Quindi questo è quello che otteniamo qui, nel dichiarare la de-programmazione di qualche mascella e dei vostri ingegneri senior.
In realtà diciamo che in futuro il tribunale sarà scritto in questo modo.
Quindi dicono che potrebbe essere un mix di programmazione orientata agli oggetti anche dichiarata la de-programmazione che non
è altro che qui la programmazione funzionale.
Quindi sarebbe un mix di programmazione orientata agli oggetti e funzionale.
Quindi quello che stiamo ottenendo qui è un ordine più elegante.
Quindi, il vantaggio principale di riassumere i flussi di bit, siamo in grado di eseguire operazioni più complesse
su raccolte che non sono possibili in precedenza.
Quindi siamo in grado di eseguire operazioni sequela.
Ma così facendo stiamo scrivendo una citazione di stile dichiarativa sotto un codice di stile dichiarativo.
Abbiamo questi vantaggi di un bene pulito chiaro ed efficiente e un parallelizzabile totale.
Ora un'ultima cosa è così qui abbiamo Lamda noi e riferimento Motard.
E questi sono ciò che ci consente di abbracciare i flussi.
Quindi queste funzionalità stanno permettendo agli sviluppatori di abbracciare i flussi di streaming potrebbero anche essere
stati introdotti prima dell'8 luglio ma prima dell'8 luglio non ci sono state bloccate le differenze Armato quindi avremmo usato
oggetti anonimi e sappiamo che gli oggetti anonimi non sono vobis e non lo farebbero Ho reso i
flussi attraenti.
Destra.
Quindi c'era una spinta da fare e come i flussi di Ambrish.
Quindi per utilizzare gli stream abbiamo bisogno di qualcosa come lambda sui riferimenti ai metodi che sono molto più
concisi da esprimere e questo è ciò che ci consente di utilizzare gli stream e anche sviluppare altre potenti librerie.
Quindi questo è un buon esempio.
Ma ora passiamo al mio editor e implementiamo effettivamente il nostro programma dimostrativo.
Quindi prima abbiamo scritto il programma di indicizzazione che trattava l'elaborazione delle pagine.
Quindi non è stato fatto in modo imperativo.
Ora convertiamolo in stile dichiarativo e vediamo tutto in azione.
OK, vediamo una vera programmazione di stile funzionale in azione.
Quindi andiamo al mio editore per questo.
Sei arrivato così lontano quest'anno ho creato questa nuova classe chiamata Strange demo.
So che tutta la discordia dalla funzione li interfaccia tutto ciò che abbiamo visto in precedenza in questa nuova
classe ed è stato ripulito un po '.
Quindi la funzionalità principale è stata spostata qui.
Ora una Ginia fatta come la funzione della saggezza o prima era in un pacchetto chiamato lambda noi sotto il
discorso comune semantico Square.
Così ho rinominato il pacchetto come il quadrato di Comdex Atlantic non funzionante.
E questo è tutto.
Quindi abbiamo le tre classi che avevamo in precedenza per i flussi.
Questa nuova demo di stream di classe è stata creata con questo nuovo pacchetto Suppe sotto funzionale chiamato stream.
OK, quindi tutte le classi di classi correlate ai flussi andranno sotto questo nuovo pacchetto.
OK, questo è ciò che abbiamo demo di stream e abbiamo già il tribunale imperativo e stiamo andando
a dichiarare o giudicare.
Ecco come lo testeremo.
Quindi qui abbiamo i quattro documenti ei quattro documenti che si sono accumulati in questo
elenco chiamato documenti e quindi abbiamo questo in meglio a Metford, che è stato calpestato dal metodo principale.
E ovviamente abbiamo la classe dell'indice all'interno del metodo imperativo.
Tutto quello che stiamo facendo è che stiamo elaborando i documenti e quindi abbiamo questo predicato in
cui stiamo portando il documento riguarda questo chiamato Stream.
E se è allora stiamo eseguendo due trasformazioni.
Quindi abbiamo qui il codice di trasformazione.
Quindi siamo nel rooking della striscia che ha attaccato il tuo metodo fiscale e l'indicizzatore per fare la trasformazione.
E per la seconda trasformazione stiamo rimuovendo gli snowbirds.
E viene assegnato all'interfaccia standard della funzione.
Quindi questa è la corte imperativa.
Ora vediamo come possiamo leggere il codice dichiarativo.
Quindi ho alcuni commenti qui e ho intenzione di costruire su questo.
Quindi, per implementare il flusso, costruiamo qualcosa chiamato come una pipeline di flusso che è una struttura comune che abbiamo
e abbiamo a che fare con i flussi.
E qui ci sono tre cose che facciamo.
Uno è necessario impostare una fonte, una fonte può essere qualcosa come un'implementazione di una raccolta o non
è su un ID o su altre fonti.
Possono esserci anche altre fonti.
Quindi una volta configurata la sorgente del flusso.
Va bene, solo in caso di raccolta, sappiamo del metodo di flusso, quindi B come Zuda
sono più operazioni intermedie e B come un termine finale in un'operazione che essenzialmente domina una stringa.
Okay, questo è quello che abbiamo qui.
L'impostazione della sorgente del flusso è analoga a quella dei bibbieri nella scuola proprio nella scuola, sarà il
modo in cui selezioniamo l'inizio da alcune tabelle.
Quindi quelle tabelle sono la fonte giusta.
Allo stesso modo, abbiamo una fonte qui su queste operazioni intermedie sarebbe qualcosa come il filtraggio
o la trasformazione o il raggruppamento così.
Quindi sono come le condizioni sono quelle che verranno dalle clausole.
Va bene.
E ciascuna delle operazioni allora intermedie la storia scritta.
OK, quindi, prima ci siamo concentrati sul filtro e sul filtro cholic, in sostanza sull'effetto filtro e
sono stati scritti in streaming un'istanza stirata a monte.
Quindi questa è un'operazione intermedia.
Allo stesso modo, c'è anche un operazione che possiamo fare ora qui lascia che esegua
questo, quindi questo è quello che abbiamo.
Questo è quello che abbiamo qui.
Quindi due dei documenti vengono stampati dai quattro perché ci sono due
dei documenti della strada.
Quindi ora questo è quello che abbiamo fatto qui.
Quindi a me le operazioni sono chiamate pigre e ho intenzione di spiegare il motivo per cui è
chiamato così sull'operazione terminale, così chiamata.
Quindi lo consideriamo mentre scriviamo il codice.
Quindi andiamo avanti e diciamo che abbiamo i documenti.
Quindi questa è la lista.
E siamo solo in disaccordo là che è stato introdotto nell'interfaccia di raccolta come ho detto prima.
Quindi questo è ciò che viene presentato qui ora sul flusso.
Quindi l'interfaccia di Richardson sull'interfaccia del flusso.
Quindi andiamo avanti e invochiamo il metodo del filtro.
OK, con questo stiamo ottenendo un flusso in modo che tu possa pensare a un flusso come sai solo un flusso di
qualcosa a monte di tutti i documenti e noi elaboreremo ciascuno di quei documenti.
Quindi invochiamo il metodo di filtro perché è quello che dobbiamo fare.
La prima cosa ed è proprio sopra lambda.
Quindi questo è un predicato.
Quindi se guardi lo streaming qui.
Quindi questo è piuttosto drammatico.
Quindi accetta un predicato.
Quindi questo è essenzialmente ciò che stiamo facendo qui.
Quindi lo stiamo assegnando a un predicato.
Ma qui stiamo facendo uso dell'API dei flussi.
Quindi una volta che il filtraggio è ciò di cui abbiamo bisogno, dobbiamo trasformarci.
Quindi, quale trasformazione esegue lo streaming perché il filtro restituirà un altro flusso un'altra istanza del flusso
che inizia a funzionare e quella che può mappare.
Quindi lo stream ha una rete che può mappare e all'interno della prima mappa dalla trasformazione di trasformazione.
Nella seconda mappa andremo a casa la seconda trasformazione.
Quindi la prima trasformazione sta semplicemente invocando questa striscia che GM attacca, così possiamo solo copiare
quel così ductwork di forma la prima trasformazione e questa è anche la seconda trasformazione che sta rumorizzando la
fine
sembra che stiamo solo stampando qui.
Quindi per quello.
Quindi mappalo anche.
Quindi entrambe queste tre sono operazioni intermedie e tutte sono eseguite nella mappa del flusso d'aria
che azzarda un flusso e filtra il tipo di aggiunta di un flusso.
Quindi, questo significa che finalmente possiamo invocare un'altra chiamata al metodo per ciascuno di
essi, quindi le puntate e il consumatore su di esso è un'operazione terminale.
Quindi con questo finiremo il flusso.
Quindi lasciami andare avanti e stampare questo.
Quindi qui mi permetta anche la discesa comune con questo strumento a strisce che abbiamo questa affermazione e rimarrà senza
commenti più tardi.
Quindi andiamo avanti e gestiamo questo.
Quindi, come puoi vedere, abbiamo esattamente lo stesso risultato qui e lo facciamo come dichiarante.
E possiamo vedere che è così ben scritto e molto elegante.
Quindi questo è quello che abbiamo.
E la prossima cosa di cui voglio parlare riguarda le operazioni pigre.
Ha detto che queste operazioni intermedie sono operazioni facili, il che significa che non ci sarà
esecuzione con l'invocazione qui.
Quindi non verranno eseguiti sotto l'invocazione di ciascun metodo.
OK finora ogni metodo è un'operazione dell'ego.
Quindi, solo quando GBM uscirà da questa istanza di dati, eseguirà queste diverse operazioni
intermedie che queste operazioni non verranno eseguite.
Quindi, guardiamolo veramente.
Lascia che te lo dimostri.
Quindi mettiamo quel punto e virgola qui.
Intendo questo comune.
Quindi qui questa è una mappa.
Sta andando a leggere su un flusso di stringa.
Si chiama estremo.
OK, questo è quello che abbiamo su lascia correre.
Quindi, come puoi vedere, non c'è output che sia noto per ogni affermazione.
Lascia che riporti anche questa cosa.
Vedi ora puoi vedere che nell'angolo imperativo sprintare questa affermazione stampata che è dentro la stupidità della mia tassa, ma
qui non sappiamo come dichiararlo in tribunale che nessuno di questi viene eseguito.
Quindi non siamo la stupidità del mio metodo fiscale non è stato nel mio libro.
Quindi abbiamo solo queste e queste sono operazioni pigre.
Ora lasciatemi solo trarre vantaggio da questo, perché possiamo fare in modo che
possiamo passare questo sogno a cui è stata data questa questione.
Quindi chiarirò la questione e dirò solo OK.
Quindi abbiamo questo barometro come flusso di forza.
Quindi questo è quello che abbiamo.
E se lo gestiamo ora possiamo vedere che otteniamo la speranza.
Quindi, se
chiamo Mundus non-ufficio non offerto come essere eseguito perché queste sono operazioni pigre ma se non commento su
di esso ironico si vede l'output perché abbiamo l'operazione ottimale qui.
Quindi questa è la cosa ora.
Quindi qui la fonte è questa.
Quindi puoi vedere che l'output è esattamente identico, il che significa che stiamo iterando attraverso i documenti nello
stream.
Quindi applichiamo il filtro sul primo filtro sul primo documento e poi se ha la
parola stream, quel documento viene trasformato qui.
Ecco perché abbiamo pacchetti geometrici ricchi di strisce.
OK.
E poi dopo stiamo facendo un'altra trasformazione e quindi stiamo stampando qui.
Così.
Quindi non è come stiamo facendo le trasformazioni agitate su tutti i documenti e quindi stiamo stampando.
Quindi non sta succedendo qui.
Quindi sta accadendo le operazioni sono esattamente identiche a come sta accadendo e alla
corte imperativa.
Quindi stiamo elaborando un documento alla volta e se passa il predicato allora applichiamo
le trasformazioni.
E poi lo stampiamo.
Questo è esattamente ciò che sta accadendo, quindi la funzionalità è identica.
È solo un codice molto più elegante.
Ora come ho detto prima, la fonte può essere qualcosa e immagazzinarla non deve essere solo un flusso.
Quindi lasciatemi commentare questo e lasciami dire che questa classe mi permetta di usare il vetro
dell'artista, ha questo nuovo metodo chiamato Dream e possiamo passare un'idea qui.
Quindi qui vogliamo utilizzare un ID come fonte per lo stream.
Quindi vediamo Neil.
Quindi stiamo passando un flusso e questa volta abbiamo l'idea come fonte.
Quindi, se corriamo di nuovo, sarà lo stesso risultato.
Oppure possiamo anche dire che possiamo avere anche un elenco di operatori virgola per questo che non è il mio terzo trimestre
qui nell'interfaccia del flusso.
Quindi possiamo solo invocarlo e possiamo passare tutti questi documenti come elenco di valori dell'operatore commerciale
con il metodo off.
Soit prende ciò che il nostro esperto dilettante.
Quindi, se sei di nuovo su questo, abbiamo lo stesso risultato.
Quindi in sintesi l'API dei flussi ci consente di trarre da alcune gravose ricadute sulle collezioni e in modo dichiarativo
che ci aiuta a capire come questo tipo di codice più pulito.
E come ho detto prima, può anche essere facilmente parallelizzabile.
E così è tutto.
E puoi anche dare un'occhiata a questo libro chiamato l'8 luglio in azione, è un ottimo libro scritto da
mia madre Mario.
Vai avanti allora, Mike Crocker, così puoi anche leggere quel libro.
Descrive così la celebrazione della filosofia dietro molte di queste caratteristiche dell'8 luglio in un modo molto carino.
Questa è la cosa che mi piace del libro, quindi è un libro molto buono.
Quando è possibile, puoi comprarlo se vuoi.
Adesso fammi anche solo tirare velocemente il flusso.
Quindi questo è al vapore.
È l'8 luglio ma puoi anche usare il 9 luglio e questa è l'interfaccia del flusso e questo è un pacchetto
di gelato.
Quindi questa è essenzialmente l'API del flusso e qui ci sono alcune interfacce.
E questa è l'interfaccia del flusso.
Quindi questo è quello che abbiamo qui.
Quindi questi sono i diversi metodi.
Quindi abbiamo già esaminato il filtro del metodo che sta prendendo un predicato.
Poi guardiamo anche al metodo di mappatura e possiamo anche guardare ad altri metodi, ma questo è il metodo della mappa
che prende la funzione.
OK.
Ed è che tutti i diversi metodi.
E dobbiamo anche aumentare.
Esistono anche altri metodi come l'uso dei record su Starcade.
Quindi questi sono tutti alcuni metodi.
In questa particolare interfaccia Ora
una cosa è una volta che si esegue
questa operazione in modo che non possiamo eseguire l'operazione del terminale ancora una volta in modo che il flusso sia stato chiuso.
OK.
E non possiamo eseguire l'operazione dominante per la seconda volta.
Dovremmo ricostruire nuovamente il flusso.
Quindi a causa di questo stiamo ottenendo questa eccezione di stato illegale.
Quindi questo è tutto.
Questa è una buona introduzione ai flussi e esploreremo ulteriormente le immagini successive.
Ma questo è ciò che speriamo per ora.
Quindi spero che ti sia piaciuto leggerlo a riguardo.
E grazie.
E felice citazione e discordia saranno disponibili nella sezione risorse.
Grazie.