1
00:00:00,000 --> 00:00:04,919
no estás tú para excesos

2
00:00:04,919 --> 00:00:05,559
ya está

3
00:00:05,559 --> 00:00:08,359
vale, bueno pues

4
00:00:08,359 --> 00:00:10,880
estábamos simplemente, que vamos a ver si lo

5
00:00:10,880 --> 00:00:12,720
completamos con lo

6
00:00:12,720 --> 00:00:14,779
básico, que es un poquito con lo que estábamos

7
00:00:14,779 --> 00:00:16,899
¿verdad? habíamos visto

8
00:00:16,899 --> 00:00:18,179
esta cosa mágica

9
00:00:18,179 --> 00:00:24,449
esta cosa

10
00:00:24,449 --> 00:00:26,329
mágica que hace

11
00:00:26,329 --> 00:00:28,230
que cualquier colección de datos

12
00:00:28,230 --> 00:00:30,530
se te serialice

13
00:00:30,530 --> 00:00:32,509
no está bien usada esa palabra

14
00:00:32,509 --> 00:00:33,490
si te ponga en filita

15
00:00:33,490 --> 00:00:35,590
y ya con esta filita

16
00:00:35,590 --> 00:00:38,530
se pueden llamar a unos cuantos

17
00:00:38,530 --> 00:00:39,869
métodos muy útiles

18
00:00:39,869 --> 00:00:42,130
que te van a hacer todo eso

19
00:00:42,130 --> 00:00:43,729
con la fila conjuntamente

20
00:00:43,729 --> 00:00:46,090
entonces ya nos olvidamos de recorrer las colecciones

21
00:00:46,090 --> 00:00:48,590
con nuestros for propios, con nuestros iterator

22
00:00:48,590 --> 00:00:49,310
con todo eso

23
00:00:49,310 --> 00:00:51,329
si podríamos hacerlo

24
00:00:51,329 --> 00:00:54,329
pero bueno, así está más profesional

25
00:00:54,329 --> 00:00:55,250
entonces

26
00:00:55,250 --> 00:00:56,450
¿estás grabando?

27
00:00:56,950 --> 00:00:59,270
sí, está grabando, no ves aquí un punto rojo

28
00:00:59,270 --> 00:01:02,810
entonces, estas funciones

29
00:01:02,810 --> 00:01:04,810
necesitan

30
00:01:04,810 --> 00:01:07,069
que le digamos que hacer

31
00:01:07,069 --> 00:01:08,909
con cada uno

32
00:01:08,909 --> 00:01:10,370
de esos elementos de la fila

33
00:01:10,370 --> 00:01:12,989
y como le decimos ese que hacer

34
00:01:12,989 --> 00:01:14,609
en general con funciones lambda

35
00:01:14,609 --> 00:01:16,609
que las funciones lambda pues no son más que

36
00:01:16,609 --> 00:01:19,069
instancias concretas de una interfaz

37
00:01:19,069 --> 00:01:20,030
funcional, vale

38
00:01:20,030 --> 00:01:22,709
entonces, en particular

39
00:01:22,709 --> 00:01:24,890
los métodos estos

40
00:01:24,890 --> 00:01:26,030
que te ofrece String

41
00:01:26,030 --> 00:01:29,090
pues te dicen que tipo

42
00:01:29,090 --> 00:01:31,349
de función lambda necesitan

43
00:01:31,349 --> 00:01:33,849
entonces hay unas cuantas

44
00:01:33,849 --> 00:01:36,069
y las básicas eran estas

45
00:01:36,069 --> 00:01:37,849
este es un tipo de función

46
00:01:37,849 --> 00:01:39,569
lambda o interfaz

47
00:01:39,569 --> 00:01:41,989
funcional que recibe

48
00:01:41,989 --> 00:01:43,810
uno y se lo come y no hace nada

49
00:01:43,810 --> 00:01:45,390
o sea no devuelve nada

50
00:01:45,390 --> 00:01:47,750
este recibe una cosa

51
00:01:47,750 --> 00:01:49,409
perdón

52
00:01:49,409 --> 00:01:50,790
vale

53
00:01:50,790 --> 00:01:53,670
estas eran las interfaces

54
00:01:53,670 --> 00:01:55,870
funcionales ya estándar en

55
00:01:55,870 --> 00:01:56,230
java

56
00:01:56,230 --> 00:01:59,310
Este recibe un elemento

57
00:01:59,310 --> 00:02:00,810
Y no te devuelve nada

58
00:02:00,810 --> 00:02:03,109
Function, recibe un elemento

59
00:02:03,109 --> 00:02:05,569
Y te devuelve otro, de los tipos que particularicemos

60
00:02:05,569 --> 00:02:05,890
Aquí

61
00:02:05,890 --> 00:02:09,349
Este recibe un elemento y te devuelve

62
00:02:09,349 --> 00:02:11,389
True o false, boolean

63
00:02:11,389 --> 00:02:13,330
Este

64
00:02:13,330 --> 00:02:15,610
No recibe nada y te devuelve algo

65
00:02:15,610 --> 00:02:17,289
Y este recibe

66
00:02:17,289 --> 00:02:19,229
Dos cosas y te devuelve una cosa

67
00:02:19,229 --> 00:02:20,870
Entonces son cinco

68
00:02:20,870 --> 00:02:23,449
Posibles tipos de interfaz

69
00:02:23,449 --> 00:02:23,949
Funcional

70
00:02:23,949 --> 00:02:32,789
y estas funciones, estos métodos de stream, te piden la que toque, una de ellas, ¿vale?

71
00:02:33,050 --> 00:02:39,750
Entonces, por ejemplo, forEach, pues te pide una a la que tú le das un dato y no haga nada.

72
00:02:39,889 --> 00:02:45,949
Ese dato que le das al forEach, ¿cuál es? Todos y cada uno de los elementos de esta fila.

73
00:02:46,430 --> 00:02:52,770
Y con todos y cada uno de los elementos de esta fila, hace lo que le digamos aquí, ¿vale?

74
00:02:52,770 --> 00:02:55,990
El filter, pues también el filter

75
00:02:55,990 --> 00:02:59,629
Le tenemos que pasar un predicado

76
00:02:59,629 --> 00:03:02,229
Que recibe todos y cada uno

77
00:03:02,229 --> 00:03:03,729
De los elementos de la filita

78
00:03:03,729 --> 00:03:06,370
Y te devuelve

79
00:03:06,370 --> 00:03:08,370
El true o false en función de la condición

80
00:03:08,370 --> 00:03:09,370
Que a ti te dé la gana

81
00:03:09,370 --> 00:03:10,909
¿Vale? Dime

82
00:03:10,909 --> 00:03:15,430
Perdón

83
00:03:15,430 --> 00:03:27,830
Está en una grabación

84
00:03:27,830 --> 00:03:31,169
Sí, está subida

85
00:03:31,169 --> 00:03:32,289
¿Vale?

86
00:03:34,969 --> 00:03:35,409
¡Silencio!

87
00:03:36,490 --> 00:03:36,830
Vale

88
00:03:36,830 --> 00:03:43,349
Otra

89
00:03:43,349 --> 00:03:44,990
De los que hay de stream

90
00:03:44,990 --> 00:03:50,389
¿En qué hay unos cuantos? Pues todos estos, que al final se acaban usando tres o cuatro.

91
00:03:51,729 --> 00:04:02,569
Pues el map. El map es el que te transforma la fila con todos sus elementos en otra fila con elementos distintos.

92
00:04:03,050 --> 00:04:07,050
A cada elemento de la fila lo transforma a otro elemento distinto.

93
00:04:07,949 --> 00:04:14,129
Entonces, esta fila la convierte a través del map a otra fila, ¿vale?

94
00:04:14,990 --> 00:04:19,290
no, no, no, map es porque te mapeo

95
00:04:19,290 --> 00:04:21,170
te mapeo cada elemento en otro

96
00:04:21,170 --> 00:04:23,230
y entonces

97
00:04:23,230 --> 00:04:25,009
la función lambda

98
00:04:25,009 --> 00:04:26,870
que hay que pasarle aquí, ¿qué tipo de función

99
00:04:26,870 --> 00:04:28,529
tendrá que ser? una función

100
00:04:28,529 --> 00:04:31,189
porque la función es la que recibe

101
00:04:31,189 --> 00:04:33,069
un elemento y te da otro

102
00:04:33,069 --> 00:04:35,350
pues esta efectivamente

103
00:04:35,350 --> 00:04:37,189
si miramos aquí

104
00:04:37,189 --> 00:04:40,779
map

105
00:04:40,779 --> 00:04:43,160
si miramos su ayuda

106
00:04:43,160 --> 00:04:43,639
su

107
00:04:43,639 --> 00:04:46,379
pues map

108
00:04:46,379 --> 00:04:47,459
efectivamente

109
00:04:47,459 --> 00:04:49,139
te lo dice

110
00:04:49,139 --> 00:04:50,819
si llamas a map

111
00:04:50,819 --> 00:04:53,639
tienes que pasar una lambda

112
00:04:53,639 --> 00:04:54,519
que sea una función

113
00:04:54,519 --> 00:04:57,319
porque yo con cada uno de los elementos de la filita

114
00:04:57,319 --> 00:04:59,360
voy a obtener otro valor distinto

115
00:04:59,360 --> 00:05:01,079
voy a aplicar esta función

116
00:05:01,079 --> 00:05:03,000
a todos y cada uno de los elementos

117
00:05:03,000 --> 00:05:04,860
entonces por ejemplo

118
00:05:04,860 --> 00:05:06,779
para meter funciones lambda más largas

119
00:05:06,779 --> 00:05:11,220
si nosotros quisiéramos hacer

120
00:05:11,220 --> 00:05:12,540
con esta fila de números

121
00:05:12,540 --> 00:05:14,920
porque estábamos con el ejemplito de la colección

122
00:05:14,920 --> 00:05:16,480
esta que era una lista de enteros

123
00:05:16,480 --> 00:05:17,959
esta de aquí

124
00:05:17,959 --> 00:05:20,079
una lista de enteros

125
00:05:20,079 --> 00:05:21,839
pues vamos a hacer

126
00:05:21,839 --> 00:05:23,620
un código

127
00:05:23,620 --> 00:05:27,220
que yo le paso la lista de enteros

128
00:05:27,220 --> 00:05:28,480
y me devuelve

129
00:05:28,480 --> 00:05:30,699
una colección de string

130
00:05:30,699 --> 00:05:31,300
que sea

131
00:05:31,300 --> 00:05:34,720
una sucesión de

