1
00:00:00,820 --> 00:00:09,890
venga vamos a seguir con lo que nos faltaba pero bueno ahora ya sí que se

2
00:00:09,890 --> 00:00:13,929
hace siempre lo mismo todo el rato mostrar porcentaje de aprobados de un

3
00:00:13,929 --> 00:00:20,609
profesor bueno pues nada vamos a hacer el método

4
00:00:20,929 --> 00:00:24,609
mostrar porcentaje de aprobados en lugar de mostrarlo por consola vamos a hacer

5
00:00:24,609 --> 00:00:29,710
que lo devuelva como valor de retorno así la aplicación que decida si lo

6
00:00:29,710 --> 00:00:39,520
muestra, lo lleva a una interfaz gráfica, lo que le dé la gana. Porcentaje de aprobados,

7
00:00:39,619 --> 00:00:46,759
¿de quién? De un profe, nos han dicho. Pues entonces ese será nuestro dato, el NIF del

8
00:00:46,759 --> 00:00:53,420
profesor. ¿Dónde están nuestros datos? Nuestros datos están en una cajita de profesores,

9
00:00:53,600 --> 00:01:08,769
¿qué hay que pasar? Pues este muy fácil. De nuevo tendremos que localizar al profe,

10
00:01:08,769 --> 00:01:14,069
Vamos a hacer una suma acumulativa, vamos a localizar al profesor, pues ya está.

11
00:01:14,530 --> 00:01:21,980
Vamos a recorrer con un for each nuestra caja.

12
00:01:22,420 --> 00:01:26,079
Un rollo, si esto fuera un diccionario, un mapa, pues sería más fácil,

13
00:01:26,079 --> 00:01:31,060
pero como no lo es, pues vamos en nuestra cajita dato por dato.

14
00:01:31,060 --> 00:01:44,120
Profesores, y ahora, si el profesor en el que estamos, su NIF es igual al NIF del profesor objetivo,

15
00:01:45,120 --> 00:01:54,319
ahora ya es cuando empezamos la suma acumulativa, para calcular el porcentaje.

16
00:01:54,319 --> 00:01:59,840
vamos a contar los aprobados

17
00:01:59,840 --> 00:02:06,120
y ahora ya pues ya está

18
00:02:06,120 --> 00:02:08,020
lo de siempre, vamos a recorrer la lista

19
00:02:08,020 --> 00:02:10,219
entonces para variar

20
00:02:10,219 --> 00:02:11,939
un poco, para variar, vamos a recorrer

21
00:02:11,939 --> 00:02:12,759
la lista con

22
00:02:12,759 --> 00:02:15,800
en lugar de con un for each, con un for de índice

23
00:02:15,800 --> 00:02:16,659
porque la lista

24
00:02:16,659 --> 00:02:18,900
getAlumnos es un

25
00:02:18,900 --> 00:02:21,080
list, entonces

26
00:02:21,080 --> 00:02:23,699
vamos a recorrer para variar con un

27
00:02:23,699 --> 00:02:24,659
for de índice

28
00:02:24,659 --> 00:02:27,780
a menor que

29
00:02:27,780 --> 00:02:32,740
p.getalumnos.size

30
00:02:32,740 --> 00:02:38,750
vale, pues vamos a recorrer esta lista

31
00:02:38,750 --> 00:02:45,729
si p.getalumnos.geti

32
00:02:45,729 --> 00:02:47,389
el alumno en la posición i

33
00:02:47,389 --> 00:02:49,710
resulta que su nota

34
00:02:49,710 --> 00:02:54,849
es mayor o igual que 5

35
00:02:54,849 --> 00:02:57,270
pues ala, el alumno está aprobado

36
00:02:57,270 --> 00:02:58,270
lo contamos

37
00:02:58,270 --> 00:03:02,050
como siempre hemos hecho, ya está

38
00:03:02,050 --> 00:03:03,449
cuando este fuera terminado

39
00:03:03,449 --> 00:03:06,490
ya tenemos el porcentaje de aprobados

40
00:03:06,490 --> 00:03:08,629
que podremos devolver así a lo bestia

41
00:03:08,629 --> 00:03:10,590
con este

42
00:03:10,590 --> 00:03:12,189
retun

43
00:03:12,189 --> 00:03:16,069
que será

44
00:03:16,069 --> 00:03:17,750
pues

45
00:03:17,750 --> 00:03:19,409
cont por

46
00:03:19,409 --> 00:03:22,629
100

47
00:03:22,629 --> 00:03:24,889
entre

48
00:03:24,889 --> 00:03:28,430
peguetalumnos

49
00:03:28,430 --> 00:03:40,280
.6, vale, pues ya está

50
00:03:40,280 --> 00:03:43,659
ese es el porcentaje de alumnos aprobados del total

51
00:03:43,659 --> 00:03:48,360
entonces de nuevo, podríamos no haber salido por aquí

52
00:03:48,360 --> 00:03:51,479
del método, podríamos no haber salido por aquí

53
00:03:51,479 --> 00:03:56,960
porque nunca hubiéramos entrado en este if

54
00:03:56,960 --> 00:04:00,300
nunca hubiéramos entrado aquí, con lo cual si nunca hubiéramos entrado en este if

55
00:04:00,300 --> 00:04:04,120
porque el profesor no existe, pues no tendríamos la cuenta

56
00:04:04,120 --> 00:04:07,060
Entonces aquí tenemos que decidir qué devolvemos en este caso.

57
00:04:08,120 --> 00:04:10,879
Bueno, pues ala, podríamos hacer devolver cero.

58
00:04:11,419 --> 00:04:18,079
Esto se queda un poco confuso en realidad, porque cuando el método devuelva cero, ¿qué significa?

