1
00:00:02,130 --> 00:00:05,420
Ciao, questo è quello da fare e bentornato.

2
00:00:05,430 --> 00:00:10,460
Diamo un'occhiata alle operazioni di raccolta che sono rappresentate dai metodi Collect.

3
00:00:10,750 --> 00:00:12,750
E questi sono metodi sovraccarichi.

4
00:00:12,740 --> 00:00:19,440
E come suggerisce il nome, i metodi Collect vengono utilizzati per raccogliere un flusso di elementi in un contenitore Container che può

5
00:00:20,040 --> 00:00:25,420
essere qualcosa come un nido o un set o una mappa o uno qualsiasi degli oggetti Giller.

6
00:00:25,470 --> 00:00:27,990
Non deve essere una struttura dati come una lista o un set.

7
00:00:27,990 --> 00:00:34,230
Può essere qualsiasi oggetto normale e quindi deve essere il contenitore e i metodi attuali sono molto importanti

8
00:00:34,330 --> 00:00:36,110
e anche molto interessanti.

9
00:00:36,120 --> 00:00:41,850
Sono davvero importanti perché è molto calmo e raccolgono flussi di elementi in qualcosa come una

10
00:00:41,850 --> 00:00:48,690
lista e sono anche molto interessanti perché possiamo anche raggruppare gli elementi del flusso e fare qualcosa come una

11
00:00:48,690 --> 00:00:49,390
mappa.

12
00:00:49,520 --> 00:00:49,770
OK.

13
00:00:49,770 --> 00:00:54,510
Quindi possiamo raggruppare possiamo anche fare un gruppo complesso come all'interno di una mappa.

14
00:00:54,510 --> 00:00:56,720
I Vladi non hanno bisogno di essere un valore singolo.

15
00:00:56,730 --> 00:00:59,470
Può anche essere un'altra struttura di dati come una lista.

16
00:00:59,580 --> 00:01:05,730
Quindi possiamo fare cose interessanti e possiamo fare tutto questo in un modo molto elegante perché stiamo usando

17
00:01:05,790 --> 00:01:07,890
uno stile di programmazione dichiarativo.

18
00:01:07,890 --> 00:01:13,780
Quindi sarà molto interessante ed è una lezione molto importante su questo concetto chiamato up e il

19
00:01:13,830 --> 00:01:16,710
reindirizzamento è anche associato al metodo Collect.

20
00:01:16,770 --> 00:01:18,660
Ed è anche molto importante.

21
00:01:18,660 --> 00:01:21,970
Quindi andiamo avanti e vediamo quali sono le operazioni di raccolta.

22
00:01:22,200 --> 00:01:25,910
E abbiamo una serie di lezioni dedicate solo al metodo Collect.

23
00:01:26,070 --> 00:01:31,020
Quindi andremo ad esplorare l'argomento Collect in una teoria molto dettagliata perché è un metodo molto

24
00:01:31,020 --> 00:01:31,590
importante.

25
00:01:33,450 --> 00:01:38,540
E dalla lezione precedente sappiamo che le operazioni di riduzione possono essere di due tipi su uno di

26
00:01:38,540 --> 00:01:41,280
essi è rappresentato se lo sviluppo che è sull'altro.

27
00:01:41,290 --> 00:01:46,240
Ma i metodi Collect quindi le operazioni di raccolta sono anche archetipiche per le operazioni di riduzione.

28
00:01:47,130 --> 00:01:52,240
Ma le riduzioni che il chilometro fa è indicato come riduzione mutabile.

29
00:01:52,430 --> 00:01:56,610
Su quello che il metodo di lettura fa come riduzione immutabile.

30
00:01:56,610 --> 00:02:02,760
Quindi quello che abbiamo visto in precedenza con le operazioni di riduzione con il metodo di utilizzo della lettura è stato immutabilmente ridotto.

31
00:02:02,760 --> 00:02:09,870
Quindi, in base alla progettazione, il metodo di utilizzo eseguirà una riduzione immutabile, mentre l'impegno progettuale è ciò che fa

32
00:02:09,960 --> 00:02:12,510
qualcosa che si chiama riduzione muter.

33
00:02:12,760 --> 00:02:21,150
E questa distinzione tra ridotto come è molto importante e se le fonti non spiegano questa distinzione in modo chiaro

34
00:02:21,150 --> 00:02:29,010
ea causa di ciò Dobler può essere confuso circa il metodo ridotto e potrebbero abusare di questo o

35
00:02:29,130 --> 00:02:32,510
di quello che usando una riduzione mutabile.

36
00:02:32,700 --> 00:02:35,470
Quindi potrebbero usarlo e usare la riduzione mutabile.

37
00:02:35,520 --> 00:02:40,590
Infatti, nell'ultima lezione, quando avevamo a che fare con la terza versione, usava un

38
00:02:40,590 --> 00:02:45,540
metodo che aveva i tre parametri come l'identità del combinatore sotto accumulatore.

39
00:02:45,540 --> 00:02:49,730
Abbiamo abusato del metodo di utilizzo della lettura che abbiamo usato una riduzione mutabile.

40
00:02:49,890 --> 00:02:50,950
E non è giusto.