132
00:05:34,720 --> 00:05:36,660
caracteres, de aes por ejemplo

133
00:05:36,660 --> 00:05:39,120
repetida tantas veces

134
00:05:39,120 --> 00:05:40,480
como sea el número

135
00:05:40,480 --> 00:05:43,459
entonces yo puedo querer hacer ese programita

136
00:05:43,459 --> 00:05:44,939
¿no? ese programita

137
00:05:44,939 --> 00:05:47,040
que sea, tengo una lista de números

138
00:05:47,040 --> 00:05:48,180
enteros, uno

139
00:05:48,180 --> 00:05:50,879
en el punto donde está

140
00:05:50,879 --> 00:05:53,279
tengo una lista

141
00:05:53,279 --> 00:05:55,000
de números enteros, uno, dos

142
00:05:55,000 --> 00:05:57,040
cinco, y quiero

143
00:05:57,040 --> 00:05:59,240
obtener una colección que sea

144
00:05:59,240 --> 00:06:00,620
de string

145
00:06:00,620 --> 00:06:02,339
tantas aes como numeritos

146
00:06:02,339 --> 00:06:03,839
esto, esto

147
00:06:03,839 --> 00:06:06,839
esto, vale

148
00:06:06,839 --> 00:06:08,939
pues por ejemplo, ¿vale? quiero hacer como una especie

149
00:06:08,939 --> 00:06:10,740
de histogramas, ¿no?

150
00:06:10,800 --> 00:06:12,560
Una especie de histogramas. Bueno, pues

151
00:06:12,560 --> 00:06:14,740
nosotros, pues aquí haríamos

152
00:06:14,740 --> 00:06:16,920
nuestro for, dentro de

153
00:06:16,920 --> 00:06:18,779
cada for para recorrer la colección,

154
00:06:19,300 --> 00:06:21,120
haríamos a su vez un for anidado

155
00:06:21,120 --> 00:06:23,420
que va concatenando las AEs

156
00:06:23,420 --> 00:06:25,160
tantas veces como me diga

157
00:06:25,160 --> 00:06:27,060
el numerito, luego a la cabeza nos

158
00:06:27,060 --> 00:06:28,959
viene un programa con dos for,

159
00:06:29,120 --> 00:06:30,379
uno dentro de otro.

160
00:06:31,100 --> 00:06:32,639
Pues bueno, esto lo hacemos en una línea,

161
00:06:32,899 --> 00:06:34,819
cascao, ¿vale?

162
00:06:37,779 --> 00:06:38,920
Vale, pues entonces,

163
00:06:38,939 --> 00:06:41,259
pensamos

164
00:06:41,259 --> 00:06:43,160
lo que yo quiero es, tengo una filita

165
00:06:43,160 --> 00:06:45,180
de números y quiero una filita de otra

166
00:06:45,180 --> 00:06:47,060
cosa, pues map

167
00:06:47,060 --> 00:06:49,180
la función map, porque la función

168
00:06:49,180 --> 00:06:51,120
map es la que de una fila de cosas

169
00:06:51,120 --> 00:06:52,300
me lleva a una fila de otra

170
00:06:52,300 --> 00:06:54,879
pues función map, vale, y ahora

171
00:06:54,879 --> 00:06:56,540
¿qué tenemos que meter en la función map?

172
00:06:56,920 --> 00:06:57,860
tenemos que meter

173
00:06:57,860 --> 00:07:01,139
una función lambda que me exprese

174
00:07:01,139 --> 00:07:03,100
la idea de, mi dato

175
00:07:03,100 --> 00:07:03,699
de entrada

176
00:07:03,699 --> 00:07:06,379
que va a ser x

177
00:07:06,379 --> 00:07:08,899
mi dato de entrada que va a ser x

178
00:07:08,899 --> 00:07:11,420
tengo que poner aquí todo el código

179
00:07:11,420 --> 00:07:13,720
necesario para construir

180
00:07:13,720 --> 00:07:17,899
una cadena

181
00:07:17,899 --> 00:07:19,699
con tantas a's por ejemplo

182
00:07:19,699 --> 00:07:20,740
como me diga x

183
00:07:20,740 --> 00:07:23,379
entonces la función lambda ya no es tan rápida

184
00:07:23,379 --> 00:07:25,420
de escribir, porque aquí yo ya

185
00:07:25,420 --> 00:07:27,360
tengo que hacer pues un string

186
00:07:27,360 --> 00:07:29,220
con catenada al string ya es más larga

187
00:07:29,220 --> 00:07:31,420
entonces cuando una función lambda tiene más de una

188
00:07:31,420 --> 00:07:33,300
línea, porque todas las que hemos hecho ahora

189
00:07:33,300 --> 00:07:35,019
tienen solamente una línea

190
00:07:35,019 --> 00:07:37,019
pero si tiene más de una línea

191
00:07:37,019 --> 00:07:39,740
Ya sí que hay que ponerle

192
00:07:39,740 --> 00:07:41,259
El código así, entre llaves

193
00:07:41,259 --> 00:07:42,019
¿Vale?

194
00:07:44,519 --> 00:07:46,120
Hay que ponerlo entre llaves

195
00:07:46,120 --> 00:07:51,019
Efectivamente, vale

196
00:07:51,019 --> 00:07:56,810
Y ahora, aquí ya podemos poner

197
00:07:56,810 --> 00:07:57,949
Cualquier código Java

198
00:07:57,949 --> 00:08:01,009
Entonces nuestro código, pues podría ser

199
00:08:01,009 --> 00:08:02,410
Para

200
00:08:02,410 --> 00:08:05,209
El código normal, pues sería este

201
00:08:05,209 --> 00:08:06,529
¿No? string s

202
00:08:06,529 --> 00:08:08,290
Igual a pipipi

203
00:08:08,290 --> 00:08:09,750
Y ahora

204
00:08:09,750 --> 00:08:15,709
para cada

205
00:08:15,709 --> 00:08:18,370
for

206
00:08:18,370 --> 00:08:23,089
pero mientras si sea menor que x

207
00:08:23,089 --> 00:08:24,689
incrementando y

208
00:08:24,689 --> 00:08:27,149
s más

209
00:08:27,149 --> 00:08:27,949
igual

210
00:08:27,949 --> 00:08:29,910
a

211
00:08:29,910 --> 00:08:32,950
y ahora

212
00:08:32,950 --> 00:08:34,850
perdón, return

213
00:08:34,850 --> 00:08:36,769
s

214
00:08:36,769 --> 00:08:39,129
vale

215
00:08:39,129 --> 00:08:40,889
pues esta

216
00:08:40,889 --> 00:08:41,870
¿cuál era la pregunta?

217
00:08:42,029 --> 00:08:44,149
si me piques otro string de enteros

218
00:08:44,149 --> 00:08:45,049
ahí dentro, ¿petaría?

219
00:08:46,450 --> 00:08:47,669
¿otro string de enteros?

220
00:08:47,710 --> 00:08:49,049
enteros.string ahí dentro

221
00:08:49,049 --> 00:08:52,649
¿que si yo llamo a esta variable enteros?

222
00:08:52,789 --> 00:08:53,370
yo creo que no

223
00:08:53,370 --> 00:08:59,090
bueno, no estoy convirtiendo

224
00:08:59,090 --> 00:09:00,730
un string entero, estoy convirtiendo un string

225
00:09:00,730 --> 00:09:02,389
solo un entero, x

226
00:09:02,389 --> 00:09:04,809
sí, string

227
00:09:04,809 --> 00:09:06,350
s, ¿vale?

228
00:09:07,210 --> 00:09:08,830
o sea, ¿qué quieres que cambie para ver si peta?

229
00:09:09,389 --> 00:09:10,389
que si metes otra vez

230
00:09:10,389 --> 00:09:14,509
enteros.stream

231
00:09:14,509 --> 00:09:18,570
enteros.stream

232
00:09:18,570 --> 00:09:20,870
o enteros.toStream

233
00:09:20,870 --> 00:09:21,649
ah, stream

234
00:09:21,649 --> 00:09:26,210
no lo sé, pero para qué quieres hacer esto

235
00:09:26,210 --> 00:09:28,210
esto es

236
00:09:28,210 --> 00:09:28,590
si yo

237
00:09:28,590 --> 00:09:32,149
si yo me grapo el dedo, ¿qué me pasa?

238
00:09:32,330 --> 00:09:33,870
pues no sé, ¿para qué quieres grapar del dedo?

239
00:09:34,570 --> 00:09:36,129
claro, es una sentencia de Java

240
00:09:36,129 --> 00:09:37,549
entonces pues sí, te deja ponerla

241
00:09:37,549 --> 00:09:41,860
entonces, esto ya

242
00:09:41,860 --> 00:09:43,820
De hecho es una función lambda muy larga

243
00:09:43,820 --> 00:09:44,519
Y muy pesada

244
00:09:44,519 --> 00:09:47,200
Entonces, esto ya es código

245
00:09:47,200 --> 00:09:50,159
Cuando la función

246
00:09:50,159 --> 00:09:51,379
Tiene

247
00:09:51,379 --> 00:09:53,100
Más líneas de código

248
00:09:53,100 --> 00:09:54,799
Aquí ya sí que es el reto

249
00:09:54,799 --> 00:09:57,379
Porque fijaos en el caso de arriba

250
00:09:57,379 --> 00:09:58,740
Habíamos hecho ya una función

251
00:09:58,740 --> 00:10:01,480
Habíamos hecho aquí una función

252
00:10:01,480 --> 00:10:02,960
Como ejemplito

253
00:10:02,960 --> 00:10:06,470
Había una función por aquí

254
00:10:06,470 --> 00:10:07,970
Ah, no, es que la cambié ya

255
00:10:07,970 --> 00:10:09,529
Bueno, imaginaos que está

256
00:10:09,529 --> 00:10:10,870
Claro, la cambié

257
00:10:10,870 --> 00:10:16,879
Imaginaos que quisiéramos devolver el doble

258
00:10:16,879 --> 00:10:19,419
pues, claro, era la que estaba

259
00:10:19,419 --> 00:10:20,200
puesta, ¿verdad?

260
00:10:21,360 --> 00:10:23,259
entonces, así

261
00:10:23,259 --> 00:10:25,360
vale, y algo me

262
00:10:25,360 --> 00:10:25,840
falta

263
00:10:25,840 --> 00:10:29,100
desfaz transformadora

264
00:10:29,100 --> 00:10:30,720
no, me falta

265
00:10:30,720 --> 00:10:32,039
quitar esto, ¿no?

266
00:10:33,080 --> 00:10:37,190
vale, ah, es que le había puesto que le devolvía