59
00:04:18,199 --> 00:04:23,819
¿Que el profesor tiene cero aprobados o que no hemos encontrado al profesor?

60
00:04:25,980 --> 00:04:32,060
Se queda un poquito confuso, entonces lo mejor sería devolver, por ejemplo, menos uno,

61
00:04:32,060 --> 00:04:33,939
porque menos uno no es un porcentaje válido.

62
00:04:34,120 --> 00:04:42,560
Entonces ahora ya este método devuelve menos uno si no hemos encontrado al profesor y si lo hemos encontrado devuelve su porcentaje de aprobados, que podría ser cero.

63
00:04:43,980 --> 00:04:56,620
Entonces esto siempre en un caso real, pues lo documentaríamos, claro, y diríamos, oye, avisaríamos menos uno si no existe el profe.

64
00:04:56,620 --> 00:04:59,660
y así el que luego usa nuestro método

65
00:04:59,660 --> 00:05:02,300
pues ya se le va a desplegar esta ayuda

66
00:05:02,300 --> 00:05:04,939
y dice, ah, vale, si me devuelves menos uno

67
00:05:04,939 --> 00:05:06,199
es que el profesor no existe

68
00:05:06,199 --> 00:05:08,379
entonces ya puedo avisar, no existe el profesor

69
00:05:08,379 --> 00:05:13,040
vale, pues nada, porcentaje de aprobados

70
00:05:13,040 --> 00:05:14,420
listo, si no me equivoco

71
00:05:14,420 --> 00:05:18,939
damos un alumno

72
00:05:18,939 --> 00:05:21,540
dime los nombres de los profes que lo tienen

73
00:05:21,540 --> 00:05:22,519
pues venga

74
00:05:22,519 --> 00:05:26,420
un método, vamos a hacer una cosa

75
00:05:26,420 --> 00:05:30,680
que los nombres de los profes que lo tienen, pues lo vamos a meter

76
00:05:30,680 --> 00:05:34,879
en una lista. Aquí va a ir la lista de los nombres

77
00:05:34,879 --> 00:05:37,860
de todos los profesores que lo tienen. Pues ya está.

78
00:05:40,420 --> 00:05:41,879
Profesores de un alumno.

79
00:05:43,600 --> 00:05:46,279
En lugar de los NIFs, los nombres.

80
00:05:46,279 --> 00:05:50,600
Un poquito lo estamos haciendo para practicar, mezclar cosas distintas.

81
00:05:51,319 --> 00:05:54,240
Entonces, imaginaos que hubiera dos profesores

82
00:05:54,240 --> 00:05:56,720
diferentes, distinto NIF

83
00:05:56,720 --> 00:05:59,360
pero el mismo nombre, los dos se llaman

84
00:05:59,360 --> 00:06:00,699
Álvaro López

85
00:06:00,699 --> 00:06:02,220
pues entonces

86
00:06:02,220 --> 00:06:04,939
si yo en este list

87
00:06:04,939 --> 00:06:07,339
me aparecerá dos veces Álvaro López

88
00:06:07,339 --> 00:06:08,000
¿vale?

89
00:06:12,379 --> 00:06:14,319
profesores de alumno, ¿de qué alumno?

90
00:06:15,819 --> 00:06:16,959
pues de este

91
00:06:16,959 --> 00:06:20,420
¿dónde está mi cajita de datos?

92
00:06:21,699 --> 00:06:22,920
se la tengo que pasar

93
00:06:22,920 --> 00:06:24,560
porque es local a mi main

94
00:06:24,560 --> 00:06:38,290
Aquí la tenemos, mi cajita de datos

95
00:06:38,290 --> 00:06:44,839
Y otra vez lo mismo, un rollo

96
00:06:44,839 --> 00:06:47,379
Tenemos que iterar para encontrar al profesor

97
00:06:47,379 --> 00:06:53,620
Si los profesores estuvieran en lugar de en un conjunto, en una lista

98
00:06:53,620 --> 00:06:56,459
Podríamos hacer todo el rato esto que hemos hecho aquí

99
00:06:56,459 --> 00:06:59,480
Sacar la posición con indexOf

100
00:06:59,480 --> 00:07:02,980
Y una vez que tenemos la posición, recuperarlo con el get

101
00:07:02,980 --> 00:07:07,480
sacaríamos con index of la posición del profesor

102
00:07:07,480 --> 00:07:08,759
con ese nif

103
00:07:08,759 --> 00:07:16,839
y ya lo recuperaríamos con get

104
00:07:16,839 --> 00:07:18,180
pero como es un conjunto

105
00:07:18,180 --> 00:07:19,079
lo que pasa es que

106
00:07:19,079 --> 00:07:30,139
aquí no es recuperar un profesor por nif suyo

107
00:07:30,139 --> 00:07:32,399
aquí pueden ser muchos profesores

108
00:07:32,399 --> 00:08:00,060
luego aquí sí que tenemos que iterar, sí o sí, tenemos que iterar, e ir metiendo en la lista todos aquellos que contengan este alumno, pues ya está, pues esto ahora ya sí que iteramos, para todos los profesores de mi caja, ¿cuál va a ser mi resultado?, mi resultado va a ser una lista de string, de nombres de profesores,

109
00:08:00,060 --> 00:08:03,139
vale, esta lista, venga, para variarla

110
00:08:03,139 --> 00:08:04,720
voy a instanciar como ArrayList

111
00:08:04,720 --> 00:08:06,819
como se supone que van a ser poquitos nombres

112
00:08:06,819 --> 00:08:08,120
un Array siempre es

113
00:08:08,120 --> 00:08:10,120
un poquito más

114
00:08:10,120 --> 00:08:13,040
eficiente, salvo si los datos

115
00:08:13,040 --> 00:08:13,920
son muy grandes

