1
00:00:00,180 --> 00:00:03,640
bueno pues todo esto

2
00:00:03,640 --> 00:00:05,540
de las interfaces funcionales

3
00:00:05,540 --> 00:00:06,440
y las funciones lambda

4
00:00:06,440 --> 00:00:09,320
nos ha surgido a nosotros

5
00:00:09,320 --> 00:00:11,359
por la utilidad

6
00:00:11,359 --> 00:00:13,720
de usar la clase stream

7
00:00:13,720 --> 00:00:15,679
que podemos asociar a cualquier

8
00:00:15,679 --> 00:00:16,660
colección de datos

9
00:00:16,660 --> 00:00:19,780
nos vino a raíz

10
00:00:19,780 --> 00:00:20,420
de ahí

11
00:00:20,420 --> 00:00:23,760
bueno antes

12
00:00:23,760 --> 00:00:25,980
de meternos con ella porque vamos a tener que sacarlo

13
00:00:25,980 --> 00:00:27,980
como se usan mucho

14
00:00:27,980 --> 00:00:30,239
Java

15
00:00:30,239 --> 00:00:32,520
y muchos de los paquetes que se pueden poner

16
00:00:32,520 --> 00:00:34,719
coger de ahí que no están en la implementación

17
00:00:34,719 --> 00:00:36,280
estándar de Java, pero bueno

18
00:00:36,280 --> 00:00:38,100
muchos de los de la implementación estándar de Java

19
00:00:38,100 --> 00:00:39,679
como por ejemplo

20
00:00:39,679 --> 00:00:41,399
la clase stream

21
00:00:41,399 --> 00:00:43,640
pues muchas clases

22
00:00:43,640 --> 00:00:45,719
de la distribución estándar de Java

23
00:00:45,719 --> 00:00:46,920
tienen métodos

24
00:00:46,920 --> 00:00:50,719
que necesitan para funcionar

25
00:00:50,719 --> 00:00:52,219
instancias de interfaces

26
00:00:52,219 --> 00:00:53,200
funcionales

27
00:00:53,200 --> 00:00:56,100
entonces si tú quieres usar esos métodos

28
00:00:56,100 --> 00:00:57,979
tienes que dar una instancia

29
00:00:57,979 --> 00:00:59,560
de una interfaz funcional

30
00:00:59,560 --> 00:01:01,439
que responda exactamente

31
00:01:01,439 --> 00:01:03,880
a los datos de entrada y salida

32
00:01:03,880 --> 00:01:05,780
que necesita ese método para trabajar

33
00:01:05,780 --> 00:01:06,819
que responda exactamente

34
00:01:06,819 --> 00:01:07,920
entonces, dime

35
00:01:07,920 --> 00:01:15,500
no sabría

36
00:01:15,500 --> 00:01:17,239
a ver, se puede hacer una relación

37
00:01:17,239 --> 00:01:18,879
pero creo que no es lo que tienes en mente

38
00:01:18,879 --> 00:01:20,900
olvídate del comparable por ahora

39
00:01:20,900 --> 00:01:22,420
vale, entonces

40
00:01:22,420 --> 00:01:25,200
para facilitar de nuevo

41
00:01:25,200 --> 00:01:27,060
para homogeneizar esto

42
00:01:27,060 --> 00:01:29,439
Java tiene

43
00:01:29,439 --> 00:01:31,200
en un paquete

44
00:01:31,200 --> 00:01:33,359
4, 5, 6, 7

45
00:01:33,359 --> 00:01:34,379
o sea unas cuantas

46
00:01:34,379 --> 00:01:37,359
unas cuantas interfaces con métodos vacíos

47
00:01:37,359 --> 00:01:39,120
y

48
00:01:39,120 --> 00:01:41,459
a su vez otras clases de Java

49
00:01:41,459 --> 00:01:43,400
para trabajar necesitan

50
00:01:43,400 --> 00:01:45,219
que tú pases instancias

51
00:01:45,219 --> 00:01:46,680
de esas interfaces

52
00:01:46,680 --> 00:01:49,239
y esas interfaces recogen

53
00:01:49,239 --> 00:01:50,579
las situaciones más habituales

54
00:01:50,579 --> 00:01:53,519
no recibir ningún parámetro y devolver

55
00:01:53,519 --> 00:01:55,519
uno, recibir un parámetro

56
00:01:55,519 --> 00:01:56,420
y devolver otro

57
00:01:56,420 --> 00:01:58,739
Recibir dos y devolver uno

58
00:01:58,739 --> 00:02:00,959
Recibir uno y no devolver ninguno

59
00:02:00,959 --> 00:02:03,480
Es decir, hay un montón de situaciones

60
00:02:03,480 --> 00:02:05,799
En cuanto a datos de entrada y salida

61
00:02:05,799 --> 00:02:08,620
Que son esas

62
00:02:08,620 --> 00:02:11,639
Luego ya como se actúe por dentro es distinto

63
00:02:11,639 --> 00:02:13,460
Lo normal es usar blanda

64
00:02:13,460 --> 00:02:17,680
Entonces, repito

65
00:02:17,680 --> 00:02:21,460
Los comportamientos

66
00:02:21,460 --> 00:02:23,060
Aparte de por lo que hacen

67
00:02:23,060 --> 00:02:25,259
Que esa es la implementación

68
00:02:25,259 --> 00:02:29,360
se caracterizan por los datos que entregan

69
00:02:29,360 --> 00:02:32,659
y reciben, es decir, por los parámetros de entrada

70
00:02:32,659 --> 00:02:35,599
y lo que devuelven, por eso se caracterizan los métodos

71
00:02:35,599 --> 00:02:38,280
por los datos que reciben

72
00:02:38,280 --> 00:02:40,560
y lo que devuelven en caso de devolver algo

73
00:02:40,560 --> 00:02:42,379
y luego por su implementación

74
00:02:42,379 --> 00:02:46,000
bueno, pues Java hace una especie de clasificación de métodos

75
00:02:46,000 --> 00:02:48,719
en función de lo que dan y lo que reciben

76
00:02:48,719 --> 00:02:51,620
hace una especie de clasificación de métodos

77
00:02:51,620 --> 00:02:54,360
lo mete en interfaces funcionales

78
00:02:54,360 --> 00:03:02,360
Y luego tú ya cuando quieres hacer métodos que den y reciban esa combinación de parámetros, haces una implementación de esa interfaz funcional.

79
00:03:03,159 --> 00:03:04,340
A ver, me explico.

80
00:03:08,020 --> 00:03:19,139
Vamos a hacer aquí otra clase para hacer ejemplos estándar, yo que sé, la voy a llamar.

81
00:03:21,360 --> 00:03:22,680
Ejemplos estándar de Java.

82
00:03:30,210 --> 00:03:35,110
Vale, pues por ejemplo, Java tiene una interfaz funcional.

83
00:03:35,110 --> 00:03:37,509
A ver, todo eso es un poco de memoria

84
00:03:37,509 --> 00:03:39,590
Así que en algún momento igual hay que recorrer

85
00:03:39,590 --> 00:03:41,590
Una interfaz funcional

86
00:03:41,590 --> 00:03:43,090
Ahora le cambio el tipo genérico

87
00:03:43,090 --> 00:03:45,430
Que se llama así

88
00:03:45,430 --> 00:04:03,620
Bueno, le voy a dar un tipo para que le importe

89
00:04:03,620 --> 00:04:06,120
Vale, pues esta interfaz funcional

90
00:04:06,120 --> 00:04:08,860
Que yo siempre puedo implementar si la necesito

91
00:04:08,860 --> 00:04:11,180
Es genérica

92
00:04:11,180 --> 00:04:14,319
Esto si nos vamos a su declaración

93
00:04:14,319 --> 00:04:23,959
Que es esta

94
00:04:23,959 --> 00:04:25,920
Es una interfaz genérica

95
00:04:25,920 --> 00:04:29,060
Es decir, yo cuando la instancio

96
00:04:29,060 --> 00:04:31,060
Particularizo el tipo de dato que quiero

97
00:04:31,060 --> 00:04:34,480
Esto de las clases genéricas

98
00:04:34,480 --> 00:04:35,439
Lo recordáis, ¿verdad?

99
00:04:35,959 --> 00:04:37,800
Tú puedes declarar una clase

100
00:04:37,800 --> 00:04:40,160
Dependiendo

101
00:04:40,160 --> 00:04:42,819
De un tipo de dato que todavía desconoces

102
00:04:42,819 --> 00:04:44,500
Pero la declaras igual

103
00:04:44,500 --> 00:04:47,199
Y la declaras

104
00:04:47,199 --> 00:04:49,079
Trabajando con este tipo genérico

105
00:04:49,079 --> 00:04:50,939
Cuando luego tú instancias esto

106
00:04:50,939 --> 00:04:53,139
Ya dices qué tipo en concreto quieres

107
00:04:53,139 --> 00:04:55,019
Lo que hemos hecho toda la vida con las colecciones

108
00:04:55,019 --> 00:04:57,839
las colecciones, las listas

109
00:04:57,839 --> 00:04:59,980
los sets son genéricos

110
00:04:59,980 --> 00:05:01,699
pero cuando los instanciamos

111
00:05:01,699 --> 00:05:03,019
ya damos un tipo de dato, ¿vale?

112
00:05:03,339 --> 00:05:05,060
bueno, pues la interfaz consumer

113
00:05:05,060 --> 00:05:07,620
este es su único

114
00:05:07,620 --> 00:05:08,779
método abstracto

115
00:05:08,779 --> 00:05:10,680
recibe un valor

116
00:05:10,680 --> 00:05:13,579
y no devuelve nada, por eso se la llama

117
00:05:13,579 --> 00:05:15,680
consumidora, le metes y no saca

118
00:05:15,680 --> 00:05:15,920
nada

119
00:05:15,920 --> 00:05:18,660
¿vale? entonces es un tipo