267
00:10:37,190 --> 00:10:38,389
un string, ¿vale?

268
00:10:43,240 --> 00:10:45,320
vale, en este caso, este ejemplo

269
00:10:45,320 --> 00:10:47,639
de función lambda

270
00:10:47,639 --> 00:10:49,779
transformadora

271
00:10:49,779 --> 00:10:50,379
o función

272
00:10:50,379 --> 00:10:52,200
solo tiene una línea

273
00:10:52,200 --> 00:10:54,539
y esa línea ya es el valor de retorno

274
00:10:54,539 --> 00:10:56,799
en ese caso no se pone el retorno

275
00:10:56,799 --> 00:10:57,480
¿vale?

276
00:10:57,899 --> 00:11:00,440
que es la mayoría de los casos para los que se pueden usar

277
00:11:00,440 --> 00:11:02,000
estas cosas, muchas veces para simplificar

278
00:11:02,000 --> 00:11:04,259
entonces yo tengo un valor, quiero obtener otro en función de él

279
00:11:04,259 --> 00:11:05,840
que lo puedo expresar en una única expresión

280
00:11:05,840 --> 00:11:08,360
pues pongo ahí la expresión y ni retorno ni nada

281
00:11:08,360 --> 00:11:10,679
pero como, pero si para construir

282
00:11:10,679 --> 00:11:11,539
el valor de retorno

283
00:11:11,539 --> 00:11:13,879
tenemos que hacer más líneas

284
00:11:13,879 --> 00:11:16,799
entonces ya sí hay que poner el retorno para indicar

285
00:11:16,799 --> 00:11:18,679
ya cuál es el valor de retorno final

286
00:11:18,679 --> 00:11:20,620
¿Vale? Que es lo que hemos hecho

287
00:11:20,620 --> 00:11:22,879
Aquí, aquí abajo

288
00:11:22,879 --> 00:11:25,669
Entonces

289
00:11:25,669 --> 00:11:28,289
Esto

290
00:11:28,289 --> 00:11:30,210
Ahora retocamos esto un poquito

291
00:11:30,210 --> 00:11:32,509
Esto me devuelve otro stream

292
00:11:32,509 --> 00:11:33,789
O sea, he cambiado

293
00:11:33,789 --> 00:11:36,710
Esta fila en una fila

294
00:11:36,710 --> 00:11:37,769
De elementos distintos

295
00:11:37,769 --> 00:11:40,409
Ahora ya he decidido qué quiero hacer con esta fila

296
00:11:40,409 --> 00:11:42,549
Hay un montón de métodos, por ejemplo

297
00:11:42,549 --> 00:11:44,769
Hay uno que es pasarla a lista

298
00:11:44,769 --> 00:11:45,570
To list

299
00:11:45,570 --> 00:11:48,690
¿Vale? Tengo el to list

300
00:11:48,690 --> 00:11:51,429
Y la paso a lista de string, por ejemplo

301
00:11:51,429 --> 00:11:53,950
O puedo, si lo que quiero es mostrarlo por consola

302
00:11:53,950 --> 00:11:55,830
Pues mostrarlo con un for each

303
00:11:55,830 --> 00:11:57,830
Yo ya decido

304
00:11:57,830 --> 00:11:58,809
Que hago con este string

305
00:11:58,809 --> 00:12:00,470
Porque esto vuelve a ser un string

306
00:12:00,470 --> 00:12:01,669
¿Vale?

307
00:12:05,070 --> 00:12:07,289
Claro, son los mismos elementos

308
00:12:07,289 --> 00:12:08,409
Pero transformados

309
00:12:08,409 --> 00:12:10,090
O sea, es la misma fila

310
00:12:10,090 --> 00:12:11,669
Pero transformada

311
00:12:11,669 --> 00:12:14,889
Entonces, por ejemplo, si lo quiero mostrar por consola

312
00:12:14,889 --> 00:12:21,980
Pues

313
00:12:21,980 --> 00:12:26,720
Pues lo podría mostrar así

314
00:12:26,720 --> 00:12:32,039
¿Vale? Entonces si ejecutamos esto

315
00:12:32,039 --> 00:12:33,039
Efectivamente

316
00:12:33,039 --> 00:12:36,220
Me saldrán las aes

317
00:12:36,220 --> 00:12:41,019
¿Vale?

318
00:12:41,659 --> 00:12:50,620
Vale, entonces

319
00:12:50,620 --> 00:12:53,100
Todo esto venía a cuento

320
00:12:53,100 --> 00:12:56,120
De la clase files

321
00:12:56,120 --> 00:12:57,279
Del paquete jabanío

322
00:12:57,279 --> 00:12:58,320
¿Verdad?

323
00:13:00,899 --> 00:13:01,580
Entonces

324
00:13:01,580 --> 00:13:03,980
Si nos volvemos a ese ejemplo

325
00:13:03,980 --> 00:13:05,820
en el que estábamos, que era

326
00:13:05,820 --> 00:13:08,039
estábamos viendo el contenido de un

327
00:13:08,039 --> 00:13:09,919
fichero, ver fichero

328
00:13:09,919 --> 00:13:11,860
con el fread, pues

329
00:13:11,860 --> 00:13:13,899
íbamos leyendo, concatenábamos

330
00:13:13,899 --> 00:13:15,460
al stream builder y se acabó

331
00:13:15,460 --> 00:13:18,159
ver fichero, vamos a hacerlo de otra manera

332
00:13:18,159 --> 00:13:19,980
pues con la

333
00:13:19,980 --> 00:13:22,120
clase paths, que es la equivalente

334
00:13:22,120 --> 00:13:23,980
a file en javanio

335
00:13:23,980 --> 00:13:27,799
podíamos leer las líneas

336
00:13:27,799 --> 00:13:29,299
directamente con read online

337
00:13:29,299 --> 00:13:31,960
y pasarlas a un stream

338
00:13:31,960 --> 00:13:34,279
Y ahora hacer esto mismo, demostrar el fichero

339
00:13:34,279 --> 00:13:35,759
Ahora lo haremos

340
00:13:35,759 --> 00:13:37,960
Directamente con la fila

341
00:13:37,960 --> 00:13:38,220
¿Vale?

342
00:13:39,679 --> 00:13:42,259
Pero ni siquiera hace falta que saquemos el stream

343
00:13:42,259 --> 00:13:42,899
Porque

344
00:13:42,899 --> 00:13:45,500
La clase files

345
00:13:45,500 --> 00:13:48,019
Ya tiene directamente un método

346
00:13:48,019 --> 00:13:49,259
Que te lo devuelve en stream

347
00:13:49,259 --> 00:13:52,059
Que es lines

348
00:13:52,059 --> 00:13:53,200
Yo creo, si

349
00:13:53,200 --> 00:13:56,519
El método lines es que ya te lo devuelve

350
00:13:56,519 --> 00:13:57,759
Directamente en stream

351
00:13:57,759 --> 00:14:26,950
Joder

352
00:14:26,950 --> 00:14:33,100
es decir, en la clase files

353
00:14:33,100 --> 00:14:34,179
que es en la que estábamos

354
00:14:34,179 --> 00:14:36,299
este me devuelve

355
00:14:36,299 --> 00:14:37,980
todas las líneas en una

356
00:14:37,980 --> 00:14:40,320
lista de cadenas

357
00:14:40,320 --> 00:14:43,139
y este me devuelve ya directamente

358
00:14:43,139 --> 00:14:45,440
un string, una filita con todas las líneas

359
00:14:45,440 --> 00:14:47,200
por si yo quiero operar directamente

360
00:14:47,200 --> 00:14:48,559
ya con el string para hacer cosas

361
00:14:48,559 --> 00:14:51,379
y no hace falta que lo extraiga como lo extraiga aquí

362
00:14:51,379 --> 00:14:53,679
entonces, por ejemplo

363
00:14:53,679 --> 00:14:54,960
para ver otro método

364
00:14:54,960 --> 00:14:56,320
de string

365
00:14:56,320 --> 00:14:57,879
que

366
00:14:57,879 --> 00:15:00,320
nos puede

367
00:15:00,320 --> 00:15:01,059
interesar usar

368
00:15:01,059 --> 00:15:04,080
vale, este método

369
00:15:04,080 --> 00:15:06,200
en particular que estábamos haciendo, ¿para qué era?

370
00:15:06,679 --> 00:15:08,059
para devolver

371
00:15:08,059 --> 00:15:10,240
un string

372
00:15:10,240 --> 00:15:12,019
con el contenido del fichero

373
00:15:12,019 --> 00:15:14,080
para devolver un string con el que tiene el fichero

374
00:15:14,080 --> 00:15:15,419
o lo que es lo mismo

375
00:15:15,419 --> 00:15:18,500
concatenamos todas las líneas y las devolvemos

376
00:15:18,500 --> 00:15:20,220
¿verdad? para eso era ese

377
00:15:20,220 --> 00:15:21,679
fichero, entonces

378
00:15:21,679 --> 00:15:24,279
con el forEach, pues bueno

379
00:15:24,279 --> 00:15:25,000
no

380
00:15:25,000 --> 00:15:27,360
Lo mostraríamos por consola

381
00:15:27,360 --> 00:15:28,220
Que no es lo que queremos

382
00:15:28,220 --> 00:15:31,299
Con el for each haríamos esto

383
00:15:31,299 --> 00:15:33,799
Filalíneas

384
00:15:33,799 --> 00:15:39,620
Para cada línea

385
00:15:39,620 --> 00:15:48,700
Para cada línea

386
00:15:48,700 --> 00:15:50,139
Pues esto de aquí

387
00:15:50,139 --> 00:16:01,519
Y me sobra esto

388
00:16:01,519 --> 00:16:09,259
A ver

389
00:16:09,259 --> 00:16:10,399
Que me dice este

390
00:16:10,399 --> 00:16:15,659
Perdón, perdón, que es que lo he puesto con el doble punto

391
00:16:15,659 --> 00:16:17,200
Y con el doble punto lógicamente

392
00:16:17,200 --> 00:16:18,600
No hace falta el parámetro de entrada

393
00:16:18,600 --> 00:16:19,539
Vale

394
00:16:19,539 --> 00:16:25,019
Vale, pues este me mostraría el fichero por consola

395
00:16:25,019 --> 00:16:26,600
Pero no es lo que queremos

396
00:16:26,600 --> 00:16:28,820
Lo que queremos es devolver un string con ello

397
00:16:28,820 --> 00:16:34,539
Si ejecutamos esto

398
00:16:34,539 --> 00:16:35,360
Mi fichero