116
00:08:13,920 --> 00:08:16,699
crea teclas ArrayList

117
00:08:16,699 --> 00:08:17,100
no

118
00:08:17,100 --> 00:08:20,060
esto sí

119
00:08:20,060 --> 00:08:22,800
vale, pues ahora ya sí

120
00:08:22,800 --> 00:08:25,079
iteramos por cada profe

121
00:08:25,079 --> 00:08:26,300
y ahora simplemente habrá que ver

122
00:08:26,300 --> 00:08:29,259
oye, tú profe, P, ¿contienes en tu lista

123
00:08:29,259 --> 00:08:36,639
de alumnos 1 con este nif? Pues ala, tu nombre a la lista. Pues ya está, esto ya hemos visto

124
00:08:36,639 --> 00:08:44,840
el contains. Vamos a ver, alumnos de este profep. Alumnos de este profep contienen un

125
00:08:44,840 --> 00:08:56,919
alumno igual a este, un alumno igual a este que tiene nif alumno. Me da lo mismo el nombre

126
00:08:56,919 --> 00:08:59,539
que ponga aquí, me da igual la nota que ponga aquí

127
00:08:59,539 --> 00:09:04,379
¿eh? oye, colección de alumnos de profe

128
00:09:04,379 --> 00:09:08,740
¿contiene a uno igual a este? esto me da igual

129
00:09:08,740 --> 00:09:12,840
porque insisto, el contains va a mirar el criterio

130
00:09:12,840 --> 00:09:16,419
de igualdad que está en equals y ese solo tira de alumno

131
00:09:16,419 --> 00:09:20,759
pues sí, oye, y lo contiene, hay un alumno con ese nombre ahí

132
00:09:20,759 --> 00:09:25,220
pues ala, entonces, a mi lista nombres vamos a añadirle

133
00:09:25,220 --> 00:09:27,519
el nombre del profe

134
00:09:27,519 --> 00:09:31,759
y punto pelota.

135
00:09:32,480 --> 00:09:32,980
Ya está.

136
00:09:34,240 --> 00:09:35,919
Cuando este fuera terminado

137
00:09:35,919 --> 00:09:38,700
devolvemos el resultado.

138
00:09:39,379 --> 00:09:40,120
Puede estar vacío

139
00:09:40,120 --> 00:09:42,279
si no hubiera ningún profe que contenga al alumno.

140
00:09:42,440 --> 00:09:43,039
Puede estar vacío.

141
00:09:43,580 --> 00:09:45,919
Pero no nulo. Siempre mejor devolver nulos

142
00:09:45,919 --> 00:09:48,460
peligrosos por los null pointer exception.

143
00:09:49,179 --> 00:09:49,700
No es nulo.

144
00:09:49,700 --> 00:09:52,179
Lo peor que me puede ocurrir

145
00:09:52,179 --> 00:09:53,440
es devolver una lista vacía.

146
00:09:55,059 --> 00:09:55,759
¡Hala! Pues este

147
00:09:55,759 --> 00:09:56,419
muy fácil.

148
00:09:57,559 --> 00:10:24,379
Nib de un profe, vamos a ordenar alfabéticamente a los alumnos, venga, dado el Nib de un profe, mostrar un listado alfabético de los alumnos, esto está así, pues venga, un método estático, vale,

149
00:10:24,379 --> 00:10:34,139
vamos a hacer una cosa vamos a hacer que me devuelva una lista de alumnos que van a ser

150
00:10:34,139 --> 00:10:47,759
los alumnos de ese profe ordenados alfabéticamente por nombre listado ordenado de quien pues listado

151
00:10:47,759 --> 00:10:58,539
ordenado de un profesor vale y de dónde saco yo los datos para trabajar saco los datos para

152
00:10:58,539 --> 00:11:21,399
trabajar de esto, para trabajar de esto, vale, bueno, pues entonces, vale, vamos a localizar

153
00:11:21,399 --> 00:11:27,059
al profe, de nuevo, sí o sí, tenemos que localizar al profe con ese need, y como esto

154
00:11:27,059 --> 00:11:32,799
es un map, como esto no es un mapa, no puedo localizar por clave, como es una lista, no

155
00:11:32,799 --> 00:11:35,019
puedo sacar la posición con el index

156
00:11:35,019 --> 00:11:36,519
of, pues no hay tutía

157
00:11:36,519 --> 00:11:38,000
a recorrer

158
00:11:38,000 --> 00:11:39,820
la caja

159
00:11:39,820 --> 00:11:42,720
vamos a encontrar

160
00:11:42,720 --> 00:11:44,440
el profesor

161
00:11:44,440 --> 00:11:46,980
que estoy buscando, que es aquel

162
00:11:46,980 --> 00:11:49,200
cuyo nif sea igual a este

163
00:11:49,200 --> 00:11:53,159
sea igual

164
00:11:53,159 --> 00:11:54,340
a este que me han dado

165
00:11:54,340 --> 00:11:56,919
una vez que lo he

166
00:11:56,919 --> 00:11:59,179
encontrado, resulta que yo aquí ya tengo

167
00:11:59,179 --> 00:12:00,740
esta lista suya

168
00:12:00,740 --> 00:12:03,000
¿vale? esto es una

169
00:12:03,000 --> 00:12:09,899
lista la lista de sus alumnos bueno pues entonces la lista ya sabemos que tiene un montón de métodos

170
00:12:09,899 --> 00:12:16,000
muy bonitos y muy interesantes que nos permiten hacer un montón de cosas y todo estupendo vale

171
00:12:16,000 --> 00:12:25,019
pues en particular tiene un método short tiene un método short que ya hemos mencionado con la

172
00:12:25,019 --> 00:12:30,620
clase a raíz la clase a raíz tenía un método estático short que ya usamos pero bueno ahora

