1
00:00:00,000 --> 00:00:04,240
venga, pues vamos a ver

2
00:00:04,240 --> 00:00:05,960
lo que más o menos habéis hecho

3
00:00:05,960 --> 00:00:08,699
aquí de nuevo el problema es otro

4
00:00:08,699 --> 00:00:10,339
aquí el problema es

5
00:00:10,339 --> 00:00:12,679
venga, ya, hemos parado

6
00:00:12,679 --> 00:00:15,099
aquí el problema es otro, os tengo que contar

7
00:00:15,099 --> 00:00:17,160
sobre un conjunto

8
00:00:17,160 --> 00:00:18,820
de alumnos, sobre un conjunto

9
00:00:18,820 --> 00:00:20,839
de datos, siempre se cuenta sobre una sucesión

10
00:00:20,839 --> 00:00:22,839
de cosas, se cuenta en una sucesión

11
00:00:22,839 --> 00:00:24,199
este, este, este

12
00:00:24,199 --> 00:00:26,760
vale, pues aquí la sucesión de cosas en la que tengo

13
00:00:26,760 --> 00:00:28,660
que contar son mis alumnos

14
00:00:28,660 --> 00:00:33,020
Vale, pues tenemos que recorrer los alumnos para contar a aquellos que cumplen algo.

15
00:00:33,719 --> 00:00:39,159
Bueno, pues lo que yo tengo que recorrer es mi array de alumnos para contar a aquellos que cumplen algo.

16
00:00:39,520 --> 00:00:40,420
Luego esto es una cuenta.

17
00:00:41,060 --> 00:00:44,259
Luego, como esto es una cuenta, siempre va a implicar un contador.

18
00:00:45,600 --> 00:00:46,079
¿Vale?

19
00:00:46,859 --> 00:00:48,640
Bueno, ¿qué tengo que contar?

20
00:00:49,479 --> 00:00:50,659
Alumnos de mi lista.

21
00:00:51,280 --> 00:00:54,920
Pues tendremos que recorrer la lista, porque yo voy a contar alumnos de mi lista.

22
00:00:55,119 --> 00:00:56,979
Pues a recorrer la lista para contarlos.

23
00:00:56,979 --> 00:01:00,020
vale, pues recorremos la lista

24
00:01:00,020 --> 00:01:01,759
de esta manera

25
00:01:01,759 --> 00:01:03,020
que es un poco la más sencilla

26
00:01:03,020 --> 00:01:19,629
vale, pues con esto estamos recorriendo

27
00:01:19,629 --> 00:01:21,230
la lista, y ahora

28
00:01:21,230 --> 00:01:23,549
¿qué alumnos contamos? todos, no

29
00:01:23,549 --> 00:01:25,750
incrementamos

30
00:01:25,750 --> 00:01:27,730
cuenta, es decir, contamos

31
00:01:27,730 --> 00:01:31,870
incrementamos la cuenta, contamos

32
00:01:31,870 --> 00:01:32,890
solo

33
00:01:32,890 --> 00:01:35,450
los alumnos get i que cumplen algo

34
00:01:35,450 --> 00:01:36,310
solo eso

35
00:01:36,310 --> 00:01:39,790
vale, incrementamos la cuenta, solo los alumnos

36
00:01:39,790 --> 00:01:42,030
get i que cumplen algo, entonces este cont más más

37
00:01:42,030 --> 00:01:43,829
en realidad es condicionado

38
00:01:43,829 --> 00:01:45,969
a que el alumno get i cumpla algo

39
00:01:45,969 --> 00:01:47,849
¿vale? vale, pues ahora hay que pensar

40
00:01:47,849 --> 00:01:48,989
ya, pero ¿qué tiene que cumplir?

41
00:01:49,849 --> 00:01:51,010
pues tiene que cumplir

42
00:01:51,010 --> 00:01:53,530
que alguna de sus asignaturas

43
00:01:53,530 --> 00:01:55,349
sea igual que esta

44
00:01:55,349 --> 00:01:57,629
sus asignaturas a su vez son

45
00:01:57,629 --> 00:01:59,609
un array, a su vez son un array

46
00:01:59,609 --> 00:02:01,689
pues entonces tendremos que meternos

47
00:02:01,689 --> 00:02:03,189
en el array de asignaturas

48
00:02:03,189 --> 00:02:05,510
e ir uno por uno a ver si

49
00:02:05,510 --> 00:02:06,670
encontramos alguna

50
00:02:06,670 --> 00:02:08,629
que sea igual a la que me han dado

51
00:02:08,629 --> 00:02:11,150
pero no nos queda más remedio que meternos

52
00:02:11,150 --> 00:02:13,150
para ver si el alumno cumple esa condición

53
00:02:13,150 --> 00:02:14,870
nos tenemos que meter en el array de asignaturas

54
00:02:14,870 --> 00:02:17,409
porque su condición es que alguna de ellas

55
00:02:17,409 --> 00:02:18,090
sea igual

56
00:02:18,090 --> 00:02:21,090
bueno, pues no pasa nada, nos metemos en el array

57
00:02:21,090 --> 00:02:22,250
de asignaturas del alumno

58
00:02:22,250 --> 00:02:26,099
como es un for dentro de otro

59
00:02:26,099 --> 00:02:28,719
porque ahora estoy en el alumno de posición y, estoy dentro

60
00:02:28,719 --> 00:02:30,699
un for está dentro de otro

61
00:02:30,699 --> 00:02:32,039
estoy en el de posición y, estoy dentro

62
00:02:32,039 --> 00:02:35,139
pues será un for con otro índice, j o el que queramos