41
00:02:51,100 --> 00:02:55,430
E se lo facciamo, possiamo finire con Inkatha preservato in risultati inefficienti.

42
00:02:55,530 --> 00:03:01,060
Quindi esamineremo questa distinzione tra i metodi ridotti e i metodi Collect.

43
00:03:01,200 --> 00:03:08,690
E quindi è una lezione molto importante e sappiamo che ci sono degli accorgimenti che riducono il flusso in un singolo

44
00:03:08,750 --> 00:03:16,090
valore e che possono essere usati per fare cose come sommare gli elementi del flusso. Trovare un Macsyma è il

45
00:03:16,150 --> 00:03:24,110
minimo sul cliente che è abituato a Riduci il flusso in un singolo contenitore e il contenitore può essere una raccolta come

46
00:03:24,110 --> 00:03:31,040
un elenco o un set o una mappa oppure può anche essere un oggetto come generatore di stringhe

47
00:03:31,040 --> 00:03:37,160
o può anche essere qualcosa chiamato oggetto di riepilogo e un oggetto di riepilogo essenzialmente riepiloga

48
00:03:37,310 --> 00:03:39,740
lo stream due diversi valori Samadi.

49
00:03:39,740 --> 00:03:41,760
Quindi è un oggetto contenitore.

50
00:03:41,770 --> 00:03:48,130
Ora, ad esempio, se lo stream è un flusso di numeri, allora a qualcuno può avere un elenco

51
00:03:48,130 --> 00:03:54,660
di qualcuno che valori come una somma o una media o un minimo assoluto su tutto ciò sarebbe isolato.

52
00:03:54,760 --> 00:03:57,590
E questo oggetto di Samara di Cortez.

53
00:03:57,710 --> 00:04:05,040
E come abbiamo accennato prima la riduzione, ma il metodo Collect è l'introduzione e questa è la

54
00:04:05,040 --> 00:04:09,510
slide della lezione precedente, è così che funziona quel metodo.

55
00:04:09,540 --> 00:04:14,160
Quindi stai usando un flusso di elementi in un singolo valore che è 15.

56
00:04:14,250 --> 00:04:16,710
Quindi l'operazione più è applicata qui.

57
00:04:16,710 --> 00:04:18,370
Così fa quell'operazione di adduzione.

58
00:04:18,380 --> 00:04:24,030
E questa è la funzione di accumulatore e che viene segnalata per essere applicata all'analisi degli

59
00:04:24,720 --> 00:04:26,970
elementi del flusso una riduzione immutabile.

60
00:04:27,090 --> 00:04:33,650
E finalmente otteniamo il valore di essere su questo è come funziona il metodo Collect.

61
00:04:33,660 --> 00:04:40,650
Quindi il metodo clock riduce lo stream a cena in modo che abbiamo gli elementi del flusso 5 5:

62
00:04:41,130 --> 00:04:46,130
01 sotto il fondo abbiamo il contenitore che ha gli elementi 5:01.

63
00:04:46,650 --> 00:04:54,000
Quindi iniziamo con il contenitore che possiamo vedere in alto e non è altro che la funzione acuminata, proprio

64
00:04:54,410 --> 00:04:59,730
come nel caso in cui USMA, come la funzione motoria umana, viene applicata ripetutamente

65
00:04:59,850 --> 00:05:01,230
in diversi passaggi.

66
00:05:01,230 --> 00:05:07,440
Quindi nel primo passo prende un contenitore vuoto sulla fust e poi cinque e poi muta il

67
00:05:07,440 --> 00:05:14,220
contenitore vuoto e fa quel giorno con il valore e poi la seconda iterazione che è il secondo

68
00:05:14,220 --> 00:05:21,120
passo del processo di accumulazione il contenitore con il valore 5 sarà combinato con il valore di su cui

69
00:05:21,120 --> 00:05:27,270
è un elemento estremo sul contenitore come ancora una volta nucleato per ottenere il valore.

70
00:05:27,370 --> 00:05:33,480
E un tipo ha il valore di una corsa sullo stesso contenitore che sarà usato ancora una volta nel

71
00:05:34,020 --> 00:05:37,100
terzo passaggio e sarà accumulato con il valore 3.

72
00:05:37,190 --> 00:05:42,230
Quindi la cena finale avrà i valori Phi 1 e 3.

73
00:05:42,600 --> 00:05:48,720
Quindi lo stesso può non essere viene utilizzato qui e viene ripetutamente nucleato con ogni

74
00:05:48,840 --> 00:05:49,790
fase dell'accumulo.

75
00:05:49,800 --> 00:05:51,470
Ecco cosa sta succedendo qui.

76
00:05:52,910 --> 00:05:57,830
Quindi abbiamo bisogno di un fornitore qui perché devi creare questo contenitore.

77
00:05:58,010 --> 00:06:03,230
Quindi l'inizio del processo di cumulo deve creare il contenitore che utilizziamo un fornitore

78
00:06:03,310 --> 00:06:08,950
e il fornitore che conosciamo è un'interfaccia di funzione che può essere utilizzata per creare nuovi oggetti.

79
00:06:09,050 --> 00:06:09,620
Destra.