173
00:12:30,620 --> 00:12:38,679
esto es otra cosa porque esto es un método no estático de la clase list vale pues list tiene

174
00:12:38,679 --> 00:12:46,659
un método ordenar que ordena esta lista es decir los mueve de sitio los mueve de sitio para que

175
00:12:46,659 --> 00:12:55,559
estén ordenados pero qué significa estar ordenados pues no lo sé depende de cómo ordenó yo los

176
00:12:55,559 --> 00:13:01,279
alumnos por orden alfabético de ni por altura por orden alfabético de nombre por nota como los

177
00:13:01,279 --> 00:13:03,320
ordeno? Pues habrá

178
00:13:03,320 --> 00:13:05,399
que decírselo a sort cómo los ordeno

179
00:13:05,399 --> 00:13:06,899
porque si no se lo digo

180
00:13:06,899 --> 00:13:09,059
pues él no va a saber cómo ordenar.

181
00:13:09,600 --> 00:13:11,500
El compilador se ha quedado muy tranquilo

182
00:13:11,500 --> 00:13:13,139
pero cuando luego ejecutemos esto

183
00:13:13,139 --> 00:13:15,200
si yo no le he dicho cómo ordenar los

184
00:13:15,200 --> 00:13:16,899
alumnos, me va a decir

185
00:13:16,899 --> 00:13:18,720
eh, alumnos

186
00:13:18,720 --> 00:13:21,279
incomparables, no puedo comparar uno con otros.

187
00:13:22,539 --> 00:13:22,759
Vale,

188
00:13:23,399 --> 00:13:25,340
pues entonces, ¿cómo indico

189
00:13:25,340 --> 00:13:26,860
yo cómo

190
00:13:26,860 --> 00:13:29,139
ordenar los alumnos? ¿Cómo

191
00:13:29,139 --> 00:13:30,559
indico yo el criterio de ordenación?

192
00:13:31,279 --> 00:13:37,879
Bueno, pues entonces alumno, si yo quiero que los alumnos sean ordenables, se puedan ordenar entre sí,

193
00:13:39,139 --> 00:13:46,720
la clase alumno tiene que adquirir el comportamiento de ser comparable, de ser ordenables, de ser comparables unos a otros.

194
00:13:46,980 --> 00:13:49,000
¿Cómo se adquieren los comportamientos?

195
00:13:49,519 --> 00:13:52,299
Implementando las interfaces que los reflejan.

196
00:13:53,019 --> 00:13:56,480
Pues tenemos una interfaz comparable, que ya hemos mencionado alguna vez,

197
00:13:56,480 --> 00:13:58,879
que es una interfaz

198
00:13:58,879 --> 00:14:00,259
que quien la implementa

199
00:14:00,259 --> 00:14:02,740
se convierte en objeto

200
00:14:02,740 --> 00:14:05,039
capaz de ser ordenado con sus iguales

201
00:14:05,039 --> 00:14:07,139
de ser menor que, mayor que

202
00:14:07,139 --> 00:14:08,320
con sus iguales

203
00:14:08,320 --> 00:14:11,100
claro, implementando el método correspondiente

204
00:14:11,100 --> 00:14:12,879
de la interfaz, si implementamos una interfaz

205
00:14:12,879 --> 00:14:14,299
hay que dar cuerpo a sus métodos

206
00:14:14,299 --> 00:14:15,860
pues habrá que dar cuerpo a ese método

207
00:14:15,860 --> 00:14:18,879
vale, entonces

208
00:14:18,879 --> 00:14:21,100
comparable es una clase genérica

209
00:14:21,100 --> 00:14:23,480
yo la puedo

210
00:14:23,480 --> 00:14:25,019
poner así sin más

211
00:14:25,019 --> 00:14:33,879
Pero entonces estaría diciendo con esto que un alumno puede ordenarse y compararse con un objeto de cualquier otra clase

212
00:14:33,879 --> 00:14:39,240
Un alumno puede compararse para ser ordenado con un profesor, con una mesa, con un gato

213
00:14:39,240 --> 00:14:40,740
No es el uso

214
00:14:40,740 --> 00:14:48,059
Normalmente cuando yo ordeno, o ordeno solo alumnos entre sí, o ordeno solo profesores, o ordeno solo gatos

215
00:14:48,059 --> 00:14:50,159
entonces

216
00:14:50,159 --> 00:14:52,860
vamos a especificarle a la clase

217
00:14:52,860 --> 00:14:53,960
genérica comparable

218
00:14:53,960 --> 00:14:55,639
tú

219
00:14:55,639 --> 00:14:58,600
que alumno

220
00:14:58,600 --> 00:15:00,860
es una clase que va a ser capaz

221
00:15:00,860 --> 00:15:02,759
de ser comparable pero

222
00:15:02,759 --> 00:15:04,480
solo con sus iguales

223
00:15:04,480 --> 00:15:06,419
con otros de la clase alumno

224
00:15:06,419 --> 00:15:08,480
solo con otros de la clase alumno

225
00:15:08,480 --> 00:15:10,559
no comparable con cualquier

226
00:15:10,559 --> 00:15:12,460
otra cosa, solo

227
00:15:12,460 --> 00:15:14,960
comparable con objetos de la clase alumno

228
00:15:14,960 --> 00:15:15,519
vale

229
00:15:15,519 --> 00:15:19,240
Ya hemos parametrizado la interfaz comparable

230
00:15:19,240 --> 00:15:25,700
Estamos obligados a dar código al método que está sin implementar

231
00:15:25,700 --> 00:15:30,039
Y aquí en este método yo ya decido mi criterio de ordenación

232
00:15:30,039 --> 00:15:33,960
Entre el alumno que llama el método y el alumno pasado por parámetro

