1
00:00:02,190 --> 00:00:04,320
Ciao, questo è dannoso per te.

2
00:00:04,410 --> 00:00:05,520
E bentornato.

3
00:00:05,520 --> 00:00:11,880
Continuiamo la nostra discussione sulla prima affermazione e in questa lezione impariamo su un

4
00:00:11,880 --> 00:00:18,600
tipo di falsa istruzione chiamata per ogni affermazione per ogni affermazione introdotta nel file java e

5
00:00:18,600 --> 00:00:26,430
aiuta principalmente Mitt iterando convenientemente su array e altre strutture di dati che vedremo in seguito nel capitolo

6
00:00:26,430 --> 00:00:27,840
quadro delle collezioni.

7
00:00:27,870 --> 00:00:33,720
Ora stiamo dicendo che permette una comoda iterazione e questo perché ogni dipartimento ha

8
00:00:33,720 --> 00:00:37,300
una sintassi molto più semplice e pulita.

9
00:00:37,350 --> 00:00:43,610
Ora, nell'ultima natura, abbiamo esaminato la prima affermazione e possiamo fare riferimento ad essa come prima

10
00:00:43,610 --> 00:00:47,210
affermazione tradizionale poiché era presente fin dall'inizio di Java.

11
00:00:48,060 --> 00:00:51,630
Ma per ogni affermazione non può essere utilizzato in determinati scenari.

12
00:00:51,630 --> 00:00:57,270
E per quegli scenari dobbiamo usare la tradizionale prima affermazione e alla fine di

13
00:00:57,360 --> 00:00:59,730
questa lezione vedremo due scenari.

14
00:00:59,730 --> 00:01:06,330
Ora, nell'ultima lezione, abbiamo esaminato questa particolare altra dichiarazione in cui vediamo come un array con 10 elementi

15
00:01:06,330 --> 00:01:07,940
da zero a nove.

16
00:01:08,130 --> 00:01:11,750
E stavamo iterando attraverso l'array e stampando gli altri elementi.

17
00:01:12,000 --> 00:01:17,970
E abbiamo anche detto che questo è il modo più comune in cui una prima affermazione può essere rappresentata.

18
00:01:17,970 --> 00:01:24,030
Abbiamo anche preso in considerazione diverse rappresentazioni, ma abbiamo detto esplicitamente che questo è il modo più comune

19
00:01:24,060 --> 00:01:27,780
in cui l'istruzione viene utilizzata almeno fino alla pubblicazione di Delphi.

20
00:01:28,410 --> 00:01:35,490
E la ragione è perché normalmente in questa rappresentazione comune faremo come una dichiarazione di inizializzazione

21
00:01:35,490 --> 00:01:42,330
come questa in cui dichiareremo una singola variabile e quindi avremo la dichiarazione di condizione

22
00:01:42,920 --> 00:01:47,060
sull'istruzione di condizione, per lo più assomiglierebbe a questa.

23
00:01:47,310 --> 00:01:48,060
Se non è.

24
00:01:48,090 --> 00:01:53,340
Ci siamo limitati a garantire che stiamo iterando fino a raggiungere la dimensione dell'array.

25
00:01:54,180 --> 00:02:01,410
E per quanto riguarda la lista di espressioni qui vorremmo semplicemente come un singolo operatore di post-incremento.

26
00:02:01,500 --> 00:02:04,470
Cioè siamo sempre stati incrementati di 1.

27
00:02:04,500 --> 00:02:10,920
Quindi questo è il modello più comune di rappresentazione più comune e possiamo

28
00:02:10,920 --> 00:02:19,590
pensare che il 95 percento delle volte useremmo tale tipo di rappresentazione almeno fino a Java 5 così da

29
00:02:19,590 --> 00:02:28,170
quando è così comunemente usato penso che Java i designer Java volessero inventare qualcosa che sarebbe molto più semplice

30
00:02:28,290 --> 00:02:32,350
da rappresentare, ma realizzerà anche la stessa cosa.

31
00:02:32,760 --> 00:02:33,190
Va bene.

32
00:02:33,240 --> 00:02:40,780
Ed è perché è così comunemente usato così per quanto riguarda i designer Java che sono venuti a conoscenza