399
00:16:35,360 --> 00:16:38,120
Voy a ver en mi main

400
00:16:38,120 --> 00:16:40,360
Vamos a probar esto en mi main

401
00:16:40,360 --> 00:16:44,480
En mi main le estoy pasando

402
00:16:44,480 --> 00:16:45,480
Nombres txt

403
00:16:45,480 --> 00:16:47,940
Y nombres txt

404
00:16:47,940 --> 00:16:49,100
Era este

405
00:16:49,100 --> 00:16:51,580
Estos nombres

406
00:16:51,580 --> 00:16:53,200
Vale

407
00:16:53,200 --> 00:16:56,460
Pues ahora en mi main llamo a este método

408
00:16:56,460 --> 00:16:58,299
pasándole ese fichero de nombres

409
00:16:58,299 --> 00:17:00,460
y este método

410
00:17:00,460 --> 00:17:01,279
efectivamente

411
00:17:01,279 --> 00:17:04,240
va a ir línea por línea

412
00:17:04,240 --> 00:17:06,099
de esta filita de líneas mostrándolas

413
00:17:06,099 --> 00:17:08,299
vamos a ver, no vaya a ser que hayamos hecho algo mal

414
00:17:08,299 --> 00:17:13,099
que si hemos hecho algo mal

415
00:17:13,099 --> 00:17:15,839
vale, aquí están

416
00:17:15,839 --> 00:17:18,799
pero no es lo que queremos que haga este método

417
00:17:18,799 --> 00:17:20,160
lo que queremos que haga este método

418
00:17:20,160 --> 00:17:21,579
es construir un string

419
00:17:21,579 --> 00:17:24,119
y devolverlo con valor de retorno

420
00:17:24,119 --> 00:17:25,619
entonces el for each

421
00:17:25,619 --> 00:17:28,039
ya no nos vale, porque aquí podríamos

422
00:17:28,039 --> 00:17:29,680
hacer un código dentro del for each

423
00:17:29,680 --> 00:17:31,099
que para cada x

424
00:17:31,099 --> 00:17:33,559
haga una cosita

425
00:17:33,559 --> 00:17:35,440
pero es que no lo va a devolver

426
00:17:35,440 --> 00:17:37,160
porque el for each no devuelve nada

427
00:17:37,160 --> 00:17:39,500
y la función tampoco nos vale

428
00:17:39,500 --> 00:17:41,599
porque la función te devuelve una cosa

429
00:17:41,599 --> 00:17:43,319
para cada elemento de la fila

430
00:17:43,319 --> 00:17:45,299
y la que nosotros devolvemos

431
00:17:45,299 --> 00:17:47,680
necesita todos los elementos de la fila

432
00:17:48,400 --> 00:17:49,579
¿entendéis la situación, no?

433
00:17:50,319 --> 00:17:51,980
entonces aquí hacer un map

434
00:17:51,980 --> 00:17:53,380
no, porque el map

435
00:17:53,380 --> 00:17:55,259
si yo aquí pongo un map

436
00:17:55,259 --> 00:17:58,539
claro, el map transforma cada elemento

437
00:17:58,539 --> 00:17:59,259
en otra cosa

438
00:17:59,259 --> 00:18:03,279
si yo pongo aquí un map con lo que sea

439
00:18:03,279 --> 00:18:05,440
el map

440
00:18:05,440 --> 00:18:07,779
trata cada elemento por separado

441
00:18:07,779 --> 00:18:09,420
en este caso

442
00:18:09,420 --> 00:18:10,680
cada línea del fichero

443
00:18:10,680 --> 00:18:12,579
entonces con cada línea del fichero

444
00:18:12,579 --> 00:18:15,480
haría algo que sería completamente independiente

445
00:18:15,480 --> 00:18:17,839
del resto de líneas y ese algo me lo devolvería

446
00:18:17,839 --> 00:18:19,079
y me lo pondría en otra fila

447
00:18:19,079 --> 00:18:20,519
pero con eso no gano nada

448
00:18:20,519 --> 00:18:23,380
porque el valor final que yo quiero

449
00:18:23,380 --> 00:18:25,799
es un valor agregado, agregado de todas

450
00:18:25,799 --> 00:18:27,160
entonces

451
00:18:27,160 --> 00:18:30,099
¿hay algún método aquí

452
00:18:30,099 --> 00:18:31,920
que me permita obtener un valor

453
00:18:31,920 --> 00:18:34,519
agregado que tenga en cuenta todos los elementos?

454
00:18:35,140 --> 00:18:35,680
pues sí

455
00:18:35,680 --> 00:18:38,079
lo que pasa es que es un poquito

456
00:18:38,079 --> 00:18:39,339
más raro de darle parámetros

457
00:18:39,339 --> 00:18:41,359
pero bueno, no pasa nada

458
00:18:41,359 --> 00:18:43,579
lo vemos, entonces uno

459
00:18:43,579 --> 00:18:45,819
mira, indaga, cotillea

460
00:18:45,819 --> 00:18:47,759
ahora la vida es más fácil

461
00:18:47,759 --> 00:18:49,240
le pregunto a HGPT y te lo dice

462
00:18:49,240 --> 00:18:50,319
¿vale?

463
00:18:52,079 --> 00:18:53,640
pero uno tiene que saber

464
00:18:53,640 --> 00:18:55,779
para que eso le sea una ayuda realmente

465
00:18:55,779 --> 00:18:59,920
Y encuentra el colet

466
00:18:59,920 --> 00:19:00,940
¿Vale?

467
00:19:01,420 --> 00:19:03,519
Encuentra el colet que por el nombre

468
00:19:03,519 --> 00:19:06,880
Por el nombre

469
00:19:06,880 --> 00:19:09,319
Podíamos ya deducir que colet

470
00:19:09,319 --> 00:19:11,460
Hace una agregación

471
00:19:11,460 --> 00:19:13,640
De todos los elementos de la fila

472
00:19:13,640 --> 00:19:14,619
Hace una agrega

473
00:19:14,619 --> 00:19:16,140
Del stream este

474
00:19:16,140 --> 00:19:19,180
Hace un agregado de todos

475
00:19:19,180 --> 00:19:21,980
¿Vale? Pero para hacer ese agregado

476
00:19:21,980 --> 00:19:23,440
Tenemos que darle

477
00:19:23,440 --> 00:19:25,779
Tenemos que darle pautas

478
00:19:25,779 --> 00:19:28,220
en función de lo que queramos hacer

479
00:19:28,220 --> 00:19:30,940
para darle el agregado hay que darle pauta

480
00:19:30,940 --> 00:19:32,240
mediante estos tres parámetros

481
00:19:32,240 --> 00:19:35,019
bueno pues colet

482
00:19:35,019 --> 00:19:37,140
asume

483
00:19:37,140 --> 00:19:38,259
que recibe un

484
00:19:38,259 --> 00:19:40,559
que obtiene un único resultado final

485
00:19:40,559 --> 00:19:41,380
un único resultado

486
00:19:41,380 --> 00:19:43,640
ese resultado final

487
00:19:43,640 --> 00:19:46,720
lo va a meter colet en una cosa que

488
00:19:46,720 --> 00:19:49,019
podemos llamar como una especie de acumulador

489
00:19:49,019 --> 00:19:51,079
una variable acumuladora

490
00:19:51,079 --> 00:19:51,819
nos suena

491
00:19:51,819 --> 00:19:54,839
al séptimo día de la clase de programación

492
00:19:54,839 --> 00:19:55,559
del año pasado

493
00:19:55,559 --> 00:19:58,480
¿Os recordáis? ¿Verdad? El séptimo día en concreto

494
00:19:58,480 --> 00:19:59,079
¿Os recordáis?

495
00:20:01,079 --> 00:20:01,680
Claro

496
00:20:01,680 --> 00:20:04,299
Pues cuando, bueno, no era el séptimo, pero por ahí

497
00:20:04,299 --> 00:20:06,400
Pues cuando hacíamos sumas

498
00:20:06,400 --> 00:20:07,259
acumulativas

499
00:20:07,259 --> 00:20:10,579
Cuando hacíamos la maravillosa

500
00:20:10,579 --> 00:20:12,119
sentencia de

501
00:20:12,119 --> 00:20:14,359
S más igual

502
00:20:14,359 --> 00:20:14,819
X

503
00:20:14,819 --> 00:20:17,960
Pues sobre S íbamos acumulando

504
00:20:17,960 --> 00:20:20,299
los X que nos iban viniendo

505
00:20:20,299 --> 00:20:20,960
de un for

506
00:20:20,960 --> 00:20:24,059
Entonces, esta es una sentencia que me permite

507
00:20:24,059 --> 00:20:25,500
hacer una suma acumulativa

508
00:20:25,500 --> 00:20:28,700
y ese inicialmente inicializábamos a cero

509
00:20:28,700 --> 00:20:29,940
si es que es una suma

510
00:20:29,940 --> 00:20:32,480
y ese era el acumulador

511
00:20:32,480 --> 00:20:34,900
una variable que funciona conceptualmente

512
00:20:34,900 --> 00:20:35,839
como un acumulador

513
00:20:35,839 --> 00:20:37,700
que va recibiendo esto

514
00:20:37,700 --> 00:20:39,920
pues este colet en realidad

515
00:20:39,920 --> 00:20:42,420
hace una operación acumulativa

516
00:20:42,420 --> 00:20:43,900
¿vale?

517
00:20:44,359 --> 00:20:47,039
entonces, ¿qué es lo que le damos aquí?

518
00:20:47,759 --> 00:20:48,460
aquí le damos

519
00:20:48,460 --> 00:20:49,599
el acumulador

520
00:20:49,599 --> 00:20:52,299
es decir, la variable

521
00:20:52,299 --> 00:20:54,779
sobre la que va a acumular

522
00:20:54,779 --> 00:20:57,480
Claro, la que te va a volver al final

523
00:20:57,480 --> 00:21:00,099
La variable sobre la que va a acumular

524
00:21:00,099 --> 00:21:02,119
El resultado

525
00:21:02,119 --> 00:21:02,819
Final

526
00:21:02,819 --> 00:21:05,460
Y aquí ya sí que le damos

527
00:21:05,460 --> 00:21:06,480
Una función lambda

528
00:21:06,480 --> 00:21:09,420
En este caso sería una bifunction

529
00:21:09,420 --> 00:21:11,599
Y a esta función lambda hay que darle

530
00:21:11,599 --> 00:21:13,940
El acumulador

531
00:21:13,940 --> 00:21:15,519
Que lo hemos generado aquí

532
00:21:15,519 --> 00:21:18,460
El valor de la fila