233
00:15:33,960 --> 00:15:36,080
¿Alfabético de nombre?

234
00:15:36,940 --> 00:15:38,419
Pues no sé, ¿qué me han dicho aquí?

235
00:15:39,139 --> 00:15:42,659
Alfabético de nombre, sí, sobreentiendo que alfabético de nombre

236
00:15:42,659 --> 00:15:44,899
vale, pues recordad que este método

237
00:15:44,899 --> 00:15:45,679
tiene que devolver

238
00:15:45,679 --> 00:15:47,500
menos uno o negativo

239
00:15:47,500 --> 00:15:49,659
si el que llama al método va antes

240
00:15:49,659 --> 00:15:51,460
que el pasado por parámetro

241
00:15:51,460 --> 00:15:53,320
cero, si son el mismo

242
00:15:53,320 --> 00:15:55,759
y uno

243
00:15:55,759 --> 00:15:58,159
si el que llama al método

244
00:15:58,159 --> 00:16:00,820
va después que el pasado por parámetro

245
00:16:00,820 --> 00:16:03,100
ir antes o después

246
00:16:03,100 --> 00:16:05,379
aquí es en función de la propiedad

247
00:16:05,379 --> 00:16:06,320
nombre

248
00:16:06,320 --> 00:16:08,860
y comparar alfabéticamente

249
00:16:08,860 --> 00:16:09,659
dos string

250
00:16:09,659 --> 00:16:11,379
sabemos que lo podemos hacer

251
00:16:11,379 --> 00:16:12,460
es decir, este string

252
00:16:12,460 --> 00:16:14,519
dis.nombre

253
00:16:14,519 --> 00:16:17,059
por ser un string

254
00:16:17,059 --> 00:16:19,980
tiene entre muchos métodos

255
00:16:19,980 --> 00:16:22,360
uno que se llama compareTo

256
00:16:22,360 --> 00:16:25,559
que si yo le paso otro string

257
00:16:25,559 --> 00:16:27,700
como este

258
00:16:27,700 --> 00:16:30,840
pues compareTo es un método de la clase string

259
00:16:30,840 --> 00:16:32,159
que me devuelve menos uno

260
00:16:32,159 --> 00:16:36,100
si este nombre está alfabéticamente antes que este

261
00:16:36,100 --> 00:16:39,860
cero si este es el mismo que este

262
00:16:39,860 --> 00:16:43,840
y más 1 si este está alfabéticamente después que este.

263
00:16:44,220 --> 00:16:46,580
Pues es justo lo que yo quiero hacer en este compareto.

264
00:16:46,960 --> 00:16:50,000
Bueno, pues entonces voy a devolver directamente esto.

265
00:16:51,000 --> 00:16:52,720
Y ya tengo el código que quería.

266
00:16:53,460 --> 00:16:58,419
Un código que me devuelve menos 1 si el objeto alumno dis que llama al método

267
00:16:58,419 --> 00:17:02,080
está alfabéticamente por nombre antes que este.

268
00:17:02,860 --> 00:17:06,279
0 si alfabéticamente por nombre están junticos.

269
00:17:06,279 --> 00:17:11,880
y más uno si este objeto dis está alfabéticamente por nombre

270
00:17:11,880 --> 00:17:15,059
después que este objeto justo, ya tengo lo que quería

271
00:17:15,059 --> 00:17:20,059
pues entonces, como alumno ya implementa la interfaz

272
00:17:20,059 --> 00:17:23,000
comparable para ser comparado con sus iguales alumno

273
00:17:23,000 --> 00:17:27,400
este método cuando yo lo ejecute, el sort

274
00:17:27,400 --> 00:17:31,900
va a saber cómo ordenar, y qué va a hacer, recolocar esta colección

275
00:17:31,900 --> 00:17:36,240
recolocarla enterita, y ahora va a dejar a los alumnos del profesor

276
00:17:36,240 --> 00:17:37,680
alfabéticamente colocados

277
00:17:37,680 --> 00:17:40,819
los va a dejar ya colocados alfabéticamente

278
00:17:40,819 --> 00:17:43,920
si yo no quisiera que tocara

279
00:17:43,920 --> 00:17:46,779
la colección de alumnos

280
00:17:46,779 --> 00:17:49,279
y simplemente me devolviera otra

281
00:17:49,279 --> 00:17:50,299
ordenada alfabéticamente

282
00:17:50,299 --> 00:17:52,420
podría copiar esta colección en una

283
00:17:52,420 --> 00:17:53,259
y ordenar esa

284
00:17:53,259 --> 00:17:55,220
y ya está, pero bueno, me da igual

285
00:17:55,220 --> 00:17:56,059
lo voy a dejar así

286
00:17:56,059 --> 00:17:59,480
para que la propia colección de alumnos del profesor

287
00:17:59,480 --> 00:18:00,519
ya se quede ordenada

288
00:18:00,519 --> 00:18:02,240
tampoco pasa nada, porque se quede ordenada

289
00:18:02,240 --> 00:18:04,779
vale, pues una vez que

290
00:18:04,779 --> 00:18:06,940
Hemos terminado

291
00:18:06,940 --> 00:18:09,740
Ya yo devuelvo

292
00:18:09,740 --> 00:18:12,220
La colección ordenada

293
00:18:12,220 --> 00:18:15,410
¿Vale?

294
00:18:16,089 --> 00:18:16,490
Ay

295
00:18:16,490 --> 00:18:19,210
Ah, perdón, que tengo que

296
00:18:19,210 --> 00:18:24,049
Hacerlo aquí porque estoy dentro del for each

297
00:18:24,049 --> 00:18:24,410
Claro

298
00:18:24,410 --> 00:18:28,970
Vale

299
00:18:28,970 --> 00:18:31,069
Retune