33
00:02:40,780 --> 00:02:46,570
di ogni affermazione e vediamo come per ogni affermazione sembra che sia molto semplice.

34
00:02:46,870 --> 00:02:54,010
Così sarebbe come lo stesso per le parole chiave tra parentesi e il corpo e chiuso e parentesi graffe.

35
00:02:54,290 --> 00:02:57,310
Okay, andiamo avanti e stampiamo lo stesso su.

36
00:02:57,370 --> 00:03:05,860
Così sarà anche come e poi chiamerò e sarà seguito da I.

37
00:03:06,630 --> 00:03:13,210
Va bene, ma qui in realtà rappresento gli elementi della destra.

38
00:03:13,720 --> 00:03:21,400
Considerando che qui si presenta l'indice dell'occhio destro, ecco l'indice dell'array e per accedere

39
00:03:21,400 --> 00:03:28,870
all'elemento dovevamo fare qualcosa di simile. Scrivo via Solo allora otterremmo l'elemento dell'array.

40
00:03:29,560 --> 00:03:34,300
Ma qui non sono l'indice e I è l'elemento stesso.

41
00:03:34,360 --> 00:03:43,050
Quindi, se lo stampiamo, faremo qualcosa di simile, quindi non ne abbiamo bisogno perché io uso self come elemento r.

42
00:03:43,810 --> 00:03:48,880
OK, questo è quello che abbiamo e, come puoi vedere, è molto più semplice e molto più semplice.

43
00:03:48,880 --> 00:03:56,860
Quindi la variabile index è ancora lì ma è implicita in questo per ogni istruzione che è nascosta e anche

44
00:03:57,250 --> 00:04:00,860
l'istruzione di condizione è presente ma è anche implicita.

45
00:04:01,240 --> 00:04:07,500
Allo stesso modo aumenta anche l'operazione di incremento post, ma anche quella nascosta.

46
00:04:07,540 --> 00:04:13,430
Va bene così la variabile indice è nascosta e non vediamo come nessuna di queste espressioni qui.

47
00:04:13,540 --> 00:04:16,670
Quindi questo lo rende davvero più pulito.

48
00:04:16,690 --> 00:04:21,890
Quindi questo viene aggiunto ma può anche essere altre strutture dati per sapere in inglese che possiamo leggerlo.

49
00:04:21,910 --> 00:04:27,890
Come per ogni elemento i n i.

50
00:04:28,000 --> 00:04:33,730
Quindi questo è il modo in cui possiamo leggerlo come un inglese e qui per ogni elemento I.

51
00:04:33,760 --> 00:04:38,870
Quindi questo sono io e dentro e possiamo pensare che Colin sia N.

52
00:04:38,920 --> 00:04:39,360
Va bene.

53
00:04:39,430 --> 00:04:41,470
E poi abbiamo il diritto.

54
00:04:42,460 --> 00:04:44,440
Quindi è quello che è.

55
00:04:44,480 --> 00:04:45,740
Quindi ora facciamo.

56
00:04:45,740 --> 00:04:48,190
Lasciami solo andare avanti e compilare ed eseguire questo.

57
00:04:48,200 --> 00:04:52,260
Quindi questa è ancora la classe demo di base e questo non è il metodo principale.

58
00:04:52,580 --> 00:04:58,110
Quindi fammi solo compilare ed eseguirlo.

59
00:04:58,170 --> 00:04:58,750
Ecco qui.

60
00:04:59,160 --> 00:05:08,810
Quindi stampa tutti gli elementi 0 2 9 ma la tradizionale istruzione di gran lunga non è limitata solo a matrici o altre

61
00:05:08,820 --> 00:05:15,330
strutture di dati e può anche essere usata per rappresentare altri tipi di logica nell'ordine.

62
00:05:15,570 --> 00:05:22,830
Abbiamo già esaminato un tipo di problema nell'ultima lezione in cui abbiamo esaminato i dispositivi di conteggio.

63
00:05:23,060 --> 00:05:27,840
Quindi stavamo cercando di contare il numero di consulenti di un particolare valore.

64
00:05:27,840 --> 00:05:28,100
Destra.

65
00:05:28,110 --> 00:05:34,110
Quindi abbiamo usato una prima frase tradizionale e la prima frase tradizionale deve essere utilizzata per questo tipo