120
00:05:18,660 --> 00:05:21,379
de interfaz que usaremos cuando

121
00:05:21,379 --> 00:05:23,639
alguien me pida un comportamiento

122
00:05:23,639 --> 00:05:24,379
en el cual

123
00:05:24,379 --> 00:05:26,899
Doy un dato y no recibo nada

124
00:05:26,899 --> 00:05:28,579
Ese comportamiento luego yo lo implemento

125
00:05:28,579 --> 00:05:29,279
Como me dé la gana

126
00:05:29,279 --> 00:05:31,379
Vale, pues entonces

127
00:05:31,379 --> 00:05:33,459
La

128
00:05:33,459 --> 00:05:36,920
Esta interfaz consumer, si yo la quiero implementar

129
00:05:36,920 --> 00:05:37,740
Pues por ejemplo

130
00:05:37,740 --> 00:05:40,720
Una posibilidad, siempre va a tener

131
00:05:40,720 --> 00:05:42,740
El x aquí, porque recibe

132
00:05:42,740 --> 00:05:44,000
Un valor, un único valor

133
00:05:44,000 --> 00:05:46,240
Luego siempre va a tener el x aquí

134
00:05:46,240 --> 00:05:48,240
¿Y qué es lo que va a hacer?

135
00:05:48,779 --> 00:05:49,959
Lo que sea que haga

136
00:05:49,959 --> 00:05:51,899
Pero no puede devolver nada

137
00:05:51,899 --> 00:05:53,620
Pues

138
00:05:53,620 --> 00:05:56,660
a lo mejor yo que sé

139
00:05:56,660 --> 00:05:59,160
conectarse con algo, mandarlo

140
00:05:59,160 --> 00:06:01,220
aquí lo más fácil que podemos hacer es mostrar

141
00:06:01,220 --> 00:06:03,339
por consola, entonces esta sería

142
00:06:03,339 --> 00:06:05,259
y vamos a aprovechar de hecho para

143
00:06:05,259 --> 00:06:06,980
meter otra cosa

144
00:06:06,980 --> 00:06:09,709
esta sería

145
00:06:09,709 --> 00:06:11,569
una

146
00:06:11,569 --> 00:06:14,029
implementación válida

147
00:06:14,029 --> 00:06:15,790
de un consumidor

148
00:06:15,790 --> 00:06:18,649
¿vale? recibe un valor

149
00:06:18,649 --> 00:06:20,470
y no me retorna nada

150
00:06:20,470 --> 00:06:22,350
entonces

151
00:06:22,350 --> 00:06:24,610
esto es una implementación válida

152
00:06:24,610 --> 00:06:26,410
de este método de aquí

153
00:06:26,410 --> 00:06:31,110
si yo la quisiera implementar

154
00:06:31,110 --> 00:06:33,230
a este consumidor de otra manera

155
00:06:33,230 --> 00:06:34,970
por ejemplo

156
00:06:34,970 --> 00:06:36,329
dándole dos parámetros

157
00:06:36,329 --> 00:06:38,949
pues me diría

158
00:06:38,949 --> 00:06:41,069
no, no, no, esto no es una implementación

159
00:06:41,069 --> 00:06:43,250
válida de esta interfaz

160
00:06:43,250 --> 00:06:45,310
solo necesito

161
00:06:45,310 --> 00:06:47,029
me tienes que pasar uno

162
00:06:47,029 --> 00:06:48,269
y solo uno

163
00:06:48,269 --> 00:06:53,540
esta si sería válida

164
00:06:53,540 --> 00:06:55,120
vale, vamos a poner

165
00:06:55,120 --> 00:06:56,939
los cuatro básicos y luego volvemos aquí

166
00:06:56,939 --> 00:06:59,040
otra vez un poquito porque esto, hay otra

167
00:06:59,040 --> 00:07:01,040
forma de escribirlo que es la que vais a ver

168
00:07:01,040 --> 00:07:03,339
siempre. Bueno, ¿qué otras interfaces

169
00:07:03,339 --> 00:07:04,519
estándar tenemos?

170
00:07:05,660 --> 00:07:07,079
Tenemos la que recibe

171
00:07:07,079 --> 00:07:08,959
un valor y te devuelve un valor.

172
00:07:09,740 --> 00:07:11,319
Esa, si no me falla

173
00:07:11,319 --> 00:07:15,550
mi memoria,

174
00:07:16,589 --> 00:07:17,209
se llama

175
00:07:17,209 --> 00:07:19,029
function. ¿Vale?

176
00:07:20,149 --> 00:07:21,430
La vamos a particularizar entero.

177
00:07:21,509 --> 00:07:30,680
Por ejemplo, esta

178
00:07:30,680 --> 00:07:32,779
es la que transforma un valor en otro.

179
00:07:33,620 --> 00:07:34,699
La función matemática

180
00:07:34,699 --> 00:07:36,819
de toda la vida, le das un valor y te saca otra función matemática

181
00:07:36,819 --> 00:07:38,579
de toda la vida, vale, pues

182
00:07:38,579 --> 00:07:39,680
una implementación

183
00:07:39,680 --> 00:07:44,740
pues mira, esta sería

184
00:07:44,740 --> 00:07:46,579
una implementación

185
00:07:46,579 --> 00:07:48,180
válida

186
00:07:48,180 --> 00:07:52,779
la importamos, están en Java útil

187
00:07:52,779 --> 00:07:54,560
como veis, las interfaces

188
00:07:54,560 --> 00:07:56,079
funcionales

189
00:07:56,079 --> 00:07:57,360
y

190
00:07:57,360 --> 00:08:03,199
que he escrito mal

191
00:08:03,199 --> 00:08:04,379
yo en esta interfaz

192
00:08:04,379 --> 00:08:06,959
a ver

193
00:08:06,959 --> 00:08:10,759
ah, claro, no, perdón, perdón

194
00:08:10,759 --> 00:08:39,399
¿Qué tontería? Vale, función es genérica, pero necesita dos tipos de datos, el de entrada y el que devuelve. Vale, lógicamente, función necesita el de entrada y el que devuelve. Vale, de hecho, si la abrimos, aquí está función, que es genérica, depende del que, el dato que recibe y el que devuelve.

195
00:08:39,399 --> 00:08:42,120
y este es su único método abstracto

196
00:08:42,120 --> 00:08:43,980
recibes del tipo T

197
00:08:43,980 --> 00:08:45,860
y devuelves del tipo R

198
00:08:45,860 --> 00:08:47,539
¿vale?

199
00:08:51,110 --> 00:08:53,230
bueno, pues esta implementación estaría bien

200
00:08:53,230 --> 00:08:55,549
le paso un entero y devuelvo un entero

201
00:08:55,549 --> 00:08:57,429
¿qué otra?

202
00:08:58,850 --> 00:09:00,570
la de predicado

203
00:09:00,570 --> 00:09:02,590
esta

204
00:09:02,590 --> 00:09:04,129
recibe un valor

205
00:09:04,129 --> 00:09:05,990
y devuelve un boolean

206
00:09:05,990 --> 00:09:07,750
se supone que verifica

207
00:09:07,750 --> 00:09:09,889
si se cumple la condición con ese valor

208
00:09:09,889 --> 00:09:12,730
Por ejemplo, vamos a hacer

209
00:09:12,730 --> 00:09:17,460
Pues que compruebes

210
00:09:17,460 --> 00:09:18,980
Si el número es par, yo que sé

211
00:09:18,980 --> 00:09:21,279
Interfaz

212
00:09:21,279 --> 00:09:22,340
Condicional

213
00:09:22,340 --> 00:09:24,960
O comprobadora, venga, vale, me gusta más

214
00:09:24,960 --> 00:09:27,360
Comprobadora

215
00:09:27,360 --> 00:09:29,759
Pues esta podría ser

216
00:09:29,759 --> 00:09:31,139
Mi dato de entrada

217
00:09:31,139 --> 00:09:34,100
Me devuelves

218
00:09:34,100 --> 00:09:36,080
X por ciento

219
00:09:36,080 --> 00:09:37,960
Dos igual a cero

220
00:09:37,960 --> 00:09:41,580
Importamos

221
00:09:42,179 --> 00:09:46,259
Vale

222
00:09:46,259 --> 00:09:54,059
Cuando solo tiene una línea, la función lambda solo tiene una línea que coincide con el valor de retorno, no se pone return, ¿vale?

223
00:09:54,860 --> 00:09:57,559
Pero la función lambda puede tener varias líneas.

224
00:09:58,159 --> 00:10:06,500
Entonces, ahí creo recordar que la última, que es la de valor, hay que poner return, la línea que tú explicas, el valor de retorno, y ahí sí que hay que poner return.

225
00:10:06,980 --> 00:10:11,700
Pero si solo tiene una línea, que es el valor de retorno, no se pone, ¿vale?

226
00:10:11,700 --> 00:10:13,279
Pero bueno, estos detalles de sintaxis

227
00:10:13,279 --> 00:10:18,279
En cualquier lado están bien especificados

228
00:10:18,279 --> 00:10:22,580
Vale, y cuál es la otra

229
00:10:22,580 --> 00:10:25,320
Ah, el supplier

230
00:10:25,320 --> 00:10:31,360
Este en lugar de consumir

231
00:10:31,360 --> 00:10:32,200
Te da

232
00:10:32,200 --> 00:10:34,220
Tú no le das nada

233
00:10:34,220 --> 00:10:35,620
Y te da algo

234
00:10:35,620 --> 00:10:37,179
Así es de generoso

235
00:10:37,179 --> 00:10:38,440
Este

236
00:10:38,440 --> 00:10:42,240
Por ejemplo

237
00:10:42,240 --> 00:10:44,279
Este es así de magnífico

238
00:10:44,279 --> 00:10:46,500
Claro

239
00:10:46,500 --> 00:10:49,500
Interfaz

240
00:10:49,500 --> 00:10:51,379
Donadora

241
00:10:51,379 --> 00:10:53,679
No, claro

