1
00:00:00,000 --> 00:00:26,559
El que nos va a dar hambre, pero bueno, pues venga, modelo, ¿vale? Paquete aparte para nuestro modelo de entidades son las entidades que definen nuestro negocio, de qué se ocupa, ¿vale? Se ocupa de menús, restaurantes, empleados, camareros, ese es nuestro negocio y se traduce en un modelo y en unas entidades, ¿vale?

2
00:00:26,559 --> 00:00:50,039
Y en caso de trabajar con una base de datos también se traducirán unas tablas, lógicamente con unas relaciones, ¿vale? Entonces esas entidades son las entidades con las que vamos a trabajar metiéndolas en colecciones, llevándolas de un sitio a otro, con lo cual los objetos de esas entidades son los que salen al mundo y son los que se exponen al mundo vía sus get y sus set, ¿vale?

3
00:00:50,039 --> 00:00:54,659
el concepto de Get y Set, aplicadlo a entidades de un modelo

4
00:00:54,659 --> 00:00:58,179
de negocio con el que tú trabajas, no a todas las clases por defecto

5
00:00:58,179 --> 00:01:02,359
no, aplicadlo al concepto de entidad, bueno pues ahora nosotros estamos

6
00:01:02,359 --> 00:01:06,599
haciendo nuestro modelo, entonces va nuestro paquete

7
00:01:06,599 --> 00:01:09,980
model por ejemplo

8
00:01:09,980 --> 00:01:14,599
así, ya está, y vamos a hacer

9
00:01:14,599 --> 00:01:18,489
nuestro restaurante

10
00:01:18,489 --> 00:01:25,150
Nuestro restaurante que tiene

11
00:01:25,150 --> 00:01:28,230
Su nombre

12
00:01:28,230 --> 00:01:34,540
Y nuestro restaurante

13
00:01:34,540 --> 00:01:36,480
Tiene un montón de

14
00:01:36,480 --> 00:01:37,519
¿Qué?

15
00:01:39,000 --> 00:01:40,439
De platos

16
00:01:40,439 --> 00:01:42,519
De la carta

17
00:01:42,519 --> 00:01:44,859
Vale

18
00:01:44,859 --> 00:01:47,680
Esto tiene

19
00:01:47,680 --> 00:01:49,760
Entonces ahora ya por fin

20
00:01:49,760 --> 00:01:52,400
Tenemos una propiedad

21
00:01:52,400 --> 00:01:54,120
Que es un montón de algo

22
00:01:54,120 --> 00:02:19,240
Ya por fin vamos a, en lugar de utilizar un array, utilizar una colección, ¿vale? ¿Qué colección? Tengo muchas posibilidades. Tengo listas y tengo conjuntos. Tengo también diccionarios, pero bueno, aunque a veces se le llama colecciones, al no heredar de colección, pues lo estudiamos aparte, después de las listas y conjuntos, ¿vale?

23
00:02:19,240 --> 00:02:22,080
ahora mismo nosotros en mente sabemos que tenemos

24
00:02:22,080 --> 00:02:24,419
listas y conjuntos

25
00:02:24,419 --> 00:02:26,819
vale, pues venga

26
00:02:26,819 --> 00:02:29,560
vamos a seleccionar un objeto lista

27
00:02:29,560 --> 00:02:31,340
para guardar todos esos platos

28
00:02:31,340 --> 00:02:35,080
el usar un objeto lista

29
00:02:35,080 --> 00:02:36,560
implica que esos platos

30
00:02:36,560 --> 00:02:38,840
en el momento de meterlos en la colección

31
00:02:38,840 --> 00:02:41,020
van a tener un orden, van a estar ahí colocaditos

32
00:02:41,020 --> 00:02:42,879
lo cual puede ser útil

33
00:02:42,879 --> 00:02:44,979
por ejemplo para funcionalidades

34
00:02:44,979 --> 00:02:46,080
del tipo

35
00:02:46,080 --> 00:02:48,659
sácame un listado de los platos que tienes

36
00:02:48,659 --> 00:02:50,360
porque van a salir por el orden

37
00:02:50,360 --> 00:02:52,240
por el que tú los has introducido

38
00:02:52,240 --> 00:02:53,699
o vas a poder ordenar

39
00:02:53,699 --> 00:02:55,159
en un conjunto

40
00:02:55,159 --> 00:02:57,500
el concepto de ordenar

41
00:02:57,500 --> 00:03:00,240
no tiene sentido, porque en el conjunto

42
00:03:00,240 --> 00:03:01,400
los elementos están así

43
00:03:01,400 --> 00:03:03,680
los conjuntos no se ordenan

44
00:03:03,680 --> 00:03:06,280
una lista sí, porque la lista

45
00:03:06,280 --> 00:03:07,580
son elementos en filita

46
00:03:07,580 --> 00:03:09,860
entonces en la lista tiene sentido

47
00:03:09,860 --> 00:03:11,759
que tú reordenes, cambies las cosas

48
00:03:11,759 --> 00:03:13,939
ahora la fila quiero que se ordene por

49
00:03:13,939 --> 00:03:15,860
el alfabético, la lista quiero que se ordene

50
00:03:15,860 --> 00:03:17,020
por precio

51
00:03:17,020 --> 00:03:19,539
entonces en general las listas

52
00:03:19,539 --> 00:03:24,360
las asociamos a ideas, a conjuntos de cosas

53
00:03:24,360 --> 00:03:27,819
que por su naturaleza pues admiten orden

54
00:03:27,819 --> 00:03:30,120
o me puede interesar a mí funcionalidades

55
00:03:30,120 --> 00:03:33,360
en las cuales sacarlas por cierto orden tiene su sentido.

56
00:03:35,080 --> 00:03:37,780
Entonces, bueno, es una colección muy habitual.

57
00:03:39,300 --> 00:03:42,539
Pues venga, y aparte es la única que conocemos nosotros hasta ahora,

58
00:03:42,639 --> 00:03:43,139
pues una lista.

59
00:03:43,780 --> 00:03:46,599
Entonces, lista plato, perdón.

60
00:03:47,819 --> 00:03:48,539
Lista plato.

61
00:03:49,539 --> 00:03:54,020
Entonces vamos a hacer la entidad plato y luego ya volvemos a esta.

62
00:03:55,180 --> 00:03:57,960
Entonces vamos a hacer nuestra entidad plato.

63
00:04:01,090 --> 00:04:06,469
Ala, el plato porque se caracteriza tal y como va a aparecer en la carta,

64
00:04:06,469 --> 00:04:17,709
pues el plato se caracteriza por el nombre y se caracteriza por su lista de ingredientes para ser así súper guays.

65
00:04:17,709 --> 00:04:19,910
bueno, primero vamos a poner el precio

66
00:04:19,910 --> 00:04:22,569
para perderle el miedo

67
00:04:22,569 --> 00:04:24,310
a los

68
00:04:24,310 --> 00:04:24,970
grappers

69
00:04:24,970 --> 00:04:28,230
lo voy a declarar a propósito

70
00:04:28,230 --> 00:04:29,889
como grappers, ¿vale?

71
00:04:29,970 --> 00:04:32,209
que da igual, se usa exactamente igual

72
00:04:32,209 --> 00:04:34,529
a la hora de asignar valores y de mostrarlos

73
00:04:34,529 --> 00:04:35,930
y de operar con ellos

74
00:04:35,930 --> 00:04:38,230
se opera igual con los operadores aritméticos

75
00:04:38,230 --> 00:04:39,930
pero

76
00:04:39,930 --> 00:04:42,209
el objeto, perdón, el número va a estar

77
00:04:42,209 --> 00:04:43,089
envuelto en un objeto

78
00:04:43,089 --> 00:04:45,430
lo cual le da

79
00:04:45,430 --> 00:04:48,089
varias prestaciones añadidas

80
00:04:48,089 --> 00:04:49,930
una de ellas, ¿puede ser nul?

81
00:04:50,970 --> 00:04:51,750
¿vale? el precio

82
00:04:51,750 --> 00:04:52,670
va a poder ser nul

83
00:04:52,670 --> 00:04:55,750
si yo pongo un precio de Abel en minúscula

84
00:04:55,750 --> 00:04:57,949
nunca va a poder ser nul, tiene que ser o 0 o 1

85
00:04:57,949 --> 00:04:59,550
o menos 3, nunca va a poder ser nul

86
00:04:59,550 --> 00:05:01,829
entonces hombre, es una prestación

87
00:05:01,829 --> 00:05:03,870
muy buena, porque el concepto

88
00:05:03,870 --> 00:05:05,189
de precio por definir

89
00:05:05,189 --> 00:05:07,370
si yo lo declaro como envolvente

90
00:05:07,370 --> 00:05:09,509
con la idea de precio por definir

91
00:05:09,509 --> 00:05:11,209
la puedo recoger, que es poniendo un nul

92
00:05:11,209 --> 00:05:13,670
pero si yo lo declaro con la D mayúscula

93
00:05:13,670 --> 00:05:16,230
la idea de precio por definir

94
00:05:16,230 --> 00:05:17,529
no podría recogerla, sí

95
00:05:17,529 --> 00:05:20,009
tendría que añadir a lo mejor un boolean

96
00:05:20,009 --> 00:05:21,930
que me ponga precio por definir o no

97
00:05:21,930 --> 00:05:24,209
o acordar que precios

98
00:05:24,209 --> 00:05:26,110
negativos significa que están sin

99
00:05:26,110 --> 00:05:27,629
definir, pero ya son acuerdos

100
00:05:27,629 --> 00:05:29,910
ya son como acuerdos artificiosos

101
00:05:29,910 --> 00:05:31,649
bueno, pues venga

102
00:05:31,649 --> 00:05:34,170
para perderle el miedo a los envolventes lo hacemos como

103
00:05:34,170 --> 00:05:36,029
esto y ya que

104
00:05:36,029 --> 00:05:37,550
estamos, vamos a ponerle aquí

105
00:05:37,550 --> 00:05:40,410
la lista de ingredientes

106
00:05:40,410 --> 00:05:42,250
del plato

107
00:05:42,250 --> 00:05:45,079
entonces

108
00:05:45,079 --> 00:06:03,259
Vale, pues primera cosa

109
00:06:03,259 --> 00:06:05,060
Bueno, me faltan GetSet

110
00:06:05,060 --> 00:06:06,600
Y constructores, que ahora los hacemos

111
00:06:06,600 --> 00:06:08,939
Primera cosa, lógicamente

112
00:06:08,939 --> 00:06:10,560
Me falta importar list

113
00:06:10,560 --> 00:06:13,139
Porque list está en el

114
00:06:13,139 --> 00:06:14,180
Paquete Java útil

115
00:06:14,180 --> 00:06:15,860
Entonces yo, o bien

116
00:06:15,860 --> 00:06:19,399
Llamo a list con su nombre verdadero

117
00:06:19,399 --> 00:06:21,300
Que su nombre verdadero es este

118
00:06:21,300 --> 00:06:22,800
Este es su nombre verdadero

119
00:06:22,800 --> 00:06:25,819
Que no lo vamos a crear

120
00:06:25,819 --> 00:06:26,819
Sí, claro que lo vamos a crear

121
00:06:26,819 --> 00:06:28,540
Pero estoy declarando la propiedad

122
00:06:28,540 --> 00:06:33,879
Ah, no, claro, sí, sí

123
00:06:33,879 --> 00:06:35,439
No, no, no, lo que estamos

124
00:06:35,439 --> 00:06:37,660
No, lo que vamos a hacer ya a partir de ahora es

125
00:06:37,660 --> 00:06:40,180
Usar las colecciones

126
00:06:40,180 --> 00:06:40,800
Claro

127
00:06:40,800 --> 00:06:43,839
Lo otro que habíamos hecho es

128
00:06:43,839 --> 00:06:46,060
Aparte de como ejercicio de programación

129
00:06:46,060 --> 00:06:48,079
Interesante, para que veáis

130
00:06:48,079 --> 00:06:49,160
Cómo están hechas por dentro

131
00:06:49,160 --> 00:06:52,220
¿Vale? Pero luego ya, claro, usamos las colecciones

132
00:06:52,220 --> 00:06:54,519
De Java útil, que es las que vais a usar

133
00:06:54,519 --> 00:06:56,879
Vale

134
00:06:56,879 --> 00:07:01,399
Vale, entonces

135
00:07:01,399 --> 00:07:03,800
Lógicamente no quiero arrastrar el java útil

136
00:07:03,800 --> 00:07:05,220
Porque es un rollo arrastrar

137
00:07:05,220 --> 00:07:06,680
Su prefijo

138
00:07:06,680 --> 00:07:09,899
Pues lo importo y ala, apañado

139
00:07:09,899 --> 00:07:12,360
Vale

140
00:07:12,360 --> 00:07:15,139
Voy a hacer

141
00:07:15,139 --> 00:07:17,399
Constructor con parámetros

142
00:07:17,399 --> 00:07:26,439
No, hombre, tampoco

143
00:07:26,439 --> 00:07:28,899
Si no vamos a complicarlo mucho

144
00:07:28,899 --> 00:07:30,899
Si es solo para ver el uso de las list

145
00:07:30,899 --> 00:07:32,000
Vale

146
00:07:32,000 --> 00:07:34,300
El ingrediente pues pepino y tomate

147
00:07:34,300 --> 00:07:35,360
Ya está

148
00:07:35,360 --> 00:07:38,800
Es que de hecho

149
00:07:38,800 --> 00:07:40,399
En una carta de un restaurante

150
00:07:40,399 --> 00:07:42,540
La lista de ingredientes de una cadena de stream

151
00:07:42,540 --> 00:07:44,139
No tiene sin tomate

152
00:07:44,139 --> 00:07:46,879
Color, cuanta cantidad de tomate

153
00:07:46,879 --> 00:07:47,660
No la sueles tener

154
00:07:47,660 --> 00:07:49,579
No tienes el nombre del ingrediente sin más

155
00:07:49,579 --> 00:07:52,540
Vale

156
00:07:52,540 --> 00:07:53,899
Bueno pues

157
00:07:53,899 --> 00:08:00,379
Vale a ver bueno

158
00:08:00,379 --> 00:08:02,879
olvidados por ahora del constructor, lo voy a meter antes

159
00:08:02,879 --> 00:08:04,899
en otra cosa, vale, pues entonces

160
00:08:04,899 --> 00:08:07,040
ahora es cuando me decís

161
00:08:07,040 --> 00:08:07,779
vosotros

162
00:08:07,779 --> 00:08:11,240
¿no hay algo que os dé un poco de angustia

163
00:08:11,240 --> 00:08:13,139
de esta línea, alguna cosa que queréis

164
00:08:13,139 --> 00:08:14,579
comentar, algún comentario

165
00:08:14,579 --> 00:08:25,740
vale, va por ahí la cosa

166
00:08:25,740 --> 00:08:27,980
ahora es cuando me hacéis el comentario de, pero

167
00:08:27,980 --> 00:08:30,379
a ver, según lo que nos contaste

168
00:08:30,379 --> 00:08:32,059
ayer, de lo cual nos

169
00:08:32,059 --> 00:08:33,320
acordamos perfectamente

170
00:08:33,320 --> 00:08:36,200
list es una interfaz

171
00:08:36,200 --> 00:08:37,299
¿verdad?

172
00:08:37,419 --> 00:08:40,059
list es una interfaz

173
00:08:40,059 --> 00:08:47,059
y de la interfaz list

174
00:08:47,059 --> 00:08:51,080
ya tengo dos implementaciones

175
00:08:51,080 --> 00:08:53,320
ArrayList y LinkedList

176
00:08:53,320 --> 00:08:59,470
entonces yo podría efectivamente

177
00:08:59,470 --> 00:09:03,830
haber puesto aquí ArrayList o LinkedList

178
00:09:03,830 --> 00:09:08,210
pero recordad que en el momento de declarar una variable