66
00:05:34,110 --> 00:05:34,970
di problemi.

67
00:05:35,250 --> 00:05:39,960
E guardiamo anche ad alcuni altri scenari in cui dobbiamo usare una prima dichiarazione tradizionale.

68
00:05:40,560 --> 00:05:43,120
Quindi questo è tutto ciò che abbiamo per ciascuno.

69
00:05:43,140 --> 00:05:46,160
Ora c'è un articolo ed efficace Java.

70
00:05:46,200 --> 00:05:53,010
Si tratta dell'articolo 46 almeno nel nostro desiderio al posto del libro e il numero dell'articolo potrebbe essere qualcos'altro in

71
00:05:53,010 --> 00:05:54,300
una versione diversa.

72
00:05:54,300 --> 00:06:01,060
Quindi quell'elemento particolare che dice preferisce per ogni loop ai file tradizionali, quindi fammi

73
00:06:03,630 --> 00:06:05,610
solo copiarlo qui.

74
00:06:05,610 --> 00:06:05,800
OK.

75
00:06:05,810 --> 00:06:06,600
Quindi questo è quello che dice.

76
00:06:06,600 --> 00:06:12,100
Dice che è necessario preferire per ogni ciclo così, quando possibile, ai tradizionali permessi.

77
00:06:12,190 --> 00:06:18,230
E qui ci sono le ragioni per cui una è la sintassi più chiara che abbiamo già visto e che abbiamo già visto.

78
00:06:18,510 --> 00:06:22,630
E non vi è alcuna penalità di prestazioni nell'uso per ciascuno.

79
00:06:22,710 --> 00:06:28,990
In effetti sembra che potrebbe essere leggermente migliore se ci occupiamo di array a causa di questo

80
00:06:29,010 --> 00:06:35,580
ciclo tradizionale qui con ogni iterazione che stiamo calcolando la lunghezza e che viene preso in considerazione implicitamente

81
00:06:35,580 --> 00:06:36,880
per ogni affermazione.

82
00:06:36,900 --> 00:06:42,330
Sarà fatto solo una volta e quel valore sarà riutilizzato per ciascuna delle iterazioni.

83
00:06:42,330 --> 00:06:49,860
OK, questo potrebbe dare un leggero vantaggio in termini di prestazioni per quanto riguarda le aree, ma non

84
00:06:49,860 --> 00:06:56,190
ci sono sicuramente finalità definitive quando lo utilizziamo per ogni affermazione e elimineremo anche

85
00:06:56,190 --> 00:06:58,580
ogni possibilità di errore ora.

86
00:06:58,790 --> 00:07:05,130
Quindi questa è una lezione più recente, ma prima ho avuto una versione diversa della lezione che ho fatto

87
00:07:05,130 --> 00:07:12,330
mentre stavo preparando quella conferenza stavo cercando di fare un esempio per la dimostrazione e mi sono imbattuto in un problema quando

88
00:07:12,330 --> 00:07:15,120
stavo cercando di usare il tradizionale prima dichiarazione.

89
00:07:15,480 --> 00:07:18,590
OK, lasciami solo mostrare qual è il problema.

90
00:07:18,630 --> 00:07:27,750
Quindi il problema è di mostrare tutte le diverse combinazioni quando tiriamo una coppia di dadi DICE ha un singolo

91
00:07:27,750 --> 00:07:35,400
DICE ha sei sei valori e se vogliamo lanciarlo li ripaga e se vogliamo mostrare tutte

92
00:07:35,610 --> 00:07:37,460
le diverse combinazioni.

93
00:07:37,800 --> 00:07:41,260
Vogliamo stampare quelle combinazioni in modo che possiamo usare una prima istruzione di estrazione.

94
00:07:41,520 --> 00:07:47,260
Quindi lasciami andare avanti e scrivere una proprietà in affitto per fare qualcosa del genere.

95
00:07:47,310 --> 00:07:48,570
Quindi abbiamo bisogno di dadi.

96
00:07:49,470 --> 00:07:57,240
Quindi lasciami dichiarare che il primo è stato chiesto e chiamiamolo uno uguale a due uno e

97
00:08:00,330 --> 00:08:01,630
basta copiare questo

98
00:08:04,330 --> 00:08:05,380
dado 2.