300
00:18:31,069 --> 00:18:34,150
P.getAlumns

301
00:18:34,150 --> 00:18:35,029
Vale

302
00:18:35,029 --> 00:18:37,529
Entonces repito, con este método

303
00:18:37,529 --> 00:18:39,589
No solo estamos devolviendo

304
00:18:39,589 --> 00:18:43,170
una colección de alumnos ordenados alfabéticamente del profe

305
00:18:43,170 --> 00:18:47,470
sino que además estamos ya alterando la propia colección de alumnos del profe

306
00:18:47,470 --> 00:18:51,230
y la estamos ya dejando ordenada. Repito, si no quisiéramos alterar

307
00:18:51,230 --> 00:18:54,789
esta colección de alumnos, sino simplemente devolver una

308
00:18:54,789 --> 00:18:58,930
con eso a unos ordenados, pues nos haríamos una copia y devolveríamos la copia

309
00:18:58,930 --> 00:19:02,230
o sea, nos haríamos una copia, ordenaríamos la copia y devolveríamos la copia

310
00:19:02,230 --> 00:19:07,109
pero bueno, depende de lo que queramos hacer. Vale, ¿qué ocurre

311
00:19:07,109 --> 00:19:09,029
si yo he llegado a este punto

312
00:19:09,029 --> 00:19:11,210
sin salir por este retún, que no encontré

313
00:19:11,210 --> 00:19:11,829
al profesor

314
00:19:11,829 --> 00:19:15,049
si no encontré al profesor, pues bueno

315
00:19:15,049 --> 00:19:16,890
tiene sentido que me devuelva yo un null

316
00:19:16,890 --> 00:19:19,190
a lo mejor, y que este método

317
00:19:19,190 --> 00:19:20,869
pues yo puedo hacer

318
00:19:20,869 --> 00:19:23,069
yo aviso

319
00:19:23,069 --> 00:19:24,509
claro, para que el que lo usa

320
00:19:24,509 --> 00:19:26,390
sepa cómo usarlo, null

321
00:19:26,390 --> 00:19:29,009
si no existe el profe, por ejemplo

322
00:19:29,009 --> 00:19:31,230
así el que

323
00:19:31,230 --> 00:19:32,569
lo use, ya sabe

324
00:19:32,569 --> 00:19:35,009
que cuando esto devuelva null

325
00:19:35,009 --> 00:19:36,849
es que el profesor no existe, luego no tiene

326
00:19:36,849 --> 00:19:37,349
sentido

327
00:19:37,349 --> 00:19:41,049
devolver un listado ordenado porque no existe

328
00:19:41,049 --> 00:19:43,630
vale

329
00:19:43,630 --> 00:19:48,009
más métodos

330
00:19:48,009 --> 00:19:50,769
eliminar alumno de un profe

331
00:19:50,769 --> 00:19:52,789
vale, hasta ahora hemos añadido y consultado

332
00:19:52,789 --> 00:19:54,710
pero no hemos eliminado elementos

333
00:19:54,710 --> 00:19:55,529
de una colección

334
00:19:55,529 --> 00:19:59,049
y si se tiene que poder

335
00:19:59,049 --> 00:20:00,829
obviamente una colección es

336
00:20:00,829 --> 00:20:02,190
algo para guardar datos

337
00:20:02,190 --> 00:20:03,789
tenerlos ahí guardaditos

338
00:20:03,789 --> 00:20:05,970
con orden o sin orden

339
00:20:05,970 --> 00:20:07,789
depende de lo que nos interese

340
00:20:07,789 --> 00:20:10,490
y consultarlos

341
00:20:10,490 --> 00:20:12,289
de vez en cuando, para ver, ah, este profe

342
00:20:12,289 --> 00:20:14,130
que estaba aquí con Niftal, ¿qué alumnos tiene?

343
00:20:14,250 --> 00:20:15,990
ah, pues para hacer consultas sobre lo que hay ahí

344
00:20:15,990 --> 00:20:17,950
pero también tenemos que poder eliminar cosas

345
00:20:17,950 --> 00:20:19,690
de ellos, de las cajas, obviamente

346
00:20:19,690 --> 00:20:20,869
tenemos que poder eliminar cosas

347
00:20:20,869 --> 00:20:22,150
bueno

348
00:20:22,150 --> 00:20:25,809
vale, bueno, antes de pasar a ese método, que no he

349
00:20:25,809 --> 00:20:27,829
incidido en ello, este

350
00:20:27,829 --> 00:20:29,130
método sort de ordenar

351
00:20:29,130 --> 00:20:31,690
tiene sentido y existe

352
00:20:31,690 --> 00:20:33,670
solo en las listas, obviamente

353
00:20:33,670 --> 00:20:34,970
porque las listas

354
00:20:34,970 --> 00:20:37,210
son las colecciones

355
00:20:37,210 --> 00:20:39,089
que tienen un orden

356
00:20:39,089 --> 00:20:40,829
¿vale? que tienen

357
00:20:40,829 --> 00:20:43,009
cada elemento en una

358
00:20:43,009 --> 00:20:43,509
posición

359
00:20:43,509 --> 00:20:46,670
entonces tiene sentido

360
00:20:46,670 --> 00:20:49,150
una acción en la que yo los cambie de posición

361
00:20:49,150 --> 00:20:50,869
como lo que hace

362
00:20:50,869 --> 00:20:52,470
short, short los cambia de posición

363
00:20:52,470 --> 00:20:55,009
para mostrármelos con otro

364
00:20:55,009 --> 00:20:56,930
orden, en un conjunto

365
00:20:56,930 --> 00:20:58,829
en un set, el método

366
00:20:58,829 --> 00:21:00,769
short no tiene sentido

367
00:21:00,769 --> 00:21:02,230
porque están todos a mogollón