533
00:21:18,460 --> 00:21:20,259
Y ahora ya

534
00:21:20,259 --> 00:21:21,859
Aquí le ponemos la expresión

535
00:21:21,859 --> 00:21:23,799
De cómo acumulo yo x

536
00:21:23,799 --> 00:21:24,779
como a mí me da la gana

537
00:21:24,779 --> 00:21:27,380
¿cómo acumulo Y

538
00:21:27,380 --> 00:21:29,079
a X?

539
00:21:30,779 --> 00:21:31,700
¿vale? esta sería

540
00:21:31,700 --> 00:21:32,680
la del segundo valor

541
00:21:32,680 --> 00:21:35,740
el segundo valor es una bifunción

542
00:21:35,740 --> 00:21:36,799
recibe dos parámetros

543
00:21:36,799 --> 00:21:39,140
el primero, colect

544
00:21:39,140 --> 00:21:42,079
asume siempre que es el acumulador que has creado aquí

545
00:21:42,079 --> 00:21:43,720
siempre es el acumulador

546
00:21:43,720 --> 00:21:45,140
lo llamas Y, lo llamas como quieras

547
00:21:45,140 --> 00:21:47,920
va a tomar el valor del acumulador que tú hayas creado aquí

548
00:21:47,920 --> 00:21:49,539
¿y quién es?

549
00:21:49,539 --> 00:21:51,099
y es el elemento de la fila

550
00:21:51,099 --> 00:21:53,200
que toca

551
00:21:53,200 --> 00:21:55,720
que esto se va haciendo uno por uno

552
00:21:55,720 --> 00:21:56,839
cada elemento de la fila

553
00:21:56,839 --> 00:21:59,880
y aquí que se devuelve

554
00:21:59,880 --> 00:22:02,059
se devuelve el resultado

555
00:22:02,059 --> 00:22:03,460
de hacer esa acumulación

556
00:22:03,460 --> 00:22:05,380
sobre el acumulador

557
00:22:05,380 --> 00:22:07,039
y eso va cambiando

558
00:22:07,039 --> 00:22:10,220
según va avanzando

559
00:22:10,220 --> 00:22:12,220
la fila, pues el acumulador

560
00:22:12,220 --> 00:22:13,380
irá reflejando

561
00:22:13,380 --> 00:22:15,660
todas y cada una de las llamadas

562
00:22:15,660 --> 00:22:17,440
que se ha hecho a eso, irá reflejando

563
00:22:17,440 --> 00:22:20,259
¿y este tercer parámetro cuál es?

564
00:22:20,579 --> 00:22:21,420
este es un poco

565
00:22:21,420 --> 00:22:22,380
raro

566
00:22:22,380 --> 00:22:25,160
Esto es porque los stream

567
00:22:25,160 --> 00:22:27,000
Pueden trabajar con

568
00:22:27,000 --> 00:22:29,460
Métodos que funcionan en paralelo

569
00:22:29,460 --> 00:22:31,599
Que funcionan con computación

570
00:22:31,599 --> 00:22:33,440
Paralela para que si la fila es muy

571
00:22:33,440 --> 00:22:34,880
Larga, pues

572
00:22:34,880 --> 00:22:37,660
Puedan trabajar en paralelo

573
00:22:37,660 --> 00:22:39,539
Por cachos, si es que eso no afecta

574
00:22:39,539 --> 00:22:41,259
Al resultado final, un map

575
00:22:41,259 --> 00:22:43,400
En realidad podría trabajar por cachos

576
00:22:43,400 --> 00:22:44,799
¿Vale? Entonces

577
00:22:44,799 --> 00:22:47,359
Si se usara

578
00:22:47,359 --> 00:22:49,079
Porque stream puede

579
00:22:49,079 --> 00:22:51,180
Esa forma paralela de trabajar

580
00:22:51,180 --> 00:22:53,420
pues te dice que haces aquí

581
00:22:53,420 --> 00:22:55,599
con esos hilos paralelos que es la alfa

582
00:22:55,599 --> 00:22:58,059
¿en qué se traduce para nosotros?

583
00:22:58,700 --> 00:22:59,680
en poner lo mismo

584
00:22:59,680 --> 00:23:01,079
en poner lo mismo, ya está

585
00:23:01,079 --> 00:23:03,359
haz paralelo o no hagas paralelo

586
00:23:03,359 --> 00:23:05,519
me da igual como lo hagas, pero vas a hacer lo mismo

587
00:23:05,519 --> 00:23:06,160
en ambos casos

588
00:23:06,160 --> 00:23:09,500
no aplicado a esto

589
00:23:09,500 --> 00:23:10,079
yo creo

590
00:23:10,079 --> 00:23:13,259
pero sí en otros contextos

591
00:23:13,259 --> 00:23:13,539
claro

592
00:23:13,539 --> 00:23:17,720
pues entonces, en nuestro caso, ¿qué es lo que queremos?

593
00:23:18,539 --> 00:23:19,619
queremos que todas

594
00:23:19,619 --> 00:23:20,500
las líneas

595
00:23:20,500 --> 00:23:22,519
se fundan en una

596
00:23:22,519 --> 00:23:24,160
se fundan en una

597
00:23:24,160 --> 00:23:28,019
¿qué acumulador necesitamos?

598
00:23:28,119 --> 00:23:28,680
un stream

599
00:23:28,680 --> 00:23:30,180
porque es el que se va a acumular

600
00:23:30,180 --> 00:23:32,359
pero

601
00:23:32,359 --> 00:23:34,619
vamos a acostumbrarnos

602
00:23:34,619 --> 00:23:35,539
ya también

603
00:23:35,539 --> 00:23:38,680
cuando vamos a trabajar con un stream

604
00:23:38,680 --> 00:23:40,640
sobre el que vamos a ir haciendo cosas

605
00:23:40,640 --> 00:23:42,420
acumulando cosas en él

606
00:23:42,420 --> 00:23:43,480
concatenándolo cosas

607
00:23:43,480 --> 00:23:44,980
en lugar de un stream

608
00:23:44,980 --> 00:23:47,500
usar un stream builder

609
00:23:47,500 --> 00:23:50,890
el stream builder

610
00:23:50,890 --> 00:23:52,069
tiene un stream dentro

611
00:23:52,069 --> 00:23:53,809
pero a la hora de usarlo

612
00:23:53,809 --> 00:23:55,890
pues por el tema de los buffers

613
00:23:55,890 --> 00:23:57,809
y por todo eso, se optimiza un poquito

614
00:23:57,809 --> 00:23:58,829
el rendimiento

615
00:23:58,829 --> 00:24:01,750
entonces para no tenerle miedo a ese

616
00:24:01,750 --> 00:24:03,569
stream builder, pues vamos a

617
00:24:03,569 --> 00:24:05,930
me da lo mismo decir que mi variable final

618
00:24:05,930 --> 00:24:07,730
es una string, que es

619
00:24:07,730 --> 00:24:09,529
una stream builder, una stream builder es

620
00:24:09,529 --> 00:24:10,710
un envoltorio de la stream

621
00:24:10,710 --> 00:24:13,609
y de la stream builder saco el stream poniendo

622
00:24:13,609 --> 00:24:15,049
tu stream cuando lo necesite

623
00:24:15,049 --> 00:24:17,490
pero las funciones que me da stream builder

624
00:24:17,490 --> 00:24:19,029
los métodos que me da stream builder

625
00:24:19,029 --> 00:24:20,910
a diferencia de los de stream

626
00:24:20,910 --> 00:24:22,549
que me da los que ya conocemos

627
00:24:22,549 --> 00:24:24,089
o los que me da StreamBuilder

628
00:24:24,089 --> 00:24:26,269
optimizan el funcionamiento del manejo de cadenas

629
00:24:26,269 --> 00:24:28,509
bueno, pues entonces

630
00:24:28,509 --> 00:24:29,509
¿qué queremos?

631
00:24:30,109 --> 00:24:30,990
primer parámetro

632
00:24:30,990 --> 00:24:34,650
función lambda que de la nada

633
00:24:34,650 --> 00:24:36,150
me da algo

634
00:24:36,150 --> 00:24:37,069
un acumulador

635
00:24:37,069 --> 00:24:39,029
perdón

636
00:24:39,029 --> 00:24:42,309
primer parámetro

637
00:24:42,309 --> 00:24:45,299
ah, vale, ahora

638
00:24:45,299 --> 00:24:48,799
es que pensaba que habías puesto algo

639
00:24:50,799 --> 00:24:52,240
no, que es que no se ve

640
00:24:52,240 --> 00:24:54,180
Primer parámetro

641
00:24:54,180 --> 00:24:56,000
Todos tienen que ser funciones lambda

642
00:24:56,000 --> 00:24:57,700
¿Vale? Colet es un método

643
00:24:57,700 --> 00:25:00,460
Primer parámetro, función lambda

644
00:25:00,460 --> 00:25:01,519
Que

645
00:25:01,519 --> 00:25:04,140
Me hace aparecer, así por la buena

646
00:25:04,140 --> 00:25:05,900
Es un stream builder de la nada

647
00:25:05,900 --> 00:25:08,400
¿Qué tipo de interfaz funcional

648
00:25:08,400 --> 00:25:08,819
Es esa?

649
00:25:10,119 --> 00:25:10,960
Una B

650
00:25:10,960 --> 00:25:14,420
Esa, una supplier

651
00:25:14,420 --> 00:25:16,460
Una supplier

652
00:25:16,460 --> 00:25:19,960
En este caso

653
00:25:19,960 --> 00:25:22,220
Una supplier de stream builder

654
00:25:22,220 --> 00:25:25,859
Porque de la nada

655
00:25:25,859 --> 00:25:28,700
Me hace aparecer un objeto stream builder

656
00:25:28,700 --> 00:25:30,839
Eso es lo primero que tengo que hacer ahí

657
00:25:30,839 --> 00:25:32,019
Una función lambda

658
00:25:32,019 --> 00:25:33,240
Que de la nada

659
00:25:33,240 --> 00:25:35,240
Y esta es la nada

660
00:25:35,240 --> 00:25:38,440
De la nada me hace aparecer

661
00:25:38,440 --> 00:25:43,640
Un stream builder

662
00:25:43,640 --> 00:25:49,700
Cuando no hay parámetros de entrada, sí

663
00:25:49,700 --> 00:25:55,000
¡Hala!

664
00:25:56,019 --> 00:25:57,619
Ya tengo el primer parámetro

665
00:25:57,619 --> 00:25:59,200
La supplier que me dice

666
00:25:59,200 --> 00:26:01,200
este es tu acumulador, te lo entrego