99
00:08:05,440 --> 00:08:08,310
Ora lascia che metta la prima istruzione

100
00:08:13,880 --> 00:08:19,870
nidificata OK ora generalmente ciò che facciamo è che noi lo copiamo e lo incolliamo.

101
00:08:19,900 --> 00:08:22,320
Questo è ciò che tendiamo a fare come programmatori.

102
00:08:22,780 --> 00:08:23,670
E questo.

103
00:08:23,800 --> 00:08:31,020
Facciamo un J e G meno di quei due punti di terra.

104
00:08:31,060 --> 00:08:33,670
Andiamo avanti e stampiamo gli altri elementi

105
00:08:42,980 --> 00:08:44,840
muore due di J.

106
00:08:45,740 --> 00:08:48,200
Ora lasciami

107
00:08:53,540 --> 00:09:01,550
andare avanti e compilare ed eseguire questo fammi fare questo.

108
00:09:01,570 --> 00:09:06,540
Qui stiamo stampando le regole dei dadi e dopo aver stampato un numero inferiore

109
00:09:06,870 --> 00:09:13,850
di regole stiamo ottenendo questa eccezione a un indice di array di record esclusa l'eccezione perché stiamo cercando di accedere e

110
00:09:13,880 --> 00:09:16,910
ogni elemento che è al di fuori dell'array.

111
00:09:17,100 --> 00:09:22,710
OK, quindi stiamo cercando di raggiungere un indice che si trova al di fuori del limite dell'array e ciò sta accadendo

112
00:09:22,890 --> 00:09:25,740
qui perché abbiamo fatto un errore di copia e incolla.

113
00:09:25,800 --> 00:09:29,150
Questo doveva essere I plus.

114
00:09:29,160 --> 00:09:33,270
Ma abbiamo avuto un vantaggio in meno in questo caso l'ho fatto deliberatamente.

115
00:09:33,480 --> 00:09:39,340
Ma come ho detto prima l'ultima volta, quando ci ho provato, è successo che non ho commesso quell'errore.

116
00:09:39,390 --> 00:09:42,780
Quindi, quando è stato io, premo qui.

117
00:09:42,810 --> 00:09:44,400
Quindi questo è quello che abbiamo qui.

118
00:09:44,400 --> 00:09:47,110
Lascia che ti mostri solo perché stiamo ricevendo questo errore.

119
00:09:47,180 --> 00:09:52,470
Quindi nella tradizione adottiva sarebbe il dado 1 0 0 e questo sarebbe il dado 2 di

120
00:09:52,470 --> 00:09:58,680
0 il che significa che stamperebbe uno contro uno come possiamo vedere qui quindi nella seconda iterazione del ciclo interno

121
00:09:58,710 --> 00:10:00,940
sarebbe un dado uno su due .

122
00:10:00,960 --> 00:10:01,160
Destra.

123
00:10:01,170 --> 00:10:03,340
Perché l'avevamo come me

124
00:10:03,360 --> 00:10:07,840
Sarebbe un dado uno a uno scusa uno su uno che è anche qui.

125
00:10:08,040 --> 00:10:11,910
E poi questo rimarrebbe ancora come un dado due a zero.

126
00:10:12,270 --> 00:10:14,830
Perché non stiamo incrementando Jay da nessuna parte.

127
00:10:14,850 --> 00:10:17,140
Sarebbe dadi 2 di 0 che è 1.

128
00:10:17,160 --> 00:10:22,730
Quindi fa uno sprint per stirare uno e poi nella terza iterazione viene incrementato ancora una volta.

129
00:10:22,760 --> 00:10:28,250
Quindi sarebbe uno dei due dadi uno su due come questo tre su Dadi due.

130
00:10:28,350 --> 00:10:29,790
Sarebbe comunque zero.

131
00:10:30,060 --> 00:10:36,540
Quindi è uno sprint tre su uno perché il primo elemento è uno qui.

132
00:10:36,540 --> 00:10:43,410
Allo stesso modo avremo dadi uno dei quattro dadi due dei dadi zero uno dei cinque dadi due dei dadi zero uno

133
00:10:43,410 --> 00:10:44,390
dei sei.

134
00:10:44,460 --> 00:10:50,120
E quello è quando otteniamo l'errore e JVM getta questo errore.