63
00:02:35,139 --> 00:02:36,680
y ahora

64
00:02:36,680 --> 00:02:38,300
¿qué colección estamos recorriendo?

65
00:02:38,300 --> 00:02:45,460
Estamos recorriendo la colección de asignaturas del alumno GetI.

66
00:02:45,979 --> 00:02:49,139
Esto es lo que estamos recorriendo.

67
00:02:50,620 --> 00:02:54,759
Estamos recorriendo la colección de asignaturas del GetI.

68
00:02:54,979 --> 00:02:56,539
Esta colección es la que recorremos.

69
00:02:57,639 --> 00:03:02,139
Luego esto será mientras sea menor que el tamaño, incrementando J.

70
00:03:03,000 --> 00:03:04,680
Y ahora aquí, ¿qué queremos hacer?

71
00:03:04,680 --> 00:03:09,960
Pues si resulta que la asignatura de posición J

72
00:03:09,960 --> 00:03:11,939
Estamos recorriendo este array

73
00:03:11,939 --> 00:03:15,060
Estamos recorriendo este array, esta lista

74
00:03:15,060 --> 00:03:17,479
Estamos recorriendo esta lista con índice J

75
00:03:17,479 --> 00:03:22,680
Bueno, pues si esta lista, la posición J en la que estoy

76
00:03:22,680 --> 00:03:26,979
Toda esta lista, la posición J

77
00:03:26,979 --> 00:03:32,629
Es igual a la asignatura que me han dado

78
00:03:32,629 --> 00:03:34,189
Pues ya puedo incrementar la cuenta

79
00:03:34,189 --> 00:03:35,889
Entonces

80
00:03:35,889 --> 00:03:39,090
Hola

81
00:03:39,090 --> 00:03:40,849
¿Te ha enviado el correo que te envié?

82
00:03:41,289 --> 00:03:43,069
Te he enviado 200.000 correos

83
00:03:43,069 --> 00:03:44,909
Pues es que Rosa, a mí me envío correos y no me llegan

84
00:03:44,909 --> 00:03:46,710
A ver

85
00:03:46,710 --> 00:03:49,430
Venga, seguimos

86
00:03:49,430 --> 00:03:51,189
Vale, pues entonces

87
00:03:51,189 --> 00:03:52,569
Esta asignatura

88
00:03:52,569 --> 00:03:54,990
La de posición J es un string

89
00:03:54,990 --> 00:03:57,469
Y tenemos que compararla con esta que es un string

90
00:03:57,469 --> 00:03:58,650
Luego comprar un string con otro

91
00:03:58,650 --> 00:03:59,550
Tiene que ser el equals

92
00:03:59,550 --> 00:04:01,949
Como ya sabéis, pues entonces aquí

93
00:04:01,949 --> 00:04:04,110
Obviamente habrá que poner un equals

94
00:04:04,110 --> 00:04:06,810
y cuál es así

95
00:04:06,810 --> 00:04:07,949
entonces si es igual

96
00:04:07,949 --> 00:04:09,969
pues la cuento

97
00:04:09,969 --> 00:04:12,050
¿vale?

98
00:04:12,469 --> 00:04:14,629
y cuando este for ya ha terminado

99
00:04:14,629 --> 00:04:15,789
ya he contado

100
00:04:15,789 --> 00:04:18,949
las apariciones de esa asignatura

101
00:04:18,949 --> 00:04:20,790
en el array de asignaturas

102
00:04:20,790 --> 00:04:22,670
de este alumno y además

103
00:04:22,670 --> 00:04:25,250
lo habré contado para todos los alumnos

104
00:04:25,250 --> 00:04:26,670
pero cuando este for

105
00:04:26,670 --> 00:04:28,310
ha terminado ya tendría la cuenta

106
00:04:28,310 --> 00:04:31,550
y la devuelvo

107
00:04:31,550 --> 00:04:32,910
¿vale? esta sería

108
00:04:32,910 --> 00:04:34,470
la primera versión

109
00:04:34,470 --> 00:04:37,269
vale, aquí lo único

110
00:04:37,269 --> 00:04:39,170
no vamos a empezar a retocarla para corregir mil cosas

111
00:04:39,170 --> 00:04:40,990
porque eso es volver a hacer lo mismo

112
00:04:40,990 --> 00:04:42,889
y otra vez, vale, verificarlo

113
00:04:42,889 --> 00:04:43,709
de la RAI y todo eso

114
00:04:43,709 --> 00:04:47,029
pero lo único aquí es el coste

115
00:04:47,029 --> 00:04:49,089
de lo que ocurre, claro, si cuando

116
00:04:49,089 --> 00:04:51,029
se hizo la matrícula, el método de matricular

117
00:04:51,029 --> 00:04:53,509
no está bien hecho, bien pulido

118
00:04:53,509 --> 00:04:55,129
y tú puedes matricular

119
00:04:55,129 --> 00:04:56,750
a un alumno de lo mismo tres veces

120
00:04:56,750 --> 00:04:58,910
le puedes matricular de lengua, luego de mates

121
00:04:58,910 --> 00:05:00,189
luego de lengua otra vez, luego de mates

122
00:05:00,189 --> 00:05:03,089
pues entonces te va a contar para un solo

123
00:05:03,089 --> 00:05:05,329
alumno, te la va a contar tres veces

124
00:05:05,329 --> 00:05:07,230
lengua, entonces te va a decir

125
00:05:07,230 --> 00:05:09,329
tú le pasas lengua y hay dos alumnos

126
00:05:09,329 --> 00:05:11,329
uno está matriculado dos veces de la misma

127
00:05:11,329 --> 00:05:12,970
y otro tres veces, te va a decir cinco