667
00:26:01,200 --> 00:26:02,700
ahora

668
00:26:02,700 --> 00:26:04,640
el segundo parámetro

669
00:26:04,640 --> 00:26:05,980
una bifunction

670
00:26:05,980 --> 00:26:08,140
y las bifunction

671
00:26:08,140 --> 00:26:10,740
es que son así obligatoriamente

672
00:26:10,740 --> 00:26:12,799
reciben dos parámetros

673
00:26:12,799 --> 00:26:14,759
y ahí solo me cae una bifunction

674
00:26:14,759 --> 00:26:17,440
el primer parámetro

675
00:26:17,440 --> 00:26:18,359
¿cuál va a ser?

676
00:26:18,359 --> 00:26:19,420
para el colet

677
00:26:19,420 --> 00:26:22,440
ya está

678
00:26:22,440 --> 00:26:22,819
x

679
00:26:22,819 --> 00:26:26,119
el colet ya sabe

680
00:26:26,119 --> 00:26:28,160
que con x tú te refieres al

681
00:26:28,160 --> 00:26:30,220
acumulador obligatoriamente. Y con

682
00:26:30,220 --> 00:26:32,180
y te refieres al elemento de la fila en la que

683
00:26:32,180 --> 00:26:34,319
estás. Vale, pues entonces

684
00:26:34,319 --> 00:26:35,859
¿qué queremos hacer

685
00:26:35,859 --> 00:26:38,039
con ese y? Pues lo que queremos

686
00:26:38,039 --> 00:26:39,880
hacer con ese y es

687
00:26:39,880 --> 00:26:41,220
acumularlo a x.

688
00:26:42,859 --> 00:26:44,440
x.append

689
00:26:44,440 --> 00:26:45,920
y

690
00:26:45,920 --> 00:26:48,220
si hubiéramos

691
00:26:48,220 --> 00:26:50,180
cogido en lugar de un newStreamBuilder

692
00:26:50,180 --> 00:26:52,019
un newStream, pues

693
00:26:52,019 --> 00:26:53,519
justo, pues pondríamos

694
00:26:53,519 --> 00:26:56,299
x igual

695
00:26:56,299 --> 00:26:57,839
a x más y.

696
00:26:58,160 --> 00:27:02,299
X igual a X más Y, pues debe ser que está perdido el manejo.

697
00:27:03,319 --> 00:27:10,000
X igual a X más Y, el manejo interno es peor que este, suponemos.

698
00:27:10,880 --> 00:27:12,180
Porque si no, no se usaría tanto.

699
00:27:13,420 --> 00:27:21,039
Vale, y nos pide un tercer parámetro que es para eventual computación paralela.

700
00:27:21,240 --> 00:27:23,039
¿Qué hago cuando lo hagan?

701
00:27:23,220 --> 00:27:28,279
Pues lo mismo, lo mismito.

702
00:27:28,279 --> 00:27:31,420
la misma función lambda

703
00:27:31,420 --> 00:27:34,339
claro, me da igual que

704
00:27:34,339 --> 00:27:35,720
yo voy acumulando

705
00:27:35,720 --> 00:27:38,099
de uno en uno o los voy acumulando

706
00:27:38,099 --> 00:27:39,319
pero los voy acumulando igual

707
00:27:39,319 --> 00:27:40,960
¿qué sentido tendría?

708
00:27:47,359 --> 00:27:48,240
no lo sé

709
00:27:48,240 --> 00:27:50,059
no lo sé

710
00:27:50,059 --> 00:27:51,940
no sé en qué situación

711
00:27:51,940 --> 00:27:53,559
habría que ver en qué situación

712
00:27:53,559 --> 00:27:56,779
se puede hacer una computación

713
00:27:56,779 --> 00:27:58,259
paralela en la cual

714
00:27:58,259 --> 00:28:00,599
pues aquí tendrás que tener en cuenta

715
00:28:00,599 --> 00:28:02,680
Cosas para gestión

716
00:28:02,680 --> 00:28:03,740
De esa computación

717
00:28:03,740 --> 00:28:06,259
Que si no las tienes en cuenta

718
00:28:06,259 --> 00:28:07,119
No te va a funcionar

719
00:28:07,119 --> 00:28:09,160
Y entonces tendrías que ponerlo aquí en líneas añadidas

720
00:28:09,160 --> 00:28:10,140
No lo sé

721
00:28:10,140 --> 00:28:14,079
Tendríamos que pensar un ejemplo

722
00:28:14,079 --> 00:28:15,180
O pedirse lo hecho a GPT

723
00:28:15,180 --> 00:28:17,619
Entonces si tienes una función lambda enorme

724
00:28:17,619 --> 00:28:19,880
La primera, tienes que copiar y pegar la misma

725
00:28:19,880 --> 00:28:22,039
A ver, lo normal es que

726
00:28:22,039 --> 00:28:23,259
Yo es que aquí las estoy poniendo

727
00:28:23,259 --> 00:28:25,380
Que te la hagas a una variable intermedia

728
00:28:25,380 --> 00:28:27,759
Te hagas aquí una bifunción

729
00:28:27,759 --> 00:28:30,299
Y aquí le pasen los dos parámetros

730
00:28:30,299 --> 00:28:34,900
no siempre

731
00:28:34,900 --> 00:28:37,759
¿en qué casos podría no tener sentido pasar el mismo?

732
00:28:37,880 --> 00:28:39,259
pues no se me ocurre ninguno

733
00:28:39,259 --> 00:28:41,160
es lo que me ha preguntado él

734
00:28:41,160 --> 00:28:45,720
si nosotros

735
00:28:45,720 --> 00:28:46,900
estamos haciendo algo

736
00:28:46,900 --> 00:28:50,140
con una fila

737
00:28:50,140 --> 00:28:51,819
y tenemos claro lo que tenemos que hacer

738
00:28:51,819 --> 00:28:53,200
pues nos da igual que lo hagan para él o no

739
00:28:53,200 --> 00:28:54,299
es que queremos hacer eso

740
00:28:54,299 --> 00:28:56,279
entonces ponemos eso las dos veces

741
00:28:56,279 --> 00:29:25,279
Vale, y esto, esto nos va a devolver un valor, nos va a devolver un stream builder, esto ya nos devuelve el collect, nos va a devolver el acumulador, eso es lo que nos devuelve, de hecho para que esto no se pierda un segundito, vamos a escribir aquí para que no se pierda stream builder.

742
00:29:27,650 --> 00:29:31,289
Builder

743
00:29:31,289 --> 00:29:36,250
Vale, y ahora pues vamos a

744
00:29:36,250 --> 00:29:39,769
Y lo devolveríamos

745
00:29:39,769 --> 00:29:44,380
RetuneStreamBuilder

746
00:29:44,380 --> 00:29:46,240
ToStream

747
00:29:46,240 --> 00:29:47,700
Que se me va a acabar, ¿por qué?

748
00:29:47,700 --> 00:29:50,000
Ah, sí, vale

749
00:29:50,000 --> 00:29:51,019
Tienes razón

750
00:29:51,019 --> 00:30:02,640
A ver, hay regleta por ahí

751
00:30:02,640 --> 00:30:13,930
es por no tener cables aquí

752
00:30:13,930 --> 00:30:15,809
porque me voy para atrás, me voy para allá y al final

753
00:30:15,809 --> 00:30:17,710
siempre me

754
00:30:17,710 --> 00:30:18,789
los cargo

755
00:30:18,789 --> 00:30:19,890
vale

756
00:30:19,890 --> 00:30:25,130
pues aquí devolvemos

757
00:30:25,130 --> 00:30:26,849
el acumulador

758
00:30:26,849 --> 00:30:29,549
en tu stream, podría haber puesto aquí que me devolvía

759
00:30:29,549 --> 00:30:31,230
un stream builder directamente y ya está

760
00:30:31,230 --> 00:30:33,829
pero bueno, como me he puesto y me devuelvo un stream

761
00:30:33,829 --> 00:30:35,369
¿vale?

762
00:30:35,690 --> 00:30:37,390
una pregunta, en el tercer

763
00:30:37,390 --> 00:30:40,750
o sea, donde has copiado

764
00:30:40,750 --> 00:30:42,549
la segunda, lo de la

765
00:30:42,549 --> 00:30:44,509
bifunción, le podías poner

766
00:30:44,509 --> 00:30:46,349
un método o algo así, ¿dónde?

767
00:30:46,710 --> 00:30:47,750
ahí, aquí

768
00:30:47,750 --> 00:30:50,529
aquí hay que poner también una bifunción

769
00:30:50,529 --> 00:30:51,930
¿vale? que es

770
00:30:51,930 --> 00:30:54,650
lo que tú harías si trabaja

771
00:30:54,650 --> 00:30:55,730
en paralelo con esa

772
00:30:55,730 --> 00:30:57,569
¿vale? esa es la idea

773
00:30:57,569 --> 00:31:00,210
¿vale? y más allá de ahí

774
00:31:00,210 --> 00:31:01,769
poco más te puedo decir

775
00:31:01,769 --> 00:31:06,119
vamos, podríamos preguntarle

776
00:31:06,119 --> 00:31:07,160
para que nos diga más detalles

777
00:31:07,160 --> 00:31:08,200
por mera curiosidad

778
00:31:08,200 --> 00:31:12,339
si tú haces otra función en la tercera

779
00:31:12,339 --> 00:31:13,539
en el tercer parámetro

780
00:31:13,539 --> 00:31:15,380
¿cuál devuelve?

781
00:31:15,599 --> 00:31:16,660
¿el segundo o el tercero?

782
00:31:17,579 --> 00:31:18,660
no, no, el segundo

783
00:31:18,660 --> 00:31:22,319
la que se hace es aquí

784
00:31:22,319 --> 00:31:23,500
a ver, vamos a

785
00:31:23,500 --> 00:31:25,799
vamos a preguntarle

786
00:31:25,799 --> 00:31:26,740
que nos dé un ejemplito

787
00:31:26,740 --> 00:31:29,900
yo es que no he usado nunca

788
00:31:29,900 --> 00:31:30,740
ese tercer parámetro

789
00:31:30,740 --> 00:31:34,980
entonces no te puedo decir nada que tenga demasiado sentido

790
00:31:34,980 --> 00:31:40,980
entonces, vamos a ver si

791
00:31:40,980 --> 00:31:43,059
nos dice algo con sentido o no

792
00:31:43,059 --> 00:31:50,630
en la función

793
00:31:50,630 --> 00:31:54,930
colet, bueno, tendría que haber puesto