135
00:10:50,130 --> 00:10:57,870
Dice array array index out of exception eccezione perché stiamo cercando di accedere agli indici sei e

136
00:10:58,140 --> 00:11:00,980
sei e abbiamo solo sei elementi.

137
00:11:00,990 --> 00:11:01,310
OK.

138
00:11:01,350 --> 00:11:06,390
Quindi, ma stiamo cercando di accedere al settimo elemento facendo un dado indice di sei.

139
00:11:06,420 --> 00:11:08,810
Ecco perché stiamo ottenendo questo errore.

140
00:11:08,850 --> 00:11:11,580
Ora se cambiamo questo in g come puoi

141
00:11:16,530 --> 00:11:24,480
vedere Prince tutte le diverse combinazioni 1 1 1 2 1 3 2 1 2 2 6 3 1 2 3 6 e

142
00:11:24,510 --> 00:11:27,020
così via 6 1 2 6 6.

143
00:11:27,030 --> 00:11:27,710
OK.

144
00:11:27,930 --> 00:11:29,340
Quindi questo è quello che è.

145
00:11:29,700 --> 00:11:37,050
Ma se usiamo una prima istruzione nidificata non avremo questo problema con un nidificato, semplicemente lo facciamo,

146
00:11:37,260 --> 00:11:37,800
diciamo

147
00:11:41,050 --> 00:11:47,870
che abbiamo appena copiato come nel caso dei quattro tradizionali e lo abbiamo fatto, diciamo

148
00:11:47,890 --> 00:11:54,160
per esempio diciamo che ti sei persino dimenticato di cambia questo a G.

149
00:11:54,990 --> 00:12:01,790
Va bene così in questo caso, se lo compilo, otteniamo solo un errore di compilazione.

150
00:12:02,080 --> 00:12:07,140
Dice che la variabile I è già definita e mi fa da guida.

151
00:12:07,260 --> 00:12:14,770
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

152
00:12:14,840 --> 00:12:19,660
all'interno del metodo principale e questa è una variabile locale e questa è una variabile locale.

153
00:12:19,660 --> 00:12:24,520
Quindi una variabile locale non può ombreggiare o nascondere un'altra variabile locale.

154
00:12:24,520 --> 00:12:30,940
Va bene così è lì e lo vedremo anche in una delle lezioni di follow-up

155
00:12:30,940 --> 00:12:38,200
quando discuteremo sull'ambito della variabile, ma sappiamo che una variabile locale può nascondere o ombreggiare una variabile di istanza.

156
00:12:38,260 --> 00:12:38,590
Destra.

157
00:12:38,590 --> 00:12:44,710
Abbiamo visto che nel qual caso dovremmo usare questo riferimento per accedere alla variabile di

158
00:12:44,710 --> 00:12:45,550
istanza.

159
00:12:45,550 --> 00:12:52,090
Va bene quindi una variabile locale che nasconde una variabile di istanza è perfettamente a posto, ma una variabile locale non può nascondere

160
00:12:52,150 --> 00:12:54,370
un'altra variabile locale con lo stesso metodo.

161
00:12:54,370 --> 00:12:56,020
E questo è ciò che sta accadendo qui.

162
00:12:56,090 --> 00:13:00,550
Questo stiamo cercando di nascondere questo con questo e otteniamo un errore di compilazione.

163
00:13:00,760 --> 00:13:02,790
Quindi è molto facile da risolvere ora.

164
00:13:02,800 --> 00:13:13,460
Quindi lo diremo e prendiamo semplicemente questa cosa e non abbiamo bisogno di niente di quello che hai appena bisogno di G

165
00:13:13,670 --> 00:13:16,030
su qualsiasi cosa comune.

166
00:13:23,890 --> 00:13:24,360
Tu vai.

167
00:13:24,360 --> 00:13:27,210
Quindi abbiamo la stessa uscita ok.

168
00:13:27,270 --> 00:13:33,300
Quindi è questo per ogni affermazione che è particolarmente preferita per le iterazioni annidate.

169
00:13:33,300 --> 00:13:33,920
Quindi è così.

170
00:13:34,110 --> 00:13:39,990
Quindi, l'ultima cosa che vogliamo osservare è che abbiamo esaminato ogni singola affermazione e ci sta permettendo