80
00:06:09,860 --> 00:06:15,910
E l'accumulatore è un'altra funzione che fa il processo di accumulazione.

81
00:06:15,980 --> 00:06:22,850
Infine, se abbiamo a che fare con un flusso parallelo, abbiamo anche bisogno di un combinatore perché possiamo considerare che l'intero

82
00:06:22,850 --> 00:06:29,000
processo influisce sulla tua immolazione come se fosse un segmento quando abbiamo a che fare con un flusso

83
00:06:29,000 --> 00:06:33,790
parallelo perché il flusso parallelo sta per suddividere gli elementi in diversi segmenti.

84
00:06:33,800 --> 00:06:39,380
Quindi in questo caso abbiamo un contenitore un valore accumulato che è un contenitore.

85
00:06:39,380 --> 00:06:42,500
In questo caso ha valori 5 1 e 3.

86
00:06:42,590 --> 00:06:49,100
Avremo anche altri segmenti e segmenti di dusks, in che modo contenitori simili dovremmo

87
00:06:49,100 --> 00:06:49,760
combinarli.

88
00:06:49,790 --> 00:06:52,650
E per questo abbiamo bisogno della funzione combinata.

89
00:06:52,790 --> 00:06:58,760
Va bene così la funzione combinatore combina i contenitori accumulati da ciascuno dei segmenti in modo

90
00:06:59,180 --> 00:07:02,420
che ciascuno dei segmenti abbia i propri contenitori.

91
00:07:03,290 --> 00:07:11,940
Passiamo al mio editor per esaminare il processo di produzione mutevole e il metodo click OK.

92
00:07:11,940 --> 00:07:17,410
Qui ci si trova nella classe delle operazioni di streaming nell'ordine del metodo delle detrazioni che abbiamo visto in precedenza.

93
00:07:17,730 --> 00:07:20,080
E questo significa che abbiamo avuto il boom in chiesa.

94
00:07:20,120 --> 00:07:24,010
Sono due versioni di quello sono doucement Questa è la seconda versione della terza versione.

95
00:07:24,240 --> 00:07:27,890
Ed ecco la seconda versione qui è una terza opzione.

96
00:07:27,900 --> 00:07:32,670
Prima hai detto che la terza opzione e il terzo desiderio e abbiamo usato una riduzione multipla e

97
00:07:32,670 --> 00:07:33,800
non avremmo dovuto farlo.

98
00:07:34,020 --> 00:07:36,060
Quindi ti concentrerai su quella materia.

99
00:07:36,150 --> 00:07:39,180
E quindi queste sono tutte le cose che faremo.

100
00:07:39,300 --> 00:07:41,300
E questo particolare Demel.

101
00:07:41,430 --> 00:07:46,390
Quindi voglio iniziare con la ricreazione sull'ordine per ridurre i metodi.

102
00:07:46,410 --> 00:07:52,110
Quindi voglio solo portare un po 'più di chiarezza su ciò per adorarci quando dobbiamo usarne uno.

103
00:07:52,110 --> 00:07:58,290
Quindi lo esamineremo e mi concentrerò anche su quello che è meno importante sul metodo di utilizzo

104
00:07:58,500 --> 00:08:02,980
tradizionale e guarderemo anche a qualcosa chiamato il principio dello streaming design.

105
00:08:03,190 --> 00:08:08,710
Finalmente lo sto osservando o solo con l'azione di mutabilità sui problemi che abbiamo con quello.

106
00:08:08,730 --> 00:08:13,460
Quindi stiamo andando a guardare quello e da lì andremo a vedere il Collect incontrato che va bene.

107
00:08:13,470 --> 00:08:15,980
Quindi queste sono alcune delle cose che vedremo.

108
00:08:15,990 --> 00:08:19,240
Quindi sarà una dimostrazione approfondita.

109
00:08:19,330 --> 00:08:23,950
Quindi qui abbiamo avuto i voti e stavamo producendo questi grandi qui.

110
00:08:24,000 --> 00:08:25,570
Stavamo semplicemente concatenando.

111
00:08:25,570 --> 00:08:28,360
Quindi questa è la seconda versione di quel metodo di utilizzo dell'Id.

112
00:08:28,360 --> 00:08:29,320
Ecco qui.

113
00:08:29,350 --> 00:08:35,260
Quindi seleziona un'identità e richiede un operatore binario e questo dà all'operatore binario

114
00:08:35,260 --> 00:08:37,550
la semplice esecuzione della concatenazione.

115
00:08:37,570 --> 00:08:41,650
Quindi qui come sorgente del flusso siamo solo la sorgente del flusso è una matrice.

116
00:08:41,890 --> 00:08:48,790
Quindi gli operatori stupidi grandi e stupidi hanno lo stesso tipo e producono un output dello stesso tipo.

117
00:08:48,790 --> 00:08:54,720
Quindi qui stiamo concatenando due stringhe e l'output è anche una stringa infinita, non con

118
00:08:54,730 --> 00:08:57,630
tre dei che usano Todd o metodo.

119
00:08:57,670 --> 00:09:04,610
Quindi ci vuole un'identità e un accumulatore come nel caso della seconda domanda.