242
00:10:53,679 --> 00:10:56,019
Entonces, aquí pones

243
00:10:56,019 --> 00:10:58,039
Sí, directa

244
00:10:58,039 --> 00:10:59,139
No, paréntesis vacíos

245
00:10:59,139 --> 00:11:01,360
Paréntesis vacíos

246
00:11:01,360 --> 00:11:03,200
¿Tienes que poner x o algo?

247
00:11:03,559 --> 00:11:05,639
No, porque no recibe nada

248
00:11:05,639 --> 00:11:07,879
Entonces, x por ejemplo

249
00:11:07,879 --> 00:11:09,940
Pues vamos a ver

250
00:11:09,940 --> 00:11:12,039
Math.ran

251
00:11:17,990 --> 00:11:19,090
Bueno, le voy a poner double

252
00:11:19,090 --> 00:11:21,049
Porque esto te lo devolvían Dabble, ¿verdad?

253
00:11:27,590 --> 00:11:28,629
¿Y random?

254
00:11:28,830 --> 00:11:29,470
¿No existe random?

255
00:11:30,629 --> 00:11:31,230
Vale

256
00:11:31,230 --> 00:11:34,009
Pues ya está

257
00:11:34,009 --> 00:11:36,370
Este es un donador de cosas

258
00:11:36,370 --> 00:11:39,870
Donador de cosas

259
00:11:39,870 --> 00:11:43,820
Y este es su método

260
00:11:43,820 --> 00:11:45,480
¿Vale?

261
00:11:47,559 --> 00:11:48,700
Así es tan mono

262
00:11:48,700 --> 00:11:49,500
Como veis

263
00:11:49,500 --> 00:11:52,879
La gran mayoría de las cosas

264
00:11:52,879 --> 00:11:54,200
Que tiene la distribución de Java

265
00:11:54,200 --> 00:11:56,019
No tiene nada

266
00:11:56,019 --> 00:11:59,240
esta interfaz es esta línea

267
00:11:59,240 --> 00:12:00,299
punto pelota

268
00:12:00,299 --> 00:12:03,240
pero claro, gracias a que todo está

269
00:12:03,240 --> 00:12:05,340
distribuido en interfaces, cosas que

270
00:12:05,340 --> 00:12:07,460
implementan, diferentes paquetes

271
00:12:07,460 --> 00:12:09,500
gracias a ese diseño

272
00:12:09,500 --> 00:12:10,759
luego

273
00:12:10,759 --> 00:12:12,320
la reutilización

274
00:12:12,320 --> 00:12:15,620
y sobre todo la escritura de códigos

275
00:12:15,620 --> 00:12:17,419
universales es tan sencilla

276
00:12:17,419 --> 00:12:19,000
entonces

277
00:12:19,000 --> 00:12:20,600
Java

278
00:12:20,600 --> 00:12:22,700
empezó con sus principios básicos

279
00:12:22,700 --> 00:12:24,740
fenomenal, ya se quedaron

280
00:12:24,740 --> 00:12:26,200
y a partir de ahí

281
00:12:26,200 --> 00:12:29,399
todo lo que ha hecho

282
00:12:29,399 --> 00:12:31,299
que gane territorio

283
00:12:31,299 --> 00:12:33,259
ha sido por cuestiones de mejora

284
00:12:33,259 --> 00:12:35,299
en el diseño, por diseñar

285
00:12:35,299 --> 00:12:37,419
de una manera o de otra, no por aportaciones

286
00:12:37,419 --> 00:12:39,179
de lo que ya hace, lo que ya hace ya lo sabemos

287
00:12:39,179 --> 00:12:41,240
igual crear clases y métodos, se acabó

288
00:12:41,240 --> 00:12:43,480
no hace más, todo lo demás

289
00:12:43,480 --> 00:12:44,899
que le permite ganar terreno

290
00:12:44,899 --> 00:12:47,659
es mejoras en el diseño de las clases

291
00:12:47,659 --> 00:12:49,100
pues lo de hacer

292
00:12:49,100 --> 00:12:50,620
interfaces funcionales

293
00:12:50,620 --> 00:12:52,919
es una mejora en el diseño enorme

294
00:12:52,919 --> 00:12:56,580
muchísimo

295
00:12:56,580 --> 00:12:59,519
muchísimoísimo

296
00:12:59,519 --> 00:13:03,500
de todas formas cuando me preguntáis

297
00:13:03,500 --> 00:13:04,460
eso se usa mucho

298
00:13:04,460 --> 00:13:07,139
entended que mi formación es limitada

299
00:13:07,139 --> 00:13:08,759
porque es que yo vivo encerrada aquí

300
00:13:08,759 --> 00:13:11,559
de lo que veo, de lo que me cuentan

301
00:13:11,559 --> 00:13:12,100
de lo que

302
00:13:12,100 --> 00:13:15,299
no, pero

303
00:13:15,299 --> 00:13:20,759
bueno ya, pero es que entonces

304
00:13:20,759 --> 00:13:23,059
cualquier cambio que hagas seguramente

305
00:13:23,059 --> 00:13:25,159
tenga más impacto en más clases

306
00:13:25,159 --> 00:13:27,500
que si lo haces respetando este diseño, casi seguro

307
00:13:27,500 --> 00:13:29,039
habría que ver luego cada caso en concreto

308
00:13:29,039 --> 00:13:31,659
pero el objetivo de una aplicación

309
00:13:31,659 --> 00:13:33,200
es que, como va

310
00:13:33,200 --> 00:13:35,500
si es buena, tendrá un tiempo

311
00:13:35,500 --> 00:13:37,379
de mantenimiento grande, esa fase será grande

312
00:13:37,379 --> 00:13:39,440
entonces el objetivo es que

313
00:13:39,440 --> 00:13:41,480
cada incorporación dentro

314
00:13:41,480 --> 00:13:43,419
de la fase de mantenimiento, no implique

315
00:13:43,419 --> 00:13:45,340
cambiar 200.000 clases, porque si

316
00:13:45,340 --> 00:13:47,539
implica esa aplicación, tendría un diseño horroroso

317
00:13:47,539 --> 00:13:49,279
y al final alguien va a decir

318
00:13:49,279 --> 00:13:51,539
mira, la hago de nueva, tiempo perdido

319
00:13:51,539 --> 00:13:53,179
dinero gastado

320
00:13:53,179 --> 00:13:55,539
Entonces todo esto

321
00:13:55,539 --> 00:13:57,379
Está orientado a que

322
00:13:57,379 --> 00:13:59,559
Cualquier incorporación en una aplicación

323
00:13:59,559 --> 00:14:01,460
Implique retocar lo mínimo

324
00:14:01,460 --> 00:14:02,340
En código

325
00:14:02,340 --> 00:14:05,320
Vale, bueno

326
00:14:05,320 --> 00:14:06,539
Vamos a incorporar la quinta

327
00:14:06,539 --> 00:14:08,820
Porque me da pena dejarla

328
00:14:08,820 --> 00:14:11,080
Bueno, hay más, en bifunción habrá más

329
00:14:11,080 --> 00:14:13,100
De hecho, como somos

330
00:14:13,100 --> 00:14:14,639
Hiper mega curiosos

331
00:14:14,639 --> 00:14:17,419
Vamos a

332
00:14:17,419 --> 00:14:19,019
Abrir aquí

333
00:14:19,019 --> 00:14:20,940
Java útil

334
00:14:20,940 --> 00:14:34,690
Todo esto son

335
00:14:34,690 --> 00:14:36,590
Interfaces funcionales

336
00:14:36,590 --> 00:14:39,600
¿Ves?

337
00:14:40,980 --> 00:14:41,500
De las

338
00:14:41,500 --> 00:14:43,820
¿Vale? Pero las básicas

339
00:14:43,820 --> 00:14:44,679
Son estas cinco

340
00:14:44,679 --> 00:14:47,200
Que voy a poner aquí

341
00:14:47,200 --> 00:14:50,000
Tampoco había tantas

342
00:14:50,000 --> 00:14:51,659
Igual había unas treinta o por ahí

343
00:14:51,659 --> 00:14:53,360
¿Vale?

344
00:14:53,480 --> 00:14:54,480
Y la quinta

345
00:14:54,480 --> 00:14:57,460
Sí

346
00:14:57,460 --> 00:15:01,389
Las más habituales

347
00:15:01,389 --> 00:15:02,509
Bifunction

348
00:15:02,509 --> 00:15:04,710
Bifunction

349
00:15:04,710 --> 00:15:07,250
Le pasas dos cosas

350
00:15:07,250 --> 00:15:08,809
Y te devuelve una

351
00:15:08,809 --> 00:15:10,149
¿Vale?

352
00:15:10,429 --> 00:15:11,870
Esta es la function

353
00:15:11,870 --> 00:15:16,909
Por ejemplo

354
00:15:16,909 --> 00:15:17,909
Le paso

355
00:15:17,909 --> 00:15:20,830
Esto

356
00:15:20,830 --> 00:15:23,029
Y me devuelve el número elevado al otro

357
00:15:23,029 --> 00:15:23,809
Ya ves tú

358
00:15:23,809 --> 00:15:26,070
Le tenemos que pasar

359
00:15:26,070 --> 00:15:30,330
Interfaz

360
00:15:30,330 --> 00:15:32,590
Doble donadora

361
00:15:32,590 --> 00:15:34,690
No, doble donadora no

362
00:15:34,690 --> 00:15:36,789
Eso

363
00:15:36,789 --> 00:15:38,029
Interfaz

364
00:15:38,029 --> 00:15:40,870
Doble transformadora, yo que sé

365
00:15:40,870 --> 00:15:44,590
Transformadora

366
00:15:44,590 --> 00:15:48,629
Esta interfaz, doble transformadora

367
00:15:48,629 --> 00:15:50,769
Exacto

368
00:15:50,769 --> 00:15:53,210
Le pasas x y te devuelve lo que a ti te dé la gana