179
00:09:08,210 --> 00:09:10,370
tú la puedes declarar como la superclase

180
00:09:10,370 --> 00:09:13,809
luego ya otro asunto es cuando la instancias

181
00:09:13,809 --> 00:09:15,350
cuando la instancias, la tienes que

182
00:09:15,350 --> 00:09:17,210
instanciar ya sí o sí

183
00:09:17,210 --> 00:09:18,870
como un objeto

184
00:09:18,870 --> 00:09:21,570
concreto, no una interfaz

185
00:09:21,570 --> 00:09:23,649
como una clase que exista, no una clase

186
00:09:23,649 --> 00:09:25,490
abstracta, ¿vale? pero en el momento de

187
00:09:25,490 --> 00:09:27,570
declararla, yo la puedo declarar

188
00:09:27,570 --> 00:09:28,509
como la superclase

189
00:09:28,509 --> 00:09:31,809
entonces, ¿qué puedo haber ganado declarándola

190
00:09:31,809 --> 00:09:33,990
así? hombre, es más cómodo

191
00:09:33,990 --> 00:09:35,490
es más cómodo ya solo por escritura

192
00:09:35,490 --> 00:09:37,549
es más cómodo, transmito ahí la idea de que

193
00:09:37,549 --> 00:09:38,629
esto va a ser una lista

194
00:09:38,629 --> 00:09:41,830
en el momento de instanciarla ya decidiré cuál va a ser

195
00:09:41,830 --> 00:09:43,730
pero ahora mismo la puedo declarar

196
00:09:43,730 --> 00:09:44,490
como una super clase

197
00:09:44,490 --> 00:09:47,289
pero no pasa nada, si yo aquí directamente

198
00:09:47,289 --> 00:09:49,909
pongo linked list o la otra

199
00:09:49,909 --> 00:09:51,809
pues ya está

200
00:09:51,809 --> 00:09:53,070
¿vale?

201
00:09:53,870 --> 00:09:55,769
¿qué otra cosa podría ganar

202
00:09:55,769 --> 00:09:57,710
si yo la declaro como list?

203
00:09:58,269 --> 00:10:00,210
pues que no me estoy comprometiendo

204
00:10:00,210 --> 00:10:02,149
desde ahí, no me estoy comprometiendo

205
00:10:02,149 --> 00:10:03,330
a qué tipo de lista usar

206
00:10:03,330 --> 00:10:05,929
¿vale? en el momento de instanciarla

207
00:10:05,929 --> 00:10:08,070
pues ya decido, ¿vale? ya decido

208
00:10:08,070 --> 00:10:10,330
pero sobre todo es por una cuestión de comodidad

209
00:10:10,330 --> 00:10:11,769
de hábito, ¿vale?

210
00:10:11,990 --> 00:10:12,690
eso por un lado

211
00:10:12,690 --> 00:10:16,129
vale, ahora

212
00:10:16,129 --> 00:10:17,750
por otro lado, esto es como el array

213
00:10:17,750 --> 00:10:20,429
el plato tiene un listo de ingredientes

214
00:10:20,429 --> 00:10:22,070
siempre viene bien y es útil

215
00:10:22,070 --> 00:10:24,330
aquí ya directamente

216
00:10:24,330 --> 00:10:25,149
instanciar

217
00:10:25,149 --> 00:10:27,110
es relativamente habitual

218
00:10:27,110 --> 00:10:30,029
porque así cuando el objeto, plato

219
00:10:30,029 --> 00:10:31,009
se instancie

220
00:10:31,009 --> 00:10:34,070
en lugar de instanciarse con un objeto

221
00:10:34,070 --> 00:10:36,549
ingrediente es null, que es feo y peligroso

222
00:10:36,549 --> 00:10:38,169
como bien sabemos por el null pointer exception,

223
00:10:38,970 --> 00:10:41,669
pues se va a instanciar con un objeto de ingredientes

224
00:10:41,669 --> 00:10:44,350
que es una lista que no es null, pero que está vacía.

225
00:10:44,809 --> 00:10:46,470
Ya se le meterán ingredientes más adelante,

226
00:10:46,870 --> 00:10:47,570
pero que está vacía.

227
00:10:48,149 --> 00:10:49,509
Entonces, es relativamente habitual

228
00:10:49,509 --> 00:10:52,750
que hagamos esto nosotros para evitar los null pointer exception.

229
00:10:53,529 --> 00:10:56,690
Y aquí ya sí que sí tengo que comprometer

230
00:10:56,690 --> 00:10:59,809
o ArrayList o LinkedList.

231
00:11:01,190 --> 00:11:01,750
¿Cuál?

232
00:11:02,330 --> 00:11:03,690
En realidad da un poco igual,

233
00:11:03,690 --> 00:11:05,649
pero los criterios de decisión

234
00:11:05,649 --> 00:11:08,169
son más o menos los que hemos

235
00:11:08,169 --> 00:11:09,370
apuntado, que es

236
00:11:09,370 --> 00:11:12,289
el array obviamente es la estructura más eficiente

237
00:11:12,289 --> 00:11:14,169
del mundo, que es la que está

238
00:11:14,169 --> 00:11:15,590
directamente en memoria Java

239
00:11:15,590 --> 00:11:16,710
por naturaleza

240
00:11:16,710 --> 00:11:20,269
pero el array cuando empieza a ser

241
00:11:20,269 --> 00:11:21,750
ya muy grande, es decir

242
00:11:21,750 --> 00:11:24,210
si prevemos que en la carta

243
00:11:24,210 --> 00:11:25,590
va a haber un montón de platos

244
00:11:25,590 --> 00:11:28,070
pues a la hora de meter

245
00:11:28,070 --> 00:11:29,769
platos nuevos y sacar platos

246
00:11:29,769 --> 00:11:31,409
ya eso se puede hacer

247
00:11:31,409 --> 00:11:32,909
menos manejable

248
00:11:32,909 --> 00:11:35,669
entonces, si en general

249
00:11:35,669 --> 00:11:37,730
no trabajamos con una, prevemos que esto

250
00:11:37,730 --> 00:11:39,649
es una cantidad de datos manejable

251
00:11:39,649 --> 00:11:41,330
y una carta lo es, esto no es como

252
00:11:41,330 --> 00:11:43,409
hacer una aplicación que sea

253
00:11:43,409 --> 00:11:45,309
lista de usuarios de Google

254
00:11:45,309 --> 00:11:47,370
pues la lista de usuarios de Google puede ser

255
00:11:47,370 --> 00:11:48,190
dos mil millones

256
00:11:48,190 --> 00:11:51,350
aquí, platos de un restaurante

257
00:11:51,350 --> 00:11:53,230
pues una array list, no pasa nada

258
00:11:53,230 --> 00:11:54,210
porque la array es eficiente

259
00:11:54,210 --> 00:11:56,590
pero si es cierto

260
00:11:56,590 --> 00:11:59,570
que si la aplicación, las funciones

261
00:11:59,570 --> 00:12:00,870
que va a tener sobre todo

262
00:12:00,870 --> 00:12:01,970
Van a ser

263
00:12:01,970 --> 00:12:04,389
Insertar y sacar, insertar y sacar

264
00:12:04,389 --> 00:12:05,970
Pues el array es costoso

265
00:12:05,970 --> 00:12:07,409
Pues bueno, puedo poner un link

266
00:12:07,409 --> 00:12:10,049
Que ya hemos visto que insertar y sacar

267
00:12:10,049 --> 00:12:10,950
Es tan fácil como

268
00:12:10,950 --> 00:12:13,009
Mover enlaces

269
00:12:13,009 --> 00:12:16,110
Entonces, criterio en general

270
00:12:16,110 --> 00:12:18,570
Conjunto de datos manejable

271
00:12:18,570 --> 00:12:19,450
Pequeñito

272
00:12:19,450 --> 00:12:22,149
10, 15 datos, array list sin duda

273
00:12:22,149 --> 00:12:24,330
Conjunto de datos

274
00:12:24,330 --> 00:12:25,690
Imprevisible

275
00:12:25,690 --> 00:12:28,230
No lo puedo calibrar por ahora

276
00:12:28,230 --> 00:12:29,129
Ya veremos

277
00:12:29,129 --> 00:12:48,330
Vale, pues entonces siguiente pregunta. ¿Qué va a hacer mi aplicación sobre todo? ¿Consultas o va a hacer inserciones y borrados? Si va a hacer consultas, sobre todo, sin duda, ArrayList. Si sobre todo lo que va a hacer va a ser inserciones y borrados, pues LinkedList.

278
00:12:48,970 --> 00:12:49,610
¿Vale?

279
00:12:49,610 --> 00:12:53,330
en este caso

280
00:12:53,330 --> 00:12:54,769
pues se supone

281
00:12:54,769 --> 00:12:57,870
podríamos decidir, vale esta aplicación

282
00:12:57,870 --> 00:12:59,710
va a crear mi carta con los

283
00:12:59,710 --> 00:13:01,769
platos y luego sobre todo se va

284
00:13:01,769 --> 00:13:03,210
a usar pues para

285
00:13:03,210 --> 00:13:05,649
consultar, en lugar de

286
00:13:05,649 --> 00:13:07,950
la carta que tú repartes en cartón

287
00:13:07,950 --> 00:13:09,570
pues le repartes una tablet a cada

288
00:13:09,570 --> 00:13:11,649
comensal y cada comensal pues

289
00:13:11,649 --> 00:13:12,409
cada vez que pinche

290
00:13:12,409 --> 00:13:15,730
en plato

291
00:13:15,730 --> 00:13:17,649
pues le saldrá

292
00:13:17,649 --> 00:13:21,289
Tendrá la lista de ingredientes que va a servir.

293
00:13:21,470 --> 00:13:22,710
Él no va a meter ingredientes nuevos.

294
00:13:23,129 --> 00:13:26,070
Bueno, sí, le va a servir para consultar.

295
00:13:26,230 --> 00:13:31,720
Pues bueno, vamos a decidir una linked list.

296
00:13:32,200 --> 00:13:35,220
Pero el uso es igual que si dijéramos una array list.

297
00:13:36,179 --> 00:13:36,399
¿Vale?

298
00:13:36,580 --> 00:13:38,519
Ahora lo vemos.

299
00:13:39,659 --> 00:13:40,360
Bueno, pues ya está.

300
00:13:40,360 --> 00:13:42,679
Este es mi plato, que se caracteriza por estas cosas.

301
00:13:44,440 --> 00:13:47,440
Lo normal es un constructor, claro, con parámetros.

302
00:13:47,440 --> 00:14:17,360
Aquí también, esto no es que esto se hace así o no se hace así, no, no hay un se hace así o no se hace así, no, es relativamente habitual y tiene sentido, cuando una entidad tiene propiedades que son colecciones de cosas, pues ofrecer un constructor con su estado básico, nombre, precio, y que lo que sea colección, no inicializarlo, y que luego tú le puedas a través de otro método añadir cosas o quitárselas, es lo habitual.

303
00:14:17,440 --> 00:14:20,080
Que tengas la posibilidad de iniciar el plato

304
00:14:20,080 --> 00:14:21,299
Sin ningún ingrediente

305
00:14:21,299 --> 00:14:23,799
Luego tú agregas y quitas ingredientes

306
00:14:23,799 --> 00:14:28,220
Entonces, bueno, sería relativamente habitual

307
00:14:28,220 --> 00:14:30,419
No es que sea lo que hay que hacer

308
00:14:30,419 --> 00:14:31,360
Como de costumbre

309
00:14:31,360 --> 00:14:32,360
Depende del contexto

310
00:14:32,360 --> 00:14:35,000
De qué me pide hacer la aplicación, etc.

311
00:14:35,860 --> 00:14:38,179
Puedes hacer un constructor con estos dos

312
00:14:38,179 --> 00:14:39,360
¿Vale?

313
00:14:39,740 --> 00:14:44,230
Y vamos a hacer los get y set

314
00:14:44,230 --> 00:14:45,669
De todo, eso sí, claro

315
00:14:45,669 --> 00:14:48,309
De todas las propiedades

316
00:14:48,309 --> 00:14:49,370
Sus get y set

317
00:14:49,370 --> 00:14:56,539
Y aquí

318
00:14:56,539 --> 00:14:59,019
tendría mucho sentido poner un método

319
00:14:59,019 --> 00:15:00,799
que fuera añadir

320
00:15:00,799 --> 00:15:02,120
ingrediente al plato

321
00:15:02,120 --> 00:15:06,759
aquí sí que sí, vamos a añadir un ingrediente

322
00:15:06,759 --> 00:15:08,620
porque el plato cuando se crea

323
00:15:08,620 --> 00:15:10,580
por primera vez, se crea sin ingredientes

324
00:15:10,580 --> 00:15:12,539
vamos a hacer

325
00:15:12,539 --> 00:15:13,820
que la aplicación

326
00:15:13,820 --> 00:15:19,259
te permita ir añadiendo los ingredientes

327
00:15:19,259 --> 00:15:20,799
claro, pues aquí

328
00:15:20,799 --> 00:15:23,159
¿qué haríamos? public void

329
00:15:23,159 --> 00:15:25,000
add ingrediente

330
00:15:25,759 --> 00:15:28,980
el ingrediente

331
00:15:28,980 --> 00:15:30,019
es un string

332
00:15:30,019 --> 00:15:39,539
Y añadir ingrediente

333
00:15:39,539 --> 00:15:41,360
Ahora ya sí es usar la lista

334
00:15:41,360 --> 00:15:43,639
¿La lista cómo se llamaba?

335
00:15:44,039 --> 00:15:45,879
La lista se llama ingredientes

336
00:15:45,879 --> 00:15:46,320
¿Verdad?

337
00:15:47,320 --> 00:15:48,480
Se llama ingredientes

338
00:15:48,480 --> 00:15:51,240
Vale, pues si fuera un array

339
00:15:51,240 --> 00:15:52,700
Si fuera un array

340
00:15:52,700 --> 00:15:55,039
Ahora es cuando tendríamos el rollo

341
00:15:55,039 --> 00:15:58,000
De hacer un array auxiliar

342
00:15:58,000 --> 00:15:59,440
Con una más, copiando en el otro

343
00:15:59,440 --> 00:16:00,559
Añadir, si fuera un array

344
00:16:00,559 --> 00:16:02,299
Pero como no es un array

345
00:16:02,299 --> 00:16:04,259
Sino que es un objeto lista

346
00:16:04,259 --> 00:16:06,100
El objeto lista

347
00:16:06,100 --> 00:16:07,860
Me ofrece métodos

348
00:16:07,860 --> 00:16:09,259
Para hacerlo él

349
00:16:09,259 --> 00:16:10,340
¿Vale?

350
00:16:10,779 --> 00:16:12,240
¿Pues qué métodos me ofrece?

351
00:16:12,440 --> 00:16:13,980
Pues me ofrece un objeto add

352
00:16:13,980 --> 00:16:15,840
¿Vale?

353
00:16:16,399 --> 00:16:18,139
Y con este objeto add

354
00:16:18,139 --> 00:16:19,580
Yo ya meto el elemento

355
00:16:19,580 --> 00:16:20,860
¿Vale?

356
00:16:22,500 --> 00:16:23,440
Pues ya está

357
00:16:23,440 --> 00:16:24,320
Es mucho más fácil

358
00:16:24,320 --> 00:16:25,379
Lógicamente que un array

359
00:16:25,379 --> 00:16:27,259
Llamo al método add

360
00:16:27,259 --> 00:16:29,899
De la interfaz list

361
00:16:29,899 --> 00:16:31,379
Que linked list

362
00:16:31,379 --> 00:16:32,840
Lo tiene implementado por dentro

363
00:16:32,840 --> 00:16:34,899
para hacer lo que ya sabemos que hace