120
00:09:04,750 --> 00:09:09,640
Ma ci vuole anche un combinatore, nemmeno una differenza tra la seconda e la terza domanda

121
00:09:09,720 --> 00:09:12,970
è che l'accumulatore qui è una funzione di byte.

122
00:09:12,970 --> 00:09:18,260
Quindi, in precedenza, nella seconda domanda a proposito, si diceva che è un byte, è un operatore binario.

123
00:09:18,310 --> 00:09:25,090
Ma qui è una per funzione che prende stupidi amatori di tipi diversi e produce avanti e indietro

124
00:09:25,090 --> 00:09:27,480
mentre lo invio con operatore binario.

125
00:09:27,480 --> 00:09:30,380
È lo stesso tipo di Tupa ma degli stessi tipi.

126
00:09:30,400 --> 00:09:37,750
Quindi qui nella terza versione sta attaccando un generatore di stringhe e una stringa e sta generando un generatore di

127
00:09:37,750 --> 00:09:38,280
stringhe.

128
00:09:38,350 --> 00:09:38,580
OK.

129
00:09:38,590 --> 00:09:42,030
Quindi sta prendendo due elementi da due diversi tipi.

130
00:09:42,070 --> 00:09:44,070
Questa è la differenza principale.

131
00:09:44,080 --> 00:09:51,070
Quindi se stai affrontando uno scenario in cui i parametri con due diversi tipi dovresti andare a

132
00:09:51,070 --> 00:09:52,970
prendere questa versione ridotta.

133
00:09:53,090 --> 00:09:59,110
OK, ma se il primer non ha lo stesso tipo, puoi usare la seconda versione qui su entrambi un

134
00:09:59,110 --> 00:10:01,060
libro con i blood stream.

135
00:10:01,330 --> 00:10:06,760
Ma in questo caso, quando trattiamo la parte dei flussi, dovremmo

136
00:10:06,760 --> 00:10:12,910
utilizzare una funzione combinatore perché nel flusso parlance avremo segmenti diversi su ciascuno di

137
00:10:12,910 --> 00:10:13,930
questi segmenti.

138
00:10:13,980 --> 00:10:20,050
Produrremo un costruttore di stringhe singolo in questo caso non è possibile utilizzare qui le combinazioni combinate

139
00:10:20,050 --> 00:10:23,910
sul cumulativo perché i tubi sono diversi con questo accumulatore.

140
00:10:24,130 --> 00:10:30,850
Ma nel caso di una bottiglia di flusso ciascuno dei segmenti produrrà un valore accumulato di quel generatore di stringhe di

141
00:10:30,850 --> 00:10:31,690
quel tipo.

142
00:10:31,690 --> 00:10:36,550
Quindi dobbiamo combinare i due valori accumulati che sono dello stesso tipo.

143
00:10:36,650 --> 00:10:38,890
Quindi dobbiamo usare questo combinatore.

144
00:10:38,910 --> 00:10:39,370
Tutto ok.

145
00:10:39,370 --> 00:10:40,800
Quindi questa è la cosa principale.

146
00:10:40,810 --> 00:10:45,970
Quindi la differenza principale tra le due funzioni è la funzione accumulatore e una di

147
00:10:45,970 --> 00:10:52,480
esse ha lo stesso tipo e nell'altra abbiamo tipi diversi se si deve usare un accumulatore che ha bisogno

148
00:10:52,480 --> 00:10:54,200
di due tipi diversi.

149
00:10:54,200 --> 00:10:56,530
Allora devi andare con questo.

150
00:10:56,610 --> 00:11:02,280
Ora la seconda cosa è che se ci pensi, in realtà non abbiamo bisogno di questo combinatore.

151
00:11:02,280 --> 00:11:07,710
Se abbiamo a che fare con questo flusso sequenziale piuttosto che su una nota post-it, la sequenza di flusso

152
00:11:07,950 --> 00:11:12,710
che succede è che abbiamo un singolo segmento proprio dove stiamo creando il generatore di stringhe.

153
00:11:12,780 --> 00:11:17,430
E poi finiamo per terminare la stringa e questo è fatto in modo particolarmente vero fino a quando

154
00:11:17,430 --> 00:11:21,120
non elaboriamo tutti gli elementi del flusso sul davanti e il proiettile è scritto.

155
00:11:21,120 --> 00:11:27,790
Quindi non abbiamo bisogno di questa particolare funzione combinatore che combina due diversi costruttori di corde.

156
00:11:27,900 --> 00:11:29,130
Quindi non ne abbiamo bisogno.

157
00:11:29,160 --> 00:11:37,470
Quindi potresti chiederti perché non come fanno le versioni diverse del metodo d'uso auto-diretto 1 per il flusso

158
00:11:37,560 --> 00:11:39,870
sequenziale e l'altro per sconfinare.

159
00:11:39,870 --> 00:11:42,280
È una domanda normale e possiamo rispondere a questa domanda.

160
00:11:42,510 --> 00:11:50,430
Ma la cosa è che i progettisti linguistici volevano che l'API del flusso fosse agnostica al tipo di

161
00:11:50,460 --> 00:11:51,690
flusso sottostante.