369
00:15:53,210 --> 00:15:54,929
Que en este caso vamos a

370
00:15:54,929 --> 00:15:55,809
Hacer pues

371
00:15:55,809 --> 00:15:58,090
Mag.pwn

372
00:15:58,090 --> 00:16:00,070
x y

373
00:16:00,070 --> 00:16:05,389
Punto y coma

374
00:16:05,389 --> 00:16:07,309
Y que he hecho mal

375
00:16:07,309 --> 00:16:16,919
ah, vale, que Pau te devuelve

376
00:16:16,919 --> 00:16:19,259
integer, entonces vamos a cambiar aquí el genérico

377
00:16:19,259 --> 00:16:20,759
para que sea

378
00:16:20,759 --> 00:16:24,440
dabble, vale

379
00:16:24,440 --> 00:16:26,279
que Pau te devuelve a dabble

380
00:16:26,279 --> 00:16:27,440
pues cambiamos aquí a dabble

381
00:16:27,440 --> 00:16:39,120
entonces

382
00:16:39,120 --> 00:16:47,029
para

383
00:16:47,029 --> 00:16:50,429
ahora, claro

384
00:16:50,429 --> 00:16:53,009
Claro, la que hemos ido abriendo cada vez

385
00:16:53,009 --> 00:16:54,070
Supplier tiene

386
00:16:54,070 --> 00:16:56,029
Esta, ya está, no tiene más

387
00:16:56,029 --> 00:16:57,590
Esto se ha acabado, una solo

388
00:16:57,590 --> 00:17:02,210
Son interfaces funcionales

389
00:17:02,210 --> 00:17:03,129
Y solo tienen una

390
00:17:03,129 --> 00:17:09,589
Vale, pues entonces

391
00:17:09,589 --> 00:17:11,650
¿Para qué nos pueden servir

392
00:17:11,650 --> 00:17:13,349
Instancias?

393
00:17:14,970 --> 00:17:16,369
Tú, si sirve bien

394
00:17:16,369 --> 00:17:17,410
Y si no, nada

395
00:17:17,410 --> 00:17:18,950
Así en la vida lo podemos ir

396
00:17:18,950 --> 00:17:20,670
Hay cosas que solamente se disfrutan.

397
00:17:20,869 --> 00:17:24,670
¿Qué es lo de las funciones lambda?

398
00:17:25,089 --> 00:17:28,069
Es solo una manera de instanciar un intervalo.

399
00:17:28,490 --> 00:17:34,690
Exactamente, es solo una manera de instanciarla sin necesidad de hacerte una clase que tenga el código dentro y hacer un new de esa clase.

400
00:17:35,210 --> 00:17:37,390
Te ahorras escribir la clase y hacer el new.

401
00:17:37,769 --> 00:17:40,789
Porque con la función lambda harás el código del método y punto pelota.

402
00:17:41,670 --> 00:17:42,109
Vale.

403
00:17:42,109 --> 00:17:45,289
bueno, pues para qué nos sirve

404
00:17:45,289 --> 00:17:47,670
el tener yo instancias

405
00:17:47,670 --> 00:17:49,170
de estas interfaces

406
00:17:49,170 --> 00:17:51,089
que he dicho que son estándar

407
00:17:51,089 --> 00:17:52,170
que ya las trae la máquina

408
00:17:52,170 --> 00:17:54,170
que ya las trae la distribución de Java

409
00:17:54,170 --> 00:17:56,329
bueno, pues porque Java a su vez

410
00:17:56,329 --> 00:17:59,109
me ofrece un montón de métodos

411
00:17:59,109 --> 00:18:01,230
y de cosas que necesitan

412
00:18:01,230 --> 00:18:03,029
consumidores, funciones

413
00:18:03,029 --> 00:18:05,049
predicados, etcétera

414
00:18:05,049 --> 00:18:06,750
entonces, si yo veo

415
00:18:06,750 --> 00:18:08,450
que me interesa, que me viene fenomenal

416
00:18:08,450 --> 00:18:10,769
usar un método de Java

417
00:18:10,769 --> 00:18:12,869
que necesita un consumidor

418
00:18:12,869 --> 00:18:15,410
pues me instancio el consumidor

419
00:18:15,410 --> 00:18:16,650
por ejemplo

420
00:18:16,650 --> 00:18:19,190
con los streams de las colecciones

421
00:18:19,190 --> 00:18:21,190
que es por lo que ha surgido todo este rollo

422
00:18:21,190 --> 00:18:22,910
entonces

423
00:18:22,910 --> 00:18:26,750
por ejemplo

424
00:18:26,750 --> 00:18:31,069
bueno para

425
00:18:31,069 --> 00:18:33,589
para hacer algo con él

426
00:18:33,589 --> 00:18:35,230
que no implica entregarlo

427
00:18:35,230 --> 00:18:37,210
como valor de retorno, como hombre lo puedes

428
00:18:37,210 --> 00:18:38,690
mostrar, pues yo que sé

429
00:18:38,690 --> 00:18:45,009
Por ejemplo

430
00:18:45,009 --> 00:18:48,069
Vamos a hacernos una lista de enteros

431
00:18:48,069 --> 00:18:53,089
Porque como tenemos aquí

432
00:19:00,650 --> 00:19:01,690
Y ahora

433
00:19:01,690 --> 00:19:15,220
Venga, por ejemplo

434
00:19:15,220 --> 00:19:19,420
Vamos a hacernos una lista de números enteros

435
00:19:19,420 --> 00:19:25,230
¿Qué habéis hecho?

436
00:19:28,250 --> 00:19:29,269
Eso es lo que pasa cuando

437
00:19:29,269 --> 00:19:30,849
Cuando mandamos a Brian

438
00:19:30,849 --> 00:19:35,049
Brian ha ido a los de educación física

439
00:19:35,049 --> 00:19:36,509
Ahí tiene un montón de trabajo

440
00:19:36,509 --> 00:19:37,890
El departamento de educación física

441
00:19:37,890 --> 00:19:40,150
Tiene mucho trabajo

442
00:19:40,150 --> 00:19:43,890
Vale

443
00:19:43,890 --> 00:19:45,569
Venga, pues entonces

444
00:19:45,569 --> 00:19:47,990
Por ejemplo, uno podría

445
00:19:47,990 --> 00:19:49,450
Querer

446
00:19:49,450 --> 00:19:52,269
A ver, mis ejemplos

447
00:19:52,269 --> 00:20:01,569
Ejemplos, mi capacidad de improvisación de ejemplos muchas veces no es la más adecuada, pero vosotros os adaptáis porque sois así de majos.

448
00:20:02,289 --> 00:20:10,809
Bueno, pues, por ejemplo, ahora podríamos querer, por favor, muéstrame todos los números enteros.

449
00:20:10,869 --> 00:20:15,069
Vamos a aprovechar una que tengamos hecha, que era multiplicar por dos.

450
00:20:15,589 --> 00:20:20,289
Muéstrame el doble de todos y cada uno de los números que hay en la lista.

451
00:20:20,289 --> 00:20:21,910
Bueno, primero vamos a llenarla con números

452
00:20:21,910 --> 00:20:23,950
Porque si no, esto es un

453
00:20:23,950 --> 00:20:32,819
Que vamos a ponerle

454
00:20:32,819 --> 00:20:34,359
Diez numeritos

455
00:20:34,359 --> 00:20:40,809
Pues vamos a hacer

456
00:20:40,809 --> 00:20:43,730
Enteros.add

457
00:20:43,730 --> 00:20:48,329
Más punto random

458
00:20:48,329 --> 00:20:53,460
Por cien

459
00:20:53,460 --> 00:20:55,420
Y hacemos el casting a int

460
00:20:55,420 --> 00:21:06,150
Ahí tenemos una lista rápida

461
00:21:06,150 --> 00:21:07,950
De números enteros, aleatorios

462
00:21:07,950 --> 00:21:10,069
Pseudo aleatorios

463
00:21:10,069 --> 00:21:11,910
La aleatoriedad no existe en el universo

464
00:21:11,910 --> 00:21:14,009
Sedo aleatorios entre

465
00:21:14,009 --> 00:21:16,789
0 y 100

466
00:21:16,789 --> 00:21:17,329
Más o menos

467
00:21:17,329 --> 00:21:19,769
Vale, ahora

468
00:21:19,769 --> 00:21:26,460
Mostramos el doble

469
00:21:26,460 --> 00:21:28,700
De todos ellos

470
00:21:28,700 --> 00:21:32,180
Sin esto de los streams

471
00:21:32,180 --> 00:21:33,259
Ni lambdas

472
00:21:33,259 --> 00:21:35,019
Ni nada de eso

473
00:21:35,019 --> 00:21:38,059
Pues

474
00:21:38,059 --> 00:21:39,539
Haríamos esto, ¿verdad?

475
00:21:56,789 --> 00:21:59,009
Sí, soy por 2.

476
00:21:59,730 --> 00:22:00,130
Vale.

477
00:22:01,069 --> 00:22:02,109
En este caso,

478
00:22:02,630 --> 00:22:04,769
no ha quedado muy largo

479
00:22:04,769 --> 00:22:07,109
porque lo que yo tengo que mostrar

480
00:22:07,109 --> 00:22:08,549
es el doble del numerito

481
00:22:08,549 --> 00:22:10,509
y el doble del numerito que multiplicar por 2 ya está.

482
00:22:11,170 --> 00:22:13,349
Pero podría ser que lo que yo tengo que mostrar

483
00:22:13,349 --> 00:22:15,630
es algo que implica

484
00:22:15,630 --> 00:22:17,950
una operativa con el numerito

485
00:22:17,950 --> 00:22:19,190
que la tengo que poner delante

486
00:22:19,190 --> 00:22:21,690
y ya se queda más largo y queda más feo y todo eso.

487
00:22:21,769 --> 00:22:22,650
Pero bueno, en cualquier caso,