128
00:05:12,970 --> 00:05:14,370
te va a decir cinco

129
00:05:14,370 --> 00:05:16,829
claro, pero esa situación de nuevo

130
00:05:16,829 --> 00:05:18,930
¿cómo se resuelve? no es que esté bien o mal

131
00:05:18,930 --> 00:05:20,970
es que esa situación se resuelve

132
00:05:20,970 --> 00:05:23,189
en función de lo que el cliente quiera que ocurra

133
00:05:23,189 --> 00:05:24,949
entonces aquí

134
00:05:24,949 --> 00:05:26,509
lo normal sería

135
00:05:26,509 --> 00:05:30,889
que cuando uno, lo que has dicho tú antes

136
00:05:30,889 --> 00:05:32,670
que en el método de matrícula de alumno

137
00:05:32,670 --> 00:05:34,670
de asignaturas se verifique si ya está

138
00:05:34,670 --> 00:05:37,089
y si ya está no te matricula

139
00:05:37,089 --> 00:05:38,410
y te diga uno ya está matriculado

140
00:05:38,410 --> 00:05:40,550
entonces ya pues el resto de métodos

141
00:05:40,550 --> 00:05:41,610
no arrastran ese problema

142
00:05:41,610 --> 00:05:43,910
eso por un lado

143
00:05:43,910 --> 00:05:45,829
vale

144
00:05:45,829 --> 00:05:48,430
otra cosa que podemos hacer

145
00:05:48,430 --> 00:05:50,649
bueno todo esto

146
00:05:50,649 --> 00:05:52,709
de aquí, este for

147
00:05:52,709 --> 00:05:54,449
que va asignatura por asignatura

148
00:05:54,449 --> 00:05:56,329
para ver si encuentra una asignatura

149
00:05:56,329 --> 00:05:58,449
que sea igual a esta

150
00:05:58,449 --> 00:06:00,670
de así, este for de aquí

151
00:06:00,670 --> 00:06:02,329
es un rollo, en realidad

152
00:06:02,329 --> 00:06:04,089
la idea que recoge ese for es

153
00:06:04,089 --> 00:06:05,550
que

154
00:06:05,550 --> 00:06:08,050
este array de asignaturas

155
00:06:08,050 --> 00:06:09,930
tenga dentro esa asignatura

156
00:06:09,930 --> 00:06:11,610
que es una idea muy natural

157
00:06:11,610 --> 00:06:14,410
una cosa muy natural que uno puede

158
00:06:14,410 --> 00:06:16,389
querer necesitar hacer en una colección es

159
00:06:16,389 --> 00:06:18,329
que esta colección

160
00:06:18,329 --> 00:06:19,629
contenga esto

161
00:06:19,629 --> 00:06:22,629
es algo muy normal que uno puede querer hacer

162
00:06:22,629 --> 00:06:24,029
entonces lo podemos hacer a mano

163
00:06:24,029 --> 00:06:26,410
como lo hemos hecho nosotros, recorriéndolo y viendo

164
00:06:26,410 --> 00:06:27,189
si lo contiene

165
00:06:27,189 --> 00:06:29,610
pero ya para eso hay un método

166
00:06:29,610 --> 00:06:32,310
que es más cómodo

167
00:06:32,310 --> 00:06:34,209
que ese método ya era el for el dentro.

168
00:06:34,329 --> 00:06:35,689
El for no se ahorra, el for lo hace él.

169
00:06:36,290 --> 00:06:37,350
Le llamamos al método y ya está.

170
00:06:37,949 --> 00:06:39,290
¿Qué es el método? Pues contains.

171
00:06:39,829 --> 00:06:41,829
Si uno busca los métodos de list que hemos visto,

172
00:06:41,970 --> 00:06:43,569
pues rápidamente le llama a contains.

173
00:06:43,709 --> 00:06:46,170
Tiene pinta de que este método, por su propio nombre,

174
00:06:47,089 --> 00:06:52,389
me dice si una colección contiene un elemento concreto.

175
00:06:53,589 --> 00:06:54,730
Entonces, por ejemplo,

176
00:06:56,290 --> 00:06:59,750
si esto mismo lo quisiéramos hacer de otra manera.

177
00:06:59,750 --> 00:07:01,910
voy a

178
00:07:01,910 --> 00:07:04,129
se me ha vuelto a olvidar

179
00:07:04,129 --> 00:07:05,050
como era lo de

180
00:07:05,050 --> 00:07:06,470
ah no, así

181
00:07:06,470 --> 00:07:09,509
vale, vamos a hacer esto mismo de otra manera

182
00:07:09,509 --> 00:07:11,850
venga, pues vamos a recorrer

183
00:07:11,850 --> 00:07:13,569
la colección de alumnos, otra vez

184
00:07:13,569 --> 00:07:27,879
vale

185
00:07:27,879 --> 00:07:30,759
pues ahora, ¿qué queremos hacer con cada alumno?

186
00:07:31,199 --> 00:07:32,339
lo que queremos es ver

187
00:07:32,339 --> 00:07:35,199
si el array de asignaturas de este alumno

188
00:07:35,199 --> 00:07:37,060
si queremos

189
00:07:37,060 --> 00:07:37,639
lo que queremos

190
00:07:37,639 --> 00:07:41,379
lo que queremos es ver si el array de asignaturas

191
00:07:41,379 --> 00:07:42,120
de este alumno

192
00:07:42,120 --> 00:07:45,319
contiene la asignatura asig

193
00:07:45,319 --> 00:07:47,360
si el array de asignaturas

194
00:07:47,360 --> 00:07:48,120
la contiene