162
00:11:51,750 --> 00:11:58,320
Quindi volevano che l'AP non distingua tra strisce sequenziali e Pablos.

163
00:11:58,390 --> 00:12:05,770
Questo è il principio di progettazione che l'API di streaming offre e questo è quello che volevano e il vantaggio è che

164
00:12:05,770 --> 00:12:11,210
facciamo un esempio, diciamo che stiamo facendo in modo che questo flusso non sia gestito.

165
00:12:11,230 --> 00:12:16,960
Quindi stiamo solo avendo una variabile che prende questo flusso e vediamo se abbiamo un altro metodo

166
00:12:16,960 --> 00:12:18,680
che effettivamente fa la riduzione.

167
00:12:18,880 --> 00:12:19,400
OK.

168
00:12:19,480 --> 00:12:23,440
E questo significa che lo faremo userei il velox non documentato del flusso.

169
00:12:23,440 --> 00:12:28,750
Quindi all'interno di questa materia supponiamo di avere quell'altra specie che è il metodo di Dool

170
00:12:28,750 --> 00:12:31,540
che ha solo due parametri su di essa.

171
00:12:31,660 --> 00:12:36,310
Ora più avanti, a un certo punto, se lo sviluppatore cambia lo stream in uno stream parallelo perché è

172
00:12:36,310 --> 00:12:38,570
molto semplice cambiare lo stream in uno stream parallelo.

173
00:12:38,810 --> 00:12:45,880
E una volta fatto ciò, non funzionerà se il raggio di equilibrio verrà passato a quel metodo che usa che usa

174
00:12:45,880 --> 00:12:50,100
un metodo che funziona con flusso sequenziale solo di quanto non riuscirà.

175
00:12:50,250 --> 00:12:57,850
Quindi i progettisti di linguaggi volevano evitare che facendo in modo che l'API non lo fosse, non distinguono

176
00:12:57,850 --> 00:13:00,030
tra flussi sequenziali e paralleli.

177
00:13:00,160 --> 00:13:05,840
Quindi se lo si cambia in un flusso se si modifica il flusso di bilanciamento, il resto della pipeline

178
00:13:05,840 --> 00:13:07,390
dovrebbe o non dovrebbe cambiare.

179
00:13:07,450 --> 00:13:09,360
Tutto dovrebbe essere perfettamente.

180
00:13:09,400 --> 00:13:11,110
Quindi questa è la cosa.

181
00:13:11,230 --> 00:13:18,160
Ma un'altra cosa è anche se la funzione combinatore non viene utilizzata qui per un flusso sequenziale, ma in

182
00:13:18,190 --> 00:13:23,600
una versione futura il combinatore potrebbe anche essere utilizzato anche per un flusso sequenziale.

183
00:13:23,620 --> 00:13:29,470
Quindi, poiché si tratta di un dettaglio di implementazione sul linguaggio, i progettisti potrebbero decidere che ciò sia

184
00:13:29,480 --> 00:13:34,270
un vantaggio che può anche utilizzare la funzione combinatore per migliorare le prestazioni.

185
00:13:34,300 --> 00:13:40,930
Ma questo è un dettaglio di implementazione e le implementazioni possono cambiare con qualsiasi peggio di tutto il JDK.

186
00:13:40,930 --> 00:13:42,550
Quindi non lo sappiamo mai.

187
00:13:42,660 --> 00:13:47,430
Sai che un'altra cosa è qui che questo combinatore non può non essere.

188
00:13:47,570 --> 00:13:53,320
OK, testiamo che anche per un Sindhi sequenziale è un flusso sequenziale.

189
00:13:53,320 --> 00:13:58,510
Ora se lo esegui come possiamo vedere, ottieni un'eccezione senza partner, quindi non può esserlo.

190
00:13:58,540 --> 00:14:01,150
Quindi tienilo a mente.

191
00:14:01,150 --> 00:14:05,050
Ora testiamo anche il principio di progettazione stesso.

192
00:14:05,050 --> 00:14:09,040
Quindi cambiamo questo e lasciamo cadere il flusso sanguigno.

193
00:14:09,050 --> 00:14:11,840
Quindi questo è un modello dall'interfaccia di streaming.

194
00:14:11,870 --> 00:14:17,540
In testa è dal Bob, muoviamoci dallo stream stream del flusso.

195
00:14:17,540 --> 00:14:18,780
Quindi viene da lì.

196
00:14:18,800 --> 00:14:25,000
Quindi, cambiamo solo questo come possiamo vedere l'output è ancora aeb.

197
00:14:25,000 --> 00:14:26,120
Quindi questo è uno.

198
00:14:26,120 --> 00:14:27,490
E questo è un concat

199
00:14:27,730 --> 00:14:29,410
Quindi facciamo la stessa cosa

200
00:14:29,470 --> 00:14:34,570
Ma anche la terza opzione che userò Metford ora puoi vedere

201
00:14:37,410 --> 00:14:44,990
che lui o ne ha inventati due ha un output diverso, quindi non ha lo stesso output.

202
00:14:45,000 --> 00:14:49,970
Potrei aggiungere ancora una volta alla saga e puoi vedere un altro Non indossare Non stiamo ottenendo a