364
00:16:34,899 --> 00:16:36,879
todo lo de los enlaces, la recorrer, etc

365
00:16:36,879 --> 00:16:38,360
y ya está

366
00:16:38,360 --> 00:16:42,919
vale, este método

367
00:16:42,919 --> 00:16:45,120
puede fallar por algún lado, puede petar

368
00:16:45,120 --> 00:16:45,980
en algún sitio

369
00:16:45,980 --> 00:16:51,279
su único petamiento posible

370
00:16:51,279 --> 00:16:53,379
es que

371
00:16:53,379 --> 00:16:55,139
el ingrediente sea null, ¿verdad?

372
00:16:55,259 --> 00:16:57,200
porque entonces sería un null pointer exception

373
00:16:57,200 --> 00:16:59,480
pero bueno, claro

374
00:16:59,480 --> 00:17:01,299
pero tal y como hemos hecho

375
00:17:01,299 --> 00:17:03,200
la aplicación, como está inicializada

376
00:17:03,200 --> 00:17:04,339
¿vale?

377
00:17:05,180 --> 00:17:07,420
Bueno, hay manera, a menos que alguien desde la aplicación

378
00:17:07,420 --> 00:17:09,119
le haga un set a nul.

379
00:17:09,319 --> 00:17:10,440
Pero ¿por qué va a hacer eso, no?

380
00:17:11,859 --> 00:17:12,259
Claro.

381
00:17:13,299 --> 00:17:14,920
Tenemos que confiar que la gente no

382
00:17:14,920 --> 00:17:16,799
va haciendo esas cosas por la vida.

383
00:17:18,279 --> 00:17:19,299
Vale, pues nuestra

384
00:17:19,299 --> 00:17:21,299
entidad plato podría...

385
00:17:21,299 --> 00:17:22,960
Ah, podríamos... Vale, vamos a hacerle un

386
00:17:22,960 --> 00:17:25,240
elimina ingrediente. Porque el que

387
00:17:25,240 --> 00:17:27,019
hace la aplicación, pues que está

388
00:17:27,019 --> 00:17:29,160
configurando los platos para la carta, que está

389
00:17:29,160 --> 00:17:31,220
creando la carta, pues

390
00:17:31,220 --> 00:17:32,920
tendrá que poder eliminar ingredientes.

391
00:17:33,180 --> 00:17:33,660
Pues venga.

392
00:17:33,660 --> 00:17:44,259
Ingrediente

393
00:17:44,259 --> 00:17:45,259
Vale

394
00:17:45,259 --> 00:17:53,059
Claro, vale, entonces

395
00:17:53,059 --> 00:17:55,700
Ingredientes

396
00:17:55,700 --> 00:18:01,089
Vale, esto ya no es tan

397
00:18:01,089 --> 00:18:02,890
Trivial, aunque uno lo use como si fuera

398
00:18:02,890 --> 00:18:05,089
Trivial, no, hay que conocer los detalles

399
00:18:05,089 --> 00:18:08,779
De nuevo, si ingredientes

400
00:18:08,779 --> 00:18:10,279
Fuera un array, menudo rollo

401
00:18:10,279 --> 00:18:12,579
Tendríamos que hacer array auxiliar, copiar uno en otro

402
00:18:12,579 --> 00:18:14,240
Saltándote el que quieres borrar, etc

403
00:18:14,240 --> 00:18:16,599
Vale, pues menos mal que no es

404
00:18:16,599 --> 00:18:18,259
Un array, sino que es un objeto

405
00:18:18,259 --> 00:18:20,759
list, en concreto

406
00:18:20,759 --> 00:18:22,539
linked list, que tiene

407
00:18:22,539 --> 00:18:24,859
un remove, de hecho

408
00:18:24,859 --> 00:18:26,660
tiene dos, porque es un método sobrecargado

409
00:18:26,660 --> 00:18:28,599
pero vámonos al segundo que ofrece

410
00:18:28,599 --> 00:18:30,819
a este de aquí, tiene un

411
00:18:30,819 --> 00:18:31,240
remove

412
00:18:31,240 --> 00:18:34,200
que funciona de la siguiente manera

413
00:18:34,200 --> 00:18:35,720
¿vale?

414
00:18:37,299 --> 00:18:40,480
¿qué hace el remove?

415
00:18:41,200 --> 00:18:42,440
coge esta lista

416
00:18:42,440 --> 00:18:44,519
va elemento

417
00:18:44,519 --> 00:18:46,039
por elemento desde el principio

418
00:18:46,039 --> 00:18:48,420
desde el principio, recordad que la lista está

419
00:18:48,420 --> 00:18:57,180
ordenada. Luego va pum, pum, pum. En cuanto encuentra un elemento igual a este, ¿y qué

420
00:18:57,180 --> 00:19:02,920
significa ser igual? Que el método equals me devuelve true. Cuando encuentro uno que

421
00:19:02,920 --> 00:19:07,039
es igual a este, lo saca de la lista. Todos los demás, por tanto, se desplazan una posición

422
00:19:07,039 --> 00:19:13,759
hacia arriba. Y además me devuelve boolean, si yo quiero utilizarlo, para true se eliminó.

423
00:19:14,000 --> 00:19:17,440
Porque podría ocurrir que después de recorrer la lista, pum, pum, pum, pum, pum, no haya

424
00:19:17,440 --> 00:19:19,299
encontrado ninguno igual a este

425
00:19:19,299 --> 00:19:21,299
entonces no pasa nada, no da error

426
00:19:21,299 --> 00:19:22,859
lo que pasa es que me devuelve falso

427
00:19:22,859 --> 00:19:25,380
entonces yo el valor de retorno true o false

428
00:19:25,380 --> 00:19:27,480
lo puedo usar si quiero como validación

429
00:19:27,480 --> 00:19:29,180
¿vale?

430
00:19:30,880 --> 00:19:31,779
por ejemplo

431
00:19:31,779 --> 00:19:32,940
yo puedo, dime

432
00:19:32,940 --> 00:19:35,039
¿por efecto se añade último

433
00:19:35,039 --> 00:19:36,079
casaño?

434
00:19:36,160 --> 00:19:38,420
al final

435
00:19:38,420 --> 00:19:41,400
el add a palo seco es al final

436
00:19:41,400 --> 00:19:43,339
si quieres al principio es

437
00:19:43,339 --> 00:19:43,880
add first

438
00:19:43,880 --> 00:19:46,859
vale, entonces

439
00:19:46,859 --> 00:19:49,279
Yo puedo usar si quiero

440
00:19:49,279 --> 00:19:50,200
Ese boolean

441
00:19:50,200 --> 00:19:54,000
Como valor de retorno aquí

442
00:19:54,000 --> 00:19:59,119
Si me da la gana

443
00:19:59,119 --> 00:20:02,339
Este método

444
00:20:02,339 --> 00:20:04,000
¿Qué haría?

445
00:20:04,059 --> 00:20:06,660
Vamos a documentarlo

446
00:20:06,660 --> 00:20:07,900
Param ingrediente

447
00:20:07,900 --> 00:20:10,539
Entonces ¿Qué hace este método?

448
00:20:11,079 --> 00:20:12,440
Pues aquí explicaríamos

449
00:20:12,440 --> 00:20:16,279
Este método

450
00:20:16,279 --> 00:20:18,380
Borra

451
00:20:18,380 --> 00:20:19,900
El primer

452
00:20:19,900 --> 00:20:22,140
Ingrediente

453
00:20:22,140 --> 00:20:23,640
De la

454
00:20:23,640 --> 00:20:25,220
Lista

455
00:20:25,220 --> 00:20:28,799
De ingredientes

456
00:20:28,799 --> 00:20:33,619
Que sea

457
00:20:33,619 --> 00:20:35,880
Igual

458
00:20:35,880 --> 00:20:37,740
A el parámetro

459
00:20:37,740 --> 00:20:42,119
¿Vale?

460
00:20:43,460 --> 00:20:44,640
Y ahora

461
00:20:44,640 --> 00:20:47,059
¿Qué devuelve? Pues devuelve

462
00:20:47,059 --> 00:20:48,940
True si

463
00:20:48,940 --> 00:20:49,759
Borró

464
00:20:49,759 --> 00:20:58,779
False si no encontró ninguno y por tanto

465
00:20:58,779 --> 00:20:59,539
No borró, claro

466
00:20:59,539 --> 00:21:11,650
Vale, esto es un comentario ya bien hecho

467
00:21:11,650 --> 00:21:12,329
Javadoc

468
00:21:12,329 --> 00:21:14,670
entonces hacer un comentario bien hecho

469
00:21:14,670 --> 00:21:16,289
javadoc implica

470
00:21:16,289 --> 00:21:18,490
que el que luego use mi método

471
00:21:18,490 --> 00:21:22,049
esta documentación la va a tener

472
00:21:22,049 --> 00:21:23,789
como ahora veremos en el main o donde sea

473
00:21:23,789 --> 00:21:26,130
y se le va a desplegar si está en un entorno de desarrollo

474
00:21:26,130 --> 00:21:27,250
incompatible

475
00:21:27,250 --> 00:21:30,049
como inteligeo, eclipse, el que sea

476
00:21:30,049 --> 00:21:31,390
pues se le va a desplegar esa ayuda

477
00:21:31,390 --> 00:21:32,589
entonces estupendo

478
00:21:32,589 --> 00:21:37,119
vale, aquí

479
00:21:37,119 --> 00:21:39,960
este boolean

480
00:21:39,960 --> 00:21:42,220
luego el que llame a este método lo puede utilizar

481
00:21:42,220 --> 00:21:44,240
para verificar si se borró o no

482
00:21:44,240 --> 00:21:46,180
y decir, oye, porque si te da falso y dices

483
00:21:46,180 --> 00:21:48,220
el ingrediente que me has dado, pues no

484
00:21:48,220 --> 00:21:50,119
lo he podido borrar, pues tú lo puedes

485
00:21:50,119 --> 00:21:52,039
ignorar o no, pero hombre, no deberíamos

486
00:21:52,039 --> 00:21:54,119
pero cuando tú en una aplicación

487
00:21:54,119 --> 00:21:56,019
mandas a hacer algo, que es una

488
00:21:56,019 --> 00:21:58,319
realimentación del tipo, sí, se eliminó

489
00:21:58,319 --> 00:22:00,079
o no, no pudo eliminarlo porque no

490
00:22:00,079 --> 00:22:01,579
existe, que es una realimentación

491
00:22:01,579 --> 00:22:04,259
pues si este método no te devolviera

492
00:22:04,259 --> 00:22:06,019
ese valor de control

493
00:22:06,019 --> 00:22:08,140
pues no tendrías ninguna realimentación, tú harías

494
00:22:08,140 --> 00:22:10,220
borrar, ya está

495
00:22:10,220 --> 00:22:12,140
ha funcionado perfectamente

496
00:22:12,140 --> 00:22:14,180
pero no sabes si realmente lo borró

497
00:22:14,180 --> 00:22:16,440
o te equivocaste y pusiste azúcar

498
00:22:16,440 --> 00:22:17,240
con ese.

499
00:22:20,000 --> 00:22:20,680
Azúcar, sí.

500
00:22:20,799 --> 00:22:22,259
¿Tú lo pondrías en el método?

501
00:22:22,599 --> 00:22:24,519
Lo pondrías en el que

502
00:22:24,519 --> 00:22:25,720
llama el método, no aquí.

503
00:22:26,259 --> 00:22:28,900
Porque si lo pones aquí lo vas a hacer con un system.println

504
00:22:28,900 --> 00:22:30,339
y eso ya te

505
00:22:30,339 --> 00:22:32,339
condena a que este método solo informa

506
00:22:32,339 --> 00:22:34,299
por consola. Si luego tú

507
00:22:34,299 --> 00:22:36,559
en el futuro quieres migrar esto a una interfaz gráfica

508
00:22:36,559 --> 00:22:38,380
pues esta clase ya no te vale.

509
00:22:38,680 --> 00:22:39,440
La tienes que retocar.

510
00:22:40,619 --> 00:22:40,779
¿Vale?

511
00:22:43,240 --> 00:22:43,680
Vale.

512
00:22:44,180 --> 00:22:47,500
Bueno, pues primer detalle importante del remove

513
00:22:47,500 --> 00:22:48,099
Del add

514
00:22:48,099 --> 00:22:50,059
No hay nada que decir

515
00:22:50,059 --> 00:22:51,420
Porque no es

516
00:22:51,420 --> 00:22:55,319
No hay nada raro que tenga, ya sabemos lo que hace

517
00:22:55,319 --> 00:22:57,619
Detalle importante

518
00:22:57,619 --> 00:22:59,279
Del remove, que esto sí que tenemos

519
00:22:59,279 --> 00:23:00,839
Que no olvidarlo

520
00:23:00,839 --> 00:23:02,900
El remove

521
00:23:02,900 --> 00:23:05,359
Te borra el primero que encuentra

522
00:23:05,359 --> 00:23:07,039
Igual, solo el primero

523
00:23:07,039 --> 00:23:08,619
Y ya está, y deja de buscar

524
00:23:08,619 --> 00:23:10,960
Imaginaos que en la lista de ingredientes

525
00:23:10,960 --> 00:23:12,880
Estuviera azúcar

526
00:23:12,880 --> 00:23:14,740
dos veces, que puede estar

527
00:23:14,740 --> 00:23:15,880
porque esto es una lista

528
00:23:15,880 --> 00:23:18,579
luego como en la lista los elementos tienen

529
00:23:18,579 --> 00:23:20,680
su posición, pueden estar repetidos

530
00:23:20,680 --> 00:23:22,819
porque se distinguen perfectamente

531
00:23:22,819 --> 00:23:24,160
por la posición en la que están

532
00:23:24,160 --> 00:23:26,119
pues si tú pones

533
00:23:26,119 --> 00:23:28,900
en la lista está azúcar en la quinta y en la octava

534
00:23:28,900 --> 00:23:30,960
y tú le dices remufa azúcar

535
00:23:30,960 --> 00:23:32,619
este método remufa

536
00:23:32,619 --> 00:23:34,740
está programado para que te borre

537
00:23:34,740 --> 00:23:36,180
solo el primero de todos

538
00:23:36,180 --> 00:23:38,519
¿vale? la primera ocurrencia

539
00:23:38,519 --> 00:23:40,640
si tú quieres

540
00:23:40,640 --> 00:23:42,619
que te borre todos, tienes que

541
00:23:42,619 --> 00:23:44,799
hacer remove muchas veces

542
00:23:44,799 --> 00:23:47,000
entonces

543
00:23:47,000 --> 00:23:48,559
vamos a hacer por ejemplo

544
00:23:48,559 --> 00:23:49,000
aquí

545
00:23:49,000 --> 00:23:54,180
la versión

546
00:23:54,180 --> 00:23:56,660
en la que te

547
00:23:56,660 --> 00:23:58,539
borra no solo el primer

548
00:23:58,539 --> 00:24:00,440
ingrediente que encuentre igual a este

549
00:24:00,440 --> 00:24:01,940
sino todos

550
00:24:01,940 --> 00:24:06,210
vamos a copiar y

551
00:24:06,210 --> 00:24:07,089
pegar esto abajo

552
00:24:07,089 --> 00:24:14,759
borra todos los ingredientes

553
00:24:14,759 --> 00:24:15,440
de la lista

554
00:24:15,440 --> 00:24:18,579
entonces aquí cambiaríamos, no borra el primer ingrediente

555
00:24:18,579 --> 00:24:20,500
todos los

556
00:24:20,500 --> 00:24:22,539
ingredientes

557
00:24:22,539 --> 00:24:24,559
de la lista de ingredientes

558
00:24:24,559 --> 00:24:26,799
que sean igual al parámetro

559
00:24:26,799 --> 00:24:28,079
vamos a hacer esta versión ahora