195
00:07:48,120 --> 00:07:49,699
eso es lo que queremos hacer

196
00:07:49,699 --> 00:07:52,959
bueno, pues buscando los métodos de lista

197
00:07:52,959 --> 00:07:54,860
vemos que

198
00:07:54,860 --> 00:08:03,240
get asignaturas

199
00:08:03,240 --> 00:08:04,360
al ser una lista

200
00:08:04,360 --> 00:08:11,949
vale, o sea, esto es

201
00:08:11,949 --> 00:08:14,029
la lista de asignaturas

202
00:08:14,029 --> 00:08:15,189
del alumno, es esta

203
00:08:15,189 --> 00:08:17,689
pues si miramos a ver los métodos

204
00:08:17,689 --> 00:08:20,449
que me ofrece la interfaz list

205
00:08:20,449 --> 00:08:22,129
vemos que me ofrece

206
00:08:22,129 --> 00:08:24,410
el método contains que me dice

207
00:08:24,410 --> 00:08:26,089
pásame un objeto

208
00:08:26,089 --> 00:08:28,189
concreto, uno, y yo te

209
00:08:28,189 --> 00:08:29,990
digo si ese objeto está

210
00:08:29,990 --> 00:08:32,049
en la lista, que es justo

211
00:08:32,049 --> 00:08:34,190
lo que queremos hacer, pasarle un string

212
00:08:34,190 --> 00:08:36,210
la asignatura y ver si

213
00:08:36,210 --> 00:08:38,129
ese objeto string está

214
00:08:38,129 --> 00:08:40,210
en la lista de string, está en la

215
00:08:40,210 --> 00:08:42,210
lista, es justo, pues es justo lo que queríamos hacer

216
00:08:42,210 --> 00:08:44,009
pues hala, llamo al método

217
00:08:44,009 --> 00:08:46,009
y ya que se preocupe

218
00:08:46,009 --> 00:08:47,889
él de hacer el for dentro

219
00:08:47,889 --> 00:08:50,090
lo que sea, porque mi código va a quedar más claro

220
00:08:50,090 --> 00:08:53,750
y así me queda

221
00:08:53,750 --> 00:08:56,110
más bonito, no es que sea más eficiente

222
00:08:56,110 --> 00:08:57,590
es más bonito

223
00:08:57,590 --> 00:09:00,029
y me falta aquí cerrar

224
00:09:00,029 --> 00:09:01,750
el if

225
00:09:01,750 --> 00:09:13,159
pues este queda más claro

226
00:09:13,159 --> 00:09:15,440
este código queda más claro que el de arriba

227
00:09:15,440 --> 00:09:20,440
contains no lo tiene

228
00:09:20,440 --> 00:09:25,639
vale

229
00:09:25,639 --> 00:09:26,340
entonces

230
00:09:26,340 --> 00:09:29,080
aquí queda más claro

231
00:09:29,080 --> 00:09:31,580
vamos alumno por alumno, para cada alumno

232
00:09:31,580 --> 00:09:33,399
su lista de asignaturas

233
00:09:33,399 --> 00:09:36,059
si su lista de asignaturas que es de string

234
00:09:36,059 --> 00:09:38,440
contiene este objeto string

235
00:09:38,440 --> 00:09:40,259
entonces la lista tiene que ser

236
00:09:40,259 --> 00:09:41,919
de un tipo de dato igual que el que yo le paso

237
00:09:41,919 --> 00:09:43,440
porque lo tiene que contener

238
00:09:43,440 --> 00:09:45,919
pues si lo contiene, cuento

239
00:09:45,919 --> 00:09:47,700
ese alumno contiene la asignatura

240
00:09:47,700 --> 00:09:56,299
y no solo es más claro

241
00:09:56,299 --> 00:09:58,679
más el que ve el código

242
00:09:58,679 --> 00:10:00,379
lo entiende mejor que arriba

243
00:10:00,379 --> 00:10:02,980
el de arriba ve dos foranidades y ya se vuelve loco

244
00:10:02,980 --> 00:10:04,820
el de abajo lo ve más claro

245
00:10:04,820 --> 00:10:06,080
y dice, ah, si lo contiene

246
00:10:06,080 --> 00:10:07,600
pues ya sé lo que estás contando

247
00:10:07,600 --> 00:10:09,940
lo entiende mejor el código

248
00:10:09,940 --> 00:10:11,039
podría ser lo que estás contando

249
00:10:11,039 --> 00:10:16,519
no solo es más claro, más legible

250
00:10:16,519 --> 00:10:18,220
uno entiende mejor lo que está haciendo esto

251
00:10:18,220 --> 00:10:20,639
sino que nos ahorramos al problema ese que decíamos

252
00:10:20,639 --> 00:10:22,919
el método contains te dice

253
00:10:22,919 --> 00:10:25,080
si lo contiene, pero te le da igual

254
00:10:25,080 --> 00:10:26,899
si lo contiene 1, 2, 3, 4 veces

255
00:10:26,899 --> 00:10:29,399
te devuelve true si lo contiene

256
00:10:29,399 --> 00:10:30,259
y false si no

257
00:10:30,259 --> 00:10:32,779
con lo cual este

258
00:10:32,779 --> 00:10:34,440
no te cuenta por duplicado

259
00:10:34,440 --> 00:10:37,159
las asignaturas que aparezcan 2, 3 veces

260
00:10:37,159 --> 00:10:38,899
en cada alumno, te las cuenta por duplicado

261
00:10:38,899 --> 00:10:41,299
esa es la ventaja que tiene respecto al de arriba

262
00:10:41,299 --> 00:10:43,220
si tienes asignatura