203
00:14:49,970 --> 00:14:50,650
e b.

204
00:14:50,930 --> 00:14:53,550
Quindi non appena lo abbiamo cambiato in parlamento.

205
00:14:53,900 --> 00:14:56,050
Quindi l'uscita è esplosa.

206
00:14:56,060 --> 00:14:58,110
Quindi non stiamo ottenendo lo stesso risultato.

207
00:14:58,340 --> 00:15:02,550
Quindi tuffo che voglio suggerire è che so dove stai lavorando con i flussi.

208
00:15:02,590 --> 00:15:06,180
Verifica sempre i tuoi risultati con il flusso Parlow.

209
00:15:06,200 --> 00:15:12,350
Quindi, per testare la correttezza, dovresti anche renderla BOTELER a quel dottore hai lo

210
00:15:12,350 --> 00:15:13,380
stesso risultato.

211
00:15:13,550 --> 00:15:18,900
Altrimenti potresti finire con un risultato errato come quello che stiamo vedendo qui.

212
00:15:19,370 --> 00:15:22,940
Quindi prova sempre a testare lo stream di Arlan EP.

213
00:15:23,210 --> 00:15:28,190
Potrebbe benissimo darti la scheda presentata con un flusso sequenziale, ma potrebbe andare male e sviluppare

214
00:15:28,220 --> 00:15:29,790
il nostro live streaming.

215
00:15:29,800 --> 00:15:30,240
OK.

216
00:15:30,470 --> 00:15:33,400
In futuro potresti effettivamente convertirlo in un flusso parallelo.

217
00:15:33,530 --> 00:15:35,890
Quindi assicurati che funzioni anche con il flusso di Barlas.

218
00:15:36,080 --> 00:15:43,720
Quindi questo è il principio di progettazione è chiaro qui, ma in questo caso la ragione per cui abbiamo questo

219
00:15:43,740 --> 00:15:48,400
è perché usa il metodo qui è l'uso sta facendo più produzione.

220
00:15:48,470 --> 00:15:53,540
Quindi qui ciò che sta accadendo è che questo è un contenitore, ma è un contenitore.

221
00:15:53,900 --> 00:16:01,670
E qui stiamo facendo Pattillo, il che significa che abbiamo più segmenti sebbene il metodo stia andando

222
00:16:01,670 --> 00:16:08,760
a partizionare gli elementi in due gruppi e in tutti e tre i gruppi.

223
00:16:08,860 --> 00:16:15,600
Quindi utilizzerà un corso diverso e tutti questi punteggi verranno condivisi con lo stesso contenitore.

224
00:16:15,730 --> 00:16:18,740
OK, lo stesso contenitore verrà utilizzato per tutti.

225
00:16:18,840 --> 00:16:23,830
E quindi ci deve essere un coordinamento tra i thread qui dove non

226
00:16:23,830 --> 00:16:29,540
c'è che direi se ci sarà una condizione di gara e per questo possiamo vedere nei personaggi.

227
00:16:29,680 --> 00:16:31,670
OK, questa è una delle cose principali.

228
00:16:32,650 --> 00:16:39,980
E un'altra cosa è che una volta che l'accumulo è stato fatto, la funzione combinatore deve combinare le cene e

229
00:16:40,300 --> 00:16:45,140
in questo caso abbiamo un singolo contenitore e combineremo lo stesso contenitore.

230
00:16:45,160 --> 00:16:48,100
Quindi combineremo lo stesso contenitore con se stesso.

231
00:16:48,160 --> 00:16:53,070
Quindi a causa di questo abbiamo anche come questo problema e ottenuto un risultato.

232
00:16:53,170 --> 00:16:59,770
Quindi è solo un due casi in quanto la stringa che non è sicura sul secondo problema è anche

233
00:16:59,770 --> 00:17:00,950
la funzione combinatore.

234
00:17:01,390 --> 00:17:02,260
Quindi questa è la cosa.

235
00:17:02,260 --> 00:17:07,920
Quindi stiamo cambiando lo stesso contenitore con il suo salvataggio diretto.

236
00:17:07,960 --> 00:17:13,330
Quindi questo è il problema principale e non dovremmo usare o usare un metodo per questo, ma

237
00:17:13,480 --> 00:17:16,360
c'è solo quattro o si rinuncia alla produzione immutabile.

238
00:17:16,360 --> 00:17:21,130
Quindi, se si guarda al metodo di utilizzo della lettura che dice che utilizza una funzione di byte.

239
00:17:21,130 --> 00:17:23,490
Ma dopo esamineremo il metodo Collect.

240
00:17:23,500 --> 00:17:25,610
Usa un consumatore di byte.

241
00:17:25,750 --> 00:17:32,850
E quando diciamo che il consumatore non colpisce nulla nelle ricerche progettate in modo naturale per il

242
00:17:32,910 --> 00:17:34,170
muting sul container.

243
00:17:34,300 --> 00:17:36,790
Andiamo avanti e guardiamo anche a questo.

244
00:17:37,130 --> 00:17:41,750
Copi solo questa cosa intera.

245
00:17:41,910 --> 00:17:45,580
Qui abbiamo questo metodo chiamato come riduzione mutabile.