488
00:22:22,750 --> 00:22:23,730
tengo que poner dos líneas.

489
00:22:23,730 --> 00:22:27,089
esto con la filosofía actual

490
00:22:27,089 --> 00:22:29,130
de mínimo esfuerzo

491
00:22:29,130 --> 00:22:30,890
pues porque voy a poner dos líneas

492
00:22:30,890 --> 00:22:31,609
y puedo poner una

493
00:22:31,609 --> 00:22:33,849
que va a quedar mucho más claro

494
00:22:33,849 --> 00:22:35,849
vale, pues entonces

495
00:22:35,849 --> 00:22:37,549
¿qué estamos haciendo aquí?

496
00:22:39,069 --> 00:22:40,630
aplicar a todos y cada uno

497
00:22:40,630 --> 00:22:41,869
de los elementos de la lista

498
00:22:41,869 --> 00:22:42,970
¿el qué?

499
00:22:44,450 --> 00:22:46,390
una función de tipo

500
00:22:46,390 --> 00:22:47,849
de la que hemos visto arriba, ¿cuál?

501
00:22:50,269 --> 00:22:51,809
no, porque estamos mostrando

502
00:22:51,809 --> 00:22:53,430
no estamos devolviendo un valor

503
00:22:53,430 --> 00:22:56,069
La que no te gustaba

504
00:22:56,069 --> 00:22:57,390
Una consumidora

505
00:22:57,390 --> 00:22:59,410
Vale, pues entonces

506
00:22:59,410 --> 00:23:01,990
Nosotros ahora podemos hacer

507
00:23:01,990 --> 00:23:04,289
Esto

508
00:23:04,289 --> 00:23:09,670
Cogemos nuestra lista de enteros

509
00:23:09,670 --> 00:23:14,140
La ponemos en filita con el stream

510
00:23:14,140 --> 00:23:16,579
Y ahora

511
00:23:16,579 --> 00:23:19,400
Al ponerla en filita con el stream

512
00:23:19,400 --> 00:23:22,059
Se me abren un montón de cosas

513
00:23:22,059 --> 00:23:23,799
Que el stream puede hacer

514
00:23:23,799 --> 00:23:24,500
¿Vale?

515
00:23:24,500 --> 00:23:27,779
por ejemplo

516
00:23:27,779 --> 00:23:29,900
entre ellas, al final uno acaba haciendo

517
00:23:29,900 --> 00:23:31,660
cuatro cosas

518
00:23:31,660 --> 00:23:33,579
de estas, el for each, el filter, el map

519
00:23:33,579 --> 00:23:35,480
cuatro cosas y ya está

520
00:23:35,480 --> 00:23:37,759
y se me abre

521
00:23:37,759 --> 00:23:39,740
un montón de posibilidades

522
00:23:39,740 --> 00:23:41,019
entonces yo busco aquí

523
00:23:41,019 --> 00:23:44,990
y encuentro

524
00:23:44,990 --> 00:23:47,690
el for each

525
00:23:47,690 --> 00:23:49,329
que

526
00:23:49,329 --> 00:23:50,869
efectivamente

527
00:23:50,869 --> 00:23:52,869
necesita un consumer

528
00:23:52,869 --> 00:23:54,750
necesita

529
00:23:54,750 --> 00:23:58,130
una interfaz funcional

530
00:23:58,130 --> 00:23:59,210
de tipo consumer

531
00:23:59,210 --> 00:24:00,170
que reciba algo

532
00:24:00,170 --> 00:24:01,190
que implemente un entero.

533
00:24:02,349 --> 00:24:02,869
¿Vale?

534
00:24:03,950 --> 00:24:05,109
Es lo que necesita

535
00:24:05,109 --> 00:24:06,309
porque mi lista es de enteros.

536
00:24:06,809 --> 00:24:06,990
¿Vale?

537
00:24:07,230 --> 00:24:08,829
Como mi lista es de enteros,

538
00:24:09,369 --> 00:24:10,250
pues él necesita

539
00:24:10,250 --> 00:24:11,470
un consumidor.

540
00:24:12,150 --> 00:24:12,670
¿Vale?

541
00:24:12,750 --> 00:24:13,650
Pues entonces

542
00:24:13,650 --> 00:24:15,049
o le doy ya la lambda

543
00:24:15,049 --> 00:24:15,890
directamente

544
00:24:15,890 --> 00:24:19,250
al for each,

545
00:24:19,329 --> 00:24:20,049
cojo el for each

546
00:24:20,049 --> 00:24:21,549
y entonces el for each

547
00:24:21,549 --> 00:24:22,630
necesita un consumer.

548
00:24:23,190 --> 00:24:24,730
Pues le podría dar la lambda

549
00:24:24,730 --> 00:24:25,710
o como ya la tengo

550
00:24:25,710 --> 00:24:26,349
escrita aquí,

551
00:24:26,509 --> 00:24:28,710
Le puedo dar esto

552
00:24:28,710 --> 00:24:30,150
Interfaz consumidora

553
00:24:30,150 --> 00:24:37,230
¿Vale?

554
00:24:42,400 --> 00:24:45,299
Ah, es que mi consumer era con stream

555
00:24:45,299 --> 00:24:47,240
No pasa nada, lo cambio a Integer

556
00:24:47,240 --> 00:24:49,990
Integer

557
00:24:49,990 --> 00:24:51,369
Vale, ya está

558
00:24:51,369 --> 00:24:54,450
Porque aquí no hay que especificar el tipo de entrada

559
00:24:54,450 --> 00:24:56,049
Se supone que ya se...

560
00:24:56,049 --> 00:24:57,130
Vale, lo cambio a Integer

561
00:24:57,130 --> 00:24:58,849
Ahora ya sí

562
00:24:58,849 --> 00:25:00,630
Entonces

563
00:25:00,630 --> 00:25:02,930
He encontrado el método

564
00:25:02,930 --> 00:25:05,750
Que ya se nos queda en la cabeza

565
00:25:05,750 --> 00:25:06,769
Que lo que hace es

566
00:25:06,769 --> 00:25:09,950
ir uno por uno, fila por filita

567
00:25:09,950 --> 00:25:11,710
aplicando

568
00:25:11,710 --> 00:25:13,549
el método de esta interfaz

569
00:25:13,549 --> 00:25:15,549
funcional, y ese método tiene que

570
00:25:15,549 --> 00:25:17,130
ser un consumidor, es decir

571
00:25:17,130 --> 00:25:19,849
recibe todos y cada uno de los elementos de la fila

572
00:25:19,849 --> 00:25:21,769
y hace lo que sea

573
00:25:21,769 --> 00:25:23,190
sin devolver retorno

574
00:25:23,190 --> 00:25:25,730
efectivamente

575
00:25:25,730 --> 00:25:27,170
sería normal, entonces

576
00:25:27,170 --> 00:25:29,250
si nosotros ejecutamos esto

577
00:25:29,250 --> 00:25:30,150
pues

578
00:25:30,150 --> 00:25:43,640
sí, porque tiene que haber 20

579
00:25:43,640 --> 00:25:49,829
Espérate, nos está cuadrando

580
00:25:49,829 --> 00:25:50,769
Esos son los numeritos

581
00:25:50,769 --> 00:25:53,990
Primero los muestra, multiplicados por 2

582
00:25:53,990 --> 00:25:55,970
Y luego tendría que

583
00:25:55,970 --> 00:25:59,089
Es coherente lo que sale

584
00:25:59,089 --> 00:26:06,809
No acabo de entender

585
00:26:06,809 --> 00:26:10,390
Sí, ahora

586
00:26:10,390 --> 00:26:12,369
Espera, vamos a quitar esto

587
00:26:12,369 --> 00:26:13,109
Para enterarnos

588
00:26:13,109 --> 00:26:20,039
vale, te lo muestra multiplicado por 2

589
00:26:20,039 --> 00:26:22,839
y ahora

590
00:26:22,839 --> 00:26:29,960
ah, bueno, claro, me lo muestra así

591
00:26:29,960 --> 00:26:31,880
porque mi consumidor no me lo

592
00:26:31,880 --> 00:26:33,339
multiplica, o sea, claro

593
00:26:33,339 --> 00:26:35,740
para que me muestre lo mismo, vale, vale, porque mi consumidor

594
00:26:35,740 --> 00:26:36,920
no te lo multiplica por 2

595
00:26:36,920 --> 00:26:39,799
vale, vale, entonces ahora ya sí

596
00:26:39,799 --> 00:26:41,480
me tendría que mostrar dos veces lo mismo

597
00:26:41,480 --> 00:26:44,460
efectivamente

598
00:26:44,460 --> 00:26:46,539
me hace

599
00:26:46,539 --> 00:26:48,500
esta la

600
00:26:48,500 --> 00:26:51,140
y esto lo otro.

601
00:26:54,259 --> 00:26:55,380
Para que me lo

602
00:26:55,380 --> 00:26:56,980
muestre, lo multiplica por dos.

603
00:26:58,720 --> 00:26:58,980
¿Vale?

604
00:26:59,759 --> 00:27:00,740
Vale, entonces

605
00:27:00,740 --> 00:27:02,460
pues una línea.

606
00:27:04,259 --> 00:27:05,359
Lo normal es...

607
00:27:05,359 --> 00:27:06,920
Una línea y lo de arriba.

608
00:27:06,920 --> 00:27:07,839
Claro, claro.

609
00:27:08,299 --> 00:27:10,960
Ya, lo de arriba

610
00:27:10,960 --> 00:27:12,420
dos. Vale.

611
00:27:12,420 --> 00:27:14,440
pero porque en este caso

612
00:27:14,440 --> 00:27:16,099
pues la lambda era muy sencillita

613
00:27:16,099 --> 00:27:18,359
era esto, vale, una línea

614
00:27:18,359 --> 00:27:19,480
pero

615
00:27:19,480 --> 00:27:21,380
¿y lo bonito que es esto?