263
00:10:43,220 --> 00:10:44,919
sea una, dos, tres, cuatro veces

264
00:10:44,919 --> 00:10:48,840
te devuelve true

265
00:10:48,840 --> 00:10:50,620
y en ese caso lo cuentas

266
00:10:50,620 --> 00:10:57,629
pero claro, el contains

267
00:10:57,629 --> 00:11:00,190
de nuevo, igual que el remove

268
00:11:00,190 --> 00:11:01,750
utiliza el equals

269
00:11:01,750 --> 00:11:04,669
porque contains despliega un for el dentro

270
00:11:04,669 --> 00:11:06,610
despliega un for el dentro

271
00:11:06,610 --> 00:11:08,809
y se pone a recordar asignatura por asignatura

272
00:11:08,809 --> 00:11:10,629
a ver si encuentra alguna

273
00:11:10,629 --> 00:11:12,809
que sea equals a esta

274
00:11:12,809 --> 00:11:14,889
es decir, lo mismo que hemos hecho arriba

275
00:11:14,889 --> 00:11:17,009
nosotros, y en cuanto encuentre alguna

276
00:11:17,009 --> 00:11:17,669
dice true

277
00:11:17,669 --> 00:11:20,110
entonces usa el equals

278
00:11:20,110 --> 00:11:23,230
con lo cual tiene que estar el equals correctamente

279
00:11:23,230 --> 00:11:24,750
implementado en la clase

280
00:11:24,750 --> 00:11:26,850
a la que pertenezca este objeto

281
00:11:26,850 --> 00:11:28,250
pero en este caso es string

282
00:11:28,250 --> 00:11:30,429
en string ya está el equals, no hay problema

283
00:11:30,429 --> 00:11:33,250
pero cuidado

284
00:11:33,250 --> 00:11:35,129
si usamos el contains

285
00:11:35,129 --> 00:11:36,889
con listas de clases nuestras

286
00:11:36,889 --> 00:11:39,009
por ejemplo, como alumno

287
00:11:39,009 --> 00:11:42,539
imaginaos, vamos a hacer un método

288
00:11:42,539 --> 00:11:44,240
ahora, que es

289
00:11:44,240 --> 00:11:46,480
decir si está matriculado o no, me dan un número

290
00:11:46,480 --> 00:11:48,000
de matrícula y yo tengo que decir si está

291
00:11:48,000 --> 00:11:50,460
un nombre, perdón, un nombre

292
00:11:50,460 --> 00:11:52,500
no, un nombre no

293
00:11:52,500 --> 00:11:54,220
porque el equals va por número de matrícula

294
00:11:54,220 --> 00:11:56,480
tendríamos que hacer otro, me dan un número de matrícula

295
00:11:57,039 --> 00:11:58,539
y yo tengo que ver

296
00:11:58,539 --> 00:12:00,799
si ese número de matrícula está, está en mi lista de alumnos

297
00:12:00,799 --> 00:12:02,100
o si no es, vale

298
00:12:02,100 --> 00:12:06,659
pues entonces vamos a hacer este método

299
00:12:06,659 --> 00:12:16,409
existe

300
00:12:16,409 --> 00:12:18,309
matrícula, le vamos a llamar al método

301
00:12:18,309 --> 00:12:20,750
y le pasamos

302
00:12:20,750 --> 00:12:22,570
un número

303
00:12:22,570 --> 00:12:24,750
de matrícula. Y hay que decir si ese número de matrícula

304
00:12:24,750 --> 00:12:25,370
existe o no.

305
00:12:30,350 --> 00:12:31,409
¿Vale? Este requisito

306
00:12:31,409 --> 00:12:33,409
podría tener sentido porque es

307
00:12:33,409 --> 00:12:35,250
una API que se llama, o sea, una

308
00:12:35,250 --> 00:12:36,870
funcionalidad que yo ofrezco fuera

309
00:12:36,870 --> 00:12:39,370
porque se puede, imaginaos que se pueden pedir

310
00:12:39,370 --> 00:12:41,149
ayudas si tú estás matriculado en un centro.

311
00:12:42,169 --> 00:12:43,370
Entonces tú das, sí, estoy

312
00:12:43,370 --> 00:12:44,750
matriculado, este es mi número de matrícula.

313
00:12:45,330 --> 00:12:47,409
Entonces, pues esta es una forma de verificar que no te has

314
00:12:47,409 --> 00:12:49,649
inventado el número, que estás realmente

315
00:12:49,649 --> 00:12:51,409
matriculado en un centro. Entonces el que

316
00:12:51,409 --> 00:12:53,470
quiera verificarlo llama a este método y le dice

317
00:12:53,470 --> 00:12:55,250
sí, el número de matrícula es válido.

318
00:12:55,509 --> 00:12:57,490
¿Vale? Es una funcionalidad que tiene sentido.

319
00:12:57,690 --> 00:12:59,110
El número de matrículas es válido.

320
00:12:59,110 --> 00:13:01,110
Está en el...

321
00:13:01,889 --> 00:13:03,570
¿Vale? Pues con el contains

322
00:13:03,570 --> 00:13:05,090
ahora podríamos hacerlo

323
00:13:05,090 --> 00:13:06,830
muy fácil. No tendremos que recorrer

324
00:13:06,830 --> 00:13:08,909
el for

325
00:13:08,909 --> 00:13:10,850
sin el contains lo haríamos así, ¿verdad?

326
00:13:11,889 --> 00:13:12,490
Haríamos

327
00:13:12,490 --> 00:13:14,490
un boolean

328
00:13:14,490 --> 00:13:16,769
está, inicialmente