560
00:24:28,079 --> 00:24:30,440
te borra todos los que sean igual al parámetro

561
00:24:30,440 --> 00:24:32,160
no solo el primero, ese te borra el primero

562
00:24:32,160 --> 00:24:32,779
y ya está

563
00:24:32,779 --> 00:24:36,779
todas las listas

564
00:24:36,779 --> 00:24:38,559
claro, todas

565
00:24:38,559 --> 00:24:40,460
porque cada elemento tiene una posición distinta

566
00:24:40,460 --> 00:24:42,440
entonces tú haces un add azúcar

567
00:24:42,440 --> 00:24:43,859
ese azúcar se queda en la cera

568
00:24:43,859 --> 00:24:45,640
Ahora haces por segunda vez

569
00:24:45,640 --> 00:24:46,500
Haz azúcar

570
00:24:46,500 --> 00:24:48,759
Pues azúcar ahí está, en la posición 1

571
00:24:48,759 --> 00:24:50,539
Y puedes hacer haz azúcar

572
00:24:50,539 --> 00:24:52,259
Pues otro azúcar en la posición 2

573
00:24:52,259 --> 00:24:55,519
Voy a ver 3 azúcar que son 3 elementos

574
00:24:55,519 --> 00:24:57,079
Iguales, según el equals

575
00:24:57,079 --> 00:24:59,539
Vale, pues remove ingrediente

576
00:24:59,539 --> 00:25:00,759
Versión 2, por ejemplo

577
00:25:00,759 --> 00:25:02,480
O la vamos a llamar versión todos

578
00:25:02,480 --> 00:25:05,400
Porque ingredientes

579
00:25:05,400 --> 00:25:08,299
Todos

580
00:25:08,299 --> 00:25:11,160
No todos los ingredientes, sino todos los que sean igual

581
00:25:11,160 --> 00:25:13,200
Todos los que sean igual

582
00:25:13,200 --> 00:25:14,519
Nombre un poco feo, pero bueno

583
00:25:14,519 --> 00:25:16,720
vale

584
00:25:16,720 --> 00:25:19,480
pues aquí tenemos un

585
00:25:19,480 --> 00:25:21,779
voy a dejar por ahora el void para que no moleste

586
00:25:21,779 --> 00:25:24,119
el compilador

587
00:25:24,119 --> 00:25:27,140
vale, aquí

588
00:25:27,140 --> 00:25:29,880
ingredientes remove, ya hemos dicho

589
00:25:29,880 --> 00:25:31,539
que te borra el primero

590
00:25:31,539 --> 00:25:33,319
que sea igual

591
00:25:33,319 --> 00:25:36,119
y como lo he encontrado te devuelve true

592
00:25:36,119 --> 00:25:37,359
si no he encontrado ninguno

593
00:25:37,359 --> 00:25:39,839
es decir, la lista se la ha pulido entera

594
00:25:39,839 --> 00:25:41,839
y no he encontrado ninguno, te devolvería false

595
00:25:41,839 --> 00:25:43,640
entonces si te devuelve true

596
00:25:43,640 --> 00:25:46,019
queremos que se ejecute otra vez

597
00:25:46,019 --> 00:25:47,740
porque habrá otro más

598
00:25:47,740 --> 00:25:50,220
o queremos que se ejecute otra vez porque borró uno

599
00:25:50,220 --> 00:25:52,099
y puede haber más, no habrá otro, puede haber más

600
00:25:52,099 --> 00:25:54,059
si te vuelve a devolver true

601
00:25:54,059 --> 00:25:56,539
querríamos que se ejecutara una tercera vez

602
00:25:56,539 --> 00:25:58,180
o sea

603
00:25:58,180 --> 00:26:00,160
queremos que el ingredientes remove

604
00:26:00,160 --> 00:26:01,700
se ejecute mientras

605
00:26:01,700 --> 00:26:03,720
él mismo no te devuelva false

606
00:26:03,720 --> 00:26:05,880
cuando él te devuelva false es que no encontró ninguno

607
00:26:05,880 --> 00:26:08,099
con lo cual no queremos que se ejecute más

608
00:26:08,099 --> 00:26:09,500
entonces

609
00:26:09,500 --> 00:26:11,960
¿cómo pondríamos esto?

610
00:26:11,960 --> 00:26:13,680
para que se ejecutara

611
00:26:13,680 --> 00:26:15,940
todas las veces necesarias

612
00:26:15,940 --> 00:26:18,059
hasta que te devolviera falso

613
00:26:18,059 --> 00:26:21,700
¿dónde lo podríamos meter?

614
00:26:25,079 --> 00:26:26,240
porque decís un for

615
00:26:26,240 --> 00:26:27,220
de buenas a primeras

616
00:26:27,220 --> 00:26:29,940
un bucle por condición de toda la vida es un while

617
00:26:29,940 --> 00:26:32,019
un for lo asociamos más

618
00:26:32,019 --> 00:26:33,880
a un bucle, que no es saliamente

619
00:26:33,880 --> 00:26:35,759
porque son intercambiables, pero un for

620
00:26:35,759 --> 00:26:38,039
lo asociamos a bucles que se ejecutan

621
00:26:38,039 --> 00:26:40,039
un número de veces que ya a priori conoces

622
00:26:40,579 --> 00:26:42,599
el while es el while por condición

623
00:26:42,599 --> 00:26:45,460
que esto se ejecute

624
00:26:45,460 --> 00:26:47,859
mientras me dé

625
00:26:47,859 --> 00:26:48,339
true

626
00:26:48,339 --> 00:26:51,779
siempre que sea true, con lo cual eso es un wild

627
00:26:51,779 --> 00:26:53,759
podrías hacerlo con un for

628
00:26:53,759 --> 00:26:55,119
pero te quedaría con un for

629
00:26:55,119 --> 00:26:57,480
en los tres campos de los puntos y comas

630
00:26:57,480 --> 00:26:59,079
el primero y el último vacíos

631
00:26:59,079 --> 00:27:00,059
y solo el del medio

632
00:27:00,059 --> 00:27:05,619
ya, pero

633
00:27:05,619 --> 00:27:06,720
significa que

634
00:27:06,720 --> 00:27:09,039
quiero que siga comprobando

635
00:27:09,039 --> 00:27:11,660
entonces si ya no hay más

636
00:27:11,660 --> 00:27:12,519
te devolverá false

637
00:27:12,519 --> 00:27:14,440
O sea, si me devuelve true

638
00:27:14,440 --> 00:27:16,240
Yo quiero volverlo a ejecutar

639
00:27:16,240 --> 00:27:18,940
Esa siguiente ejecución puede que ya no encuentre ninguno

640
00:27:18,940 --> 00:27:21,220
Entonces ya sé, ya me devolverá falsa

641
00:27:21,220 --> 00:27:27,299
¿Vale?

642
00:27:30,460 --> 00:27:31,900
Ya está, ya hemos terminado

643
00:27:31,900 --> 00:27:35,619
Lo metemos efectivamente en un while

644
00:27:35,619 --> 00:27:38,359
En un while que no necesita cuerpo

645
00:27:38,359 --> 00:27:39,700
Fijaos que while tan raro

646
00:27:39,700 --> 00:27:44,759
Ah, es que lo enchufa donde no es

647
00:27:44,759 --> 00:27:56,460
Vale, este while que he puesto yo

648
00:27:56,460 --> 00:27:58,779
Sería igual que este

649
00:27:58,779 --> 00:28:00,339
¿Vale?

650
00:28:00,339 --> 00:28:04,809
sería igual que hacer este while de aquí

651
00:28:04,809 --> 00:28:08,759
en realidad este es el while que quiero hacer

652
00:28:08,759 --> 00:28:10,160
¿verdad? un while

653
00:28:10,160 --> 00:28:12,420
que lo único que hace

654
00:28:12,420 --> 00:28:14,680
ya está en la propia condición, recordad

655
00:28:14,680 --> 00:28:15,559
que en una condición

656
00:28:15,559 --> 00:28:18,779
lo que importa es que el resultado

657
00:28:18,779 --> 00:28:20,680
de evaluar esa condición tiene un boolean

658
00:28:20,680 --> 00:28:22,779
pero en el propio proceso

659
00:28:22,779 --> 00:28:24,539
de evaluar la condición se harán cosas

660
00:28:24,539 --> 00:28:26,259
¿no? es como cuando hacíamos

661
00:28:26,259 --> 00:28:30,009
pues mientras

662
00:28:30,009 --> 00:28:32,230
n

663
00:28:32,230 --> 00:28:33,910
igual a 3

664
00:28:33,910 --> 00:28:35,829
distinto de 7

665
00:28:35,829 --> 00:28:38,529
esta es una condición

666
00:28:38,529 --> 00:28:39,569
perfectamente válida

667
00:28:39,569 --> 00:28:41,950
porque esto distinto

668
00:28:41,950 --> 00:28:43,109
de esto es un boolean

669
00:28:43,109 --> 00:28:45,009
lo que pasa es que dentro de una condición

670
00:28:45,009 --> 00:28:47,269
puede haber sentencias

671
00:28:47,269 --> 00:28:50,009
que sean necesarias ser ejecutadas

672
00:28:50,009 --> 00:28:51,470
para ya evaluar la condición

673
00:28:51,470 --> 00:28:53,349
pues aquí estamos en las mismas

674
00:28:53,349 --> 00:28:55,410
esto se va a ejecutar

675
00:28:55,410 --> 00:28:57,609
cada vez que evaluemos la condición

676
00:28:57,609 --> 00:28:58,809
es decir, el propio remove

677
00:28:58,809 --> 00:29:01,230
se va a ejecutar cuando evaluamos la condición

678
00:29:01,230 --> 00:29:02,029
el propio remove

679
00:29:02,029 --> 00:29:04,450
Y a su vez te va a dar el true o el false

680
00:29:04,450 --> 00:29:05,529
Luego es una condición

681
00:29:05,529 --> 00:29:07,890
Entonces este while va a estar todo el rato

682
00:29:07,890 --> 00:29:09,490
Haz el primer remove

683
00:29:09,490 --> 00:29:11,730
Que me ha dado false, ya está

684
00:29:11,730 --> 00:29:13,670
Ya no hace más remove, porque ya me ha dado false

685
00:29:13,670 --> 00:29:15,950
Vale, haz el primer remove

686
00:29:15,950 --> 00:29:16,789
Que me ha dado true

687
00:29:16,789 --> 00:29:18,750
Pues haz un siguiente

688
00:29:18,750 --> 00:29:21,410
Que me sigues dando true, es decir, has borrado un segundo

689
00:29:21,410 --> 00:29:23,430
Pues hazme un siguiente

690
00:29:23,430 --> 00:29:26,430
Que ahora ya me das false, es porque no había un tercero

691
00:29:26,430 --> 00:29:27,529
Con lo cual el while termina

692
00:29:27,529 --> 00:29:29,109
Entonces

693
00:29:29,109 --> 00:29:32,589
Como un while

694
00:29:32,589 --> 00:29:34,410
con cuerpo vacío

695
00:29:34,410 --> 00:29:36,049
o un for con cuerpo vacío

696
00:29:36,049 --> 00:29:36,950
es un poco feo

697
00:29:36,950 --> 00:29:39,029
pues esto lo podemos hacer

698
00:29:39,029 --> 00:29:41,009
cerrando aquí con un punto y coma

699
00:29:41,009 --> 00:29:44,450
¿vale? lo podemos cerrar ahí con un punto y coma

700
00:29:44,450 --> 00:29:45,950
si uno cierra un while

701
00:29:45,950 --> 00:29:47,470
o un for con un punto y coma

702
00:29:47,470 --> 00:29:49,769
significa que ese bucle

703
00:29:49,769 --> 00:29:51,410
tiene un cuerpo vacío

704
00:29:51,410 --> 00:29:52,309
no tiene nada de otro

705
00:29:52,309 --> 00:29:54,569
¿significa eso que no hace nada?

706
00:29:54,630 --> 00:29:55,250
claro que hace

707
00:29:55,250 --> 00:29:57,170
cada vez que evaluamos la condición

708
00:29:57,170 --> 00:29:58,309
están pasando cosas

709
00:29:58,309 --> 00:30:00,049
cada vez que evaluamos la condición

710
00:30:00,049 --> 00:30:01,390
no siempre

711
00:30:01,390 --> 00:30:04,549
pasan cosas cada vez que evaluamos una condición

712
00:30:04,549 --> 00:30:06,769
si la condición

713
00:30:06,769 --> 00:30:07,369
es esta

714
00:30:07,369 --> 00:30:12,170
este bucle sí que no hace nada de nada

715
00:30:12,170 --> 00:30:15,170
porque evaluar esta condición no implica que pase nada

716
00:30:15,170 --> 00:30:16,309
no implica que pase nada

717
00:30:16,309 --> 00:30:18,990
entonces este bucle pues efectivamente no hace nada

718
00:30:18,990 --> 00:30:20,630
pero este sí

719
00:30:20,630 --> 00:30:22,410
porque evaluar la condición

720
00:30:22,410 --> 00:30:24,670
implica que se hagan cosas

721
00:30:24,670 --> 00:30:29,890
¿qué era la pregunta?

722
00:30:30,670 --> 00:30:30,970
dígame

723
00:30:30,970 --> 00:30:34,470
¿hay alguna vez

724
00:30:34,470 --> 00:30:39,529
Claro, aquí ahora vamos a pensar, vamos a pensar cómo lo podríamos hacer, ¿vale?

725
00:30:39,529 --> 00:30:45,690
Porque aquí el tema, ahora ya sí que tendríamos, si queremos dar un feedback, no podemos dejarlo así,

726
00:30:45,809 --> 00:30:53,990
porque esto, si yo pongo aquí el, ¿vale? El retun, el false, el true, aquí sí que tendríamos que avisar

727
00:30:53,990 --> 00:30:58,190
con algún indicador si encontró o no encontró, es decir, si alguna vez entró en el bucle o no.

728
00:30:58,190 --> 00:31:11,750
Entonces, si queremos dar ese feedback, tenemos que avisar mediante una variable que luego devuelvo. Y esa variable me tiene que avisar si yo he entrado alguna vez en el bucle o no.

729
00:31:12,769 --> 00:31:22,890
Entonces, si yo quiero hacer un feedback, sí vamos a tener que abrir este while para detectar si yo he entrado al menos una vez. Y si he entrado al menos una vez, devuelvo, ¿vale?

730
00:31:22,890 --> 00:31:27,309
pero bueno, esto que nos asuste

731
00:31:27,309 --> 00:31:29,049
entonces vamos a dejar esto en comentario

732
00:31:29,049 --> 00:31:30,990
para que nadie se le olvide

733
00:31:30,990 --> 00:31:32,789
que esto es lo que yo haría

734
00:31:32,789 --> 00:31:35,230
si quiero borrar todos los que sean

735
00:31:35,230 --> 00:31:37,230
igual a este, todos los que sean igual

736
00:31:37,230 --> 00:31:38,269
vale

737
00:31:38,269 --> 00:31:41,190
pero si queremos hacer un boolean, un feedback

738
00:31:41,190 --> 00:31:42,829
pues venga

739
00:31:42,829 --> 00:31:44,430
boolean ahí

740
00:31:44,430 --> 00:31:47,309
inicialmente a falso

741
00:31:47,309 --> 00:31:48,930
y ahora me hago

742
00:31:48,930 --> 00:31:52,910
mi while, ahora ya con

743
00:31:52,910 --> 00:31:54,210
su cuerpo

744
00:31:54,210 --> 00:32:01,990
Y ya está

745
00:32:01,990 --> 00:32:09,769
Y lo devuelvo

746
00:32:09,769 --> 00:32:11,490
Y aquí boolean

747
00:32:11,490 --> 00:32:18,849
¿Vale? Entonces con que entre solo una vez

748
00:32:18,849 --> 00:32:20,029
Pues ya está