171
00:13:39,990 --> 00:13:44,130
di iterare convenientemente attraverso due aree su altre strutture di dati.

172
00:13:44,130 --> 00:13:52,180
Quindi, quando lo vogliamo, uno sarebbe breve per i quattro tradizionali.

173
00:13:52,690 --> 00:13:52,960
Va bene.

174
00:13:52,980 --> 00:14:02,790
Vorremmo farlo se avessimo bisogno se avessimo bisogno di accedere all'indice in quel momento dovremmo usare un lobo frontale tradizionale perché

175
00:14:02,790 --> 00:14:06,630
per ognuno non va ad accedere all'indice.

176
00:14:06,630 --> 00:14:06,900
Va bene.

177
00:14:06,900 --> 00:14:13,920
Ora ci sono alcuni scenari in cui avremmo bisogno che, per esempio, tu voglia trasformare il giusto.

178
00:14:14,290 --> 00:14:14,510
Va bene.

179
00:14:14,520 --> 00:14:20,820
Quindi hai l'array e vuoi vedere come mescolare gli elementi dell'array o se ricordi nell'ultima

180
00:14:20,820 --> 00:14:28,610
lezione abbiamo guardato questo particolare esempio in cui avevamo questo array ma lo abbiamo fatto e un capovolgimento

181
00:14:28,780 --> 00:14:30,990
degli elementi del array.

182
00:14:31,240 --> 00:14:35,380
Okay, abbiamo creato un array inverso e abbiamo scritto questa logica per questo.

183
00:14:35,490 --> 00:14:39,810
E alla fine se stampiamo stava stampando gli elementi in ordine inverso.

184
00:14:39,870 --> 00:14:40,140
Destra.

185
00:14:40,500 --> 00:14:43,730
Quindi gli elementi venivano scambiati qui in ogni iterazione.

186
00:14:44,040 --> 00:14:51,840
Quindi, se vuoi farlo, dobbiamo andare per i quattro tradizionali perché abbiamo bisogno di scambiare gli elementi

187
00:14:51,870 --> 00:14:53,450
in ogni iterazione.

188
00:14:53,480 --> 00:14:55,390
E quindi abbiamo bisogno di accedere all'indice.

189
00:14:55,440 --> 00:14:57,410
Quindi ci stavamo trasformando la matrice.

190
00:14:57,650 --> 00:14:57,850
Va bene.

191
00:14:57,900 --> 00:15:00,360
Ecco quando avremo bisogno di questo.

192
00:15:00,360 --> 00:15:07,380
E la seconda cosa è se vogliamo fare un'iterazione parallela, okay, la tradizione parallela è in ogni iterazione

193
00:15:07,710 --> 00:15:09,660
di un ciclo for.

194
00:15:09,660 --> 00:15:14,020
Abbiamo più array che abbiamo bisogno di iterare per bene.

195
00:15:14,100 --> 00:15:17,710
Dobbiamo eseguire iterazioni su più array nella stessa iterazione.

196
00:15:17,820 --> 00:15:20,180
Quindi lo chiamiamo fa l'iterazione parallela.

197
00:15:20,340 --> 00:15:22,460
E per ognuno non lo supporterebbe.

198
00:15:22,500 --> 00:15:26,570
Quindi prendiamo questo per esempio.

199
00:15:26,830 --> 00:15:30,520
In realtà questo, ma non abbiamo bisogno di un

200
00:15:33,930 --> 00:15:35,810
nidificante, puoi farlo qui.

201
00:15:35,950 --> 00:15:49,710
X e incollalo qui e possiamo inizializzare G uguale a zero qui e vedremmo G plus plus.

202
00:15:49,740 --> 00:15:57,640
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

203
00:15:57,700 --> 00:16:00,530
0 dadi 2 di 0 su così via.

204
00:16:00,550 --> 00:16:01,690
Quindi lasciami solo

205
00:16:07,500 --> 00:16:10,260
intendo solo per mettere che scrive una riga vuota lì.

206
00:16:14,900 --> 00:16:16,060
OK, eccolo qui.

207
00:16:16,070 --> 00:16:17,030
Questo è l'ultimo.

208
00:16:17,720 --> 00:16:21,470
Quindi questa è un'iterazione parallela di due aree.