794
00:31:54,930 --> 00:31:58,069
método, pero da igual, de stream

795
00:31:58,069 --> 00:32:03,779
me pones un ejemplo

796
00:32:03,779 --> 00:32:09,599
En el que el tercer parámetro

797
00:32:09,599 --> 00:32:15,440
Para computación

798
00:32:15,440 --> 00:32:18,259
Del stream

799
00:32:18,259 --> 00:32:21,400
En paralelo

800
00:32:21,400 --> 00:32:25,819
Sea interesante

801
00:32:25,819 --> 00:32:29,200
Que sea diferente

802
00:32:29,200 --> 00:32:30,680
Al segundo

803
00:32:30,680 --> 00:32:32,220
A ver si se entra de lo que le he preguntado

804
00:32:32,220 --> 00:32:38,339
Mira, está en pelota como tú

805
00:32:41,559 --> 00:32:43,240
Vale, a ver qué nos dice.

806
00:32:43,680 --> 00:32:44,980
Vamos a ver si la entendemos.

807
00:32:55,440 --> 00:32:57,200
¿Qué? ¿Pero cómo que te has perdido?

808
00:32:57,259 --> 00:32:58,039
Si me lo has preguntado tú.

809
00:32:58,039 --> 00:32:58,420
¿Qué?

810
00:33:00,880 --> 00:33:01,559
Bueno,

811
00:33:02,039 --> 00:33:03,579
su player R es

812
00:33:03,579 --> 00:33:04,680
el tipo este.

813
00:33:05,779 --> 00:33:07,160
Es el acumulador.

814
00:33:09,380 --> 00:33:10,960
Este es el acumulador

815
00:33:10,960 --> 00:33:13,259
Y este es el tipo de datos

816
00:33:13,259 --> 00:33:14,539
De la fila

817
00:33:14,539 --> 00:33:16,160
Vale, entonces

818
00:33:16,160 --> 00:33:18,960
Su player crea el contenedor, el que yo llamo acumulador

819
00:33:18,960 --> 00:33:21,680
Añade un elemento al contenedor

820
00:33:21,680 --> 00:33:23,059
Y este es el combiner

821
00:33:23,059 --> 00:33:25,079
Que combina dos

822
00:33:25,079 --> 00:33:26,759
Contenedores parciales

823
00:33:26,759 --> 00:33:29,480
Cuando usas un string paralelo

824
00:33:29,480 --> 00:33:30,720
¿Vale?

825
00:33:32,160 --> 00:33:32,839
Entonces

826
00:33:32,839 --> 00:33:35,779
Entonces

827
00:33:35,779 --> 00:33:38,380
Cuando usas un string paralelo

828
00:33:38,380 --> 00:33:40,980
si esto ya lo sabemos

829
00:33:40,980 --> 00:33:42,140
vamos a ver un ejemplo interesante

830
00:33:42,140 --> 00:33:45,019
tú puedes usar esta sentencia

831
00:33:45,019 --> 00:33:46,440
de combinación, usas

832
00:33:46,440 --> 00:33:49,059
en un hilo una y en otro hilo la otra

833
00:33:49,059 --> 00:33:50,940
nosotros estamos usando la misma

834
00:33:50,940 --> 00:33:51,519
en los dos

835
00:33:51,519 --> 00:33:54,579
y entonces este

836
00:33:54,579 --> 00:33:56,480
te combina los dos

837
00:33:56,480 --> 00:33:58,640
si usas un string

838
00:33:58,640 --> 00:33:59,420
en paralelo

839
00:33:59,420 --> 00:34:02,680
el string secuencial, el combiner

840
00:34:02,680 --> 00:34:03,539
no se usa

841
00:34:03,539 --> 00:34:08,139
que no tengo ni idea

842
00:34:08,139 --> 00:34:11,440
Vamos a ver, ¿por qué te crees que le he preguntado?

843
00:34:15,440 --> 00:34:16,739
A ver, venga

844
00:34:16,739 --> 00:34:19,139
A ver si entendéis

845
00:34:19,139 --> 00:34:20,039
Este ejemplito

846
00:34:20,039 --> 00:34:21,579
Vamos a ver

847
00:34:21,579 --> 00:34:24,639
Tenemos una lista de palabras

848
00:34:24,639 --> 00:34:25,420
Vale

849
00:34:25,420 --> 00:34:28,619
Ahora, sacamos un stream paralelo

850
00:34:28,619 --> 00:34:31,119
Sacamos un stream

851
00:34:31,119 --> 00:34:32,820
Paralelo para que ahora ya

852
00:34:32,820 --> 00:34:33,920
El tercer elemento

853
00:34:33,920 --> 00:34:36,039
Entre a jugar, ¿vale?

854
00:34:36,099 --> 00:34:37,559
Porque si no, no juega nada

855
00:34:37,559 --> 00:34:39,420
sacamos el string paralelo

856
00:34:39,420 --> 00:34:41,659
vale, va a acumular en un string builder

857
00:34:41,659 --> 00:34:42,119
también

858
00:34:42,119 --> 00:34:45,219
esto que está haciendo aquí

859
00:34:45,219 --> 00:34:47,719
es lo mismo que hemos hecho

860
00:34:47,719 --> 00:34:48,179
nosotros

861
00:34:48,179 --> 00:34:51,039
claro, esto lo que pasa es que

862
00:34:51,039 --> 00:34:53,099
es la forma, esto de aquí

863
00:34:53,099 --> 00:34:55,380
es exactamente igual

864
00:34:55,380 --> 00:34:56,460
que esto

865
00:34:56,460 --> 00:35:03,000
entonces

866
00:35:03,000 --> 00:35:05,219
ayer dijimos

867
00:35:05,219 --> 00:35:07,000
que cuando se usan

868
00:35:07,000 --> 00:35:09,480
los métodos estándares

869
00:35:09,480 --> 00:35:11,420
de instancia o de clase

870
00:35:11,420 --> 00:35:13,320
sin cambiar el parámetro

871
00:35:13,320 --> 00:35:15,280
sin cambiar nada, se podían usar

872
00:35:15,280 --> 00:35:17,099
los dos puntos, eso aplica para el new

873
00:35:17,099 --> 00:35:19,300
estamos usando el constructor

874
00:35:19,300 --> 00:35:21,519
tal cual, sin cambiar el parámetro

875
00:35:21,519 --> 00:35:22,699
que va adentro, sin nada

876
00:35:22,699 --> 00:35:24,920
pues entonces, podemos poner

877
00:35:24,920 --> 00:35:27,340
screen builder, dos puntos y el método que queremos

878
00:35:27,340 --> 00:35:28,559
usar, new

879
00:35:28,559 --> 00:35:30,059
¿vale? entonces

880
00:35:30,059 --> 00:35:34,110
esto

881
00:35:34,110 --> 00:35:36,349
y esto

882
00:35:36,349 --> 00:35:38,809
es lo mismo

883
00:35:38,809 --> 00:35:40,210
es lo mismo, ¿vale?

884
00:35:40,530 --> 00:35:42,550
ahora, este es el acumulador, está claro

885
00:35:42,550 --> 00:35:44,530
el primer combiner

886
00:35:44,530 --> 00:35:47,409
¿qué te hace?

887
00:35:47,530 --> 00:35:49,409
pues sobre el string builder

888
00:35:49,409 --> 00:35:51,130
si tu longitud es mayor que 0

889
00:35:51,130 --> 00:35:52,929
te pone un vacío

890
00:35:52,929 --> 00:35:55,070
y luego además te pone

891
00:35:55,070 --> 00:35:57,469
esto te lo hace para que la primera vez que acumules

892
00:35:57,469 --> 00:35:58,849
no te ponga el vacío delante, ¿vale?

893
00:35:59,269 --> 00:36:01,530
es decir, este acumulador

894
00:36:01,530 --> 00:36:03,829
nos está sacando todas estas

895
00:36:03,829 --> 00:36:05,409
una detrás de otra

896
00:36:05,409 --> 00:36:07,530
con un espacio delante, en medio

897
00:36:07,530 --> 00:36:09,510
¿vale? si es la primera

898
00:36:09,510 --> 00:36:10,469
no pone espacio

899
00:36:10,469 --> 00:36:13,769
y ahora este, que es el que nos angustia

900
00:36:13,769 --> 00:36:14,530
este

901
00:36:14,530 --> 00:36:16,030
¿qué hace aquí?

902
00:36:16,869 --> 00:36:18,949
este es otro combiner diferente

903
00:36:18,949 --> 00:36:21,289
que a ver si deducimos que puede pintar ahí

904
00:36:21,289 --> 00:36:23,130
y porque es interesante y se hace en una

905
00:36:23,130 --> 00:36:24,090
computación paralela

906
00:36:24,090 --> 00:36:26,289
ah bueno, que es que no lo estoy

907
00:36:26,289 --> 00:36:28,329
vale, este otro

908
00:36:28,329 --> 00:36:31,429
coge

909
00:36:31,429 --> 00:36:32,829
los dos stream builders

910
00:36:32,829 --> 00:36:35,050
resultantes de las dos computaciones

911
00:36:35,050 --> 00:36:36,369
en paralelo que está haciendo

912
00:36:36,369 --> 00:36:38,369
se supone que al haber hecho el parallel string

913
00:36:38,369 --> 00:36:41,070
le damos vía libre para que vaya

914
00:36:41,070 --> 00:36:42,829
usando el primer acumulador

915
00:36:42,829 --> 00:36:45,010
en paralelo con trozos

916
00:36:45,010 --> 00:36:46,989
de la fila, le damos vía libre

917
00:36:46,989 --> 00:36:49,230
para que lo haga, bueno pues estos son

918
00:36:49,230 --> 00:36:50,789
los dos trocitos

919
00:36:50,789 --> 00:36:54,199
resultantes

920
00:36:54,199 --> 00:36:56,780
de las computaciones paralelas

921
00:36:56,780 --> 00:36:58,300
son estos dos, los stream builder

922
00:36:58,300 --> 00:37:00,639
y que hace, cuando tengas ya esos dos

923
00:37:00,639 --> 00:37:02,760
cachos construidos porque vas en paralelo

924
00:37:02,760 --> 00:37:04,719
si son mayores

925
00:37:04,719 --> 00:37:06,320
que cero, es decir que

926
00:37:06,320 --> 00:37:08,400
estás ya en medio del proceso, no estás

927
00:37:08,400 --> 00:37:09,699
al principio en ninguno de ellos,

928
00:37:10,719 --> 00:37:12,719
ponles un espacio entre ellos,

929
00:37:13,139 --> 00:37:14,340
pon un espacio al primero y