749
00:32:20,029 --> 00:32:21,670
Ha borrado alguno

750
00:32:21,670 --> 00:32:23,670
True si borró

751
00:32:23,670 --> 00:32:25,930
Entonces podríamos aquí añadir en la condición

752
00:32:25,930 --> 00:32:27,950
Si borró alguno

753
00:32:27,950 --> 00:32:29,609
Si borró alguno devuelve true

754
00:32:29,609 --> 00:32:31,509
Si no, nada

755
00:32:31,509 --> 00:32:35,480
¿Vale? Pues la clase plato

756
00:32:35,480 --> 00:32:36,880
Igual la podemos dejar así ya

757
00:32:36,880 --> 00:32:39,460
Añadir ingredientes

758
00:32:39,460 --> 00:32:41,160
Borrar ingredientes

759
00:32:41,160 --> 00:32:43,200
bueno, tendría sentido mostrar la lista

760
00:32:43,200 --> 00:32:44,940
de ingredientes, ¿verdad?

761
00:32:47,160 --> 00:32:52,130
Vamos a hacer una cosa.

762
00:32:52,630 --> 00:32:54,890
De nuevo, para no comprometernos con que la salida

763
00:32:54,890 --> 00:32:57,170
sea por consola. Que el listado

764
00:32:57,170 --> 00:32:58,630
me lo construya en un string

765
00:32:58,630 --> 00:33:03,339
que me devuelva. Listado

766
00:33:03,339 --> 00:33:04,799
ingredientes del plato.

767
00:33:06,380 --> 00:33:07,380
Para listado

768
00:33:07,380 --> 00:33:08,619
ingredientes del plato

769
00:33:08,619 --> 00:33:11,039
no necesitamos

770
00:33:11,039 --> 00:33:13,059
nada, porque

771
00:33:13,059 --> 00:33:15,099
la información está en la lista de ingredientes de arriba.

772
00:33:18,440 --> 00:33:19,359
Entonces, esto sería

773
00:33:19,359 --> 00:33:22,319
una concatenación

774
00:33:22,319 --> 00:33:24,359
acumulativa donde yo tengo que recorrer

775
00:33:24,359 --> 00:33:28,339
la lista, recorrer

776
00:33:28,339 --> 00:33:30,059
toda la lista con el for

777
00:33:30,059 --> 00:33:32,440
hasta que

778
00:33:32,440 --> 00:33:34,519
no acabe su tamaño, que será seguramente

779
00:33:34,519 --> 00:33:35,559
el método size

780
00:33:35,559 --> 00:33:38,259
y para recorrer

781
00:33:38,259 --> 00:33:39,440
cada uno de ellos en el get

782
00:33:39,440 --> 00:33:42,240
pues venga, para que no os aburráis demasiado

783
00:33:42,240 --> 00:33:43,920
acceden

784
00:33:43,920 --> 00:33:48,839
vale, pues a ver

785
00:33:48,839 --> 00:33:51,500
hasta aquí, hasta aquí

786
00:33:51,500 --> 00:33:52,539
más o menos fácil, ¿no?

787
00:33:52,539 --> 00:33:54,259
¿Qué habéis hecho aquí?

788
00:33:54,539 --> 00:33:56,980
Pues bueno, esto es una concatenación acumulativa

789
00:33:56,980 --> 00:34:02,329
Esta es una concatenación acumulativa

790
00:34:02,329 --> 00:34:07,539
Una concatenación acumulativa

791
00:34:07,539 --> 00:34:09,280
La empezamos así

792
00:34:09,280 --> 00:34:12,480
Como si fuera una suma acumulativa

793
00:34:12,480 --> 00:34:13,920
Que la empezamos con un cero

794
00:34:13,920 --> 00:34:15,619
Uy, cero, perdón

795
00:34:15,619 --> 00:34:16,980
A cadena vacía

796
00:34:16,980 --> 00:34:18,059
Vale

797
00:34:18,059 --> 00:34:21,619
Y ahora ya vamos a recorrer

798
00:34:21,619 --> 00:34:24,579
Todos los elementos que queremos concatenar

799
00:34:24,579 --> 00:34:26,940
Que son todos y cada uno de los elementos de la lista.

800
00:34:27,659 --> 00:34:29,239
¿Cómo recorremos una lista?

801
00:34:30,019 --> 00:34:32,039
Pues con un for, ¿vale?

802
00:34:35,699 --> 00:34:41,019
La primera, el listado de ingredientes, ¿vale?

803
00:35:02,360 --> 00:35:02,840
¿Vale?

804
00:35:05,500 --> 00:35:07,699
Voy, voy, voy, tranquilos.

805
00:35:08,280 --> 00:35:10,460
Un espacio no quiero meterle, ¿qué pasa?

806
00:35:10,619 --> 00:35:12,000
Le voy a meter un salto de línea.

807
00:35:12,340 --> 00:35:14,940
Para que me aparezcan en, ¿vale?

808
00:35:16,639 --> 00:35:17,119
Vale.

809
00:35:18,559 --> 00:35:20,599
Entonces, pues este está claro, ¿no?

810
00:35:20,860 --> 00:35:23,619
El método Ogued me permite recorrer por posición.

811
00:35:24,679 --> 00:35:30,980
Entonces, me va a mostrar los ingredientes en el orden en el que yo los inserté.

812
00:35:31,619 --> 00:35:32,039
¿Vale?

813
00:35:32,079 --> 00:35:33,340
En el orden en el que yo los inserté.

814
00:35:34,099 --> 00:35:35,199
Pero uno, dos.

815
00:35:36,340 --> 00:35:36,599
¿Vale?

816
00:35:36,599 --> 00:35:36,639
¿Vale?

817
00:35:36,639 --> 00:35:46,380
puedo recorrer una lista

818
00:35:46,380 --> 00:35:48,320
también, ¿recordáis el for each que lo hemos usado

819
00:35:48,320 --> 00:35:48,880
en Arrays?

820
00:35:49,599 --> 00:35:51,260
pues también lo podemos usar

821
00:35:51,260 --> 00:35:54,039
bueno, a ver que no he hecho el retun, lo podemos usar

822
00:35:54,039 --> 00:35:54,880
en colecciones

823
00:35:54,880 --> 00:35:59,280
un result

824
00:35:59,280 --> 00:36:00,280
vale

825
00:36:00,280 --> 00:36:03,940
es decir, podríamos también

826
00:36:03,940 --> 00:36:06,320
recorrer la lista con un for each

827
00:36:06,320 --> 00:36:06,980
de esta manera

828
00:36:06,980 --> 00:36:12,289
Para cada string

829
00:36:12,289 --> 00:36:16,050
En ingredientes

830
00:36:16,050 --> 00:36:24,769
Pues result

831
00:36:24,769 --> 00:36:26,510
Más igual y

832
00:36:26,510 --> 00:36:28,690
¿Vale?

833
00:36:30,230 --> 00:36:32,829
Es decir, exactamente igual

834
00:36:32,829 --> 00:36:34,090
Que lo usábamos en Arrays

835
00:36:34,090 --> 00:36:36,889
Pues también se puede usar para cualquier colección

836
00:36:36,889 --> 00:36:39,110
Para recorrer una colección

837
00:36:39,110 --> 00:36:40,849
La puedo recorrer

838
00:36:40,849 --> 00:36:42,190
Con esta sintaxis también

839
00:36:42,190 --> 00:36:46,500
Tiene muchos matices

840
00:36:46,500 --> 00:36:49,800
tiene muchos matices

841
00:36:49,800 --> 00:36:50,400
que

842
00:36:50,400 --> 00:36:53,679
ya veremos

843
00:36:53,679 --> 00:36:55,199
porque hay situaciones en las que puede fallar

844
00:36:55,199 --> 00:36:57,579
pero bueno, ahora no estamos en esa situación

845
00:36:57,579 --> 00:36:59,880
yo puedo usar un forit

846
00:36:59,880 --> 00:37:01,420
siempre que quiera recorrer

847
00:37:01,420 --> 00:37:03,900
cuando vamos a consultar

848
00:37:03,900 --> 00:37:05,960
a mostrar, simplemente no tenemos que tenerle

849
00:37:05,960 --> 00:37:07,940
ningún miedo, así podemos

850
00:37:07,940 --> 00:37:09,539
mostrar sin ningún problema

851
00:37:09,539 --> 00:37:11,840
si lo que queremos es

852
00:37:11,840 --> 00:37:13,980
además modificar la colección

853
00:37:13,980 --> 00:37:16,139
ya veremos que no es tan fácil

854
00:37:16,139 --> 00:37:19,320
porque si luego aquí vamos a modificar

855
00:37:19,320 --> 00:37:21,239
la colección, se va a producir un error

856
00:37:21,239 --> 00:37:22,880
de concurrencia y es

857
00:37:22,880 --> 00:37:25,219
el for se ha apoderado de la colección

858
00:37:25,219 --> 00:37:27,239
ahora tú llamas a un método

859
00:37:27,239 --> 00:37:29,099
que a su vez también

860
00:37:29,099 --> 00:37:30,960
trata de hacer cosas con la colección

861
00:37:30,960 --> 00:37:33,300
Java no te deja, pero bueno, eso ya surgirá

862
00:37:33,300 --> 00:37:35,239
más adelante, pero en principio

863
00:37:35,239 --> 00:37:37,519
un for each, para recorrer una colección

864
00:37:37,519 --> 00:37:39,239
y mostrarla, magnífico

865
00:37:39,880 --> 00:37:40,739
¿vale?

866
00:37:40,880 --> 00:37:41,639
ningún problema

867
00:37:41,639 --> 00:37:45,039
el único matiz es exactamente

868
00:37:45,039 --> 00:37:46,320
igual que con los arrays

869
00:37:46,320 --> 00:37:49,139
que el for each

870
00:37:49,139 --> 00:37:50,699
recorre la colección

871
00:37:50,699 --> 00:37:51,519
entera.

872
00:37:52,760 --> 00:37:54,019
De principio a fin.

873
00:37:54,699 --> 00:37:56,480
Con el for tengo más control

874
00:37:56,480 --> 00:37:59,000
sobre cuántas iteraciones hago

875
00:37:59,000 --> 00:38:00,380
en función de lo que ponga aquí.

876
00:38:00,940 --> 00:38:02,760
Yo puedo quedarme en 6 menos 7

877
00:38:02,760 --> 00:38:03,659
donde quiera.

878
00:38:05,760 --> 00:38:07,039
Entonces este recorre la colección

879
00:38:07,039 --> 00:38:08,860
entera. Luego para

880
00:38:08,860 --> 00:38:10,280
mostrar, en este caso

881
00:38:10,280 --> 00:38:13,219
mostrar lo que estamos haciendo es concatenar, pues ya está.

882
00:38:18,429 --> 00:38:20,809
realmente podríamos optimizar

883
00:38:20,809 --> 00:38:22,969
optimizar, lo que pasa es que no es fácil de entender

884
00:38:22,969 --> 00:38:25,050
y ya lo dejaremos

885
00:38:25,050 --> 00:38:26,349
para principios de segundo

886
00:38:26,349 --> 00:38:28,110
pero bueno, como lo veréis por ahí

887
00:38:28,110 --> 00:38:30,969
podríamos hacer una cosa

888
00:38:30,969 --> 00:38:32,110
con las colecciones

889
00:38:32,110 --> 00:38:35,050
que se llama serializarlas

890
00:38:35,630 --> 00:38:38,090
y cuando las serializas

891
00:38:38,090 --> 00:38:39,269
puedes trabajar

892
00:38:39,269 --> 00:38:40,909
como a mogollón con ellas

893
00:38:40,909 --> 00:38:42,969
pero eso tiene que ver con la programación

894
00:38:42,969 --> 00:38:43,650
funcional

895
00:38:43,650 --> 00:38:46,909
que incorporaremos más adelante

896
00:38:46,909 --> 00:38:48,789
veremos a ver cuando podemos

897
00:38:48,789 --> 00:38:50,369
pero lo voy a poner aquí porque

898
00:38:50,369 --> 00:38:52,710
si lo, porque chargpt

899
00:38:52,710 --> 00:38:54,650
lógicamente va a hacer las cosas serializando

900
00:38:54,650 --> 00:38:56,690
porque es mucho más cómodo, pero no es fácil

901
00:38:56,690 --> 00:38:58,750
de entender, hay que explicar bien antes lo que es la programación

902
00:38:58,750 --> 00:39:00,630
funcional, pero solo lo pongo aquí

903
00:39:00,630 --> 00:39:01,929
a efectos de ver o no de examinar

904
00:39:01,929 --> 00:39:06,269
es decir, vosotros si tenéis una colección cualquiera

905
00:39:06,269 --> 00:39:08,130
una colección cualquiera, como en este

906
00:39:08,130 --> 00:39:09,210
caso ingredientes

907
00:39:09,210 --> 00:39:11,469
podéis hacer una cosa que se llama

908
00:39:11,469 --> 00:39:13,889
voy a serializarla, es decir

909
00:39:13,889 --> 00:39:16,190
poner todos los elementos como si fuera

910
00:39:16,190 --> 00:39:17,409
en fila para Java

911
00:39:17,409 --> 00:39:19,969
voy a serializarla, ¿cómo se serializa?

912
00:39:20,869 --> 00:39:22,289
pues poniendo

913
00:39:22,289 --> 00:39:23,269
stream

914
00:39:23,269 --> 00:39:28,130
vale, con esto

915
00:39:28,130 --> 00:39:30,670
hemos serializado la colección

916
00:39:30,670 --> 00:39:32,010
ya veremos un poco qué significa

917
00:39:32,010 --> 00:39:33,610
si tú la serializas

918
00:39:33,610 --> 00:39:35,889
puedes trabajar con ella a mogollón

919
00:39:35,889 --> 00:39:38,369
de golpe, sin tener que ir

920
00:39:38,369 --> 00:39:40,610
elemento por elemento recorriéndolo en un for

921
00:39:40,610 --> 00:39:42,650
o sea, con la serialización

922
00:39:42,650 --> 00:39:44,849
de stream, lo que desaparecen

923
00:39:44,849 --> 00:39:45,590
son los for

924
00:39:45,590 --> 00:39:48,550
desaparecen los for, lo puedes hacer

925
00:39:48,550 --> 00:39:49,369
todo en una sola línea

926
00:39:49,369 --> 00:39:50,849
entonces

927
00:39:50,849 --> 00:39:53,869
lo pongo escrito para que veáis

928
00:39:53,869 --> 00:39:55,989
el aspecto, pues ahora yo trabajo

929
00:39:55,989 --> 00:39:58,030
a mogollón con toda, ¿qué es lo que quiero hacer?

930
00:39:58,550 --> 00:39:59,989
pues quiero para cada

931
00:39:59,989 --> 00:40:00,889
elemento

932
00:40:00,889 --> 00:40:03,090
quiero mostrarlo

933
00:40:03,090 --> 00:40:05,530
vale, pues hago esto

934
00:40:05,530 --> 00:40:07,630
que es lo que me muestra

935
00:40:07,630 --> 00:40:11,920
vale, ni quiero que entendáis

936
00:40:11,920 --> 00:40:13,320
lo que

937
00:40:13,320 --> 00:40:14,659
significa esto

938
00:40:14,659 --> 00:40:17,159
nada más que por encima

939
00:40:17,159 --> 00:40:19,320
ni lo vamos a ver ahora

940
00:40:19,320 --> 00:40:21,599
en detalle porque es imposible, porque es programación funcional

941
00:40:21,599 --> 00:40:23,460
lambda si es complicado

942
00:40:23,460 --> 00:40:25,179
pero como

943
00:40:25,179 --> 00:40:27,420
cada vez que alguien, como le preguntáis

944
00:40:27,420 --> 00:40:29,559
cosas a HGPT todo el rato y él lógicamente