616
00:27:21,700 --> 00:27:22,400
que bonito

617
00:27:22,400 --> 00:27:24,900
normalmente no se ve bonito

618
00:27:24,900 --> 00:27:27,980
claro, así no se ve bonito

619
00:27:27,980 --> 00:27:30,339
porque esto lo hace confuso

620
00:27:30,339 --> 00:27:31,960
si uno ve este código

621
00:27:31,960 --> 00:27:34,180
tiene que decir, ¿y esto que hace?

622
00:27:34,279 --> 00:27:34,900
y te tienes que ir buscando

623
00:27:34,900 --> 00:27:38,299
entonces lo normal es meter ahí la lambda

624
00:27:38,299 --> 00:27:40,579
vale, entonces lo normal

625
00:27:40,579 --> 00:27:42,579
es haber hecho esto

626
00:27:42,579 --> 00:27:52,490
for each

627
00:27:52,490 --> 00:27:54,569
y ahora aquí habríamos metido

628
00:27:54,569 --> 00:27:56,430
esto directamente

629
00:27:56,430 --> 00:28:07,839
esto si

630
00:28:07,839 --> 00:28:09,440
queda bonito

631
00:28:09,440 --> 00:28:18,160
vale, si ejecutamos esto

632
00:28:18,160 --> 00:28:20,779
va a dar un error porque los stream

633
00:28:20,779 --> 00:28:21,720
son

634
00:28:21,720 --> 00:28:24,920
están muy bien, pero tienen alguna cosa

635
00:28:24,920 --> 00:28:27,119
un poco pesada, y es que una vez que has recorrido

636
00:28:27,119 --> 00:28:29,019
la fila, el stream se queda

637
00:28:29,019 --> 00:28:30,519
inutilizable

638
00:28:30,519 --> 00:28:32,519
no puedes reiniciarlo otra vez

639
00:28:32,519 --> 00:28:34,480
entonces

640
00:28:34,480 --> 00:28:36,640
tendríamos que volver a generarlo

641
00:28:36,640 --> 00:28:38,460
no puedes reiniciarlo

642
00:28:38,460 --> 00:28:40,400
entonces, veis ahora

643
00:28:40,400 --> 00:28:41,759
si yo ejecuto esto

644
00:28:41,759 --> 00:28:44,769
lo tengo aquí, ¿no?

645
00:28:46,470 --> 00:28:53,079
¿cómo es que no me ha salido un error?

646
00:29:06,690 --> 00:29:10,829
Ah, claro, me sale error porque es que la estoy generando otra

647
00:29:10,829 --> 00:29:11,089
vez.

648
00:29:11,750 --> 00:29:13,589
Claro, la estoy generando otra vez.

649
00:29:13,829 --> 00:29:16,210
Pero si guardáis esto, el problema es que si lo guardáis

650
00:29:16,210 --> 00:29:19,109
en un stream, el error os da así, ¿vale?

651
00:29:19,809 --> 00:29:21,390
Imaginaos que generamos el stream.

652
00:29:24,180 --> 00:29:26,319
El stream de íntegre.

653
00:29:29,039 --> 00:29:32,799
Fila números, ¿vale?

654
00:29:33,460 --> 00:29:34,819
Y lo generáis.

655
00:29:38,630 --> 00:29:41,569
Y ahora ya usamos aquí fila números.

656
00:29:41,569 --> 00:29:48,190
Y tratamos de volver a usar fila números otra vez

657
00:29:48,190 --> 00:29:49,430
Es decir, el mismo stream

658
00:29:49,430 --> 00:29:50,970
El mismo, de antes

659
00:29:50,970 --> 00:29:55,269
Tratamos de volver a usar aquí fila números

660
00:29:55,269 --> 00:30:00,059
Aquí sí me da un error

661
00:30:00,059 --> 00:30:02,079
Porque el mismo stream, este mismo

662
00:30:02,079 --> 00:30:02,859
Generado aquí

663
00:30:02,859 --> 00:30:05,099
Si yo lo he recorrido una vez para hacer algo

664
00:30:05,099 --> 00:30:06,359
Ya no lo puedo recorrer otra vez

665
00:30:06,359 --> 00:30:08,920
Y no puedo reinicializar ese mismo stream

666
00:30:08,920 --> 00:30:11,420
¿Vale? Aquí ya sí que da un error

667
00:30:11,420 --> 00:30:13,019
Solo

668
00:30:13,019 --> 00:30:15,140
¿Vale? El stream ya está cerrado

669
00:30:15,140 --> 00:30:16,579
Claro

670
00:30:16,579 --> 00:30:25,059
Por eso es por lo que normalmente en lugar de guardar el string, a crear el string y luego usarlo, lo voy creando cada vez que lo necesito.

671
00:30:25,279 --> 00:30:26,240
O sea, se cierra automáticamente.

672
00:30:26,759 --> 00:30:28,279
Se cierra automáticamente, se cierra automáticamente.

673
00:30:28,460 --> 00:30:35,240
Entonces, en lugar de esta opción, es muchísimo mejor la opción que hemos escrito antes.

674
00:30:36,680 --> 00:30:48,130
La que hemos puesto antes, que era esta.

675
00:30:48,130 --> 00:30:58,299
Ah, si mejor

676
00:30:58,299 --> 00:31:00,079
Cada vez que uso el stream

677
00:31:00,079 --> 00:31:00,960
Lo genero de nuevas

678
00:31:00,960 --> 00:31:05,349
Porque si no

679
00:31:05,349 --> 00:31:07,730
¿Qué?

680
00:31:10,950 --> 00:31:12,089
Te va a gustar

681
00:31:12,089 --> 00:31:14,769
Que te va a acabar gustando, de verdad

682
00:31:14,769 --> 00:31:20,960
Eso ya

683
00:31:20,960 --> 00:31:22,799
No sé, depende de ti

684
00:31:22,799 --> 00:31:24,279
Vale

685
00:31:24,279 --> 00:31:27,099
Igual que esta for each

686
00:31:27,099 --> 00:31:29,380
Esta filter

687
00:31:29,380 --> 00:31:30,339
Por ejemplo

688
00:31:30,339 --> 00:31:32,839
Por ejemplo, vamos a

689
00:31:32,839 --> 00:31:35,960
Ay, ay, ya

690
00:31:35,960 --> 00:31:37,279
Se me ha despertado

691
00:31:37,279 --> 00:31:38,880
Vamos a, ahora

692
00:31:38,880 --> 00:31:41,059
En lugar de mostrar el doble de todos ellos

693
00:31:41,059 --> 00:31:43,140
Vamos a mostrar

694
00:31:43,140 --> 00:31:46,299
Los pares

695
00:31:46,299 --> 00:31:47,759
Por ejemplo

696
00:31:47,759 --> 00:31:50,359
Vamos a mostrar los pares

697
00:31:50,359 --> 00:31:53,079
Ahora sí que el programa serían

698
00:31:53,079 --> 00:31:54,059
Tres líneas

699
00:31:54,059 --> 00:31:55,619
Según la

700
00:31:55,619 --> 00:31:59,000
La filosofía antigua

701
00:31:59,000 --> 00:32:00,920
Y eso ya es mucho

702
00:32:00,920 --> 00:32:08,880
Esto ya sí que sería muy feo, ¿verdad?

703
00:32:09,859 --> 00:32:10,519
Bueno, vale

704
00:32:10,519 --> 00:32:12,480
Puedes poner el operador condicional, lo que sea

705
00:32:12,480 --> 00:32:13,539
Pero el operador condicional

706
00:32:13,539 --> 00:32:15,599
Es muy angustioso

707
00:32:15,599 --> 00:32:19,240
Sí, sí, está bien

708
00:32:19,240 --> 00:32:20,460
Sí, pero es

709
00:32:20,460 --> 00:32:22,099
Genera un poco de ansiedad

710
00:32:22,099 --> 00:32:24,500
Porque te da afinaciones muy largas a veces

711
00:32:24,500 --> 00:32:30,119
Vale

712
00:32:30,119 --> 00:32:31,819
Pues esto sería mostrarlo

713
00:32:31,819 --> 00:32:35,180
tú le enseñas esto

714
00:32:35,180 --> 00:32:37,220
a alguien que lleve tiempo programando en Java

715
00:32:37,220 --> 00:32:39,039
y te va a decir

716
00:32:39,039 --> 00:32:41,240
vos no lo va a decir, pero lo va a pensar

717
00:32:41,240 --> 00:32:42,880
va a pensar, va a decir

718
00:32:42,880 --> 00:32:45,559
madre de Dios, vale, que patatero

719
00:32:45,559 --> 00:32:46,720
es, ¿no? este chaval

720
00:32:46,720 --> 00:32:49,400
hay gente que

721
00:32:49,400 --> 00:32:51,200
sigue insistiendo en usar el stream

722
00:32:51,200 --> 00:32:52,640
si no insistís

723
00:32:52,640 --> 00:32:53,880
funciona

724
00:32:53,880 --> 00:32:56,900
vale

725
00:32:56,900 --> 00:32:59,319
pero seguramente, yo todo es

726
00:32:59,319 --> 00:33:01,220
seguramente, porque yo no vivo ahí fuera

727
00:33:01,220 --> 00:33:03,000
Vivo aquí dentro, pero bueno, intento

728
00:33:03,000 --> 00:33:05,579
Más o menos en tratar de

729
00:33:05,579 --> 00:33:07,599
De ilustrarme lo más posible

730
00:33:07,599 --> 00:33:08,599
De cómo se vive fuera

731
00:33:08,599 --> 00:33:10,559
Pero intuyo

732
00:33:10,559 --> 00:33:14,200
Que si alguien ve este código

733
00:33:14,200 --> 00:33:16,480
Pensaría, joder, vaya código patatero

734
00:33:16,480 --> 00:33:18,539
Vale, ¿cómo lo podemos hacer?

735
00:33:19,000 --> 00:33:19,480
Pues hombre