246
00:17:46,020 --> 00:17:49,490
Quindi qui aggiungerò un mostro alla questione del colore.

247
00:17:49,560 --> 00:17:50,960
Quindi è solo la stessa cosa.

248
00:17:50,970 --> 00:17:59,020
Quindi permettimi di cambiare questo per raccogliere Narberth. Abbiamo detto che avevamo bisogno di un fornitore all'inizio della

249
00:17:59,020 --> 00:17:59,560
lezione.

250
00:17:59,550 --> 00:18:03,370
Ha detto che abbiamo bisogno di un fornitore qui perché tutto ciò che è stato speso per i ritorni.

251
00:18:03,390 --> 00:18:07,990
Quindi Hala dice che abbiamo bisogno di un fornitore e abbiamo bisogno di un accumulatore.

252
00:18:07,990 --> 00:18:10,330
E abbiamo anche bisogno di un combinatore.

253
00:18:10,450 --> 00:18:11,730
Ma è un fornitore.

254
00:18:11,740 --> 00:18:13,040
Quindi è un'interfaccia di funzione.

255
00:18:13,060 --> 00:18:19,180
Quindi non possiamo semplicemente creare un oggetto, ma dobbiamo passare un metodo di riferimento o un lambda.

256
00:18:19,180 --> 00:18:25,610
Quindi, poiché è uno strato morbido, la fornitura di pasta ha un metodo chiamato Ottieni tutto ciò che il fornitore

257
00:18:25,690 --> 00:18:28,780
fa è creare una nuova istanza di stringa bulgur.

258
00:18:29,040 --> 00:18:29,840
OK.

259
00:18:30,020 --> 00:18:32,770
E quindi questo è anche il flusso di Paglia.

260
00:18:32,800 --> 00:18:37,820
Quindi qui all'interno di ogni segmento verrà creato un contenitore.

261
00:18:37,840 --> 00:18:42,520
Quindi ogni segmento avrà il suo contenitore e il resto delle cose è lo stesso.

262
00:18:42,520 --> 00:18:45,720
Quindi permettimi di copiare semplicemente la dichiarazione di

263
00:18:58,920 --> 00:19:05,680
stampa sul tuo intendo dire uso su requanters. Quindi stai invocando l'opzione di mutabilità dal metodo principale torna

264
00:19:05,770 --> 00:19:10,580
qui su questo in modo che tu possa vederlo piegare a e b.

265
00:19:10,590 --> 00:19:12,550
Ok, questo sta sbagliando.

266
00:19:12,620 --> 00:19:16,720
Quindi permettimi di cambiare anche questo in un normale flusso sequenziale.

267
00:19:16,800 --> 00:19:20,130
Siamo solo noi ma qui.

268
00:19:20,150 --> 00:19:22,560
Quindi, ancora una volta è solo la stessa uscita.

269
00:19:22,580 --> 00:19:27,600
Quindi stiamo ottenendo lo stesso risultato sia che si tratti di un flusso sequenziale a nostro modo che non si tratta di

270
00:19:27,650 --> 00:19:28,290
un'altra stringa.

271
00:19:28,370 --> 00:19:29,790
Ok allora.

272
00:19:29,800 --> 00:19:35,030
Quindi abbiamo bisogno di usare il metodo orologio e orologio come vediamo qui.

273
00:19:35,030 --> 00:19:39,370
Ha anche un accumulatore, ha anche un combinatore ma ci riprende più tardi.

274
00:19:39,440 --> 00:19:46,340
Ma ancora più importante l'accumulatore qui è un consumatore di byte con quello che userei era una funzione byte

275
00:19:46,520 --> 00:19:51,770
per funzione o valore Denso che avevamo come consumatore di biciclette non restituisce nulla.

276
00:19:51,860 --> 00:19:58,000
Ha solo il metodo accettate che non fa nulla a Arterton.

277
00:19:58,040 --> 00:20:03,710
Quindi uno dei parametri deve essere un contenitore che viene accumulato.

278
00:20:04,710 --> 00:20:06,360
Che ovviamente sta per essere mutato.

279
00:20:06,540 --> 00:20:07,520
Quindi questa è la cosa.

280
00:20:07,560 --> 00:20:15,540
Ora c'è anche una versione qui possiamo fare questo M. W. libro riduzione con l'uso.

281
00:20:15,570 --> 00:20:16,950
Facendo questo.

282
00:20:17,160 --> 00:20:21,910
Quindi qui quello che stiamo facendo è quasi la stessa cosa.

283
00:20:21,930 --> 00:20:25,710
È appena ormeggiato qui e inizia a dire semplicemente come Bedacht.

284
00:20:25,740 --> 00:20:33,090
Quindi, invece di lavorare su questo particolare parametro che è il contenitore, stiamo creando un nuovo

285
00:20:33,090 --> 00:20:34,000
contenitore.

286
00:20:34,100 --> 00:20:34,410
OK.

287
00:20:34,440 --> 00:20:35,170
Ecco qui.

288
00:20:35,220 --> 00:20:41,490
E quindi stiamo aggiungendo il generatore di stringhe a questo perché sugli uomini che usano metodi che sono sovraccarichi di metodi uno