329
00:13:16,769 --> 00:13:22,879
vimos que no está. Y ahora

330
00:13:22,879 --> 00:13:24,639
recorremos todos los alumnos

331
00:13:24,639 --> 00:13:26,940
y en cuanto encontremos

332
00:13:26,940 --> 00:13:29,340
uno cuya matrícula es ese, cambiamos el boolean.

333
00:13:29,580 --> 00:14:09,970
Pues aquí haríamos, si alumnos.getI.getNúmeroDeMatrícula es igual que el número de matrícula que me acaban de dar, la paso abajo, pues entonces ya sé que está.

334
00:14:12,039 --> 00:14:13,240
Entonces lo cambio a true.

335
00:14:16,460 --> 00:14:24,159
De partida, sumo que no está, recorro los alumnos, en cuanto encuentro uno cuyo número de matrícula coincide, está igual a true.

336
00:14:24,159 --> 00:14:26,799
Y si no quiero que el for se esté hasta el infinito

337
00:14:26,799 --> 00:14:29,539
Pues puedo añadirle esto

338
00:14:29,539 --> 00:14:31,919
Mientras no lo haya encontrado

339
00:14:31,919 --> 00:14:35,610
¿Verdad?

340
00:14:36,750 --> 00:14:38,649
Y así nos sigue hasta el infinito el bucle

341
00:14:38,649 --> 00:14:44,590
Así para que se vea más pegado

342
00:14:44,590 --> 00:14:47,409
¿Vale? Recorro los alumnos

343
00:14:47,409 --> 00:14:49,789
Mientras no haya llegado al final

344
00:14:49,789 --> 00:14:51,769
Y no lo haya encontrado

345
00:14:51,769 --> 00:14:54,070
¿Este alumno coincide?

346
00:14:54,429 --> 00:14:55,629
Sí, ah pues ya está

347
00:14:55,629 --> 00:14:57,509
Esta es igual a true

348
00:14:57,509 --> 00:14:59,389
el for cuando vuelva arriba

349
00:14:59,389 --> 00:15:00,370
ya va a salir

350
00:15:00,370 --> 00:15:02,470
vale, y ahora ya

351
00:15:02,470 --> 00:15:06,629
existe, bueno este

352
00:15:06,629 --> 00:15:08,529
lo natural sería que volviera un boolean

353
00:15:08,529 --> 00:15:10,570
este método

354
00:15:10,570 --> 00:15:12,450
volvería un boolean y ahora aquí

355
00:15:12,450 --> 00:15:16,909
devolveríamos así

356
00:15:16,909 --> 00:15:17,889
por ejemplo

357
00:15:17,889 --> 00:15:20,129
vale

358
00:15:20,129 --> 00:15:25,220
esta sería una versión sin contains

359
00:15:25,220 --> 00:15:25,820
y sin nada

360
00:15:25,820 --> 00:15:27,000
vale

361
00:15:27,000 --> 00:15:31,259
de nuevo aquí lo que estamos en realidad

362
00:15:31,259 --> 00:15:33,200
conceptualmente lo que estamos

363
00:15:33,200 --> 00:15:35,019
haciendo es ver si hay

364
00:15:35,019 --> 00:15:37,299
si existe un alumno

365
00:15:37,299 --> 00:15:39,039
tal en la colección

366
00:15:39,039 --> 00:15:40,919
es lo que estamos viendo, si existe un alumno de

367
00:15:40,919 --> 00:15:43,259
la colección, ver si está

368
00:15:43,259 --> 00:15:44,159
si lo contiene

369
00:15:44,159 --> 00:15:46,879
es lo que estamos haciendo, pues para eso es el método

370
00:15:46,879 --> 00:15:48,940
contains, para ver si una colección contiene

371
00:15:48,940 --> 00:15:51,179
algo, pues entonces

372
00:15:51,179 --> 00:15:53,440
esto mismo

373
00:15:53,440 --> 00:15:59,340
lo podríamos hacer

374
00:15:59,340 --> 00:16:01,139
con el contains en una sola línea

375
00:16:01,139 --> 00:16:05,220
más cómodo, si alumnos

376
00:16:05,220 --> 00:16:06,600
la colección

377
00:16:06,600 --> 00:16:09,000
alumnos contiene

378
00:16:09,000 --> 00:16:12,620
¿qué contiene la conación alumno?

379
00:16:13,179 --> 00:16:14,539
pues un alumno con

380
00:16:14,539 --> 00:16:16,500
número de matrícula S

381
00:16:16,500 --> 00:16:18,500
entonces

382
00:16:18,500 --> 00:16:20,600
como no tengo un constructor solo con número de

383
00:16:20,600 --> 00:16:21,240
matrícula

384
00:16:21,240 --> 00:16:24,620
voy a hacerme el alumno auxiliar aquí arriba

385
00:16:24,620 --> 00:16:35,330
aux.set

386
00:16:35,950 --> 00:16:59,000
vale, pues aquí no he hecho

387
00:16:59,000 --> 00:17:00,840
ningún for, el for ya lo hace dentro

388
00:17:00,840 --> 00:17:02,960
con des, no es que nos lo evitemos, ya lo hará

389
00:17:02,960 --> 00:17:05,000
dentro él, que hace este método

390
00:17:05,000 --> 00:17:07,220
se pone a recorrer esta colección

391
00:17:07,220 --> 00:17:09,279
y en cuanto

392
00:17:09,279 --> 00:17:11,180
encuentra un objeto

393
00:17:11,180 --> 00:17:12,940
en esta colección igual

394
00:17:12,940 --> 00:17:14,619
que este, devuelve true