736
00:33:19,480 --> 00:33:20,880
¿Qué es lo que estamos haciendo?

737
00:33:21,559 --> 00:33:24,119
Estamos filtrando los pares

738
00:33:24,119 --> 00:33:25,539
Para luego mostrarlos

739
00:33:25,539 --> 00:33:28,359
Filtrar, filter, mostrar for each

740
00:33:28,359 --> 00:33:29,660
Y le ponéis lo de arriba

741
00:33:29,660 --> 00:33:33,640
Claro, pues vamos a hacer esto en una sola línea.

742
00:33:35,279 --> 00:33:36,619
Enteros, punto stream.

743
00:33:37,299 --> 00:33:38,380
Ya tenemos la filita.

744
00:33:39,200 --> 00:33:41,480
Ahora, vamos a filtrar.

745
00:33:41,900 --> 00:33:44,640
Ahora, si uno busca aquí los métodos para ver qué cosas

746
00:33:44,640 --> 00:33:50,140
puede hacer, ve un filter que usa un predicado.

747
00:33:50,559 --> 00:33:52,460
Porque el filter, el método filter,

748
00:33:52,619 --> 00:33:59,119
si tú le pasas un predicado, lo que hace es ir uno por uno y a

749
00:33:59,119 --> 00:34:02,519
A los que te den true, como resultado de ese predicado,

750
00:34:02,599 --> 00:34:05,180
los que te den true los conserva en la fila

751
00:34:05,180 --> 00:34:07,059
y a los que den false los tira a la basura.

752
00:34:08,019 --> 00:34:10,599
Luego el filter se queda con los que dan true

753
00:34:10,599 --> 00:34:13,219
en función del predicado que tú le pases.

754
00:34:15,099 --> 00:34:18,500
Entonces podríamos pasarle este predicado de aquí,

755
00:34:18,820 --> 00:34:20,179
que hace justo eso,

756
00:34:20,539 --> 00:34:22,559
pero vamos a poner la función lambda directamente

757
00:34:22,559 --> 00:34:24,380
porque es lo que haríamos en un caso real.

758
00:34:24,380 --> 00:34:26,159
en un caso real

759
00:34:26,159 --> 00:34:28,480
haríamos, oye, fíltrame

760
00:34:28,480 --> 00:34:30,679
los pares, pues venga

761
00:34:30,679 --> 00:34:32,179
te doy aquí mi predicado

762
00:34:32,179 --> 00:34:35,840
aquí

763
00:34:35,840 --> 00:34:40,639
ah, me lo dice por el punto y coma

764
00:34:40,639 --> 00:34:42,360
vale, pero es que yo no quiero terminar todavía

765
00:34:42,360 --> 00:34:44,840
ahora ya con la fila que me ha quedado

766
00:34:44,840 --> 00:34:46,760
porque lo que normalmente hacemos

767
00:34:46,760 --> 00:34:48,519
es ir anidando, anidando llamadas

768
00:34:48,519 --> 00:34:51,099
aquí ahora tengo una filita más corta

769
00:34:51,099 --> 00:34:53,139
tengo una fila solo con los pares

770
00:34:53,139 --> 00:34:55,360
Y ahora, ¿qué quiero hacer con esa fila?

771
00:34:55,960 --> 00:34:57,920
Con todos y cada uno quiero mostrarlo.

772
00:34:58,119 --> 00:34:59,460
Pues venga, llamas al for each.

773
00:35:01,650 --> 00:35:03,510
Y con el for each, ¿qué quieres hacer?

774
00:35:03,809 --> 00:35:05,969
Pero voy a poner el for each aquí abajo para que se vea.

775
00:35:07,570 --> 00:35:09,550
Claro, con el for each, ¿qué queremos hacer?

776
00:35:09,670 --> 00:35:13,409
Pues con el for each queremos para cada x,

777
00:35:13,769 --> 00:35:22,440
system.out.printlnx.

778
00:35:25,179 --> 00:35:29,159
Pues en una sola línea estamos mostrando los pares.

779
00:35:29,900 --> 00:35:30,579
Lo de arriba.

780
00:35:32,199 --> 00:35:32,599
¿Vale?

781
00:35:33,219 --> 00:35:35,019
Que ya sé que a ti no te gusta, Pablo.

782
00:35:42,079 --> 00:35:45,280
¿Vale? Aquí, bueno, es difícil de ver porque no he puesto ni separadores ni nada.

783
00:35:46,559 --> 00:35:48,340
Pero está mostrando los pares.

784
00:35:48,579 --> 00:35:49,519
No lo creemos, ¿verdad?

785
00:35:59,099 --> 00:36:04,000
Bueno, pues con estas líneas de código os tenéis que ir familiarizando.

786
00:36:04,000 --> 00:36:06,460
que es una colección

787
00:36:06,460 --> 00:36:07,340
le paso el string

788
00:36:07,340 --> 00:36:09,659
y llamo a lo que necesite llamar

789
00:36:09,659 --> 00:36:14,320
hasta aquí ninguna duda

790
00:36:14,320 --> 00:36:15,980
¿no? vale, esto ya es

791
00:36:15,980 --> 00:36:17,079
practicarlo y se acabó

792
00:36:17,079 --> 00:36:19,900
aquí lo único, esto

793
00:36:19,900 --> 00:36:21,840
esto en particular

794
00:36:21,840 --> 00:36:23,900
este sistema

795
00:36:23,900 --> 00:36:26,099
de X, no os lo vais a

796
00:36:26,099 --> 00:36:27,460
encontrar escrito así nunca

797
00:36:27,460 --> 00:36:30,380
entonces os digo

798
00:36:30,380 --> 00:36:31,860
como os lo vais a encontrar escrito

799
00:36:31,860 --> 00:36:33,400
y por qué se puede escribir así

800
00:36:33,400 --> 00:36:37,320
para que no volváis locos.

801
00:36:37,480 --> 00:36:38,300
A ver, ¿qué ocurre?

802
00:36:39,079 --> 00:36:40,219
Pues ocurre lo siguiente.

803
00:36:42,059 --> 00:36:43,199
Que cuando...

804
00:36:43,199 --> 00:36:48,059
¿Ocurre qué?

805
00:36:48,719 --> 00:36:50,059
Cuando una función lambda

806
00:36:50,059 --> 00:36:53,719
lo que hace es llamar a un método estático

807
00:36:53,719 --> 00:36:54,480
de una clase

808
00:36:54,480 --> 00:36:57,440
pasando en el parámetro tal cual,

809
00:36:58,400 --> 00:36:59,960
que es justo lo que está haciendo aquí.

810
00:36:59,960 --> 00:37:02,500
println es un método

811
00:37:02,500 --> 00:37:04,079
estático de system.out

812
00:37:04,079 --> 00:37:06,360
y le estamos pasando el parámetro

813
00:37:06,360 --> 00:37:07,400
de entrada tal cual

814
00:37:07,400 --> 00:37:10,559
pues en esa situación, bueno y en alguna

815
00:37:10,559 --> 00:37:12,320
otra, cuando llamamos también a

816
00:37:12,320 --> 00:37:14,500
un método de instancia, también valdría

817
00:37:14,500 --> 00:37:16,440
de esta propia x

818
00:37:16,440 --> 00:37:18,440
pero bueno, eso lo podemos ver ahora

819
00:37:18,440 --> 00:37:19,739
pero el caso más fácil de entender

820
00:37:19,739 --> 00:37:22,559
cuando estamos llamando a un método

821
00:37:22,559 --> 00:37:24,280
estático de una clase

822
00:37:24,280 --> 00:37:26,579
y a ese método estático le estamos

823
00:37:26,579 --> 00:37:28,380
pasando el parámetro

824
00:37:28,380 --> 00:37:28,940
de entrada

825
00:37:28,940 --> 00:37:32,360
se suele llamar entonces

826
00:37:32,360 --> 00:37:33,840
al método

827
00:37:33,840 --> 00:37:35,480
o se le suele escribir así

828
00:37:35,480 --> 00:37:38,199
pongo la clase

829
00:37:38,199 --> 00:37:40,079
para la que voy a llamar el método estático

830
00:37:40,079 --> 00:37:42,079
esa clase es la que tiene

831
00:37:42,079 --> 00:37:42,980
el método estático

832
00:37:42,980 --> 00:37:46,119
pongo dos puntos

833
00:37:46,119 --> 00:37:46,739
dos veces

834
00:37:46,739 --> 00:37:49,239
dos puntos dos puntos

835
00:37:49,239 --> 00:37:50,739
y ahora pongo

836
00:37:50,739 --> 00:37:53,840
el nombre del método sin paréntesis

837
00:37:53,840 --> 00:37:54,559
ni nada

838
00:37:54,559 --> 00:37:57,840
entonces cuando Java

839
00:37:57,840 --> 00:37:59,679
esto interpreta

840
00:37:59,679 --> 00:38:01,739
que esto es el nombre de una clase

841
00:38:01,739 --> 00:38:05,650
que esto es un método estático

842
00:38:05,650 --> 00:38:07,630
de esa clase al que le pasas

843
00:38:07,630 --> 00:38:08,730
el parámetro de entrada

844
00:38:08,730 --> 00:38:10,489
es lo que interpreta

845
00:38:10,489 --> 00:38:12,809
entonces es más cómodo de escribir

846
00:38:12,809 --> 00:38:15,590
también podría ser

847
00:38:15,590 --> 00:38:17,050
un método de instancia

848
00:38:17,050 --> 00:38:19,289
de esta clase al que le pasas

849
00:38:19,289 --> 00:38:21,510
el parámetro de entrada, pero se suele usar para métodos

850
00:38:21,510 --> 00:38:22,070
estáticos

851
00:38:22,070 --> 00:38:26,300
a ver

852
00:38:31,239 --> 00:38:38,679
No, porque primero tenéis que...

853
00:38:38,679 --> 00:38:40,280
A ver, yo no puedo contar esto en primero.