289
00:20:41,490 --> 00:20:45,330
di loro può prendere un generatore di stringhe e può prendere una stringa.

290
00:20:45,330 --> 00:20:48,250
Quindi in questo caso stiamo usando entrambi i metodi di ordine di Autard.

291
00:20:48,520 --> 00:20:53,430
Per aggiungere un generatore di stringhe qui sotto per aggiungere la stringa stessa.

292
00:20:53,430 --> 00:20:58,900
Quindi il problema con questo in modo che questo genererà sotto contatto o mettere un limite su di esso qui.

293
00:20:58,910 --> 00:21:03,070
Questo ha anche BOTELER, qui ha ancora sta producendo un B.

294
00:21:03,070 --> 00:21:04,580
Eccolo concat 3.

295
00:21:04,620 --> 00:21:07,580
Si chiama inventare, stiamo stampando Cancri qui.

296
00:21:07,860 --> 00:21:14,070
Ma il problema con questo è che abbiamo diversi passaggi di accumulazione su ciascuno di essi sta creando un

297
00:21:14,070 --> 00:21:15,440
nuovo generatore di stringhe.

298
00:21:15,690 --> 00:21:16,010
OK.

299
00:21:16,020 --> 00:21:18,500
Quindi questa è una cosa inefficiente.

300
00:21:18,540 --> 00:21:24,570
Quindi non stiamo mutando lo stesso generatore di stringhe, ma stiamo creando una nuova stringa dove ad ogni passo.

301
00:21:24,570 --> 00:21:25,810
Quindi questa è la differenza.

302
00:21:25,860 --> 00:21:27,570
Ma il metodo click.

303
00:21:27,570 --> 00:21:31,490
Quindi questo metodo dà anche il corretto a.

304
00:21:31,500 --> 00:21:33,200
È ancora inefficiente

305
00:21:33,540 --> 00:21:34,050
OK.

306
00:21:34,110 --> 00:21:35,550
Ecco, questo è tutto.

307
00:21:35,550 --> 00:21:39,470
Quindi questa è la prima versione della chiamata mormorata e ha tutto questo.

308
00:21:39,550 --> 00:21:46,740
C'è anche una versione semplificata perché il metodo di clock caricato sarà discusso nella

309
00:21:47,100 --> 00:21:50,300
prossima lezione, ma usiamolo qui.

310
00:21:50,580 --> 00:21:58,740
Quindi, invece di avere tutte queste tre funzioni dei barometri, possiamo solo dire che i collezionisti di collettori sono una classe

311
00:21:58,740 --> 00:22:07,050
nel flusso di punti dot di Djala, è una classe di supporto e fornisce alcuni tipi predefiniti di collezionisti senza carta e

312
00:22:07,050 --> 00:22:13,800
quei collezionisti possono aiutarci a realizzare questo tipo di funzionalità quindi c'è un collezionista per aver fatto

313
00:22:13,800 --> 00:22:22,550
questo tipo di lavoro e ci ha chiamati a unirci a Gorder, da quando mi sono unito ai collezionisti e intendo un quarterback

314
00:22:22,710 --> 00:22:24,290
che in realtà

315
00:22:27,510 --> 00:22:30,830
sono le stringhe di Densa a modernizzarsi, quindi progettare

316
00:22:43,240 --> 00:22:49,130
fa praticamente quello che stiamo facendo qui e ci sono anche collezionisti per altri scopi.

317
00:22:49,150 --> 00:22:55,410
E come per esempio se vuoi generare lo streaming in una lista, allora abbiamo qualcosa per questo.

318
00:22:55,410 --> 00:23:00,460
E se vuoi raggruppare gli elementi del flusso come un altro metodo per quello e altri metodi di

319
00:23:00,460 --> 00:23:02,610
produzione statici per quel gruppo chiamato da.

320
00:23:02,620 --> 00:23:03,700
E possiamo usare quello.

321
00:23:03,700 --> 00:23:07,940
Quindi lasciami correre ora, eccolo qui.

322
00:23:07,950 --> 00:23:13,280
Quindi, ancora una volta sei catturato con il ricongiungimento, ci sta dando lo stesso anche se è

323
00:23:13,280 --> 00:23:14,500
circa 12 corde.

324
00:23:14,550 --> 00:23:15,840
Quindi questa è la cosa.

325
00:23:15,840 --> 00:23:21,240
Quindi questi sono lì per raccogliere metodi e spiegheremo di più su questi collezionisti e sulla prossima lezione.

326
00:23:21,300 --> 00:23:24,280
Ma ora abbiamo un'idea su come usarlo.

327
00:23:24,330 --> 00:23:25,550
Quindi questo è tutto.

328
00:23:25,650 --> 00:23:26,350
Grazie.

329
00:23:26,440 --> 00:23:31,060
Spero vi sia piaciuto conoscere il metodo del collezionista e la produzione mutevole.

330
00:23:31,530 --> 00:23:32,390
E questo è tutto.

331
00:23:32,440 --> 00:23:33,020
Grazie.

332
00:23:33,040 --> 00:23:33,950
E felice codifica.