395
00:17:14,619 --> 00:17:17,000
en cuanto encuentra uno igual que este

396
00:17:17,000 --> 00:17:19,039
devuelve true, repito

397
00:17:19,039 --> 00:17:20,940
el context es como el remove, que en cuanto

398
00:17:20,940 --> 00:17:22,460
encontraba uno igual lo eliminaba

399
00:17:22,460 --> 00:17:24,799
pues este en cuanto encuentra uno igual

400
00:17:24,799 --> 00:17:25,819
devuelve true

401
00:17:25,819 --> 00:17:28,779
y encontrar uno igual significa

402
00:17:28,779 --> 00:17:30,740
hacer el equals todo el rato de este

403
00:17:30,740 --> 00:17:32,700
con cada uno de los de la colección

404
00:17:32,700 --> 00:17:33,420
hacer el equals

405
00:17:33,420 --> 00:17:36,599
y como el equals está basado en el número de matrícula

406
00:17:36,599 --> 00:17:38,799
en cuanto encuentre

407
00:17:38,799 --> 00:17:40,900
uno con el número de matrícula igual que este

408
00:17:40,900 --> 00:17:42,279
ya devuelve el proof

409
00:17:42,279 --> 00:17:46,079
¿vale? pero esto solo tiene sentido

410
00:17:46,079 --> 00:17:47,480
si en alumno

411
00:17:47,480 --> 00:17:50,059
tenemos efectivamente un equal

412
00:17:50,059 --> 00:17:50,440
hecho

413
00:17:50,440 --> 00:17:53,140
con número de matrícula

414
00:17:53,140 --> 00:17:55,980
porque si no lo tenemos hecho

415
00:17:55,980 --> 00:17:57,759
la igualdad

416
00:17:57,759 --> 00:17:59,619
para contains entre

417
00:17:59,619 --> 00:18:01,660
aux y alumnos es que sea

418
00:18:01,660 --> 00:18:03,980
idéntico el mismo, la misma referencia de memoria

419
00:18:03,980 --> 00:18:05,619
y es imposible, este lo acabamos de crear

420
00:18:05,619 --> 00:18:08,019
no tiene nada que ver con la lista

421
00:18:08,019 --> 00:18:09,960
la igualdad que nos interesa

422
00:18:09,960 --> 00:18:11,779
es que el número de matrícula de este sea igual que este

423
00:18:11,779 --> 00:18:13,920
o que este o que este, luego eso hay que hacerlo en el equal

424
00:18:13,920 --> 00:18:16,869
¿vale?

425
00:18:21,420 --> 00:18:23,359
entonces hombre, aquí ya podríamos

426
00:18:23,359 --> 00:18:24,140
directamente

427
00:18:24,140 --> 00:18:27,480
es que todo esto de arriba

428
00:18:27,480 --> 00:18:29,539
incluso va a ser

429
00:18:29,539 --> 00:18:31,420
más cómodo si quitamos

430
00:18:31,420 --> 00:18:33,759
todo esto, hasta nos sobrearía

431
00:18:33,759 --> 00:18:35,440
y devolvemos

432
00:18:35,440 --> 00:18:36,980
directamente, ¿verdad?

433
00:18:39,140 --> 00:18:39,539
retun

434
00:18:39,539 --> 00:18:40,700
alumnos.contains

435
00:18:40,700 --> 00:18:42,480
y nos queda

436
00:18:42,480 --> 00:18:48,230
más sencillo

437
00:18:48,230 --> 00:18:49,589
devuelve

438
00:18:49,589 --> 00:18:51,650
alumnos.contains este

439
00:18:51,650 --> 00:18:54,170
devolverá true si lo contiene

440
00:18:54,170 --> 00:18:55,869
devolverá false si no

441
00:18:55,869 --> 00:18:58,150
por ejemplo

442
00:18:58,150 --> 00:19:00,829
aquí ya sí que es una tontería

443
00:19:00,829 --> 00:19:02,789
hacerse el boolean porque es que este ya

444
00:19:02,789 --> 00:19:03,990
me devuelve true

445
00:19:03,990 --> 00:19:06,950
si esta colección contiene uno igual a este

446
00:19:06,950 --> 00:19:08,769
me devuelve false si no

447
00:19:08,769 --> 00:19:16,420
bueno pues estos son un poco los

448
00:19:16,420 --> 00:19:17,299
métodos

449
00:19:17,299 --> 00:19:19,440
con los que se trabajan

450
00:19:19,440 --> 00:19:21,559
con las listas, pues el añadir

451
00:19:21,559 --> 00:19:22,900
obviamente para añadir

452
00:19:22,900 --> 00:19:25,079
remove para borrar, ojo

453
00:19:25,079 --> 00:19:27,279
con el equals, el remove

454
00:19:27,279 --> 00:19:29,220
borra cuando encuentra uno igual

455
00:19:29,220 --> 00:19:31,359
según lo que diga el equals

456
00:19:31,359 --> 00:19:33,059
de la clase a la que pertenecen

457
00:19:33,059 --> 00:19:35,460
entonces ese equals tienes tú que haberlo implementado

458
00:19:35,460 --> 00:19:37,000
para que la igualdad sea la que te interesa

459
00:19:37,000 --> 00:19:38,960
el contains

460
00:19:38,960 --> 00:19:41,220
lo acabamos de decir, el get

461
00:19:41,220 --> 00:19:42,599
para recuperar por posición

462
00:19:42,599 --> 00:19:45,180
el index of, pues para ver en que

463
00:19:45,180 --> 00:19:47,119
posición está un objeto, pues son

464
00:19:47,119 --> 00:19:49,519
más o menos los métodos con los que trabajamos