854
00:38:43,000 --> 00:38:43,760
Claro que te voy a decir.

855
00:38:43,880 --> 00:38:45,679
¿Se acuerda? Porque...

856
00:38:45,679 --> 00:38:47,159
No, primero tenéis que...

857
00:38:47,159 --> 00:38:49,460
Vale, a ver, ¿quién había dicho que no lo había entendido?

858
00:38:50,000 --> 00:38:50,719
Vale, vale.

859
00:38:52,059 --> 00:38:53,739
Este método, ¿vale?

860
00:38:58,340 --> 00:38:58,739
Vale.

861
00:38:59,300 --> 00:39:01,139
Este método, lo que tú estás haciendo aquí,

862
00:39:01,239 --> 00:39:21,820
Es, estás llamando a un método estático de una clase, ¿verdad? Vale, es un método estático de esa clase. Bueno, y le estás pasando directamente el argumento de entrada, sin multiplicar por 2, sin dividirlo por 7, directamente el argumento de entrada.

863
00:39:21,820 --> 00:39:24,980
ese es un caso muy particular que puede ser que tú

864
00:39:24,980 --> 00:39:26,940
uses a veces dentro de tu función

865
00:39:26,940 --> 00:39:29,159
pues si identificas

866
00:39:29,159 --> 00:39:30,340
que estás haciendo eso

867
00:39:30,340 --> 00:39:32,559
llamar a un método estático

868
00:39:32,559 --> 00:39:34,000
de una clase

869
00:39:34,000 --> 00:39:36,780
la que sea la clase y sea el que sea

870
00:39:36,780 --> 00:39:37,760
el método estático

871
00:39:37,760 --> 00:39:40,940
pasándole directamente el parámetro

872
00:39:40,940 --> 00:39:42,159
sin modificar

873
00:39:42,159 --> 00:39:44,639
puedes escribir esto de otra manera

874
00:39:44,639 --> 00:39:45,980
que queda más claro

875
00:39:45,980 --> 00:39:48,800
que es el nombre de la clase

876
00:39:48,800 --> 00:39:49,840
la que sea

877
00:39:49,840 --> 00:39:52,280
en este caso el asisten out

878
00:39:52,280 --> 00:39:55,539
punto, punto, punto, punto

879
00:39:55,539 --> 00:39:56,519
ahí seguidito

880
00:39:56,519 --> 00:39:58,940
y después el nombre del método

881
00:39:58,940 --> 00:40:01,699
sin paréntesis

882
00:40:01,699 --> 00:40:03,400
la primera vez que ponemos

883
00:40:03,400 --> 00:40:05,139
un método sin paréntesis no pasa nada

884
00:40:05,139 --> 00:40:06,000
aquí se puede

885
00:40:06,000 --> 00:40:08,119
y ya está

886
00:40:08,119 --> 00:40:11,440
y ¿por qué no ponemos paréntesis?

887
00:40:11,900 --> 00:40:13,659
porque se asume

888
00:40:13,659 --> 00:40:14,480
en este caso

889
00:40:14,480 --> 00:40:17,380
que el parámetro de entrada a este método

890
00:40:17,380 --> 00:40:18,840
es este

891
00:40:18,840 --> 00:40:21,400
se asume, no tienes que decirlo, se asume

892
00:40:21,400 --> 00:40:23,320
si el parámetro de entrada

893
00:40:23,320 --> 00:40:25,239
este método estático fuera otro

894
00:40:25,239 --> 00:40:27,260
diferente a este, como este

895
00:40:27,260 --> 00:40:28,699
multiplica por 7, no sé qué

896
00:40:28,699 --> 00:40:31,199
pues no puedes llamarlo así, lo llamas

897
00:40:31,199 --> 00:40:32,940
con la forma estándar y se acabó

898
00:40:32,940 --> 00:40:33,920
¿vale?

899
00:40:34,679 --> 00:40:37,019
entonces normalmente como el for each

900
00:40:37,019 --> 00:40:38,800
se usa mucho para mostrar

901
00:40:38,800 --> 00:40:40,840
los valores, para hacer comprobaciones

902
00:40:40,840 --> 00:40:42,179
y mostrar por consola

903
00:40:42,179 --> 00:40:44,559
este es un parámetro

904
00:40:44,559 --> 00:40:46,480
típico que se le pasa al for each

905
00:40:46,480 --> 00:40:48,960
Porque tú quieres hacer una comprobación de lo que hay en tu colección

906
00:40:48,960 --> 00:40:49,940
Es un parámetro típico

907
00:40:49,940 --> 00:40:52,539
Entonces, en lugar de

908
00:40:52,539 --> 00:40:54,039
Encontraroslo así

909
00:40:54,039 --> 00:40:56,340
Os lo encontraréis

910
00:40:56,340 --> 00:41:00,159
Así

911
00:41:00,159 --> 00:41:04,889
Y

912
00:41:04,889 --> 00:41:08,719
Así

913
00:41:08,719 --> 00:41:11,320
¿Vale?

914
00:41:11,320 --> 00:41:11,380
¿Vale?

915
00:41:16,309 --> 00:41:16,869
Entonces

916
00:41:16,869 --> 00:41:19,329
No hay parámetro

917
00:41:19,329 --> 00:41:20,409
De entrada en el lambda

918
00:41:20,409 --> 00:41:22,170
¿Veis? Un segundito

919
00:41:22,170 --> 00:41:25,269
¿Vosotros veis? Aquí una especificación de lambda

920
00:41:25,269 --> 00:41:26,989
que tiene estos dos puntos raros.

921
00:41:30,630 --> 00:41:31,989
¿Veis una especificación de lambda

922
00:41:31,989 --> 00:41:33,289
con estos dos puntos raros?

923
00:41:33,750 --> 00:41:35,590
Pues rápidamente asumís que

924
00:41:35,590 --> 00:41:38,909
esto es una clase,

925
00:41:40,090 --> 00:41:42,369
esto es un método estático de la clase

926
00:41:42,369 --> 00:41:44,829
y a ese método estático

927
00:41:44,829 --> 00:41:46,670
se le pasan

928
00:41:46,670 --> 00:41:48,250
tal cual

929
00:41:48,250 --> 00:41:50,670
los parámetros de entrada

930
00:41:50,670 --> 00:41:53,090
que especifica esta interfaz.

931
00:41:53,849 --> 00:41:55,510
En este caso, como es un for each

932
00:41:55,510 --> 00:41:57,610
y el for each te pide un consumer,

933
00:41:57,989 --> 00:41:59,489
Solo hay un parámetro de entrada.

934
00:42:00,289 --> 00:42:01,789
Pero si esto no fuera un for it,

935
00:42:02,210 --> 00:42:03,489
sino que fuera otro método,

936
00:42:03,610 --> 00:42:06,070
que lo que le pasas es una bifunction, por ejemplo,

937
00:42:08,300 --> 00:42:10,500
y le pasas un método estático,

938
00:42:11,519 --> 00:42:13,860
también lo puedes especificar así,

939
00:42:14,539 --> 00:42:16,019
sin poner los parámetros,

940
00:42:16,420 --> 00:42:17,920
y se asume que a ese método estático

941
00:42:17,920 --> 00:42:20,019
le pasas los dos parámetros.

942
00:42:21,420 --> 00:42:22,719
¿Vale? Los dos parámetros.

943
00:42:25,119 --> 00:42:26,420
Esto, por ejemplo, sí, dime.

944
00:42:26,420 --> 00:42:34,000
todas las clases que tengan algún método estático

945
00:42:34,000 --> 00:42:36,219
que reciba tantos parámetros

946
00:42:36,219 --> 00:42:37,840
como esa interfaz funcional

947
00:42:37,840 --> 00:42:40,460
si es consumer 1, si es bifunction 2

948
00:42:40,460 --> 00:42:44,079
¿vale? funciona con cualquier método estático

949
00:42:44,079 --> 00:42:54,059
¿vale? pues

950
00:42:54,059 --> 00:43:07,079
¿eh?

951
00:43:08,579 --> 00:43:09,059
¿perdón?

952
00:43:09,059 --> 00:43:11,519
Sí, sí, sí, está todo grabado

953
00:43:11,519 --> 00:43:12,780
Lo que pasa es que

954
00:43:12,780 --> 00:43:15,079
Lo que pinto aquí

955
00:43:15,079 --> 00:43:16,679
No se graba ahí, pero bueno

956
00:43:16,679 --> 00:43:18,300
Vale, entonces

957
00:43:18,300 --> 00:43:21,460
Por ejemplo, para cerrar esto ya

958
00:43:21,460 --> 00:43:26,760
Otro método

959
00:43:26,760 --> 00:43:28,699
Que se suele usar mucho

960
00:43:28,699 --> 00:43:31,889
De stream

961
00:43:31,889 --> 00:43:34,269
El map

962
00:43:34,269 --> 00:43:36,389
El map

963
00:43:36,389 --> 00:43:37,849
Usa una función

964
00:43:37,849 --> 00:43:39,530
El map lo que te hace es

965
00:43:39,530 --> 00:43:41,449
Cada elemento de tu filita

966
00:43:41,449 --> 00:43:43,010
Te lo transforma en otro

967
00:43:43,010 --> 00:44:09,889
Por ejemplo, vamos a hacer un código que te construya, que te transforme al map, tendríamos que pasarle una lambda que te transforme cada numerito entero,

968
00:44:09,889 --> 00:44:13,090
Que te lo transforme

969
00:44:13,090 --> 00:44:18,860
En su

970
00:44:18,860 --> 00:44:20,980
Factorial, vamos a complicarnos la vida

971
00:44:20,980 --> 00:44:22,280
Lo podemos hacer aparte

972
00:44:22,280 --> 00:44:23,699
Y antes de ya dejarlo

973
00:44:23,699 --> 00:44:25,260
Pero vamos a parar, ¿vale?

974
00:44:25,300 --> 00:44:25,900
Que son y 20