368
00:21:02,230 --> 00:21:04,069
¿vale? están todos a mogollón

369
00:21:04,069 --> 00:21:07,390
Otra cosa es que

370
00:21:07,390 --> 00:21:10,430
Cuando yo itero por un set

371
00:21:10,430 --> 00:21:13,150
Itere con algún tipo de orden o no

372
00:21:13,150 --> 00:21:15,589
Pero eso ya tiene que ver con el preset

373
00:21:15,589 --> 00:21:16,950
Que todavía no hemos mencionado

374
00:21:16,950 --> 00:21:19,089
Pero en un conjunto

375
00:21:19,089 --> 00:21:21,230
Lo que tenemos que ver ahora a priori

376
00:21:21,230 --> 00:21:23,269
Es que está todo ahí a mogollón metido

377
00:21:23,269 --> 00:21:24,549
Entonces no tiene sentido

378
00:21:24,549 --> 00:21:26,470
Ahora los voy a ordenar por color de ojo

379
00:21:26,470 --> 00:21:28,549
Pero que vas a ordenar si están todos ahí a mogollón

380
00:21:28,549 --> 00:21:30,589
No hay ninguna posición en la que ponerlos

381
00:21:30,589 --> 00:21:32,829
Venga

382
00:21:32,829 --> 00:21:36,829
Pues estábamos diciendo que nos faltaba eliminar un alumno de un profe.

383
00:21:40,130 --> 00:21:46,390
Eliminar un alumno de un profe, ya que estamos en plan valor boolean de control para ver si algo existe o no.

384
00:21:46,750 --> 00:21:47,630
Pues lo ponemos.

385
00:21:49,289 --> 00:21:51,589
Eliminar alumno.

386
00:21:52,329 --> 00:21:54,309
¿De quién? Pues de un dato.

387
00:21:59,289 --> 00:21:59,930
Profesor.

388
00:22:00,950 --> 00:22:03,609
¿Qué alumno vamos a eliminar de ese profesor?

389
00:22:07,180 --> 00:22:08,079
Pues este.

390
00:22:10,539 --> 00:22:11,960
¿Dónde están mis datos?

391
00:22:12,779 --> 00:22:15,619
Qué suerte, todavía estaba en el portapapeles.

392
00:22:17,000 --> 00:22:18,759
Aquí está mi cajita de datos.

393
00:22:19,859 --> 00:22:22,279
Bueno, pues estamos en las mismas una y otra vez.

394
00:22:22,279 --> 00:22:33,019
Vamos a tener que recorrer mi lista de profesores hasta encontrar el profesor objetivo.

395
00:22:34,240 --> 00:22:39,750
Y estamos en las mismas.

396
00:22:39,750 --> 00:22:42,470
si este es mi profesor objetivo

397
00:22:42,470 --> 00:22:51,029
si este es mi profesor

398
00:22:51,029 --> 00:22:51,950
objetivo

399
00:22:51,950 --> 00:22:54,049
el cual

400
00:22:54,049 --> 00:22:56,630
tiene como propiedad nif una

401
00:22:56,630 --> 00:22:57,730
igual a esta

402
00:22:57,730 --> 00:23:01,230
pues entonces ahora resulta que tendrá una lista de alumnos

403
00:23:01,230 --> 00:23:03,130
vacía o no

404
00:23:03,130 --> 00:23:04,450
pero bueno tendrá una lista de alumnos

405
00:23:04,450 --> 00:23:06,630
y yo de esta lista quiero

406
00:23:06,630 --> 00:23:08,390
eliminar un alumno

407
00:23:08,390 --> 00:23:10,009
igual a este

408
00:23:10,009 --> 00:23:12,109
un alumno igual a este

409
00:23:12,109 --> 00:23:14,069
hombre pues magnífico

410
00:23:14,069 --> 00:23:21,650
Porque mi clase list, collection en general, tiene un método estupendo que es remove, ¿vale?

411
00:23:23,049 --> 00:23:24,549
Y remove, ¿qué hace?

412
00:23:25,430 --> 00:23:29,450
Tú le pasas un objeto y remove te borra.

413
00:23:29,450 --> 00:23:36,349
Ahora, la primera instancia que ha encontrado en esta lista igual a ese objeto.

414
00:23:37,349 --> 00:23:38,589
La primera que ha encontrado.

415
00:23:38,589 --> 00:23:42,970
si hubiera más iguales a ese objeto

416
00:23:42,970 --> 00:23:44,990
que podría verlo, porque esto es una lista

417
00:23:44,990 --> 00:23:47,690
luego podría ver varios alumnos con ese nif

418
00:23:47,690 --> 00:23:50,109
te borra solo la primera

419
00:23:50,109 --> 00:23:52,250
si yo vuelvo a hacer otro remove

420
00:23:52,250 --> 00:23:55,309
te borra la primera que encuentra

421
00:23:55,309 --> 00:23:57,970
que sería la segunda que quedó de antes

422
00:23:57,970 --> 00:24:00,609
luego importante, cada remove

423
00:24:00,609 --> 00:24:03,950
te borra solo una instancia igual a esta

424
00:24:03,950 --> 00:24:05,269
que es la primera que encuentra

425
00:24:05,269 --> 00:24:09,230
si hay más instancias iguales a esta las deja

426
00:24:09,230 --> 00:24:13,009
habría que hacer sucesivo remove, podríamos meterlo en un while

427
00:24:13,009 --> 00:24:17,690
y este remove aparte te devuelve true o false

428
00:24:17,690 --> 00:24:21,150
en función de si ha hecho una eliminación efectiva o no la ha hecho

429
00:24:21,150 --> 00:24:24,910
porque no ha encontrado nada igual, bueno por lo pronto vamos a pasarle