465
00:19:49,519 --> 00:19:51,380
y así podemos guardar objetos

466
00:19:51,380 --> 00:19:53,079
de forma muy fácil y trabajar con ellos

467
00:19:53,079 --> 00:19:53,779
de forma muy fácil.

468
00:19:55,119 --> 00:19:57,279
Y ya la complejidad está envuelta dentro

469
00:19:57,279 --> 00:19:59,380
de los métodos, dentro está ya envuelta la complejidad,

470
00:19:59,519 --> 00:20:01,299
pero el uso es muy

471
00:20:01,299 --> 00:20:02,180
sencillo.

472
00:20:05,220 --> 00:20:05,359
¿Vale?

473
00:20:09,390 --> 00:20:10,210
Vale, pues

474
00:20:10,210 --> 00:20:13,730
vamos a dejar plantear un ejercicio para que

475
00:20:13,730 --> 00:20:15,690
antes de empezar con otra

476
00:20:15,690 --> 00:20:17,490
cosa, que no...

477
00:20:17,490 --> 00:20:19,809
para que asentéis y poseéis un poco

478
00:20:19,809 --> 00:20:27,150
de esto. A ver,

479
00:20:27,150 --> 00:23:20,140
A ver. Vale, pues de esto de aquí, que tenéis ya la virtual. Vale, para que sea parecido a esto, ¿vale? Este en lugar de asignaturas, el 3, trabaja con profesores, ¿vale?

480
00:23:20,140 --> 00:23:22,960
dos clases

481
00:23:22,960 --> 00:23:24,859
el profesor tiene una lista de alumnos

482
00:23:24,859 --> 00:23:26,700
entonces

483
00:23:26,700 --> 00:23:28,640
aquí todo listas

484
00:23:28,640 --> 00:23:30,380
aquí dice una lista y

485
00:23:30,380 --> 00:23:32,680
en el main se guardarán los profesores en un set

486
00:23:32,680 --> 00:23:34,220
no, todo listas

487
00:23:34,220 --> 00:23:35,819
vale, todo listas

488
00:23:35,819 --> 00:23:40,119
entonces, hace de esto

489
00:23:40,119 --> 00:23:43,140
pero lo que

490
00:23:43,140 --> 00:23:45,119
dice en la clase main se guardará el conjunto

491
00:23:45,119 --> 00:23:46,960
de profesores en un set, no, se guardará

492
00:23:46,960 --> 00:23:48,420
en una lista también, en otra lista

493
00:23:48,420 --> 00:23:54,119
vale, pues venga, el 3 de esa hoja

494
00:23:54,119 --> 00:23:57,920
que es muy similar a lo que hemos visto

495
00:23:57,920 --> 00:23:59,559
pero con otros ejemplos para

496
00:23:59,559 --> 00:24:02,559
para ver si queda claro

497
00:24:02,559 --> 00:24:04,259
pues este 3, ahora, ¿vale?

498
00:26:26,809 --> 00:26:27,809
Gracias.

499
00:27:07,460 --> 00:27:08,460
Gracias.

500
00:27:43,380 --> 00:27:44,380
Gracias.

501
00:28:13,380 --> 00:28:14,380
Gracias.

502
00:29:37,660 --> 00:29:38,660
Gracias.

503
00:30:22,500 --> 00:30:23,500
Gracias.

504
00:34:09,559 --> 00:34:10,559
Gracias.

505
00:36:01,420 --> 00:36:02,420
Gracias.

506
00:36:31,420 --> 00:36:32,420
Gracias.

507
00:37:01,420 --> 00:37:02,420
Gracias.

508
00:37:31,420 --> 00:37:32,420
Gracias.

509
00:38:01,420 --> 00:38:02,420
Gracias.

510
00:38:31,420 --> 00:39:01,400
No, no, no.

511
00:39:01,420 --> 00:39:02,420
Gracias.

512
00:39:31,420 --> 00:39:32,420
Gracias.

513
00:40:01,420 --> 00:40:02,420
Gracias.

514
00:40:31,420 --> 00:40:32,420
Gracias.

515
00:41:01,420 --> 00:41:02,420
Gracias.

516
00:41:31,420 --> 00:41:32,420
Gracias.

517
00:42:01,420 --> 00:42:03,420
¡Gracias!

518
00:42:31,420 --> 00:42:34,300
que pensaba yo que nos quedaba una hora entera

519
00:42:34,300 --> 00:42:35,340
de clase a las dos y media

520
00:42:35,340 --> 00:42:38,219
y ahora una y treinta y cinco

521
00:42:38,219 --> 00:42:55,909
a ver, pues ya lo estaba hablando

522
00:42:55,909 --> 00:42:56,530
con este chaval

523
00:42:56,530 --> 00:43:01,050
pero a ver, el uso es el mismo

524
00:43:01,050 --> 00:43:02,289
y no lo conozco por la marca

525
00:43:02,289 --> 00:43:05,230
así que no incorpora

526
00:43:05,230 --> 00:43:06,429
nada más que unos cuantos matices

527
00:43:06,429 --> 00:43:07,050
nada más

528
00:43:12,389 --> 00:43:39,869
pero es que ya veréis

529
00:43:39,869 --> 00:43:40,769
que es lo mismo

530
00:43:40,769 --> 00:43:41,429
da lo mismo

531
00:43:41,429 --> 00:43:43,750
usar un set que usar un disc

532
00:43:43,750 --> 00:43:44,389
da lo mismo

533
00:43:44,389 --> 00:43:49,250
no sufras de verdad porque

534
00:44:03,650 --> 00:44:05,389
uy no veo