945
00:40:29,559 --> 00:40:31,639
las colecciones las va a serializar

946
00:40:31,639 --> 00:40:33,280
pues vais a ver

947
00:40:33,280 --> 00:40:35,639
esto es una versión mínima

948
00:40:35,639 --> 00:40:37,420
cosas de estas, entonces cuando

949
00:40:37,420 --> 00:40:39,239
le pidáis ayuda con ejercicios

950
00:40:39,239 --> 00:40:40,719
le deberíais decir

951
00:40:40,719 --> 00:40:42,960
no me utilices lambdas

952
00:40:42,960 --> 00:40:45,219
vale, ni

953
00:40:45,219 --> 00:40:47,320
programación funcional, vosotros

954
00:40:47,320 --> 00:40:48,019
le decís

955
00:40:48,019 --> 00:40:50,659
no me utilices lambdas

956
00:40:50,659 --> 00:40:55,369
para que no haga esas cosas raras

957
00:40:55,369 --> 00:40:56,969
¿vale? que no son raras

958
00:40:56,969 --> 00:40:59,030
es una forma de programar más natural del mundo

959
00:40:59,030 --> 00:40:59,550
pero bueno

960
00:40:59,550 --> 00:41:01,710
¿vale?

961
00:41:03,690 --> 00:41:04,170
entonces

962
00:41:04,170 --> 00:41:06,909
repito solo

963
00:41:06,909 --> 00:41:08,630
para que no suene a chino

964
00:41:08,630 --> 00:41:11,090
una colección se puede serializar

965
00:41:11,090 --> 00:41:12,809
con stream y desde el momento

966
00:41:12,809 --> 00:41:14,789
que la serializas se te abre un mundo de

967
00:41:14,789 --> 00:41:17,170
posibilidades para hacer a mogollón con la colección

968
00:41:17,170 --> 00:41:18,969
sin necesidad de ir tirando

969
00:41:18,969 --> 00:41:21,130
con un for, una de ellas por ejemplo

970
00:41:21,130 --> 00:41:22,610
es llamando a for each que es

971
00:41:22,610 --> 00:41:24,889
oye a cada uno de ellos, haz lo que yo te diga

972
00:41:24,889 --> 00:41:27,090
pues con cada uno de ellos, ven muéstramelo

973
00:41:27,090 --> 00:41:27,570
por ejemplo

974
00:41:27,570 --> 00:41:30,130
en este caso más que mostrarlo

975
00:41:30,130 --> 00:41:32,369
lo que le pondríamos sería esto

976
00:41:32,369 --> 00:41:33,730
para cada uno elemento

977
00:41:33,730 --> 00:41:36,070
pues bueno, es que sería complicado

978
00:41:36,070 --> 00:41:38,550
para cada elemento x

979
00:41:38,550 --> 00:41:40,329
pues haríamos

980
00:41:40,329 --> 00:41:42,590
result más igual

981
00:41:42,590 --> 00:41:43,670
x

982
00:41:43,670 --> 00:41:46,230
esto es lo que le diríamos pero que

983
00:41:46,230 --> 00:41:47,110
vale

984
00:41:47,110 --> 00:41:50,230
tendríamos que hacerlo con un stream builder

985
00:41:50,230 --> 00:41:51,449
bueno

986
00:41:51,449 --> 00:41:53,469
lo quito

987
00:41:53,469 --> 00:41:55,670
¿vale? nada, nada, nada

988
00:41:55,670 --> 00:41:56,809
o sea que

989
00:41:56,809 --> 00:41:59,210
lo que yo había puesto antes era para mostrar

990
00:41:59,210 --> 00:42:01,929
para concatenar, ahí tendría que poner otra cosa

991
00:42:01,929 --> 00:42:03,710
tendría que poner una función lambda, pero olvidaros

992
00:42:03,710 --> 00:42:05,849
vale, entonces lo que pasa es que no quería dejar

993
00:42:05,849 --> 00:42:07,750
de decirlo porque es la otra forma

994
00:42:07,750 --> 00:42:09,449
natural de recorrer una colección

995
00:42:09,449 --> 00:42:11,449
pues serializándola, pero como

996
00:42:11,449 --> 00:42:13,710
os olvidáis, solo que sepáis

997
00:42:13,710 --> 00:42:15,730
que eso existe

998
00:42:15,730 --> 00:42:16,730
y que ya lo veremos

999
00:42:16,730 --> 00:42:18,769
Pero que ahora no

1000
00:42:18,769 --> 00:42:21,449
Vale, pues entonces

1001
00:42:21,449 --> 00:42:23,889
El Foris le voy a dejar aquí comentado

1002
00:42:23,889 --> 00:42:28,989
¿Qué os ocurre?

1003
00:42:29,989 --> 00:42:31,949
¿Qué pasa? ¿Que la huelga se hizo oficial por fin?

1004
00:42:31,949 --> 00:42:32,409
No, no sé

1005
00:42:32,409 --> 00:42:33,510
Pues

1006
00:42:33,510 --> 00:42:38,389
Vale, pues entonces

1007
00:42:38,389 --> 00:42:40,710
Listado de ingredientes

1008
00:42:40,710 --> 00:42:41,150
Ya está

1009
00:42:41,150 --> 00:42:43,130
Concatenamos y se acabó

1010
00:42:43,130 --> 00:42:46,030
Y aquí no hay mucho en lo que rascar

1011
00:42:46,030 --> 00:42:47,510
no hay mucho en lo que rascar

1012
00:42:47,510 --> 00:42:54,969
a ver, pero el tuestrin de string

1013
00:42:54,969 --> 00:42:57,449
es que tu obsesión de los métodos

1014
00:42:57,449 --> 00:42:59,989
le vas a hacer un tuestrin a string

1015
00:42:59,989 --> 00:43:01,690
tu obsesión de los métodos viene

1016
00:43:01,690 --> 00:43:03,989
porque crees que programar es llamar

1017
00:43:03,989 --> 00:43:05,190
a métodos que te hagan cosas

1018
00:43:05,190 --> 00:43:06,510
y es que no tiene nada que ver

1019
00:43:06,510 --> 00:43:08,969
programar es pienso

1020
00:43:08,969 --> 00:43:10,329
ya está, ahí lo tienes bien claro

1021
00:43:10,329 --> 00:43:13,090
el programador es el que tiene

1022
00:43:13,090 --> 00:43:14,389
un papel con un boli delante

1023
00:43:14,389 --> 00:43:15,989
todo lo demás son sucedáneos

1024
00:43:15,989 --> 00:43:18,869
No, pero creo que le refería a la lista entera

1025
00:43:18,869 --> 00:43:20,449
Sí, o sea, la lista entera

1026
00:43:20,449 --> 00:43:24,949
Sí, vale

1027
00:43:24,949 --> 00:43:25,510
Pero

1028
00:43:25,510 --> 00:43:28,110
Pues sí

1029
00:43:28,110 --> 00:43:30,369
Es que ni siquiera te hace falta, si lo pasas a un sistema

1030
00:43:30,369 --> 00:43:31,289
Que ya te llama tu stream

1031
00:43:31,289 --> 00:43:33,429
Pero no quiero que hagas eso

1032
00:43:33,429 --> 00:43:35,070
Lo que yo quiero es que me recorras la lista

1033
00:43:35,070 --> 00:43:37,130
Estamos aprendiendo a trabajar con listas

1034
00:43:37,130 --> 00:43:39,050
Porque habrá veces que no será

1035
00:43:39,050 --> 00:43:40,889
Tú el tu stream

1036
00:43:40,889 --> 00:43:42,289
Te va a servir para mostrarla

1037
00:43:42,289 --> 00:43:44,590
Pero es que aquí el tu stream no te vale

1038
00:43:44,590 --> 00:43:46,590
Porque estamos concatenando

1039
00:43:46,590 --> 00:43:48,670
Claro, aquí no te vale

1040
00:43:48,670 --> 00:43:50,949
Te vale si tú quieres hacer un

1041
00:43:50,949 --> 00:43:52,289
System.out.println

1042
00:43:52,289 --> 00:43:54,869
Vale

1043
00:43:54,869 --> 00:43:56,010
Pero es que aquí

1044
00:43:56,010 --> 00:43:59,650
No hay ninguna llamada al system.out.println

1045
00:43:59,650 --> 00:44:00,909
Vale, entonces aquí no

1046
00:44:00,909 --> 00:44:02,590
Venga, seguimos

1047
00:44:02,590 --> 00:44:04,230
A ver

1048
00:44:04,230 --> 00:44:07,650
Esta, aquí ya si hay un pelininín

1049
00:44:07,650 --> 00:44:09,170
Un pelininín más

1050
00:44:09,170 --> 00:44:10,510
Donde rascar, vale

1051
00:44:10,510 --> 00:44:13,429
Entonces, uno aquí podría pensar

1052
00:44:13,429 --> 00:44:14,630
Y hacerlo en plan a lo

1053
00:44:14,630 --> 00:44:16,469
De repente pipipipipi

1054
00:44:16,469 --> 00:44:18,389
Y decir si contiene ingrediente

1055
00:44:18,389 --> 00:44:21,590
Pues venga voy a recorrerla así un poco a lo loco

1056
00:44:21,590 --> 00:44:23,010
La recorro

1057
00:44:23,010 --> 00:44:25,630
Para cada string

1058
00:44:25,630 --> 00:44:26,389
Y

1059
00:44:26,389 --> 00:44:29,650
En ingredientes

1060
00:44:29,650 --> 00:44:32,110
O sea yo asumo de partida

1061
00:44:32,110 --> 00:44:35,809
Asumo de partida

1062
00:44:35,809 --> 00:44:36,510
Que no hay

1063
00:44:36,510 --> 00:44:40,099
Está igual a false

1064
00:44:40,099 --> 00:44:41,519
Y ahora

1065
00:44:41,519 --> 00:44:46,059
Para cada uno en ingredientes

1066
00:44:46,059 --> 00:44:50,659
Si i.equals

1067
00:44:50,659 --> 00:44:51,760
El que me han pasado

1068
00:44:51,760 --> 00:44:54,579
Entonces está igual a

1069
00:44:54,579 --> 00:44:55,239
Falso

1070
00:44:55,239 --> 00:44:57,519
Si puedes

1071
00:44:57,519 --> 00:44:58,559
Digo true

1072
00:44:58,559 --> 00:45:01,179
¿Os queréis relajar un poco?

1073
00:45:03,019 --> 00:45:03,699
¿Vale?

1074
00:45:04,000 --> 00:45:06,239
Puedes en algunos casos, no en otros

1075
00:45:06,239 --> 00:45:07,420
Por eso hay que entender

1076
00:45:07,420 --> 00:45:09,860
Al dedillo lo que estamos haciendo

1077
00:45:09,860 --> 00:45:11,780
Puedes lo que creo que me vas a decir

1078
00:45:11,780 --> 00:45:13,199
Vale, y ahora

1079
00:45:13,199 --> 00:45:14,199
return

1080
00:45:14,199 --> 00:45:16,099
esta

1081
00:45:16,099 --> 00:45:18,119
vale

1082
00:45:18,119 --> 00:45:23,440
ah, vale

1083
00:45:23,440 --> 00:45:25,960
bueno, pues podríamos hacer esto

1084
00:45:25,960 --> 00:45:27,079
y tiene sentido, ¿verdad?

1085
00:45:27,739 --> 00:45:29,739
vamos a recorrer la lista partiendo

1086
00:45:29,739 --> 00:45:32,019
inicialmente, mi supuesto es que no está

1087
00:45:32,019 --> 00:45:33,780
recorro, si encuentro un

1088
00:45:33,780 --> 00:45:35,820
contraejemplo, que este

1089
00:45:35,820 --> 00:45:37,159
es igual a ingrediente

1090
00:45:37,159 --> 00:45:40,019
lo cambio y lo devuelvo

1091
00:45:40,019 --> 00:45:40,559
¿vale?

1092
00:45:40,559 --> 00:45:43,300
vale, ¿qué ocurre aquí?

1093
00:45:44,019 --> 00:45:44,840
ocurre aquí

1094
00:45:44,840 --> 00:45:46,719
que mi criterio

1095
00:45:46,719 --> 00:45:49,380
para ver si el elemento

1096
00:45:49,380 --> 00:45:51,539
si hay algún elemento en la lista que cumpla

1097
00:45:51,539 --> 00:45:53,539
lo que yo digo, es el de

1098
00:45:53,539 --> 00:45:55,360
igualdad, es el de igualdad

1099
00:45:55,360 --> 00:45:57,159
porque podría ser

1100
00:45:57,159 --> 00:45:59,659
¿existe algún ingrediente en la lista

1101
00:45:59,659 --> 00:46:01,019
que empiece por A?

1102
00:46:01,960 --> 00:46:03,440
entonces, si es eso

1103
00:46:03,440 --> 00:46:05,119
yo aquí no pondría

1104
00:46:05,119 --> 00:46:07,280
equals, pondría así

1105
00:46:07,280 --> 00:46:08,940
charat, no sé qué

1106
00:46:08,940 --> 00:46:11,059
igual al char que yo he pasado

1107
00:46:11,059 --> 00:46:13,380
entonces ahí no sería

1108
00:46:13,380 --> 00:46:15,420
por equals, pero en este caso en particular

1109
00:46:15,420 --> 00:46:17,480
el criterio por el que

1110
00:46:17,480 --> 00:46:19,440
yo estoy viendo si el elemento

1111
00:46:19,440 --> 00:46:21,280
está o no está es porque sea

1112
00:46:21,280 --> 00:46:23,679
igual al que yo he pasado

1113
00:46:23,679 --> 00:46:25,460
vale, pues cuando el criterio

1114
00:46:25,460 --> 00:46:27,579
es ese, efectivamente tengo un método

1115
00:46:27,579 --> 00:46:29,099
estupendo que es el contains

1116
00:46:29,099 --> 00:46:31,119
¿no me vas a decir eso?

1117
00:46:31,300 --> 00:46:33,019
¿caches? que poco previsible

1118
00:46:33,019 --> 00:46:38,699
claro

1119
00:46:38,699 --> 00:46:40,699
si que puedes, vale

1120
00:46:40,699 --> 00:47:05,300
Es un código poco estructurado, feo, propio de jóvenes, no, propio de jóvenes y de Python, que es un lenguaje hecho para generación Z, ¿vale? Pero al final no se le pueden poner puertas al campo y si hay que desestructurar los códigos, pues se desestructuran.

1121
00:47:05,300 --> 00:47:07,880
¿qué significa desestructurar

1122
00:47:07,880 --> 00:47:09,619
un código? que ya no saben ni por dónde

1123
00:47:09,619 --> 00:47:11,820
sales, o sea que hay retun por todos lados

1124
00:47:11,820 --> 00:47:13,599
entonces tú tienes un código así

1125
00:47:13,599 --> 00:47:15,260
y en un código estructurado

1126
00:47:15,260 --> 00:47:17,159
sales al final

1127
00:47:17,159 --> 00:47:19,920
¿vale? en un código no estructurado

1128
00:47:19,920 --> 00:47:21,639
pues tienes if con

1129
00:47:21,639 --> 00:47:23,360
retun por todos lados o while con retun

1130
00:47:23,360 --> 00:47:24,900
entonces tu código pues

1131
00:47:24,900 --> 00:47:27,579
si tú haces eso en un diagrama

1132
00:47:27,579 --> 00:47:29,619
de flujo, pues el diagrama

1133
00:47:29,619 --> 00:47:30,880
de flujo te queda más feo que nada

1134
00:47:30,880 --> 00:47:33,440
¿vale? la idea de código

1135
00:47:33,440 --> 00:47:35,519
estructurado y código no estructurado va por ahí

1136
00:47:35,519 --> 00:47:36,820
es cierto

1137
00:47:36,820 --> 00:47:39,159
que es mucho más cómodo