430
00:24:24,910 --> 00:24:29,029
un objeto igual que queremos borrar, pues newAlumno

431
00:24:29,029 --> 00:24:33,390
newAlumno y el nombre es que nos da lo mismo

432
00:24:33,390 --> 00:24:41,829
y la nota nos da lo mismo, porque el remove te borra un alumno igual a este de aquí

433
00:24:41,829 --> 00:24:47,630
y la igualdad la va a mirar exclusivamente en función de esta propiedad.

434
00:24:48,609 --> 00:24:51,529
Luego me da igual lo que ponga aquí, ¿vale?

435
00:24:51,849 --> 00:24:54,230
Pero eso sí, al remove hay que pasarle un objeto alumno.

436
00:24:55,769 --> 00:24:56,609
Venga, pues ya está.

437
00:24:57,210 --> 00:25:00,390
Entonces este remove, además de hacer la eliminación,

438
00:25:00,390 --> 00:25:08,130
Si es que encuentra alguno con un if igual a ese, te devuelve true si realmente hizo la eliminación o false si no.

439
00:25:08,250 --> 00:25:10,730
Pues vamos a aprovechar ese valor para ponernos el retorno.

440
00:25:11,950 --> 00:25:12,750
Y ya está.

441
00:25:13,730 --> 00:25:16,369
¿Qué ocurre si hemos llegado a este punto?

442
00:25:17,009 --> 00:25:21,609
Si hemos llegado a este punto es porque en ningún momento hemos encontrado un profesor con ese if.

443
00:25:21,970 --> 00:25:26,730
Luego, si no hemos encontrado un profesor con ese if, o directamente que no hay profesores, luego no ha entrado nunca aquí,

444
00:25:26,730 --> 00:25:29,329
Pues no ha borrado nada, está claro

445
00:25:29,329 --> 00:25:31,690
Porque no hay ni profesor ni nada

446
00:25:31,690 --> 00:25:33,470
O puede haber encontrado

447
00:25:33,470 --> 00:25:35,630
Bueno, no, sí, si ha encontrado profesor

448
00:25:35,630 --> 00:25:37,630
Y no tiene alumno, este ya sale por falso

449
00:25:37,630 --> 00:25:39,990
Vale, si no ha encontrado al profesor

450
00:25:39,990 --> 00:25:41,410
O es que ni hay profesores

451
00:25:41,410 --> 00:25:42,750
Hemos llegado a este punto

452
00:25:42,750 --> 00:25:45,009
Tenemos que seguir devolviendo algo

453
00:25:45,009 --> 00:25:47,109
Pues en este caso devolveremos falso

454
00:25:47,109 --> 00:25:49,609
Porque no hemos encontrado nada

455
00:25:49,609 --> 00:25:53,019
Vale

456
00:25:53,019 --> 00:25:55,759
Pues estas serían

457
00:25:55,759 --> 00:25:58,559
Todas las funcionalidades del ejercicio

458
00:25:58,559 --> 00:26:04,700
Ahora, deberíais vosotros probarlas en un main, ¿vale?

459
00:26:04,720 --> 00:26:10,019
Probar en un main, a ver, insertar alumnos con un menú, poner nota a un alumno, etc.

460
00:26:10,480 --> 00:26:15,799
Para verificar que realmente están bien, porque puedo haberme equivocado en alguna cosa,

461
00:26:15,880 --> 00:26:18,440
que es la alguna excepción, para verificar que realmente están bien.

462
00:26:19,319 --> 00:26:21,000
Entender bien todo esto, claro.

463
00:26:21,980 --> 00:26:25,660
Y continuar haciendo ejercicios, ¿vale?

464
00:26:25,660 --> 00:26:28,779
Todo esto lo podéis hacer

465
00:26:28,779 --> 00:26:31,099
Todo esto lo podéis hacer

466
00:26:31,099 --> 00:26:32,220
Esto es hacerse una propia

467
00:26:32,220 --> 00:26:33,180
Una propia

468
00:26:33,180 --> 00:26:34,900
Vale

469
00:26:34,900 --> 00:26:37,319
Esto también

470
00:26:37,319 --> 00:26:38,759
Ah no, esto ya es un map

471
00:26:38,759 --> 00:26:43,190
Esto tiene map

472
00:26:43,190 --> 00:26:44,730
Y bueno, aquí hay

473
00:26:44,730 --> 00:26:47,089
Y esto

474
00:26:47,089 --> 00:26:49,390
Tiene excepciones

475
00:26:49,390 --> 00:26:54,130
Pero este de aquí

476
00:26:54,130 --> 00:26:55,710
Por ejemplo, este de aquí

477
00:26:55,710 --> 00:26:56,829
Hacedlo sí o sí

478
00:26:56,829 --> 00:26:58,890
¿Vale? Que es similar

479
00:26:58,890 --> 00:27:02,509
similar o más fácil que el que hemos hecho

480
00:27:02,509 --> 00:27:04,950
¿vale? porque tiene solamente una clase

481
00:27:04,950 --> 00:27:09,609
¿vale? una clase que tiene un conjunto de objetos

482
00:27:09,609 --> 00:27:13,329
entonces lo ideal sería hacer este ejercicio

483
00:27:13,329 --> 00:27:16,529
de tal manera, una versión en la cual

484
00:27:16,529 --> 00:27:19,509
los discos que tiene la discoteca sean una lista

485
00:27:19,509 --> 00:27:23,869
y otra versión en la que los discos que tenga la discoteca sean un conjunto

486
00:27:23,869 --> 00:27:28,630
¿vale? y ver si hay algunas diferencias

487
00:27:28,630 --> 00:27:30,750
que podamos aplicar entre una versión y otra.

488
00:27:32,430 --> 00:27:34,089
Vale, pues venga, lo dejamos aquí.