Ciao, questo è dannoso per te.
E bentornato.
Continuiamo la nostra discussione sulla prima affermazione e in questa lezione impariamo su un
tipo di falsa istruzione chiamata per ogni affermazione per ogni affermazione introdotta nel file java e
aiuta principalmente Mitt iterando convenientemente su array e altre strutture di dati che vedremo in seguito nel capitolo
quadro delle collezioni.
Ora stiamo dicendo che permette una comoda iterazione e questo perché ogni dipartimento ha
una sintassi molto più semplice e pulita.
Ora, nell'ultima natura, abbiamo esaminato la prima affermazione e possiamo fare riferimento ad essa come prima
affermazione tradizionale poiché era presente fin dall'inizio di Java.
Ma per ogni affermazione non può essere utilizzato in determinati scenari.
E per quegli scenari dobbiamo usare la tradizionale prima affermazione e alla fine di
questa lezione vedremo due scenari.
Ora, nell'ultima lezione, abbiamo esaminato questa particolare altra dichiarazione in cui vediamo come un array con 10 elementi
da zero a nove.
E stavamo iterando attraverso l'array e stampando gli altri elementi.
E abbiamo anche detto che questo è il modo più comune in cui una prima affermazione può essere rappresentata.
Abbiamo anche preso in considerazione diverse rappresentazioni, ma abbiamo detto esplicitamente che questo è il modo più comune
in cui l'istruzione viene utilizzata almeno fino alla pubblicazione di Delphi.
E la ragione è perché normalmente in questa rappresentazione comune faremo come una dichiarazione di inizializzazione
come questa in cui dichiareremo una singola variabile e quindi avremo la dichiarazione di condizione
sull'istruzione di condizione, per lo più assomiglierebbe a questa.
Se non è.
Ci siamo limitati a garantire che stiamo iterando fino a raggiungere la dimensione dell'array.
E per quanto riguarda la lista di espressioni qui vorremmo semplicemente come un singolo operatore di post-incremento.
Cioè siamo sempre stati incrementati di 1.
Quindi questo è il modello più comune di rappresentazione più comune e possiamo
pensare che il 95 percento delle volte useremmo tale tipo di rappresentazione almeno fino a Java 5 così da
quando è così comunemente usato penso che Java i designer Java volessero inventare qualcosa che sarebbe molto più semplice
da rappresentare, ma realizzerà anche la stessa cosa.
Va bene.
Ed è perché è così comunemente usato così per quanto riguarda i designer Java che sono venuti a conoscenza
di ogni affermazione e vediamo come per ogni affermazione sembra che sia molto semplice.
Così sarebbe come lo stesso per le parole chiave tra parentesi e il corpo e chiuso e parentesi graffe.
Okay, andiamo avanti e stampiamo lo stesso su.
Così sarà anche come e poi chiamerò e sarà seguito da I.
Va bene, ma qui in realtà rappresento gli elementi della destra.
Considerando che qui si presenta l'indice dell'occhio destro, ecco l'indice dell'array e per accedere
all'elemento dovevamo fare qualcosa di simile. Scrivo via Solo allora otterremmo l'elemento dell'array.
Ma qui non sono l'indice e I è l'elemento stesso.
Quindi, se lo stampiamo, faremo qualcosa di simile, quindi non ne abbiamo bisogno perché io uso self come elemento r.
OK, questo è quello che abbiamo e, come puoi vedere, è molto più semplice e molto più semplice.
Quindi la variabile index è ancora lì ma è implicita in questo per ogni istruzione che è nascosta e anche
l'istruzione di condizione è presente ma è anche implicita.
Allo stesso modo aumenta anche l'operazione di incremento post, ma anche quella nascosta.
Va bene così la variabile indice è nascosta e non vediamo come nessuna di queste espressioni qui.
Quindi questo lo rende davvero più pulito.
Quindi questo viene aggiunto ma può anche essere altre strutture dati per sapere in inglese che possiamo leggerlo.
Come per ogni elemento i n i.
Quindi questo è il modo in cui possiamo leggerlo come un inglese e qui per ogni elemento I.
Quindi questo sono io e dentro e possiamo pensare che Colin sia N.
Va bene.
E poi abbiamo il diritto.
Quindi è quello che è.
Quindi ora facciamo.
Lasciami solo andare avanti e compilare ed eseguire questo.
Quindi questa è ancora la classe demo di base e questo non è il metodo principale.
Quindi fammi solo compilare ed eseguirlo.
Ecco qui.
Quindi stampa tutti gli elementi 0 2 9 ma la tradizionale istruzione di gran lunga non è limitata solo a matrici o altre
strutture di dati e può anche essere usata per rappresentare altri tipi di logica nell'ordine.
Abbiamo già esaminato un tipo di problema nell'ultima lezione in cui abbiamo esaminato i dispositivi di conteggio.
Quindi stavamo cercando di contare il numero di consulenti di un particolare valore.
Destra.
Quindi abbiamo usato una prima frase tradizionale e la prima frase tradizionale deve essere utilizzata per questo tipo
di problemi.
E guardiamo anche ad alcuni altri scenari in cui dobbiamo usare una prima dichiarazione tradizionale.
Quindi questo è tutto ciò che abbiamo per ciascuno.
Ora c'è un articolo ed efficace Java.
Si tratta dell'articolo 46 almeno nel nostro desiderio al posto del libro e il numero dell'articolo potrebbe essere qualcos'altro in
una versione diversa.
Quindi quell'elemento particolare che dice preferisce per ogni loop ai file tradizionali, quindi fammi
solo copiarlo qui.
OK.
Quindi questo è quello che dice.
Dice che è necessario preferire per ogni ciclo così, quando possibile, ai tradizionali permessi.
E qui ci sono le ragioni per cui una è la sintassi più chiara che abbiamo già visto e che abbiamo già visto.
E non vi è alcuna penalità di prestazioni nell'uso per ciascuno.
In effetti sembra che potrebbe essere leggermente migliore se ci occupiamo di array a causa di questo
ciclo tradizionale qui con ogni iterazione che stiamo calcolando la lunghezza e che viene preso in considerazione implicitamente
per ogni affermazione.
Sarà fatto solo una volta e quel valore sarà riutilizzato per ciascuna delle iterazioni.
OK, questo potrebbe dare un leggero vantaggio in termini di prestazioni per quanto riguarda le aree, ma non
ci sono sicuramente finalità definitive quando lo utilizziamo per ogni affermazione e elimineremo anche
ogni possibilità di errore ora.
Quindi questa è una lezione più recente, ma prima ho avuto una versione diversa della lezione che ho fatto
mentre stavo preparando quella conferenza stavo cercando di fare un esempio per la dimostrazione e mi sono imbattuto in un problema quando
stavo cercando di usare il tradizionale prima dichiarazione.
OK, lasciami solo mostrare qual è il problema.
Quindi il problema è di mostrare tutte le diverse combinazioni quando tiriamo una coppia di dadi DICE ha un singolo
DICE ha sei sei valori e se vogliamo lanciarlo li ripaga e se vogliamo mostrare tutte
le diverse combinazioni.
Vogliamo stampare quelle combinazioni in modo che possiamo usare una prima istruzione di estrazione.
Quindi lasciami andare avanti e scrivere una proprietà in affitto per fare qualcosa del genere.
Quindi abbiamo bisogno di dadi.
Quindi lasciami dichiarare che il primo è stato chiesto e chiamiamolo uno uguale a due uno e
basta copiare questo
dado 2.
Ora lascia che metta la prima istruzione
nidificata OK ora generalmente ciò che facciamo è che noi lo copiamo e lo incolliamo.
Questo è ciò che tendiamo a fare come programmatori.
E questo.
Facciamo un J e G meno di quei due punti di terra.
Andiamo avanti e stampiamo gli altri elementi
muore due di J.
Ora lasciami
andare avanti e compilare ed eseguire questo fammi fare questo.
Qui stiamo stampando le regole dei dadi e dopo aver stampato un numero inferiore
di regole stiamo ottenendo questa eccezione a un indice di array di record esclusa l'eccezione perché stiamo cercando di accedere e
ogni elemento che è al di fuori dell'array.
OK, quindi stiamo cercando di raggiungere un indice che si trova al di fuori del limite dell'array e ciò sta accadendo
qui perché abbiamo fatto un errore di copia e incolla.
Questo doveva essere I plus.
Ma abbiamo avuto un vantaggio in meno in questo caso l'ho fatto deliberatamente.
Ma come ho detto prima l'ultima volta, quando ci ho provato, è successo che non ho commesso quell'errore.
Quindi, quando è stato io, premo qui.
Quindi questo è quello che abbiamo qui.
Lascia che ti mostri solo perché stiamo ricevendo questo errore.
Quindi nella tradizione adottiva sarebbe il dado 1 0 0 e questo sarebbe il dado 2 di
0 il che significa che stamperebbe uno contro uno come possiamo vedere qui quindi nella seconda iterazione del ciclo interno
sarebbe un dado uno su due .
Destra.
Perché l'avevamo come me
Sarebbe un dado uno a uno scusa uno su uno che è anche qui.
E poi questo rimarrebbe ancora come un dado due a zero.
Perché non stiamo incrementando Jay da nessuna parte.
Sarebbe dadi 2 di 0 che è 1.
Quindi fa uno sprint per stirare uno e poi nella terza iterazione viene incrementato ancora una volta.
Quindi sarebbe uno dei due dadi uno su due come questo tre su Dadi due.
Sarebbe comunque zero.
Quindi è uno sprint tre su uno perché il primo elemento è uno qui.
Allo stesso modo avremo dadi uno dei quattro dadi due dei dadi zero uno dei cinque dadi due dei dadi zero uno
dei sei.
E quello è quando otteniamo l'errore e JVM getta questo errore.
Dice array array index out of exception eccezione perché stiamo cercando di accedere agli indici sei e
sei e abbiamo solo sei elementi.
OK.
Quindi, ma stiamo cercando di accedere al settimo elemento facendo un dado indice di sei.
Ecco perché stiamo ottenendo questo errore.
Ora se cambiamo questo in g come puoi
vedere Prince tutte le diverse combinazioni 1 1 1 2 1 3 2 1 2 2 6 3 1 2 3 6 e
così via 6 1 2 6 6.
OK.
Quindi questo è quello che è.
Ma se usiamo una prima istruzione nidificata non avremo questo problema con un nidificato, semplicemente lo facciamo,
diciamo
che abbiamo appena copiato come nel caso dei quattro tradizionali e lo abbiamo fatto, diciamo
per esempio diciamo che ti sei persino dimenticato di cambia questo a G.
Va bene così in questo caso, se lo compilo, otteniamo solo un errore di compilazione.
Dice che la variabile I è già definita e mi fa da guida.
Va bene così, anche se abbiamo bisogno di un errore di copia e incolla, otterremmo questo errore e questo errore è dovuto al fatto che siamo
all'interno del metodo principale e questa è una variabile locale e questa è una variabile locale.
Quindi una variabile locale non può ombreggiare o nascondere un'altra variabile locale.
Va bene così è lì e lo vedremo anche in una delle lezioni di follow-up
quando discuteremo sull'ambito della variabile, ma sappiamo che una variabile locale può nascondere o ombreggiare una variabile di istanza.
Destra.
Abbiamo visto che nel qual caso dovremmo usare questo riferimento per accedere alla variabile di
istanza.
Va bene quindi una variabile locale che nasconde una variabile di istanza è perfettamente a posto, ma una variabile locale non può nascondere
un'altra variabile locale con lo stesso metodo.
E questo è ciò che sta accadendo qui.
Questo stiamo cercando di nascondere questo con questo e otteniamo un errore di compilazione.
Quindi è molto facile da risolvere ora.
Quindi lo diremo e prendiamo semplicemente questa cosa e non abbiamo bisogno di niente di quello che hai appena bisogno di G
su qualsiasi cosa comune.
Tu vai.
Quindi abbiamo la stessa uscita ok.
Quindi è questo per ogni affermazione che è particolarmente preferita per le iterazioni annidate.
Quindi è così.
Quindi, l'ultima cosa che vogliamo osservare è che abbiamo esaminato ogni singola affermazione e ci sta permettendo
di iterare convenientemente attraverso due aree su altre strutture di dati.
Quindi, quando lo vogliamo, uno sarebbe breve per i quattro tradizionali.
Va bene.
Vorremmo farlo se avessimo bisogno se avessimo bisogno di accedere all'indice in quel momento dovremmo usare un lobo frontale tradizionale perché
per ognuno non va ad accedere all'indice.
Va bene.
Ora ci sono alcuni scenari in cui avremmo bisogno che, per esempio, tu voglia trasformare il giusto.
Va bene.
Quindi hai l'array e vuoi vedere come mescolare gli elementi dell'array o se ricordi nell'ultima
lezione abbiamo guardato questo particolare esempio in cui avevamo questo array ma lo abbiamo fatto e un capovolgimento
degli elementi del array.
Okay, abbiamo creato un array inverso e abbiamo scritto questa logica per questo.
E alla fine se stampiamo stava stampando gli elementi in ordine inverso.
Destra.
Quindi gli elementi venivano scambiati qui in ogni iterazione.
Quindi, se vuoi farlo, dobbiamo andare per i quattro tradizionali perché abbiamo bisogno di scambiare gli elementi
in ogni iterazione.
E quindi abbiamo bisogno di accedere all'indice.
Quindi ci stavamo trasformando la matrice.
Va bene.
Ecco quando avremo bisogno di questo.
E la seconda cosa è se vogliamo fare un'iterazione parallela, okay, la tradizione parallela è in ogni iterazione
di un ciclo for.
Abbiamo più array che abbiamo bisogno di iterare per bene.
Dobbiamo eseguire iterazioni su più array nella stessa iterazione.
Quindi lo chiamiamo fa l'iterazione parallela.
E per ognuno non lo supporterebbe.
Quindi prendiamo questo per esempio.
In realtà questo, ma non abbiamo bisogno di un
nidificante, puoi farlo qui.
X e incollalo qui e possiamo inizializzare G uguale a zero qui e vedremmo G plus plus.
E possiamo rimuovere l'intera cosa in modo che sia un singolo singolo di iterazione per un ciclo in modo da stampare i dadi 1 di
0 dadi 2 di 0 su così via.
Quindi lasciami solo
intendo solo per mettere che scrive una riga vuota lì.
OK, eccolo qui.
Questo è l'ultimo.
Quindi questa è un'iterazione parallela di due aree.
Quindi se vogliamo farlo dobbiamo andare per il tradizionale quattro perché con ogni affermazione possiamo solo
come un singolo.
Ari non possiamo avere multipli perché questa è la sintassi di ciascuno.
Quindi questa è l'iterazione parallela.
E la terza è l'iterazione a rovescio.
Quindi, se devi tornare indietro se devi eseguire un iterare all'indietro, devi andare per la prima frase
tradizionale e se ricordi nella lezione precedente anche prima di implementarla.
OK.
Prima di fare l'inversione dell'ordine, avevamo in effetti una prima affermazione in cui stavamo visualizzando gli elementi
dalla direzione indietro e quindi la variabile indice doveva essere discriminata.
Quindi, se mai dovessimo fare una cosa del genere, dovremmo usare l'abete tradizionale e per ognuno
sarà sempre solo l'iterazione in avanti.
In modo che il set e l'articolo l'articolo 46 e l'efficace libro Java parlino anche di uno scenario in
più o meno lusinghiero.
Quindi il filtraggio entra in gioco quando stiamo osservando altre strutture di dati dalle
raccolte del capitolo del libro, dove mentre stiamo iterando in una determinata iterazione avremmo un elemento e se vogliamo
rimuoverlo è uno scenario in cui avremmo bisogno di qualcosa come un tradizionale prima affermazione e questa lotta
non funzionerà per quello.
Quindi questo è un esempio.
Ma dal momento che non abbiamo a che fare con queste strutture di dati, qui non abbiamo l'esempio qui.
OK, quindi non abbiamo intenzione di discuterne ulteriormente.
Ma qualcosa del genere sarà discusso nel capitolo del manuale sulle collezioni.
Quindi è importante.
Quindi questo è il per ogni affermazione.
È utile principalmente per iterare comodamente attraverso array e altre strutture dati.
OK.
Quindi è usato come strumento alternativo.
Quindi a questo modello comune che avevamo usato con la farm tradizionale e ha una sintassi molto
più semplice e non ha alcuna penalizzazione delle prestazioni ed elimina anche ogni possibilità di errore.
OK.
Quindi questo è il per ciascuno.
Quindi, quando è possibile, è necessario utilizzare per ogni ciclo come questo elemento raccomanda prima per ogni file
N2 tradizionale.
Questo è tutto.
Grazie e buon codice.
Ci vediamo nella prossima lezione.