209
00:16:21,470 --> 00:16:28,120
Quindi se vogliamo farlo dobbiamo andare per il tradizionale quattro perché con ogni affermazione possiamo solo

210
00:16:28,130 --> 00:16:29,670
come un singolo.

211
00:16:29,730 --> 00:16:34,180
Ari non possiamo avere multipli perché questa è la sintassi di ciascuno.

212
00:16:34,190 --> 00:16:35,610
Quindi questa è l'iterazione parallela.

213
00:16:35,630 --> 00:16:40,760
E la terza è l'iterazione a rovescio.

214
00:16:40,760 --> 00:16:48,050
Quindi, se devi tornare indietro se devi eseguire un iterare all'indietro, devi andare per la prima frase

215
00:16:48,530 --> 00:16:53,920
tradizionale e se ricordi nella lezione precedente anche prima di implementarla.

216
00:16:53,980 --> 00:16:54,260
OK.

217
00:16:54,350 --> 00:17:01,400
Prima di fare l'inversione dell'ordine, avevamo in effetti una prima affermazione in cui stavamo visualizzando gli elementi

218
00:17:01,400 --> 00:17:06,500
dalla direzione indietro e quindi la variabile indice doveva essere discriminata.

219
00:17:06,800 --> 00:17:14,120
Quindi, se mai dovessimo fare una cosa del genere, dovremmo usare l'abete tradizionale e per ognuno

220
00:17:14,120 --> 00:17:17,450
sarà sempre solo l'iterazione in avanti.

221
00:17:17,450 --> 00:17:25,050
In modo che il set e l'articolo l'articolo 46 e l'efficace libro Java parlino anche di uno scenario in

222
00:17:25,150 --> 00:17:26,750
più o meno lusinghiero.

223
00:17:26,880 --> 00:17:32,120
Quindi il filtraggio entra in gioco quando stiamo osservando altre strutture di dati dalle

224
00:17:32,150 --> 00:17:38,630
raccolte del capitolo del libro, dove mentre stiamo iterando in una determinata iterazione avremmo un elemento e se vogliamo

225
00:17:38,630 --> 00:17:44,950
rimuoverlo è uno scenario in cui avremmo bisogno di qualcosa come un tradizionale prima affermazione e questa lotta

226
00:17:44,960 --> 00:17:46,680
non funzionerà per quello.

227
00:17:46,730 --> 00:17:47,890
Quindi questo è un esempio.

228
00:17:47,900 --> 00:17:54,850
Ma dal momento che non abbiamo a che fare con queste strutture di dati, qui non abbiamo l'esempio qui.

229
00:17:54,850 --> 00:17:57,100
OK, quindi non abbiamo intenzione di discuterne ulteriormente.

230
00:17:57,290 --> 00:18:00,430
Ma qualcosa del genere sarà discusso nel capitolo del manuale sulle collezioni.

231
00:18:00,830 --> 00:18:01,700
Quindi è importante.

232
00:18:01,730 --> 00:18:03,490
Quindi questo è il per ogni affermazione.

233
00:18:03,590 --> 00:18:10,070
È utile principalmente per iterare comodamente attraverso array e altre strutture dati.

234
00:18:10,070 --> 00:18:10,330
OK.

235
00:18:10,340 --> 00:18:12,500
Quindi è usato come strumento alternativo.

236
00:18:12,500 --> 00:18:19,820
Quindi a questo modello comune che avevamo usato con la farm tradizionale e ha una sintassi molto

237
00:18:20,240 --> 00:18:27,500
più semplice e non ha alcuna penalizzazione delle prestazioni ed elimina anche ogni possibilità di errore.

238
00:18:27,790 --> 00:18:28,320
OK.

239
00:18:28,490 --> 00:18:29,510
Quindi questo è il per ciascuno.

240
00:18:29,510 --> 00:18:36,320
Quindi, quando è possibile, è necessario utilizzare per ogni ciclo come questo elemento raccomanda prima per ogni file

241
00:18:36,320 --> 00:18:37,510
N2 tradizionale.

242
00:18:37,510 --> 00:18:38,130
Questo è tutto.

243
00:18:38,240 --> 00:18:40,520
Grazie e buon codice.

244
00:18:40,520 --> 00:18:41,540
Ci vediamo nella prossima lezione.