930
00:37:14,340 --> 00:37:15,119
concatenar el segundo.

931
00:37:16,280 --> 00:37:18,139
¿Vale? Bueno, pues entonces,

932
00:37:18,320 --> 00:37:20,559
esto tiene bastante sentido, ¿verdad? Lo que está haciendo.

933
00:37:20,960 --> 00:37:22,460
Ahora ya quizás sí que nos queda más claro.

934
00:37:23,380 --> 00:37:24,440
Este programa, este

935
00:37:24,440 --> 00:37:26,320
método que nos ofrece, ¿qué quería hacer?

936
00:37:26,800 --> 00:37:27,860
Tenía un montón de palabras

937
00:37:27,860 --> 00:37:30,380
y las quería poner todas juntas,

938
00:37:30,480 --> 00:37:31,400
separadas por espacio.

939
00:37:32,159 --> 00:37:33,659
La primera pregunta que nos hacemos,

940
00:37:34,300 --> 00:37:36,300
¿esto tiene sentido hacerlo por Caxos?

941
00:37:36,320 --> 00:37:38,280
o no puedo hacerlo por cachos

942
00:37:38,280 --> 00:37:39,539
y luego unir los cachos

943
00:37:39,539 --> 00:37:42,260
porque si no puedo hacerlo por cachos y luego unir

944
00:37:42,260 --> 00:37:43,940
los cachos, me olvido del

945
00:37:43,940 --> 00:37:46,219
para el string, del combiner final

946
00:37:46,219 --> 00:37:48,320
y de todo eso, hago string

947
00:37:48,320 --> 00:37:49,579
en el tercer parámetro

948
00:37:49,579 --> 00:37:52,119
casco lo mismo o cualquier cosa

949
00:37:52,119 --> 00:37:53,539
a mi es que me mosquea lo del

950
00:37:53,539 --> 00:37:56,519
cuando no es para ello, casi no lo uso, así que casi me he mosqueado

951
00:37:56,519 --> 00:37:58,119
por eso yo cascaría lo mismo

952
00:37:58,119 --> 00:38:00,280
¿vale? siempre, porque así nunca

953
00:38:00,280 --> 00:38:01,360
jamás vais a tener un error

954
00:38:01,360 --> 00:38:04,519
¿vale? pero si yo veo que mi problema

955
00:38:04,519 --> 00:38:07,019
lo puedo hacer por cachos, poner a 2

956
00:38:07,019 --> 00:38:08,900
oye tú, júntame

957
00:38:08,900 --> 00:38:10,579
estas palabras con espacios

958
00:38:10,579 --> 00:38:12,559
y tú en paralelo, júntame estas con espacios

959
00:38:12,559 --> 00:38:15,099
y luego ya me encargaré del combiner final

960
00:38:15,099 --> 00:38:16,820
si identifico que ese problema

961
00:38:16,820 --> 00:38:18,840
se puede hacer así, casco el

962
00:38:18,840 --> 00:38:21,019
para el stream, entonces en este

963
00:38:21,019 --> 00:38:22,900
si se puede hacer así, yo puedo

964
00:38:22,900 --> 00:38:24,980
juntar unas palabritas, luego juntar otras

965
00:38:24,980 --> 00:38:26,179
y luego el agregado

966
00:38:26,179 --> 00:38:28,159
bueno, pues entonces ahora ya

967
00:38:28,159 --> 00:38:30,659
hago el acumulador

968
00:38:30,659 --> 00:38:32,360
el segundo parámetro sería

969
00:38:32,360 --> 00:38:35,340
lo que se hace en cada hilo por separado

970
00:38:35,340 --> 00:38:36,840
lo que se hace en cada hilo

971
00:38:36,840 --> 00:38:38,800
que en este caso es

972
00:38:38,800 --> 00:38:42,010
esto

973
00:38:42,010 --> 00:38:45,570
lo mismo que hemos hecho nosotros, lo que se hace en cada hilo

974
00:38:45,570 --> 00:38:46,610
y luego

975
00:38:46,610 --> 00:38:48,909
en el combiner final le digo

976
00:38:48,909 --> 00:38:51,230
con tus dos resultados

977
00:38:51,230 --> 00:38:53,369
parciales, según te vayan

978
00:38:53,369 --> 00:38:55,389
llegando resultados parciales

979
00:38:55,389 --> 00:38:57,429
que los resultados parciales van a ser

980
00:38:57,429 --> 00:38:59,130
siempre dos acumuladores, claro

981
00:38:59,130 --> 00:39:01,429
según te van llegando resultados parciales

982
00:39:01,429 --> 00:39:03,389
haz esto, que en este caso

983
00:39:03,389 --> 00:39:05,389
los resultados parciales a su vez implican

984
00:39:05,389 --> 00:39:06,670
pegarlos entre sí

985
00:39:06,670 --> 00:39:09,449
pero es un poco lo que has hecho antes

986
00:39:09,449 --> 00:39:10,449
lo que pasa que con

987
00:39:10,449 --> 00:39:13,269
claro, lo que pasa es que le estás dando la orden

988
00:39:13,269 --> 00:39:14,789
le estás diciendo, oye

989
00:39:14,789 --> 00:39:16,469
como no vas a trabajar

990
00:39:16,469 --> 00:39:19,269
en un único hilo, coge una palabra

991
00:39:19,269 --> 00:39:21,250
pégala, coge una palabra, pégala, coge una palabra

992
00:39:21,250 --> 00:39:23,070
pégala, sino que vas a

993
00:39:23,070 --> 00:39:25,250
tener a dos tíos, este cogiendo

994
00:39:25,250 --> 00:39:27,190
palabras y pegando, este cogiendo palabras y pegando

995
00:39:27,190 --> 00:39:29,550
con los dos cachos que te den, ¿qué quieres que haga?

996
00:39:30,190 --> 00:39:31,349
pues con los dos cachos

997
00:39:31,349 --> 00:39:32,610
que te den, quiero que hagas esto

998
00:39:32,610 --> 00:39:37,070
Este combiner tercero

999
00:39:37,070 --> 00:39:38,570
efectivamente tiene sentido

1000
00:39:38,570 --> 00:39:41,269
si tú has generado el stream

1001
00:39:41,269 --> 00:39:42,829
con ParallelStream

1002
00:39:42,829 --> 00:39:45,110
porque con ese

1003
00:39:45,110 --> 00:39:46,309
habilitas

1004
00:39:46,309 --> 00:39:49,190
que trabaje así

1005
00:39:49,190 --> 00:39:50,690
encargándoselo a dos tíos distintos

1006
00:39:50,690 --> 00:39:52,969
pero solo habilitarás

1007
00:39:52,969 --> 00:39:54,989
que trabaje con dos tíos distintos

1008
00:39:54,989 --> 00:39:56,469
si el problema

1009
00:39:56,469 --> 00:39:58,929
por su propia naturaleza te lo permite

1010
00:39:58,929 --> 00:40:00,909
Hay problemas en los que

1011
00:40:00,909 --> 00:40:02,590
tienes que ir por partes

1012
00:40:02,590 --> 00:40:04,309
¿vale? por ejemplo

1013
00:40:04,309 --> 00:40:06,429
que un programa

1014
00:40:06,429 --> 00:40:08,630
que tienes una lista de números enteros y te los suma

1015
00:40:08,630 --> 00:40:10,829
pues también podrías habilitar el paralelo

1016
00:40:10,829 --> 00:40:12,929
un tío me suma estos cachos

1017
00:40:12,929 --> 00:40:14,630
otro tío me suma estos números

1018
00:40:14,630 --> 00:40:17,130
con los dos acumuladores

1019
00:40:17,130 --> 00:40:18,909
que serían dos integer

1020
00:40:18,909 --> 00:40:19,969
¿vale?

1021
00:40:20,929 --> 00:40:22,489
le digo que me sume los dos

1022
00:40:22,489 --> 00:40:24,960
dime

1023
00:40:24,960 --> 00:40:28,280
entiendo

1024
00:40:28,280 --> 00:40:30,639
si esto es bifunction

1025
00:40:30,639 --> 00:40:32,699
es que son dos cachos

1026
00:40:32,699 --> 00:40:35,059
y por la cabecera del método

1027
00:40:35,059 --> 00:40:37,420
creo que te dice que tiene que ser bifunction

1028
00:40:37,420 --> 00:40:39,380
entonces yo no sé si habrá

1029
00:40:39,380 --> 00:40:41,820
claro, entonces si es bifunction

1030
00:40:41,820 --> 00:40:43,500
ese solo te permite

1031
00:40:43,500 --> 00:40:44,159
dos cachos

1032
00:40:44,159 --> 00:40:45,179
vale

1033
00:40:45,179 --> 00:40:58,409
bueno, pues este método

1034
00:40:58,409 --> 00:41:00,530
nuestro nos devolvería

1035
00:41:00,530 --> 00:41:01,829
todas las

1036
00:41:01,829 --> 00:41:04,110
entonces, una tras otra

1037
00:41:04,110 --> 00:41:04,949
una tras otra

1038
00:41:04,949 --> 00:41:08,190
sí, esto lo podríamos haber hecho en paralelo

1039
00:41:08,190 --> 00:41:10,429
también, porque de hecho es el mismo

1040
00:41:10,429 --> 00:41:10,789
que el otro

1041
00:41:10,789 --> 00:41:12,730
lo podríamos haber hecho en paralelo

1042
00:41:12,730 --> 00:41:14,389
también, vale

1043
00:41:14,389 --> 00:41:17,409
si ejecutamos

1044
00:41:17,409 --> 00:41:18,949
el ver fichero 2 ahora

1045
00:41:18,949 --> 00:41:19,590
aquí

1046
00:41:19,590 --> 00:41:23,050
en nuestro main, debería sacarnoslos

1047
00:41:23,050 --> 00:41:24,989
también, mi duda es el punto y coma

1048
00:41:24,989 --> 00:41:26,869
perdón, el punto y coma, el salto de línea

1049
00:41:26,869 --> 00:41:29,030
si deberíamos haber puesto

1050
00:41:29,030 --> 00:41:31,429
un salto de línea, si efectivamente

1051
00:41:31,429 --> 00:41:32,849
deberíamos haber puesto un salto de línea

1052
00:41:32,849 --> 00:41:34,630
entonces deberíamos

1053
00:41:34,630 --> 00:41:36,849
a este

1054
00:41:36,849 --> 00:41:39,210
acumulador

1055
00:41:39,210 --> 00:42:07,650
de aquí, append y punto append, salto de línea. Ahora entiendo que ya sí. Bueno, pues