1138
00:47:39,159 --> 00:47:41,400
hacer un código, efectivamente escribir

1139
00:47:41,400 --> 00:47:43,099
un código en el cual tú plantes el retorno

1140
00:47:43,099 --> 00:47:45,099
o te quieres ir y ya tienes el resultado y ya está

1141
00:47:45,099 --> 00:47:47,260
pero un código poco

1142
00:47:47,260 --> 00:47:48,940
estructurado es más ilegible

1143
00:47:48,940 --> 00:47:51,119
esa es la idea, es más ilegible

1144
00:47:51,119 --> 00:47:53,159
pero al final, pues mira

1145
00:47:53,159 --> 00:47:54,579
ya no se puede luchar contra los elementos

1146
00:47:54,579 --> 00:47:57,239
y el código no estructurado pues está

1147
00:47:57,239 --> 00:47:59,260
en todas partes, esta sería la

1148
00:47:59,260 --> 00:48:01,119
versión bonita de este método

1149
00:48:01,119 --> 00:48:02,280
¿vale?

1150
00:48:06,159 --> 00:48:08,940
vale, bueno pues entonces

1151
00:48:08,940 --> 00:48:09,739
a lo que íbamos

1152
00:48:09,739 --> 00:48:11,840
aquí efectivamente

1153
00:48:11,840 --> 00:48:15,159
el criterio que yo estoy usando para ver

1154
00:48:15,159 --> 00:48:16,860
si hay algún elemento

1155
00:48:16,860 --> 00:48:18,860
que cumpla lo que yo le he dicho

1156
00:48:18,860 --> 00:48:20,960
en la lista es el de igualdad

1157
00:48:20,960 --> 00:48:23,280
pues efectivamente tenemos un método

1158
00:48:23,280 --> 00:48:24,980
que es el contains que ya me lo hace

1159
00:48:24,980 --> 00:48:26,820
entonces todo este código

1160
00:48:26,820 --> 00:48:28,639
lo podría yo

1161
00:48:28,639 --> 00:48:31,380
haber resumido de la siguiente manera

1162
00:48:31,380 --> 00:48:33,280
ingredientes

1163
00:48:34,219 --> 00:48:34,980
punto

1164
00:48:34,980 --> 00:48:36,739
contains

1165
00:48:36,739 --> 00:48:37,920
ingrediente

1166
00:48:37,920 --> 00:48:41,099
y esto ya me devuelve un true o un

1167
00:48:41,099 --> 00:48:43,000
false, en función

1168
00:48:43,000 --> 00:48:44,920
de si hay algún elemento

1169
00:48:44,920 --> 00:48:47,139
en la lista igual a ingrediente

1170
00:48:47,139 --> 00:48:49,099
o no lo hay, esto ya

1171
00:48:49,099 --> 00:48:49,780
me lo devuelve

1172
00:48:49,780 --> 00:48:56,019
while no, o sea esto ya te dice

1173
00:48:56,019 --> 00:48:57,079
esto en un while para que

1174
00:48:57,079 --> 00:49:00,099
contains ya tiene

1175
00:49:00,099 --> 00:49:01,360
su propio bucle dentro

1176
00:49:01,360 --> 00:49:03,300
que se pone a recorrer la lista

1177
00:49:03,300 --> 00:49:06,280
en cuanto encuentra

1178
00:49:06,280 --> 00:49:08,079
un ingrediente igual

1179
00:49:08,079 --> 00:49:10,059
a este, te devuelve true.

1180
00:49:10,780 --> 00:49:12,119
Y si no encuentra ninguno,

1181
00:49:12,199 --> 00:49:13,260
te devuelve falsa.

1182
00:49:15,400 --> 00:49:16,099
Luego el

1183
00:49:16,099 --> 00:49:18,239
contains, para que funcione y tenga

1184
00:49:18,239 --> 00:49:20,199
sentido, tiene que haber un criterio

1185
00:49:20,199 --> 00:49:21,519
de igualdad definido

1186
00:49:21,519 --> 00:49:23,219
en la entidad

1187
00:49:23,219 --> 00:49:26,320
de la que forman parte

1188
00:49:26,320 --> 00:49:28,239
los elementos de la lista. Si no, no tiene

1189
00:49:28,239 --> 00:49:30,320
ningún sentido. En este caso

1190
00:49:30,320 --> 00:49:32,119
lo hay, que es string. String

1191
00:49:32,119 --> 00:49:34,360
tiene su criterio de igualdad. Y es que todos los caracteres

1192
00:49:34,360 --> 00:49:36,139
sean iguales. Luego aquí el contains

1193
00:49:36,139 --> 00:49:37,320
Funciona perfectamente

1194
00:49:37,320 --> 00:49:39,599
¿Vale? Pero luego

1195
00:49:39,599 --> 00:49:40,940
Como ya vamos a ver en plato

1196
00:49:40,940 --> 00:49:42,300
No nos va a funcionar el contains

1197
00:49:42,300 --> 00:49:45,039
Porque plato no tiene un criterio de igualdad

1198
00:49:45,039 --> 00:49:46,480
A menos que se lo pongamos

1199
00:49:46,480 --> 00:49:49,940
Pero aquí ingredientes tiene string

1200
00:49:49,940 --> 00:49:51,400
String tiene su criterio de igualdad

1201
00:49:51,400 --> 00:49:51,980
Que es equals

1202
00:49:51,980 --> 00:49:54,860
Con lo cual contains me va a mirar

1203
00:49:54,860 --> 00:49:57,619
Si existe alguno en toda la lista

1204
00:49:57,619 --> 00:49:59,300
Equals a este

1205
00:49:59,300 --> 00:50:01,760
Es decir, contains por dentro

1206
00:50:01,760 --> 00:50:03,099
Está haciendo esto

1207
00:50:03,099 --> 00:50:05,360
Si nos vamos a contains

1208
00:50:05,360 --> 00:50:06,559
Esto es lo que está haciendo.

1209
00:50:06,940 --> 00:50:07,219
Ya está.

1210
00:50:07,280 --> 00:50:08,639
Está haciendo exactamente eso.

1211
00:50:10,840 --> 00:50:11,360
¿Vale?

1212
00:50:13,559 --> 00:50:20,250
¿Pero qué ocurre si ahora me piden un método que me dice...

1213
00:50:22,210 --> 00:50:27,250
Contiene ingrediente...

1214
00:50:27,889 --> 00:50:33,469
Pues a lo mejor alguien le tiene alergia a todos los ingredientes de más de 10 letras.

1215
00:50:34,469 --> 00:50:37,090
Entonces puede tomar cordero, pero no puede tomar corderito.

1216
00:50:37,250 --> 00:50:42,349
Entonces, pues uno se le hace un método que es, contiene ingrediente largo.

1217
00:50:47,969 --> 00:50:53,250
Claro, imagínate que tú tienes alergia a todos los alimentos de más de un número de letras.

1218
00:50:54,989 --> 00:50:59,429
Entonces, necesitas que esa aplicación tenga esa funcionalidad.

1219
00:51:02,250 --> 00:51:04,070
Contiene ingrediente mayor que esto.

1220
00:51:04,429 --> 00:51:05,849
Pues aquí no hay contains que valga.

1221
00:51:06,150 --> 00:51:07,570
Aquí no hay contains que valga.

1222
00:51:07,570 --> 00:51:09,909
aquí lógicamente tendríamos que hacer

1223
00:51:09,909 --> 00:51:10,949
ya este código de aquí

1224
00:51:10,949 --> 00:51:19,530
aquí no hay

1225
00:51:19,530 --> 00:51:20,849
contains que valga, aquí

1226
00:51:20,849 --> 00:51:25,409
si length

1227
00:51:25,409 --> 00:51:28,050
y punto length

1228
00:51:28,050 --> 00:51:29,170
porque es un string

1229
00:51:29,170 --> 00:51:31,190
y punto length

1230
00:51:31,190 --> 00:51:33,190
resulta que es mayor

1231
00:51:33,190 --> 00:51:35,250
que numletras

1232
00:51:35,250 --> 00:51:37,610
pues sí, hay uno

1233
00:51:37,610 --> 00:51:39,670
mayor que el número

1234
00:51:39,670 --> 00:51:41,630
de letras, entonces esto

1235
00:51:41,630 --> 00:51:43,269
jamás lo podríamos hacer con contains

1236
00:51:43,269 --> 00:51:45,449
lógicamente, porque el contains lo que mira

1237
00:51:45,449 --> 00:51:47,670
es si existe algún elemento exactamente

1238
00:51:47,670 --> 00:51:49,590
igual al que

1239
00:51:49,590 --> 00:51:51,010
le estamos pasando.

1240
00:52:05,800 --> 00:52:05,940
¿Vale?

1241
00:52:19,610 --> 00:52:20,929
Vale, en cuanto al remove,

1242
00:52:21,530 --> 00:52:23,590
nos subimos un momentito al remove de arriba.

1243
00:52:27,500 --> 00:52:28,380
A este remove.

1244
00:52:29,440 --> 00:52:30,960
El remove y el contains

1245
00:52:30,960 --> 00:52:32,179
los dos tiran de equal.

1246
00:52:32,840 --> 00:52:34,880
Recordad, por eso es necesario que el

1247
00:52:34,880 --> 00:52:36,920
equals esté implementado en la entidad que sea.

1248
00:52:37,360 --> 00:52:38,119
Aquí es string,

1249
00:52:38,119 --> 00:52:39,400
no hay problema.

1250
00:52:39,840 --> 00:52:40,780
Equals está en string.

1251
00:52:40,780 --> 00:52:43,199
vale, remove

1252
00:52:43,199 --> 00:52:45,500
cuando hemos desplegado antes lo que había

1253
00:52:45,500 --> 00:52:47,679
hemos visto que hay dos versiones

1254
00:52:47,679 --> 00:52:49,500
de remove, borrar

1255
00:52:49,500 --> 00:52:51,619
pasamos un elemento y que te

1256
00:52:51,619 --> 00:52:53,820
borre el elemento, el primero que encuentre

1257
00:52:53,820 --> 00:52:54,840
igual a ese

1258
00:52:54,840 --> 00:52:57,320
pero también hay una versión de remove que es

1259
00:52:57,320 --> 00:52:59,760
bórrame por posición, te pasas la 0, la 1, la 2

1260
00:52:59,760 --> 00:53:01,519
depende de lo que queramos usar

1261
00:53:01,519 --> 00:53:03,619
¿vale? aquí en este

1262
00:53:03,619 --> 00:53:05,460
queremos borrar el que

1263
00:53:05,460 --> 00:53:07,300
sea igual a este, pero

1264
00:53:07,300 --> 00:53:09,019
podríamos querer borrar por posición

1265
00:53:09,019 --> 00:53:11,940
por ejemplo, una forma muy retorcida

1266
00:53:11,940 --> 00:53:13,480
de hacer esto, aquí no tendría sentido

1267
00:53:13,480 --> 00:53:15,860
hay un método que es el método

1268
00:53:15,860 --> 00:53:16,699
indexOf

1269
00:53:16,699 --> 00:53:25,829
y el método indexOf

1270
00:53:25,829 --> 00:53:28,289
si tú le pasas un elemento

1271
00:53:28,289 --> 00:53:30,230
te devuelve

1272
00:53:30,230 --> 00:53:32,369
la primera posición

1273
00:53:32,369 --> 00:53:34,250
de la lista en la que

1274
00:53:34,250 --> 00:53:36,030
encuentra que hay un elemento

1275
00:53:36,030 --> 00:53:37,969
igual según equals a esto

1276
00:53:37,969 --> 00:53:40,030
a veces es útil

1277
00:53:40,030 --> 00:53:41,829
entonces en este caso

1278
00:53:41,829 --> 00:53:44,010
una forma muy retorcida de hacer este remove

1279
00:53:44,010 --> 00:53:45,469
Podría haber sido esta

1280
00:53:45,469 --> 00:53:48,429
Ingredientes

1281
00:53:48,429 --> 00:53:50,309
Punto remove

1282
00:53:50,309 --> 00:53:52,369
Y le pasamos eso

1283
00:53:52,369 --> 00:53:56,860
Le voy a poner una variable aparte

1284
00:53:56,860 --> 00:53:58,880
Para que no quede el código tan largo

1285
00:53:58,880 --> 00:54:01,500
Int posición

1286
00:54:01,500 --> 00:54:02,920
Igual a

1287
00:54:02,920 --> 00:54:06,760
Ingredientes

1288
00:54:06,760 --> 00:54:09,099
Punto index

1289
00:54:09,099 --> 00:54:09,840
Of

1290
00:54:09,840 --> 00:54:11,739
Ingredientes

1291
00:54:11,739 --> 00:54:14,820
Y ahora borramos

1292
00:54:14,820 --> 00:54:15,800
Por la posición

1293
00:54:15,800 --> 00:54:21,179
vale, pues

1294
00:54:21,179 --> 00:54:23,300
estas dos líneas

1295
00:54:23,300 --> 00:54:24,639
y esta

1296
00:54:24,639 --> 00:54:27,920
en este caso te hacen exactamente

1297
00:54:27,920 --> 00:54:29,539
lo mismo, vale

1298
00:54:29,539 --> 00:54:35,519
index of

1299
00:54:35,519 --> 00:54:36,880
te devuelve

1300
00:54:36,880 --> 00:54:40,079
la primera posición de la lista en la que encuentro

1301
00:54:40,079 --> 00:54:41,139
un elemento igual a S

1302
00:54:41,139 --> 00:54:44,139
si hubiera varios iguales a S

1303
00:54:44,139 --> 00:54:45,639
te devuelve el primero de todos

1304
00:54:45,639 --> 00:54:47,880
solamente, el primer índice

1305
00:54:47,880 --> 00:54:49,480
en el que encuentra que hay un elemento igual

1306
00:54:49,480 --> 00:54:51,760
Entonces tú borras

1307
00:54:51,760 --> 00:54:52,639
Y ya está

1308
00:54:52,639 --> 00:54:54,460
Otra pregunta

1309
00:54:54,460 --> 00:54:57,460
Todas estas cosas no ignoran

1310
00:54:57,460 --> 00:54:59,320
Los uppercase, no ignoran las mayúsculas

1311
00:54:59,320 --> 00:55:01,059
No, a ver

1312
00:55:01,059 --> 00:55:02,760
No, a ver, es que aquí estamos

1313
00:55:02,760 --> 00:55:04,039
No, porque aquí estamos hablando

1314
00:55:04,039 --> 00:55:07,119
Del criterio equals que tenga cada cosa

1315
00:55:07,119 --> 00:55:08,760
El criterio equals de string

1316
00:55:08,760 --> 00:55:11,340
No ignora mayúsculas y minúsculas

1317
00:55:11,340 --> 00:55:12,639
O sea, tenéis que

1318
00:55:12,639 --> 00:55:13,019
Si quieres

1319
00:55:13,019 --> 00:55:14,940
Claro

1320
00:55:14,940 --> 00:55:18,099
Si tú no puedes hacer un

1321
00:55:18,099 --> 00:55:19,719
si tú quieres ignorándolo

1322
00:55:19,719 --> 00:55:21,980
no podrías hacer un contains

1323
00:55:21,980 --> 00:55:23,719
porque el contains

1324
00:55:23,719 --> 00:55:25,239
es el equals tal cual

1325
00:55:25,239 --> 00:55:28,500
entonces tú quieres el equals ignore case

1326
00:55:28,500 --> 00:55:30,380
si el equals ignore case

1327
00:55:30,380 --> 00:55:32,300
no es el equals que incorpora el contains

1328
00:55:32,300 --> 00:55:33,840
entonces

1329
00:55:33,840 --> 00:55:35,679
pues nada, recorres y ya está

1330
00:55:35,679 --> 00:55:38,159
o hay una cosa que puedes hacer

1331
00:55:38,159 --> 00:55:40,239
pasas toda

1332
00:55:40,239 --> 00:55:42,099
tu lista de ingredientes a minúscula

1333
00:55:42,780 --> 00:55:44,519
con lower, la pasas toda a minúscula

1334
00:55:44,519 --> 00:55:45,920
el ingrediente que te han dado

1335
00:55:45,920 --> 00:55:46,920
lo pasas a minúscula

1336
00:55:46,920 --> 00:55:48,739
Y ahora ya sí llamas al remove

1337
00:55:48,739 --> 00:55:52,579
A ver, pasas

1338
00:55:52,579 --> 00:55:55,420
La lista de ingredientes la pasas toda a minúscula

1339
00:55:55,420 --> 00:55:58,099
Pasas el ingrediente que te han dado a minúscula

1340
00:55:58,099 --> 00:55:59,440
Y llamas al remove

1341
00:55:59,440 --> 00:56:00,460
Ya sin más

1342
00:56:00,460 --> 00:56:07,619
Tu uppercase te pasa el string que tú le des a mayúscula

1343
00:56:11,440 --> 00:56:12,280
Bueno, a ver, no

1344
00:56:12,280 --> 00:56:16,900
A ver, lo que yo estoy diciendo es

1345
00:56:16,900 --> 00:56:19,380
que el equals de string es

1346
00:56:19,380 --> 00:56:21,099
equals, no es equals ignore case

1347
00:56:21,099 --> 00:56:23,679
entonces si tú quieres borrar un ingrediente de la lista

1348
00:56:23,679 --> 00:56:25,860
ignorando mayúsculas y minúsculas

1349
00:56:25,860 --> 00:56:27,480
entonces no puedes hacerlo

1350
00:56:27,480 --> 00:56:29,380
con remove, tendrías que

1351
00:56:29,380 --> 00:56:30,820
recorrer la lista

1352
00:56:30,820 --> 00:56:32,940
y con cada uno

1353
00:56:32,940 --> 00:56:35,559
si equals ignore case, pues entonces

1354
00:56:35,559 --> 00:56:37,440
lo que sea, que queremos hacerlo

1355
00:56:37,440 --> 00:56:39,099
con remove, pues entonces

1356
00:56:39,099 --> 00:56:41,480
llevamos toda la lista a minúscula y el

1357
00:56:41,480 --> 00:56:43,360
ingrediente a minúscula o al revés, toda la lista

1358
00:56:43,360 --> 00:56:45,219
a mayúscula y el ingrediente a mayúscula, lo que quieras

1359
00:56:45,219 --> 00:56:46,539
¿vale?

1360
00:56:46,900 --> 00:56:49,739
vale, pues entonces esto es una forma

1361
00:56:49,739 --> 00:56:51,440
esto de aquí es una forma muy retorcida

1362
00:56:51,440 --> 00:56:53,440
de hacer esto mismo, aquí lo único

1363
00:56:53,440 --> 00:56:55,519
es la validación

1364
00:56:55,519 --> 00:56:57,559
el index

1365
00:56:57,559 --> 00:56:59,380
of te devuelve la

1366
00:56:59,380 --> 00:57:01,500
posición del elemento que ha encontrado

1367
00:57:01,500 --> 00:57:03,559
igual, si no ha encontrado ninguno

1368
00:57:03,559 --> 00:57:04,840
te devuelve menos uno

1369
00:57:04,840 --> 00:57:07,559
entonces se lo meteríamos en un bucle que sería

1370
00:57:07,559 --> 00:57:09,460
while pos igual a esto

1371
00:57:09,460 --> 00:57:10,599
diferente de menos uno

1372
00:57:10,599 --> 00:57:12,920
mientras sea diferente de menos uno

1373
00:57:12,920 --> 00:57:17,780
vale, es decir

1374
00:57:17,780 --> 00:57:18,780
tendríamos que hacer

1375
00:57:18,780 --> 00:57:24,590
por ejemplo

1376
00:57:24,590 --> 00:57:26,789
y ahora

1377
00:57:26,789 --> 00:57:32,340
mientras la posición

1378
00:57:32,340 --> 00:57:34,539
siendo la posición igual

1379
00:57:34,539 --> 00:57:36,280
el índice de ese ingrediente

1380
00:57:36,280 --> 00:57:37,719
sea

1381
00:57:37,719 --> 00:57:40,599
diferente de menos

1382
00:57:40,599 --> 00:57:42,659
uno, sea diferente

1383
00:57:42,659 --> 00:57:44,599
de menos uno, pues mientras

1384
00:57:44,599 --> 00:57:46,619
sea diferente de menos uno es porque sigue habiendo

1385
00:57:46,619 --> 00:57:48,659
un ingrediente así, lo borro

1386
00:57:48,659 --> 00:57:50,559
por posición y además

1387
00:57:50,559 --> 00:57:52,320
aviso de que está para

1388
00:57:52,320 --> 00:57:54,300
boolean

1389
00:57:54,300 --> 00:57:56,760
Está igual a false

1390
00:57:56,760 --> 00:58:00,760
Y avisaría de que he borrado uno

1391
00:58:00,760 --> 00:58:02,219
Está igual a true

1392
00:58:02,219 --> 00:58:05,059
Es decir, todo este código

1393
00:58:05,059 --> 00:58:06,800
Es equivalente al de abajo

1394
00:58:06,800 --> 00:58:08,559
¿No?

1395
00:58:08,599 --> 00:58:09,960
Es una tontería, vamos, que hemos hecho

1396
00:58:09,960 --> 00:58:11,199
Para que veamos el index of

1397
00:58:11,199 --> 00:58:12,659
Return está

1398
00:58:12,659 --> 00:58:15,039
Todo este código de arriba

1399
00:58:15,039 --> 00:58:18,280
Hace exactamente lo mismo que el de abajo

1400
00:58:18,280 --> 00:58:19,800
Exactamente lo mismo

1401
00:58:19,800 --> 00:58:24,440
Luego efectivamente un poco tonto

1402
00:58:24,440 --> 00:58:26,400
Pero bueno

1403
00:58:26,400 --> 00:58:27,699
Ya sabemos lo que es el index of

1404
00:58:27,699 --> 00:58:40,239
lo voy a dejar comentado

1405
00:58:40,239 --> 00:58:49,480
vale, pues plato ya tiene aquí

1406
00:58:49,480 --> 00:58:51,280
un montón de funcionalidades, de cosas

1407
00:58:51,280 --> 00:58:53,619
¿qué le pasa

1408
00:58:53,619 --> 00:58:54,340
al restaurante?

1409
00:58:55,400 --> 00:58:57,440
bueno, pues el restaurante lo que tiene ahora es una lista

1410
00:58:57,440 --> 00:58:59,320
de platos, ahora esto ya no es tan

1411
00:58:59,320 --> 00:59:01,400
trivial, porque la colección

1412
00:59:01,400 --> 00:59:03,340
tiene platos que puede no tener equals

1413
00:59:03,340 --> 00:59:04,800
tendríamos que hacérselo

1414
00:59:04,800 --> 00:59:06,420
etcétera

1415
00:59:06,420 --> 00:59:08,739
vale, pero vamos a seguir el mismo criterio

1416
00:59:08,739 --> 00:59:11,300
que es, vamos a

1417
00:59:11,300 --> 00:59:13,239
crear platos

1418
00:59:13,239 --> 00:59:14,980
Pues venga, railis para variar

1419
00:59:14,980 --> 00:59:24,460
Y ahora un constructor

1420
00:59:24,460 --> 00:59:30,150
Con el nombre del plato

1421
00:59:30,150 --> 00:59:31,869
Solamente, ya se van añadiendo platos

1422
00:59:31,869 --> 00:59:32,489
A la carta

1423
00:59:32,489 --> 00:59:36,860
Sus getter y sus setter

1424
00:59:36,860 --> 00:59:45,710
Sus getter y sus setter

1425
00:59:45,710 --> 00:59:51,179
Y ahora, ¿qué métodos

1426
00:59:51,179 --> 00:59:53,219
Nos interesa hacer?

1427
00:59:53,300 --> 00:59:55,139
Los dejamos aquí escritos y planteados

1428
00:59:55,139 --> 00:59:57,059
Para que los hagáis

1429
00:59:57,059 --> 00:59:59,500
Pues bueno, con el restaurante nos va a interesar

1430
00:59:59,500 --> 01:00:01,480
Añadirle un plato a la carta

1431
01:00:01,480 --> 01:00:03,340
Claro, ese nos va a interesar

1432
01:00:03,340 --> 01:00:12,260
¿Qué más nos va a interesar?

1433
01:00:12,519 --> 01:00:12,800
Pues

1434
01:00:12,800 --> 01:00:15,119
Del restaurante

1435
01:00:15,119 --> 01:00:16,920
Pues ver la carta

1436
01:00:16,920 --> 01:00:20,869
Que me lo devuelva como stream también

1437
01:00:20,869 --> 01:00:26,690
Ver la carta del restaurante

1438
01:00:26,690 --> 01:00:32,510
¿Vale?

1439
01:00:33,550 --> 01:00:34,429
Por ejemplo

1440
01:00:34,429 --> 01:00:35,570
¿Qué otra funcionalidad?

1441
01:00:36,409 --> 01:00:38,929
Ver los platos que contienen un ingrediente

1442
01:00:38,929 --> 01:00:40,469
Para así

1443
01:00:40,469 --> 01:00:42,969
Eliminarlos

1444
01:00:42,969 --> 01:00:44,110
De nuestras opciones

1445
01:00:44,110 --> 01:00:48,059
Public stream

1446
01:00:48,059 --> 01:00:51,519
Platos con

1447
01:00:51,519 --> 01:00:53,880
Ingrediente

1448
01:00:53,880 --> 01:00:58,119
Pasamos el ingrediente

1449
01:00:58,119 --> 01:00:59,400
Y me devuelve un listado

1450
01:00:59,400 --> 01:01:00,920
De los platos que lo tengan

1451
01:01:00,920 --> 01:01:02,139
Para decir esto, no

1452
01:01:02,139 --> 01:01:09,889
De los platos que contengan ese ingrediente

1453
01:01:09,889 --> 01:01:20,130
Bueno, eliminar un plato de la lista

1454
01:01:20,130 --> 01:01:20,510
Claro

1455
01:01:20,510 --> 01:01:28,150
Boolean, eliminar un plato

1456
01:01:28,150 --> 01:01:30,309
De la carta, que no lo queremos

1457
01:01:30,309 --> 01:01:36,760
Eliminar un plato

1458
01:01:36,760 --> 01:01:39,300
Dando el nombre de ese plato

1459
01:01:39,300 --> 01:01:41,900
Estoy poniendo los retun

1460
01:01:41,900 --> 01:01:43,440
Para que el compilador no falle

1461
01:01:43,440 --> 01:01:46,059
Damos el nombre del plato

1462
01:01:46,059 --> 01:01:47,980
Y eliminar el plato

1463
01:01:47,980 --> 01:01:49,059
De esa carta

1464
01:01:49,059 --> 01:01:51,860
¿Qué más cosas

1465
01:01:51,860 --> 01:01:53,900
Nos puede interesar hacer con la carta del restaurante?

1466
01:01:59,500 --> 01:02:01,559
Buscar un plato con un nombre

1467
01:02:01,559 --> 01:02:02,760
Para ver qué ingredientes tiene

1468
01:02:02,760 --> 01:02:04,980
Por ejemplo, mostrar ingredientes

1469
01:02:04,980 --> 01:02:05,840
Efectivamente

1470
01:02:05,840 --> 01:02:12,389
Pero que te devuelva el plato

1471
01:02:12,389 --> 01:02:14,150
Dices, buscar un plato y que te lo devuelva

1472
01:02:14,150 --> 01:02:15,929
Si, lo que pasa es que el plato solamente tiene

1473
01:02:15,929 --> 01:02:17,590
Nombre y

1474
01:02:17,590 --> 01:02:25,099
Claro, y como plato solamente tiene

1475
01:02:25,099 --> 01:02:26,360
Nombre e ingredientes

1476
01:02:26,360 --> 01:02:27,780
O sea, le das el nombre del plato

1477
01:02:27,780 --> 01:02:30,139
Te devuelve el plato entero que a su vez

1478
01:02:30,139 --> 01:02:31,320
Tiene el mismo nombre e ingredientes

1479
01:02:31,320 --> 01:02:33,260
Por eso decía que te devuelvan los ingredientes directamente

1480
01:02:33,260 --> 01:02:34,460
¿No?

1481
01:02:35,179 --> 01:02:37,159
De hecho, vamos a hacerlo así para cambiar

1482
01:02:37,159 --> 01:02:38,280
Es que así no

1483
01:02:38,280 --> 01:02:40,820
Vamos a hacer un método que te devuelve

1484
01:02:40,820 --> 01:02:44,039
Este es el que es más interesante

1485
01:02:44,039 --> 01:02:46,260
Bueno, que es una

1486
01:02:46,260 --> 01:02:47,739
Listar

1487
01:02:47,739 --> 01:02:53,320
No, get ingredientes

1488
01:02:53,320 --> 01:02:54,960
De un plato

1489
01:02:54,960 --> 01:02:57,239
Y que vamos a pasar el nombre

1490
01:02:57,239 --> 01:02:57,960
De ese plato

1491
01:02:57,960 --> 01:03:03,940
Y que te de los ingredientes de ese plato

1492
01:03:03,940 --> 01:03:06,219
Si lo hubiéramos puesto precio

1493
01:03:06,219 --> 01:03:08,699
Tendría un poco más de interés

1494
01:03:08,699 --> 01:03:12,079
Vamos a ponerle al

1495
01:03:12,079 --> 01:03:14,039
Ah, que claro que tiene precio

1496
01:03:14,039 --> 01:03:15,920
Y estamos pasando el precio completamente

1497
01:03:15,920 --> 01:03:20,670
pero que no lo hemos usado

1498
01:03:20,670 --> 01:03:23,070
para nada, entonces ahora ya en restaurante

1499
01:03:23,070 --> 01:03:24,289
sí, vamos a usar

1500
01:03:24,289 --> 01:03:27,349
por ejemplo

1501
01:03:27,349 --> 01:03:29,250
mostrar

1502
01:03:29,250 --> 01:03:31,070
cuenta no porque no hay

1503
01:03:31,070 --> 01:03:32,710
un objeto que sea pedido

1504
01:03:32,710 --> 01:03:34,369
que se podría añadir el pedido

1505
01:03:34,369 --> 01:03:36,489
una comanda concreta, vale

1506
01:03:36,489 --> 01:03:38,110
pues vamos a

1507
01:03:38,110 --> 01:03:40,829
ahora ya sí

1508
01:03:40,829 --> 01:03:42,949
que me devuelva el nombre

1509
01:03:42,949 --> 01:03:44,889
del plato

1510
01:03:44,889 --> 01:03:46,409
más caro de todos

1511
01:03:46,409 --> 01:03:47,690
Porque ya que vengo

1512
01:03:47,690 --> 01:03:49,090
Pues me voy a dejar la pasta

1513
01:03:49,090 --> 01:03:56,139
Exacto

1514
01:03:56,139 --> 01:03:58,480
El que recomiendas a tus clientes

1515
01:03:58,480 --> 01:04:00,559
Devuélveme pues te recomiendo

1516
01:04:00,559 --> 01:04:02,760
Las gambas fritas

1517
01:04:02,760 --> 01:04:05,320
Por ejemplo

1518
01:04:05,320 --> 01:04:20,360
Venga y vamos a dejar estos métodos así por ahora

1519
01:04:20,360 --> 01:04:20,880
¿Vale?

1520
01:04:23,789 --> 01:04:26,530
Pues ala, os ponéis con ellos de aquí al viernes

1521
01:04:26,530 --> 01:04:30,630
Y el viernes nos vemos