1
00:00:01,649 --> 00:00:06,849
Vamos a hacer el método de mostrar un listado alfabético.

2
00:00:07,849 --> 00:00:09,830
Vamos a entender primero la aplicación.

3
00:00:10,050 --> 00:00:13,710
La aplicación tiene la clase alumno, por ahora esto lo vamos a quitar,

4
00:00:13,929 --> 00:00:18,070
porque como tu lucidez no ha dado para completarlo, pues lo quitamos.

5
00:00:18,809 --> 00:00:23,629
Tenemos nuestro alumno con NIF nombre y nota, constructores, get y set,

6
00:00:23,629 --> 00:00:25,329
Hasco de Equals

7
00:00:25,329 --> 00:00:25,789
Por

8
00:00:25,789 --> 00:00:28,609
Por NIF

9
00:00:28,609 --> 00:00:31,429
Y este que lo vamos a quitar

10
00:00:31,429 --> 00:00:31,750
Porque

11
00:00:31,750 --> 00:00:34,950
No vale para nada

12
00:00:34,950 --> 00:00:37,490
Vale, la clase alumno

13
00:00:37,490 --> 00:00:38,530
Te la aprobamos

14
00:00:38,530 --> 00:00:39,630
Vale

15
00:00:39,630 --> 00:00:43,009
Me gustaría en tu stream

16
00:00:43,009 --> 00:00:44,350
De Yasmín

17
00:00:44,350 --> 00:00:47,429
Vale, la clase alumno ya está, te la aprobamos

18
00:00:47,429 --> 00:00:48,509
Venga, clase profesor

19
00:00:48,509 --> 00:00:52,070
Clase profesor tiene una lista de alumnos

20
00:00:52,070 --> 00:00:52,950
Vale

21
00:00:52,950 --> 00:00:55,530
yo aquí

22
00:00:55,530 --> 00:00:58,649
a menos que vayas a usar

23
00:00:58,649 --> 00:01:00,990
los métodos específicos de linked list

24
00:01:00,990 --> 00:01:02,490
el push, el pull

25
00:01:02,490 --> 00:01:04,549
yo aquí no pondría linked list

26
00:01:04,549 --> 00:01:06,010
pondría list directamente

27
00:01:06,010 --> 00:01:09,170
hace el código un poquito más legible

28
00:01:09,170 --> 00:01:10,150
¿vale?

29
00:01:11,989 --> 00:01:12,549
constructor

30
00:01:12,549 --> 00:01:14,010
get set

31
00:01:14,010 --> 00:01:15,989
aquí por tanto

32
00:01:15,989 --> 00:01:20,420
get set

33
00:01:20,420 --> 00:01:23,040
y luego has puesto algunos métodos del tipo

34
00:01:23,040 --> 00:01:25,299
Vamos a ver todos los alumnos de la lista

35
00:01:25,299 --> 00:01:27,780
Has recorrido la lista

36
00:01:27,780 --> 00:01:33,500
Más cómodo

37
00:01:33,500 --> 00:01:34,340
De escribir

38
00:01:34,340 --> 00:01:35,579
En este momento

39
00:01:35,579 --> 00:01:37,420
Que solamente vas a recorrer para mostrar

40
00:01:37,420 --> 00:01:40,200
Más cómodo que lo hagas con un for each

41
00:01:40,200 --> 00:01:40,840
Directamente

42
00:01:40,840 --> 00:01:42,900
Que no con un for de índice

43
00:01:42,900 --> 00:01:47,609
Y si alumno tiene tu string

44
00:01:47,609 --> 00:01:48,909
Que lo tiene

45
00:01:48,909 --> 00:01:50,989
Si alumno tiene tu string

46
00:01:50,989 --> 00:01:52,730
Puedes

47
00:01:52,730 --> 00:01:54,810
Tirar

48
00:01:54,810 --> 00:01:55,930
Si es solamente para verlos

49
00:01:55,930 --> 00:01:57,010
puedes tirar del

50
00:01:57,010 --> 00:01:58,790
toString de list

51
00:01:58,790 --> 00:02:02,170
y hacer directamente system.out.println

52
00:02:02,170 --> 00:02:03,469
alumnos.

53
00:02:03,609 --> 00:02:05,909
Porque el toString de list ya te

54
00:02:05,909 --> 00:02:07,849
hace un mostrado bastante apañado de los

55
00:02:07,849 --> 00:02:09,870
elementos de una lista. Llamando a

56
00:02:09,870 --> 00:02:11,030
los toString de alumnos.

57
00:02:11,389 --> 00:02:13,349
Pero vamos, que esto está bien igualmente.

58
00:02:14,669 --> 00:02:15,849
Vale, en profesor vamos

59
00:02:15,849 --> 00:02:17,050
a buscar un alumno

60
00:02:17,050 --> 00:02:20,969
dado su NIF. Pues

61
00:02:20,969 --> 00:02:23,449
recorres y lo devuelves.

62
00:02:24,990 --> 00:02:25,509
Vale,

63
00:02:25,509 --> 00:02:27,889
Dos retun, dos puntos de salida

64
00:02:27,889 --> 00:02:29,349
No pasa nada

65
00:02:29,349 --> 00:02:31,270
Feo, pero no pasa nada

66
00:02:31,270 --> 00:02:34,090
Al final acabamos programando un poco así

67
00:02:34,090 --> 00:02:35,409
¿Vale?

68
00:02:35,610 --> 00:02:36,210
¿Esto es lluvia?

69
00:02:38,009 --> 00:02:39,389
Porcentaje de aprobados

70
00:02:39,389 --> 00:02:43,949
Yo aquí añadiría

71
00:02:43,949 --> 00:02:48,620
Si alumnos es

72
00:02:48,620 --> 00:02:51,520
Igual a nul

73
00:02:51,520 --> 00:02:53,759
O

74
00:02:53,759 --> 00:02:55,719
Mucho mejor

75
00:02:55,719 --> 00:02:59,159
porque a ver, tú sabes

76
00:02:59,159 --> 00:03:01,979
en principio que esta colección

77
00:03:01,979 --> 00:03:03,620
la has inicializado

78
00:03:03,620 --> 00:03:05,639
pero en realidad no sabes en qué momento vas a acabar

79
00:03:05,639 --> 00:03:07,759
llamando a este método, igual llamas a este método

80
00:03:07,759 --> 00:03:09,680
habiendo puesto alguien esa colección

81
00:03:09,680 --> 00:03:11,520
a nul, habiendo tenido esa

82
00:03:11,520 --> 00:03:12,759
buenísima idea

83
00:03:12,759 --> 00:03:15,759
entonces esta verificación es mucho mejor

84
00:03:15,759 --> 00:03:16,620
y más habitual

85
00:03:16,620 --> 00:03:19,280
si alumnos es nul o

86
00:03:19,280 --> 00:03:21,500
sin ser nul, su tamaño es cero

87
00:03:21,500 --> 00:03:23,340
no hay porcentaje de aprobados

88
00:03:23,340 --> 00:03:27,460
y si su tamaño no es cero

89
00:03:27,460 --> 00:03:28,879
pues ya sumas

90
00:03:28,879 --> 00:03:31,580
los aprobados y los divides entre el total

91
00:03:31,580 --> 00:03:33,500
y lo conviertes a

92
00:03:33,500 --> 00:03:35,699
double, la división

93
00:03:35,699 --> 00:03:37,280
pero, a ver

94
00:03:37,280 --> 00:03:39,840
conviertes

95
00:03:39,840 --> 00:03:41,860
a double después

96
00:03:41,860 --> 00:03:43,639
con lo cual esta división

97
00:03:43,639 --> 00:03:45,500
es la división entera, porque se está haciendo

98
00:03:45,500 --> 00:03:47,520
división entre dos enteros, esta convención a double

99
00:03:47,520 --> 00:03:50,639
no te vale para nada, ¿vale?

100
00:03:50,639 --> 00:03:52,900
si quieres con decimales tendrías que convertir a double

101
00:03:52,900 --> 00:03:55,379
O bien aprobados

102
00:03:55,379 --> 00:03:56,439
O bien alumnos.6

103
00:03:56,439 --> 00:03:56,979
Uno de los dos

104
00:03:56,979 --> 00:04:00,439
Entonces ya la división se convierte en división con decimales

105
00:04:00,439 --> 00:04:01,680
Y ya no tendrías este casting

106
00:04:01,680 --> 00:04:04,340
Es decir, estos paréntesis

107
00:04:04,340 --> 00:04:06,060
Así

108
00:04:06,060 --> 00:04:08,500
Por ejemplo, ya está

109
00:04:08,500 --> 00:04:09,400
Simplemente eso

110
00:04:09,400 --> 00:04:15,319
Porque entiendo yo que el operador va antes del casting

111
00:04:15,319 --> 00:04:16,920
A lo mejor no, a lo mejor me estoy

112
00:04:16,920 --> 00:04:17,899
Colando

113
00:04:17,899 --> 00:04:19,959
Y primero hace el casting

114
00:04:19,959 --> 00:04:25,930
Y luego ya hace la división

115
00:04:25,930 --> 00:04:27,170
No lo sé

116
00:04:27,170 --> 00:04:28,970
Pero yo creo que

117
00:04:28,970 --> 00:04:31,069
En cualquier caso

118
00:04:31,069 --> 00:04:34,889
Esto es más seguro

119
00:04:34,889 --> 00:04:36,449
Pero bueno, se podría comprobar

120
00:04:36,449 --> 00:04:37,769
Para ver exactamente qué hace

121
00:04:37,769 --> 00:04:40,310
Si primero hace la división y luego el casting al revés

122
00:04:40,310 --> 00:04:41,449
Vale

123
00:04:41,449 --> 00:04:44,670
¿Tenemos un alumno con ese NIF?

124
00:04:45,129 --> 00:04:46,930
Pues esto está bien

125
00:04:46,930 --> 00:04:48,930
Porque no ha salido con un retún por medio

126
00:04:48,930 --> 00:04:50,930
Está muy bien

127
00:04:50,930 --> 00:04:51,730
¿Eh?

128
00:04:52,410 --> 00:04:53,009
Vale

129
00:04:53,009 --> 00:04:55,649
Punto string, eliminar alumno

130
00:04:55,649 --> 00:04:57,870
¿Creas un alumno con el criterio de igualdad?

131
00:04:57,870 --> 00:04:58,850
fuera, borrado

132
00:04:58,850 --> 00:05:02,230
y ahora, ahora viene lo que nos interesa

133
00:05:02,230 --> 00:05:03,029
y lo que nos gusta

134
00:05:03,029 --> 00:05:05,230
vamos a hacer un listado

135
00:05:05,230 --> 00:05:07,649
de alumnos alfabéticamente ordenados

136
00:05:07,649 --> 00:05:10,269
pues esto sería tan bonito

137
00:05:10,269 --> 00:05:11,490
como ordenar la lista

138
00:05:11,490 --> 00:05:13,810
ordenar la lista

139
00:05:13,810 --> 00:05:16,189
para eso hay ya algoritmos de ordenación

140
00:05:16,189 --> 00:05:16,649
ya

141
00:05:16,649 --> 00:05:19,949
planteados, como el de la burbuja

142
00:05:19,949 --> 00:05:21,889
el quizor, que no tenemos tiempo para ver

143
00:05:21,889 --> 00:05:23,089
cómo funcionan por dentro

144
00:05:23,089 --> 00:05:26,430
que ya están programados dentro de métodos

145
00:05:26,430 --> 00:05:42,230
Entonces, mi objeto alumnos, por ser una lista, tiene un método sort, ¿vale?, que me ordena, ¿vale?, tiene un método sort que me ordena, alumnos, ¿vale?

146
00:05:42,350 --> 00:05:59,170
Entonces, el método sort me está diciendo que le pase un criterio de comparación, pero yo puedo ignorarlo y decir, no, no te paso ningún criterio de comparación,

147
00:05:59,170 --> 00:06:02,149
porque el criterio de comparación ya lo voy a guardar

148
00:06:02,149 --> 00:06:03,470
en la clase alumna

149
00:06:03,470 --> 00:06:05,110
¿Vale? Ese sería el plan A

150
00:06:05,110 --> 00:06:08,470
El plan B sería no guardar el criterio

151
00:06:08,470 --> 00:06:10,310
en la clase alumno y pasárselo por aquí

152
00:06:10,310 --> 00:06:11,750
Vamos a hacer primero el plan A

153
00:06:11,750 --> 00:06:14,529
Plana, quiero dar a los alumnos

154
00:06:14,529 --> 00:06:16,350
Primera pregunta que me hago

155
00:06:16,350 --> 00:06:18,069
¿Quiero que se queden ordenados de por vida?

156
00:06:18,649 --> 00:06:20,329
¿O solo quiero mostrar el listado alfabético

157
00:06:20,329 --> 00:06:22,350
pero quiero que los alumnos se queden

158
00:06:22,350 --> 00:06:23,670
en el orden de inserción que estaban?

159
00:06:25,209 --> 00:06:25,449
¿Vale?

160
00:06:26,689 --> 00:06:28,370
Pues entonces, depende de lo que yo quiera

161
00:06:28,370 --> 00:06:30,430
porque el método sort

162
00:06:30,430 --> 00:06:31,610
¿qué es lo que hace?

163
00:06:32,870 --> 00:06:33,990
la lista

164
00:06:33,990 --> 00:06:37,399
¿vale?

165
00:06:38,079 --> 00:06:39,740
te la deja ordenada

166
00:06:39,740 --> 00:06:42,379
entonces si no queremos que la deje ordenada

167
00:06:42,379 --> 00:06:44,079
si lo que queremos es solo para el listado

168
00:06:44,079 --> 00:06:46,019
pues entonces podríamos copiar

169
00:06:46,019 --> 00:06:48,560
alumnos en otra lista

170
00:06:48,560 --> 00:06:50,540
y ordenar esa ¿vale?

171
00:06:50,939 --> 00:06:52,680
pero bueno, vamos a ordenarla

172
00:06:52,680 --> 00:06:53,160
sin más

173
00:06:53,160 --> 00:06:56,579
vale, alumnos.sort

174
00:06:57,279 --> 00:06:58,639
y ahora yo

175
00:06:58,639 --> 00:06:59,879
ya la recorrería

176
00:06:59,879 --> 00:07:02,040
mostraría

177
00:07:02,040 --> 00:07:12,490
vale, entonces

178
00:07:12,490 --> 00:07:14,769
ah, que me devuelve la lista ordenada

179
00:07:14,769 --> 00:07:16,350
vale, retun alumnos

180
00:07:16,350 --> 00:07:18,649
bueno, no

181
00:07:18,649 --> 00:07:19,949
que la devuelva, y luego la

182
00:07:19,949 --> 00:07:22,509
es que lo mejor es devolverla y no hacer aquí el siso

183
00:07:22,509 --> 00:07:23,709
eso es lo mejor realmente

184
00:07:23,709 --> 00:07:26,709
retun

185
00:07:26,709 --> 00:07:27,709
alumnos

186
00:07:27,709 --> 00:07:32,480
vale, pues entonces

187
00:07:32,480 --> 00:07:34,339
tú tienes en tu

188
00:07:34,339 --> 00:07:36,379
main unas pruebas

189
00:07:36,379 --> 00:07:37,560
hechas o algo, un menú

190
00:07:37,560 --> 00:07:39,459
y cuáles

191
00:07:39,459 --> 00:07:42,399
todas las funciones del menú te funcionan

192
00:07:42,399 --> 00:07:44,300
¿no? insertar profesor

193
00:07:44,300 --> 00:07:46,120
alargar nuevo alumno, poner nota, mostrar

194
00:07:46,120 --> 00:07:48,000
alumno enfáticamente, las 6 es

195
00:07:48,000 --> 00:07:50,360
¿vale? entonces vamos a suponer que

196
00:07:50,360 --> 00:07:52,379
vamos a ejecutar esto

197
00:07:52,379 --> 00:08:01,839
insertamos

198
00:08:01,839 --> 00:08:03,980
profesor, nif

199
00:08:03,980 --> 00:08:06,240
y nombre, ahí te falta

200
00:08:06,240 --> 00:08:08,199
el next line

201
00:08:08,199 --> 00:08:10,040
vale, pues venga

202
00:08:10,040 --> 00:08:11,920
vámonos a salir

203
00:08:11,920 --> 00:08:12,660
¿con qué se sale?

204
00:08:12,660 --> 00:08:20,860
Vale, pues nos falta

205
00:08:20,860 --> 00:08:23,540
Next in

206
00:08:23,540 --> 00:08:25,600
Y ahora nos queda aquí el next line

207
00:08:25,600 --> 00:08:35,740
¿No? Vale, ejecutamos

208
00:08:35,740 --> 00:08:36,299
Otra vez

209
00:08:36,299 --> 00:08:39,759
Vamos a insertar un profesor

210
00:08:39,759 --> 00:08:44,059
Nib del profesor, Pepe, nombre del profesor

211
00:08:44,059 --> 00:08:45,519
Pepe, nombre

212
00:08:45,519 --> 00:08:48,000
Ala, ya está

213
00:08:48,000 --> 00:08:51,299
Vamos a agregarle un alumno, dos

214
00:08:51,299 --> 00:08:52,700
Para que los ordene alfabéticamente

215
00:08:52,700 --> 00:08:55,100
nif del alumno

216
00:08:55,100 --> 00:08:56,559
1, 2, 3, 4

217
00:08:56,559 --> 00:08:57,919
nombre del alumno

218
00:08:57,919 --> 00:08:59,519
Pepito

219
00:08:59,519 --> 00:09:06,169
nif del profesor a quien se lo quiero agregar

220
00:09:06,169 --> 00:09:06,929
a este

221
00:09:06,929 --> 00:09:10,190
no se ha encontrado el profesor

222
00:09:10,190 --> 00:09:12,129
ya te hemos encontrado un pedazo de bug

223
00:09:12,129 --> 00:09:14,250
no se ha encontrado

224
00:09:14,250 --> 00:09:15,929
el profesor con ese nif

225
00:09:15,929 --> 00:09:17,990
y yo le he pasado un profesor

226
00:09:17,990 --> 00:09:19,009
cuyo nif es este

227
00:09:19,009 --> 00:09:23,429
esto ha fallado en la opción

228
00:09:23,429 --> 00:09:25,710
agregar nuevo alumno a un profesor

229
00:09:25,710 --> 00:09:55,980
Vamos a ver, vamos a agregar nuevo alumno a un profesor, NIF del profesor, aquí lo lees, y ahora llamas a buscar profesor con ese nombre, buscar profesor, recorres la colección de profes, si su NIF, vale, aquí podrías ahorrarte todo esto y poner un equals, ¿no?

230
00:09:55,980 --> 00:09:58,700
Ah, vale

231
00:09:58,700 --> 00:10:01,860
Ah, bueno, vale

232
00:10:01,860 --> 00:10:02,840
Pero podrías haberlo puesto

233
00:10:02,840 --> 00:10:05,759
Entonces, ReptumProfes

234
00:10:05,759 --> 00:10:06,179
Y voy a hacer

235
00:10:06,179 --> 00:10:07,960
.size

236
00:10:07,960 --> 00:10:09,379
Y ahora

237
00:10:09,379 --> 00:10:12,720
Los datos, ¿dónde los tienes?

238
00:10:12,840 --> 00:10:13,360
En el main

239
00:10:13,360 --> 00:10:17,000
Los datos los tienes aquí en el main

240
00:10:17,000 --> 00:10:17,860
¿No? En tus profes

241
00:10:17,860 --> 00:10:21,159
Vale, y tú cuando agregas el profe

242
00:10:21,159 --> 00:10:22,220
Lo has agregado de verdad

243
00:10:22,220 --> 00:10:23,960
Vamos a ver

244
00:10:23,960 --> 00:10:27,659
profes has agregado de verdad

245
00:10:27,659 --> 00:10:29,360
entonces

246
00:10:29,360 --> 00:10:33,340
main buscar profesor

247
00:10:33,340 --> 00:10:44,000
es igual al if que me han dado

248
00:10:44,000 --> 00:10:46,639
vale, y ahora

249
00:10:46,639 --> 00:10:48,000
en tu main

250
00:10:48,000 --> 00:10:54,120
cuando llamas aquí

251
00:10:59,279 --> 00:11:00,000
si

252
00:11:00,000 --> 00:11:00,720
aux

253
00:11:00,720 --> 00:11:02,279
no es null

254
00:11:02,279 --> 00:11:05,059
añades a los alumnos de aux

255
00:11:05,059 --> 00:11:07,779
El alumno, y si no nos ha encontrado

256
00:11:07,779 --> 00:11:09,679
Aquí está entrando en el else, es decir

257
00:11:09,679 --> 00:11:11,620
Aux está siendo null

258
00:11:11,620 --> 00:11:16,179
¿Por qué está siendo aux null?

259
00:11:24,610 --> 00:11:25,750
¿Por qué está siendo null?

260
00:11:25,850 --> 00:11:27,429
Estás recorriendo esta colección

261
00:11:27,429 --> 00:11:27,909
¿Verdad?

262
00:11:29,429 --> 00:11:30,710
Que está aquí arriba

263
00:11:30,710 --> 00:11:37,320
A ver, vamos a volverlo a ejecutar

264
00:11:37,320 --> 00:11:41,759
Nif, uno, dos, tres y cuatro

265
00:11:41,759 --> 00:11:43,159
Nombre

266
00:11:43,159 --> 00:11:45,159
Ya está

267
00:11:45,159 --> 00:11:47,159
Agregar alumno

268
00:11:47,159 --> 00:11:49,299
2, 2, 2, 2

269
00:11:49,299 --> 00:11:51,259
Nombre del alumno

270
00:11:51,259 --> 00:11:53,639
Nif del profesor

271
00:11:53,639 --> 00:11:54,960
A quien se lo queremos agregar

272
00:11:54,960 --> 00:11:57,299
1, 2, 3 y 4

273
00:11:57,299 --> 00:12:00,700
No se ha encontrado el profesor

274
00:12:00,700 --> 00:12:06,879
Bueno, es que en el print

275
00:12:06,879 --> 00:12:09,399
Aquí en el caso 3

276
00:12:09,399 --> 00:12:13,139
Este print sale solo

277
00:12:13,139 --> 00:12:15,139
En el else de este aux

278
00:12:15,139 --> 00:12:17,080
Con lo cual solo si aux es igual a null

279
00:12:17,080 --> 00:12:18,960
Con lo cual

280
00:12:18,960 --> 00:12:20,940
Este método te está devolviendo nulo

281
00:12:20,940 --> 00:12:22,100
Entonces vamos a ponerle aquí

282
00:12:22,100 --> 00:12:24,500
Esto no se hace

283
00:12:24,500 --> 00:12:25,980
Se debuguea, ¿vale?

284
00:12:26,460 --> 00:12:28,679
No se pone en System.Auth

285
00:12:28,679 --> 00:12:31,139
Se hace el debug

286
00:12:31,139 --> 00:12:32,600
Pero como nosotros

287
00:12:32,600 --> 00:12:35,320
Estamos por encima de todo eso

288
00:12:35,320 --> 00:12:37,379
¿Vale?

289
00:12:38,299 --> 00:12:40,940
Vamos a ver el nif del profesor que le pasamos

290
00:12:40,940 --> 00:12:42,320
Eso lo pasamos correctamente

291
00:12:42,320 --> 00:12:43,840
Vamos a ver

292
00:12:43,840 --> 00:12:48,629
Vamos a salir de aquí

293
00:12:48,629 --> 00:12:52,299
Cerrando

294
00:12:52,299 --> 00:12:53,940
Ejecutamos

295
00:12:53,940 --> 00:12:58,789
1, 2, 3 y 4

296
00:12:58,789 --> 00:13:03,620
2, agregar alumno

297
00:13:03,620 --> 00:13:04,940
1, 1, 1, 1

298
00:13:04,940 --> 00:13:07,980
Nombre de alumno, NIF del profesor

299
00:13:07,980 --> 00:13:09,240
1, 2, 3 y 4

300
00:13:09,240 --> 00:13:14,399
Lo coge correctamente

301
00:13:14,399 --> 00:13:16,139
1, 2, 3 y 4

302
00:13:16,139 --> 00:13:18,779
Y ahora cuando llama este método

303
00:13:18,779 --> 00:13:20,879
O sea, esto está claro

304
00:13:20,879 --> 00:13:22,820
Cuando llamamos

305
00:13:22,820 --> 00:13:23,519
Este método

306
00:13:23,519 --> 00:13:46,990
A ver si cuando instancias el profesor

307
00:13:46,990 --> 00:13:49,590
Lo instancias con el nombre y el nif cambiado

308
00:13:49,590 --> 00:13:50,990
Que no sería la primera vez que pasa

309
00:13:50,990 --> 00:13:54,389
Le cambias el nif por nombre

310
00:13:54,389 --> 00:13:56,690
A ver, primero nif y luego nombre

311
00:13:56,690 --> 00:13:58,110
Dis.nif igual a nif

312
00:13:58,110 --> 00:14:00,389
Pues vamos a ver cuando agregas profe

313
00:14:00,389 --> 00:14:04,990
Cuando agregas profe

314
00:14:04,990 --> 00:14:06,169
Míralo

315
00:14:06,169 --> 00:14:08,190
Aquí está el error

316
00:14:08,190 --> 00:14:11,549
Buen ejemplo de que los errores de una zona

317
00:14:11,549 --> 00:14:13,529
suelen venir por cosas que están

318
00:14:13,529 --> 00:14:15,330
completamente alejadas

319
00:14:15,330 --> 00:14:16,529
e impensables

320
00:14:16,529 --> 00:14:19,230
que cuando construía el profesor

321
00:14:19,230 --> 00:14:22,370
le pasa el nombre donde tiene que ir el NIF

322
00:14:22,370 --> 00:14:23,809
y el NIF donde tiene que ir el nombre

323
00:14:23,809 --> 00:14:30,059
entonces uno efectivamente se está 20 años con esto

324
00:14:30,059 --> 00:14:33,740
pero cuando ya le pasa una vez ya no le vuelve a pasar

325
00:14:33,740 --> 00:14:35,440
¿vale? buena enseñanza

326
00:14:35,440 --> 00:14:37,220
¡qué vergüenza!

327
00:14:38,480 --> 00:14:40,340
¿ves? si ya sabías que te ibas a ir humillada

328
00:14:40,340 --> 00:14:43,720
1, 2, 3 y 4

329
00:14:43,720 --> 00:14:47,529
2

330
00:14:47,529 --> 00:14:49,529
agregamos nuevo alumno, nid del alumno

331
00:14:49,529 --> 00:14:51,070
1, 1, 1, 1

332
00:14:51,070 --> 00:14:52,490
Juanito

333
00:14:52,490 --> 00:14:54,929
1, 2, 3 y 4

334
00:14:54,929 --> 00:14:57,529
a ver

335
00:14:57,529 --> 00:14:58,830
que feo

336
00:14:58,830 --> 00:15:01,009
alumno agregado correctamente

337
00:15:01,009 --> 00:15:03,669
vale, pero salvo por alumno

338
00:15:03,669 --> 00:15:05,750
agregado correctamente se supone que ya está

339
00:15:05,750 --> 00:15:07,730
y ahora

340
00:15:07,730 --> 00:15:09,590
vamos a agregarle otro

341
00:15:09,590 --> 00:15:10,990
para ordenar alfabéticamente

342
00:15:10,990 --> 00:15:13,509
que como sabemos que no va a funcionar

343
00:15:13,509 --> 00:15:14,929
venga, vamos a agregar otro alumno

344
00:15:14,929 --> 00:15:16,889
nivel alumno, 2, 2, 2, 2

345
00:15:16,889 --> 00:15:19,409
vamos a llamarle a este

346
00:15:19,409 --> 00:15:20,669
que vaya

347
00:15:20,669 --> 00:15:22,830
antes para que los cambie

348
00:15:22,830 --> 00:15:25,429
esta se llama Ana

349
00:15:25,429 --> 00:15:27,429
nivel

350
00:15:27,429 --> 00:15:28,889
1, 2, 3 y 4

351
00:15:28,889 --> 00:15:30,529
agregado

352
00:15:30,529 --> 00:15:34,440
ahora

353
00:15:34,440 --> 00:15:37,100
si llamamos a la opción

354
00:15:37,100 --> 00:15:37,700
6

355
00:15:37,700 --> 00:15:40,360
la de mostrar a los alfabéticos no entordenados

356
00:15:40,360 --> 00:15:41,480
que es la que llama al sort

357
00:15:41,480 --> 00:15:44,220
Si llamamos a la función 6

358
00:15:44,220 --> 00:15:45,419
¿Vale?

359
00:15:46,519 --> 00:15:47,240
No ha hecho

360
00:15:47,240 --> 00:15:49,700
Espérate, es que debería haber dado un error

361
00:15:49,700 --> 00:15:51,399
En lugar de no hacer nada

362
00:15:51,399 --> 00:15:53,720
Ah, es que la función 6

363
00:15:53,720 --> 00:15:56,340
Vale, en la función 6 lo que nosotros querríamos hacer sería

364
00:15:56,340 --> 00:15:58,379
Un siso de

365
00:15:58,379 --> 00:16:00,299
De

366
00:16:00,299 --> 00:16:03,679
Lo que nos devuelve el método

367
00:16:03,679 --> 00:16:05,539
Que el método está en profesor, ¿verdad?

368
00:16:06,860 --> 00:16:07,220
Entonces

369
00:16:07,220 --> 00:16:09,639
¿Verdad?

370
00:16:09,639 --> 00:16:11,840
de un profesor. Ah, bueno, habrá que pedir el profesor.

371
00:16:12,559 --> 00:16:13,480
Nib del profe.

372
00:16:17,000 --> 00:16:18,059
Control C.

373
00:16:18,539 --> 00:16:18,840
Vale.

374
00:16:21,720 --> 00:16:23,340
Entonces, caso 6.

375
00:16:24,399 --> 00:16:25,740
Necesitamos, antes que nada,

376
00:16:26,500 --> 00:16:27,899
pedir el nib del profesor

377
00:16:27,899 --> 00:16:29,259
del que quiere sacar el listado.

378
00:16:33,440 --> 00:16:34,059
Y ahora,

379
00:16:35,320 --> 00:16:36,480
nib del profesor.

380
00:16:37,539 --> 00:16:38,019
Vale.

381
00:16:39,759 --> 00:16:40,639
Y ahora,

382
00:16:40,940 --> 00:16:43,700
vamos a

383
00:16:43,700 --> 00:16:46,799
sacar la posición en la que está

384
00:16:46,799 --> 00:16:48,879
este profe para luego llamar

385
00:16:48,879 --> 00:16:50,960
a sort, vamos a sacar la posición

386
00:16:50,960 --> 00:16:52,100
en que está este profe

387
00:16:52,100 --> 00:16:54,720
la posición en la que está este profe es

388
00:16:54,720 --> 00:16:55,860
tan fácil como

389
00:16:55,860 --> 00:16:57,320
profes

390
00:16:57,320 --> 00:16:59,639
profes está aquí en mi main

391
00:16:59,639 --> 00:17:01,960
puedo llamarlo directamente

392
00:17:01,960 --> 00:17:03,700
no está aquí profes en mi main

393
00:17:03,700 --> 00:17:05,940
vale

394
00:17:05,940 --> 00:17:10,619
pues profes está aquí

395
00:17:10,619 --> 00:17:12,160
entonces

396
00:17:12,160 --> 00:17:15,440
profes.index

397
00:17:15,440 --> 00:17:27,950
index of new profesor de nif, este de aquí, nombre, me da lo mismo.

398
00:17:30,509 --> 00:17:33,829
Entonces, este me da la posición del profe con ese nif.

399
00:17:33,829 --> 00:17:48,329
Y ahora, el profe con esa posición, get posición, le llamo al método listado alfabético.

400
00:17:48,329 --> 00:17:51,490
Y ahora a este le paso

401
00:17:51,490 --> 00:17:52,769
Sí, lo acabo de llamar

402
00:17:52,769 --> 00:17:54,890
Y ahora ya llamo al SISO de este de aquí

403
00:17:54,890 --> 00:18:00,730
¿Qué método?

404
00:18:05,279 --> 00:18:06,960
Bueno, no es que se pueda eliminar

405
00:18:06,960 --> 00:18:08,960
Es que le metes este código dentro

406
00:18:08,960 --> 00:18:10,680
Le metes esto dentro y ya está

407
00:18:10,680 --> 00:18:13,920
Pero sí que tendrías que sacarlo del main

408
00:18:13,920 --> 00:18:14,579
Idealmente

409
00:18:14,579 --> 00:18:17,220
Vale, pues entonces le ponemos el SISO aquí

410
00:18:17,220 --> 00:18:20,299
Venga

411
00:18:20,299 --> 00:18:38,049
y voy a bajar

412
00:18:38,049 --> 00:18:38,869
esto del system out

413
00:18:38,869 --> 00:18:39,410
aquí abajo

414
00:18:39,410 --> 00:18:42,910
vale

415
00:18:42,910 --> 00:18:43,509
pues lo

416
00:18:43,509 --> 00:18:44,430
que hemos hecho aquí

417
00:18:44,430 --> 00:18:45,230
en este código

418
00:18:45,230 --> 00:18:47,289
lo entendemos

419
00:18:47,289 --> 00:18:47,509
¿no?

420
00:18:48,710 --> 00:18:49,569
nos dan el nif

421
00:18:49,569 --> 00:18:50,369
de un profesor

422
00:18:50,369 --> 00:18:52,769
sacamos

423
00:18:52,769 --> 00:18:54,609
el profesor

424
00:18:54,609 --> 00:18:55,349
con ese nif

425
00:18:55,349 --> 00:18:57,009
no estamos ni validando

426
00:18:57,009 --> 00:18:58,029
que exista o no exista

427
00:18:58,029 --> 00:18:58,670
para hacer como

428
00:18:58,670 --> 00:18:59,349
lo sacamos

429
00:18:59,349 --> 00:19:00,730
entonces primero

430
00:19:00,730 --> 00:19:01,769
he sacado la posición

431
00:19:01,769 --> 00:19:02,690
de ese profe

432
00:19:02,690 --> 00:19:06,069
con el método indexof

433
00:19:06,069 --> 00:19:07,109
que me saca la primera

434
00:19:07,109 --> 00:19:10,150
posición que encuentra

435
00:19:10,150 --> 00:19:12,250
con un profesor

436
00:19:12,250 --> 00:19:14,130
igual a este, y como la igualdad es por

437
00:19:14,130 --> 00:19:16,269
nif, es el nombre, le puedo poner null, me da igual

438
00:19:16,269 --> 00:19:18,029
saco la posición y ahora

439
00:19:18,029 --> 00:19:20,349
este es el profe, es el profe que estoy buscando

440
00:19:20,349 --> 00:19:21,609
y ahora

441
00:19:21,609 --> 00:19:24,109
a este profe

442
00:19:24,109 --> 00:19:25,109
le llamo al método

443
00:19:25,109 --> 00:19:27,589
le llamo al método que me devuelve

444
00:19:27,589 --> 00:19:30,369
la lista de alumnos alfabéticamente ordenados

445
00:19:30,369 --> 00:19:31,990
y ahora ya la estoy

446
00:19:31,990 --> 00:19:33,390
pasando por consola para que la orden

447
00:19:33,390 --> 00:19:35,309
para que la muestre, perdón

448
00:19:35,309 --> 00:19:35,950
vale

449
00:19:35,950 --> 00:19:42,289
vale, claro, eso es lo que quiero hacer

450
00:19:42,289 --> 00:19:44,130
para ver el error que sale, vale

451
00:19:44,130 --> 00:19:47,490
vale, entonces esto, hombre

452
00:19:47,490 --> 00:19:49,890
para ser un poquito más

453
00:19:49,890 --> 00:19:51,869
guays, pues esto será

454
00:19:51,869 --> 00:19:52,970
si lo contiene, verdad

455
00:19:52,970 --> 00:19:54,990
si

456
00:19:54,990 --> 00:19:55,849
profes

457
00:19:55,849 --> 00:19:59,069
contains

458
00:19:59,069 --> 00:20:02,130
a este

459
00:20:02,130 --> 00:20:12,059
vale, si lo contiene

460
00:20:12,059 --> 00:20:14,359
si contiene a un profe igual a este

461
00:20:14,359 --> 00:20:16,119
entonces sí, hacemos todo esto de aquí

462
00:20:16,119 --> 00:20:18,119
si lo contiene

463
00:20:18,119 --> 00:20:20,640
si no lo contiene, pues decimos

464
00:20:20,640 --> 00:20:22,200
oye, es que no existe ese profe

465
00:20:22,200 --> 00:20:22,640
¿verdad?

466
00:20:31,349 --> 00:20:33,650
no existe profe con ese nif

467
00:20:33,650 --> 00:20:40,759
vale, pues la parte del main sería esta

468
00:20:40,759 --> 00:20:43,180
sacamos el profe con ese nif

469
00:20:43,180 --> 00:20:44,559
si es que está

470
00:20:44,559 --> 00:20:46,619
en la lista, a través del contains

471
00:20:46,619 --> 00:20:48,400
está, lo saco

472
00:20:48,400 --> 00:20:50,559
que no está, digo que no existe profe

473
00:20:50,559 --> 00:20:52,900
ahora, efectivamente, cuando ejecutemos

474
00:20:52,900 --> 00:20:53,319
esto

475
00:20:53,319 --> 00:20:55,000
pues

476
00:20:55,000 --> 00:21:03,559
cuando ejecutemos esto

477
00:21:03,559 --> 00:21:06,359
insertamos profesor

478
00:21:06,359 --> 00:21:07,880
1, 2, 3, 4

479
00:21:07,880 --> 00:21:10,000
nombre del profesor

480
00:21:10,000 --> 00:21:12,319
agregar nuevo alumno

481
00:21:12,319 --> 00:21:13,660
1, 1, 1, 1

482
00:21:13,660 --> 00:21:15,579
alum 1

483
00:21:15,579 --> 00:21:20,779
y se lo agrego a este, ahora

484
00:21:20,779 --> 00:21:25,140
2, vamos a agregarle otro, 2, 2, 2, 2

485
00:21:25,140 --> 00:21:28,759
a alum, para que vaya

486
00:21:28,759 --> 00:21:31,900
después, para que vaya antes, perdón

487
00:21:31,900 --> 00:21:35,619
alum 2, vale

488
00:21:35,619 --> 00:21:40,559
nombre del alumno, a quien a este, agregados

489
00:21:40,559 --> 00:21:42,980
lista alfabético, 6

490
00:21:42,980 --> 00:21:46,539
Ah, nif del profesor

491
00:21:46,539 --> 00:21:46,859
Vale

492
00:21:46,859 --> 00:21:49,660
Quiero el listado alfabético del profesor

493
00:21:49,660 --> 00:21:51,160
Un, dos, tres y cuatro

494
00:21:51,160 --> 00:21:51,799
Vale

495
00:21:51,799 --> 00:21:54,599
¿No existe profe con ese nif?

496
00:21:55,799 --> 00:21:58,140
Porque en profesor no hemos hecho el contains

497
00:21:58,140 --> 00:21:59,519
El equals, ¿verdad?

498
00:22:00,519 --> 00:22:01,059
¿Sí está hecho?

499
00:22:01,619 --> 00:22:02,099
Claro

500
00:22:02,099 --> 00:22:06,000
Entonces, ¿por qué no ha encontrado profe con ese nif?

501
00:22:06,579 --> 00:22:08,700
Porque el contains

502
00:22:08,700 --> 00:22:10,039
Tira del equals

503
00:22:10,039 --> 00:22:10,960
¿Vale?

504
00:22:10,960 --> 00:22:13,299
Entonces, como yo no tengo el equals

505
00:22:13,299 --> 00:22:16,019
No he encontrado un profesor igual a este otro

506
00:22:16,019 --> 00:22:17,880
Porque este tiene una dirección de memoria

507
00:22:17,880 --> 00:22:19,160
Y estos tienen otras

508
00:22:19,160 --> 00:22:22,240
Entonces, para que funcione tanto el context

509
00:22:22,240 --> 00:22:23,220
Como el index of

510
00:22:23,220 --> 00:22:24,859
El profesor tiene que tener su equals

511
00:22:24,859 --> 00:22:26,200
Que no lo tiene

512
00:22:26,200 --> 00:22:32,890
Pues vamos a ponérselo

513
00:22:32,890 --> 00:22:34,609
Venga, un equals por nif

514
00:22:34,609 --> 00:22:39,180
Vale, a ver si ya avanzamos

515
00:22:39,180 --> 00:22:40,079
Hasta donde queremos

516
00:22:40,079 --> 00:22:43,380
Ala, volvemos a ejecutar

517
00:22:43,380 --> 00:22:45,000
Uno

518
00:22:45,000 --> 00:22:47,079
Insertar profesor, 1, 2, 3, 4

519
00:22:47,079 --> 00:22:48,140
Vamos a poner solo un alumno

520
00:22:48,140 --> 00:22:50,319
Si total no lo va a ser capaz de ordenar, nos da igual

521
00:22:50,319 --> 00:22:53,160
Nib del alumno, 1, 1, 1

522
00:22:53,160 --> 00:22:54,680
Nombre del alumno

523
00:22:54,680 --> 00:22:57,619
Alum, 1, 2, 3 y 4

524
00:22:57,619 --> 00:23:00,119
6

525
00:23:00,119 --> 00:23:03,039
Nib del profesor, 1, 2, 3 y 4

526
00:23:03,039 --> 00:23:04,039
Vale

527
00:23:04,039 --> 00:23:12,970
¿Por qué no ha saltado el error?

528
00:23:12,970 --> 00:23:15,450
A ver que hemos hecho bien

529
00:23:15,450 --> 00:23:17,170
Si la idea

530
00:23:17,170 --> 00:23:19,029
Vamos a ver

531
00:23:19,029 --> 00:23:22,369
GetPost, alumnos alfabéticamente ordenados.

532
00:23:22,690 --> 00:23:22,970
Vale.

533
00:23:24,089 --> 00:23:24,890
Entonces.

534
00:23:33,579 --> 00:23:36,180
Ya, pero el sort tira del comparable.

535
00:23:36,599 --> 00:23:38,500
Entonces, ¿por qué no me ha salido aquí un?

536
00:23:39,799 --> 00:23:40,240
Un.

537
00:23:43,619 --> 00:23:45,000
Comparar, ¿por qué no me ha salido?

538
00:23:45,720 --> 00:23:47,480
Vale, pues repito rápidamente.

539
00:23:47,839 --> 00:23:49,359
Cuando la lista tiene un solo elemento,

540
00:23:50,019 --> 00:23:51,660
aunque no haya criterio de ordenación,

541
00:23:51,880 --> 00:23:54,940
En tiempo de ejecución no va a fallar porque no intenta ordenar nada.

542
00:23:55,579 --> 00:23:58,339
Cuando tiene más de uno, ya sí que intenta comparar uno con otro.

543
00:23:59,180 --> 00:24:01,599
Entonces, ahí es cuando nos sale este error, ¿vale?

544
00:24:01,619 --> 00:24:02,339
De compararle.

545
00:24:03,200 --> 00:24:03,440
Vale.

546
00:24:04,359 --> 00:24:08,480
Método 1 para hacer ese criterio de ordenación.

547
00:24:08,700 --> 00:24:09,240
Método 1.

548
00:24:10,220 --> 00:24:11,279
Pues hacer lo que nos dice.

549
00:24:12,099 --> 00:24:12,940
¿Qué es?

550
00:24:13,200 --> 00:24:17,480
Bueno, pues voy a hacer que mi clase alumno sea comparable con otros alumnos.

551
00:24:17,480 --> 00:24:29,420
Para eso implemento el rol o la interfaz de comparable

552
00:24:29,420 --> 00:24:33,500
Ahora, como ya sabemos tipos genéricos

553
00:24:33,500 --> 00:24:35,880
Podemos hacer esto un poco más bonito y más pulido

554
00:24:35,880 --> 00:24:37,640
Veis que se pone en amarillo

555
00:24:37,640 --> 00:24:39,619
Y si veis el aviso en amarillo

556
00:24:39,619 --> 00:24:42,839
Dice, cuidado que comparable es una clase genérica

557
00:24:42,839 --> 00:24:45,880
Si tú me pones el comparable sin más

558
00:24:45,880 --> 00:24:48,559
te estás permitiendo comparar alumnos

559
00:24:48,559 --> 00:24:49,559
con cualquier otra cosa

560
00:24:49,559 --> 00:24:52,539
comparar un chorizo con una morcilla

561
00:24:52,539 --> 00:24:54,839
pues no queremos eso en una aplicación

562
00:24:54,839 --> 00:24:56,200
¿vale? entonces

563
00:24:56,200 --> 00:24:58,500
para poder asegurarnos de que los

564
00:24:58,500 --> 00:25:00,500
alumnos solo se pueden comparar

565
00:25:00,500 --> 00:25:01,539
con otros alumnos

566
00:25:01,539 --> 00:25:04,660
vamos a concretar el tipo

567
00:25:04,660 --> 00:25:06,339
genérico de comparable así

568
00:25:06,339 --> 00:25:11,589
¿vale? entonces

569
00:25:11,589 --> 00:25:13,549
repito, comparable

570
00:25:13,549 --> 00:25:15,730
es genérica, una clase genérica ya sabéis

571
00:25:15,730 --> 00:25:17,589
que no hay que especificar

572
00:25:17,589 --> 00:25:20,890
exactamente esa incógnita genérica

573
00:25:20,890 --> 00:25:23,789
para la que trabaja, pero si no se especifica

574
00:25:23,789 --> 00:25:25,670
se supone que trabaja con object

575
00:25:25,670 --> 00:25:29,490
luego, si yo no la especifico, yo podría

576
00:25:29,490 --> 00:25:32,329
comparar, permitiría en tiempo de escritura de código

577
00:25:32,329 --> 00:25:35,710
y el compilador no me diría nada, podría comparar

578
00:25:35,710 --> 00:25:38,150
dentro del compare tú, alumnos

579
00:25:38,150 --> 00:25:42,069
con árboles, y el compilador no me daría ningún problema

580
00:25:42,069 --> 00:25:44,690
a lo mejor estoy haciendo eso porque quiero

581
00:25:44,690 --> 00:25:47,190
o a lo mejor estoy haciendo porque me he equivocado, lo normal es porque me he equivocado

582
00:25:47,190 --> 00:25:48,869
porque una aplicación no quiere comparar

583
00:25:48,869 --> 00:25:51,630
alumnos con árboles, quiere comparar

584
00:25:51,630 --> 00:25:53,730
alumnos con alumnos, profesores con profesores

585
00:25:53,730 --> 00:25:55,690
mesas con mesas, pues vamos a

586
00:25:55,690 --> 00:25:57,569
fijar ya desde el tiempo de escritura

587
00:25:57,569 --> 00:25:59,609
de código, desde el tiempo de compilación, vamos a

588
00:25:59,609 --> 00:26:01,190
fijar ya esa restricción

589
00:26:01,190 --> 00:26:03,569
pues para eso fijamos

590
00:26:03,569 --> 00:26:05,569
el tipo genérico de la interfaz

591
00:26:05,569 --> 00:26:07,589
comparable, lo fijamos

592
00:26:07,589 --> 00:26:09,609
¿vale? y decimos, no, no, no

593
00:26:09,609 --> 00:26:11,809
perdona, cada objeto alumno

594
00:26:11,809 --> 00:26:13,569
solo está permitido

595
00:26:13,569 --> 00:26:15,509
ya desde tiempo de código que se compare con

596
00:26:15,509 --> 00:26:15,970
alumnos

597
00:26:15,970 --> 00:26:19,009
¿Vale? Si abrimos esta comparable

598
00:26:19,009 --> 00:26:20,869
Pues

599
00:26:20,869 --> 00:26:25,089
Si se abriera

600
00:26:25,089 --> 00:26:26,329
Alguna vez

601
00:26:26,329 --> 00:26:28,670
Pues

602
00:26:28,670 --> 00:26:31,170
Bueno, tendría que haberle

603
00:26:31,170 --> 00:26:36,630
Comparable

604
00:26:36,630 --> 00:26:38,450
¿Veis?

605
00:26:38,490 --> 00:26:40,490
Vemos que efectivamente es genérica

606
00:26:40,490 --> 00:26:42,250
Depende del tipo T

607
00:26:42,250 --> 00:26:44,190
Yo lo puedo dejar abierto

608
00:26:44,190 --> 00:26:46,430
Con lo cual sería object o la puedo concretar

609
00:26:46,430 --> 00:26:48,509
Pues me interesa concretarla

610
00:26:48,509 --> 00:26:49,390
Para hacer un código

611
00:26:49,390 --> 00:26:51,569
más robusto, ahora ya

612
00:26:51,569 --> 00:26:53,869
el alumno solo

613
00:26:53,869 --> 00:26:55,190
se va a poder comparar con alumnos

614
00:26:55,190 --> 00:26:57,390
bueno, pues como implementa comparable

615
00:26:57,390 --> 00:26:59,769
ya sabemos que hay que implementar el método

616
00:26:59,769 --> 00:27:00,549
de la interfaz

617
00:27:00,549 --> 00:27:03,509
¿y ese método cuál es?

618
00:27:05,029 --> 00:27:05,630
este

619
00:27:05,630 --> 00:27:07,410
el compare tú

620
00:27:07,410 --> 00:27:09,529
¿veis?

621
00:27:10,130 --> 00:27:11,849
y el compare tú, que es el

622
00:27:11,849 --> 00:27:13,430
método que obligatoriamente tengo que

623
00:27:13,430 --> 00:27:15,910
implementar en alumnos

624
00:27:15,910 --> 00:27:17,069
se implementa comparable

625
00:27:17,069 --> 00:27:19,049
que es este, como veis

626
00:27:19,049 --> 00:27:21,470
ya asume que yo solo puedo

627
00:27:21,470 --> 00:27:22,809
pasar aquí un alumno, solo

628
00:27:22,809 --> 00:27:25,670
si yo el comparar lo hubiera dejado abierto

629
00:27:25,670 --> 00:27:27,549
este compare tú

630
00:27:27,549 --> 00:27:28,430
sería con object

631
00:27:28,430 --> 00:27:31,369
con lo cual yo aquí podría hacer lo que me da la gana

632
00:27:31,369 --> 00:27:33,609
porque no es

633
00:27:33,609 --> 00:27:35,029
obligatorio comparar con un alumno

634
00:27:35,029 --> 00:27:36,970
a lo mejor quiero eso en algún momento

635
00:27:36,970 --> 00:27:39,690
pero eso no responde a una lógica natural

636
00:27:39,690 --> 00:27:41,630
¿vale? entonces me interesa

637
00:27:41,630 --> 00:27:42,569
más concretar

638
00:27:42,569 --> 00:27:43,950
bueno pues ahora ya

639
00:27:43,950 --> 00:27:46,329
¿qué orden quiero yo entre alumnos?

640
00:27:46,609 --> 00:27:49,009
el alfabético, el alfabético va por nombre

641
00:27:49,009 --> 00:27:51,450
ya sabemos que el compare tú

642
00:27:51,450 --> 00:27:52,509
lo que sí que le pasa

643
00:27:52,509 --> 00:27:55,009
es que su criterio es

644
00:27:55,009 --> 00:27:57,690
tiene que devolver negativo

645
00:27:57,690 --> 00:27:59,410
normalmente ponemos menos uno

646
00:27:59,410 --> 00:28:01,170
si el que llama el método

647
00:28:01,170 --> 00:28:03,930
va antes que el parámetro

648
00:28:03,930 --> 00:28:05,269
cero

649
00:28:05,269 --> 00:28:07,490
si es la misma posición de orden

650
00:28:07,490 --> 00:28:09,630
y positivo si el que

651
00:28:09,630 --> 00:28:11,509
llama el método quiero que vaya

652
00:28:11,509 --> 00:28:12,470
después del parámetro

653
00:28:12,470 --> 00:28:15,289
si yo estuviera ordenando por edades

654
00:28:15,289 --> 00:28:16,569
pues sería tan fácil como

655
00:28:16,569 --> 00:28:19,710
devolver la edad del primero menos la edad del segundo

656
00:28:19,710 --> 00:28:21,390
si yo estuviera comparando

657
00:28:21,390 --> 00:28:21,970
por edades

658
00:28:21,970 --> 00:28:24,829
es decir, si mi clase alumno

659
00:28:24,829 --> 00:28:27,289
o por notas, los quiero ordenar por notas

660
00:28:27,289 --> 00:28:29,450
los quiero ordenar por notas

661
00:28:29,450 --> 00:28:31,329
pues podría hacer

662
00:28:31,329 --> 00:28:31,910
esto

663
00:28:31,910 --> 00:28:33,430
retun

664
00:28:33,430 --> 00:28:36,430
dis.nota

665
00:28:36,430 --> 00:28:39,390
menor que o.nota

666
00:28:39,390 --> 00:28:41,289
y así

667
00:28:41,289 --> 00:28:43,309
si el

668
00:28:43,309 --> 00:28:45,150
si el primero

669
00:28:45,150 --> 00:28:47,150
tiene menos nota que el segundo

670
00:28:47,150 --> 00:28:49,450
esto me da negativo

671
00:28:49,450 --> 00:28:51,529
luego efectivamente

672
00:28:51,529 --> 00:28:53,230
el primero iría antes, porque esto me da

673
00:28:53,230 --> 00:28:55,150
negativo, si los quiero ordenar por orden ascendente

674
00:28:55,150 --> 00:28:56,589
claro, por orden ascendente de nota

675
00:28:56,589 --> 00:28:59,369
si los dos tienen la misma nota, esto me daría cero

676
00:28:59,369 --> 00:29:00,990
lo cual significaría misma posición

677
00:29:00,990 --> 00:29:03,349
si el primero tiene más

678
00:29:03,349 --> 00:29:05,589
nota, esto sería positivo

679
00:29:05,589 --> 00:29:07,410
que efectivamente significa

680
00:29:07,410 --> 00:29:08,910
que el primero va después

681
00:29:08,910 --> 00:29:11,390
¿vale? este sería

682
00:29:11,390 --> 00:29:13,789
por ejemplo, el orden

683
00:29:13,789 --> 00:29:16,829
Ascendente de nota

684
00:29:16,829 --> 00:29:20,180
¿Vale?

685
00:29:20,400 --> 00:29:22,140
Que mi criterio de ordenación es

686
00:29:22,140 --> 00:29:24,140
Orden descendente de nota

687
00:29:24,140 --> 00:29:26,960
Pues lo contrario

688
00:29:26,960 --> 00:29:32,539
Pues sería lo contrario

689
00:29:32,539 --> 00:29:44,900
Vale, pero yo no quiero ese orden

690
00:29:44,900 --> 00:29:46,519
Quiero el orden por nombre

691
00:29:46,519 --> 00:29:50,140
Vale, los nombres son string

692
00:29:50,140 --> 00:29:52,519
Ordenar alfabéticamente string

693
00:29:52,519 --> 00:29:54,519
No es trivial, no lo hemos hecho

694
00:29:54,519 --> 00:29:55,900
Menos mal

695
00:29:55,900 --> 00:29:58,259
Que la clase string, por ser una clase

696
00:29:58,259 --> 00:29:59,400
Tiene un montón de métodos ya hechos

697
00:29:59,400 --> 00:30:02,940
entre ellos la clase string tiene un método compare tú

698
00:30:02,940 --> 00:30:06,819
que te compara alfabéticamente un string con el que tú le pases

699
00:30:06,819 --> 00:30:08,380
qué suerte que lo tiene

700
00:30:08,380 --> 00:30:11,019
porque ahora yo lo puedo usar aquí

701
00:30:11,019 --> 00:30:16,240
y si yo pongo dis.nombre

702
00:30:16,240 --> 00:30:19,339
este método tiene un compare tú

703
00:30:19,339 --> 00:30:22,839
que si yo le paso otro string

704
00:30:22,839 --> 00:30:25,319
que en este caso sería o.nombre

705
00:30:25,319 --> 00:30:30,190
pues el método compare tú de la clase string

706
00:30:30,190 --> 00:30:33,109
ya se encarga de devolverme

707
00:30:33,109 --> 00:30:35,950
menos 1 si este está alfabéticamente

708
00:30:35,950 --> 00:30:37,450
antes que este

709
00:30:37,450 --> 00:30:40,529
0 si alfabéticamente son idénticos

710
00:30:40,529 --> 00:30:44,650
y más 1 si este está alfabéticamente después de este

711
00:30:44,650 --> 00:30:46,289
o sea, el compareTo de string

712
00:30:46,289 --> 00:30:49,190
ya me devuelve menos 1, 0, más 1

713
00:30:49,190 --> 00:30:50,970
en función del criterio de orden alfabético

714
00:30:50,970 --> 00:30:53,549
luego el orden alfabético ya está programado aquí

715
00:30:53,549 --> 00:30:56,390
en la clase compareTo de string

716
00:30:56,390 --> 00:30:58,930
pues yo tiro del método compareTo

717
00:30:58,930 --> 00:31:01,730
para hacer mi propio compare tú de alumno.

718
00:31:02,150 --> 00:31:02,730
Y ya está.

719
00:31:03,369 --> 00:31:04,509
Le paso hasta el retún.

720
00:31:05,369 --> 00:31:05,970
Y listo.

721
00:31:09,099 --> 00:31:14,220
Luego ya tengo mi compare tú de alumno.

722
00:31:15,759 --> 00:31:19,359
Que se apoya en el compare tú de la clase string.

723
00:31:24,700 --> 00:31:26,859
Y así haría yo el criterio que me diera a mí la gana

724
00:31:26,859 --> 00:31:28,220
programándolo como quisiera.

725
00:31:30,880 --> 00:31:31,900
Pero eso te lo...

726
00:31:31,900 --> 00:31:33,839
Te ha tomado un orden...

727
00:31:33,839 --> 00:31:34,400
Alfabético.

728
00:31:35,140 --> 00:31:38,000
El compare tú de string está pensado para el orden alfabético

729
00:31:38,000 --> 00:31:38,880
según la tabla ASTI

730
00:31:38,880 --> 00:31:41,880
pues

731
00:31:41,880 --> 00:31:46,539
multiplicas por menos uno

732
00:31:46,539 --> 00:31:47,099
ya está

733
00:31:47,099 --> 00:31:51,559
entonces en orden alfabético inverso

734
00:31:51,559 --> 00:31:52,619
multiplicas por menos uno

735
00:31:52,619 --> 00:32:13,000
pues ahora ya sí que no nos va a dar

736
00:32:13,000 --> 00:32:13,559
ese error

737
00:32:13,559 --> 00:32:16,119
para cualquier situación

738
00:32:16,119 --> 00:32:21,170
no, no, no

739
00:32:21,170 --> 00:32:24,390
No, no, no

740
00:32:24,390 --> 00:32:25,369
Porque el criterio

741
00:32:25,369 --> 00:32:26,869
Yo ahí dejo mi null sin problema

742
00:32:26,869 --> 00:32:29,390
Este null, ese es el plan B

743
00:32:29,390 --> 00:32:30,950
Si yo no tengo el comparable

744
00:32:30,950 --> 00:32:32,849
Entonces ya sí que lo tengo que meter ahí

745
00:32:32,849 --> 00:32:33,490
Pero es el plan B

746
00:32:33,490 --> 00:32:36,250
Si yo ya en comparable tengo el criterio

747
00:32:36,250 --> 00:32:38,609
En ese sort puede ir un null

748
00:32:38,609 --> 00:32:39,690
Porque ya no lo necesita

749
00:32:39,690 --> 00:32:43,150
Null porque vacío no me lo admite

750
00:32:43,150 --> 00:32:46,049
El sort necesita siempre algo

751
00:32:46,049 --> 00:32:47,930
Si tú no quieres darle nada

752
00:32:47,930 --> 00:32:49,789
Un null, que un null es un objeto válido

753
00:32:49,789 --> 00:32:51,089
¿Vale?

754
00:32:51,170 --> 00:32:53,410
Entonces, el método estaba aquí, ¿no?

755
00:32:56,299 --> 00:32:56,819
¿Vale?

756
00:32:57,140 --> 00:32:59,619
El método sort no admite ir sin parámetros.

757
00:33:00,079 --> 00:33:05,420
Pero yo el objeto que necesita no lo va a usar porque ya tiene el del comparable.

758
00:33:05,619 --> 00:33:06,940
Pues le paso el objeto null.

759
00:33:09,180 --> 00:33:12,400
Entonces, ahora debería funcionar.

760
00:33:14,220 --> 00:33:15,180
Insertar profe.

761
00:33:15,299 --> 00:33:16,420
Un, dos, tres y cuatro.

762
00:33:16,799 --> 00:33:17,819
Nombre del profesor.

763
00:33:19,059 --> 00:33:19,960
Agregar alumno.

764
00:33:20,460 --> 00:33:22,740
Vamos a agregar primero al alumno Zazo.

765
00:33:23,500 --> 00:33:30,220
Ah, no, el NIF, 1, 1, 1, 1, y se llama Zazo, a 1, 2, 3, 4.

766
00:33:31,039 --> 00:33:37,500
Y ahora le agregamos otro, desordenado alfabéticamente, Aka.

767
00:33:38,059 --> 00:33:42,079
No, el NIF es 2, 2, 2, 2, y se llama Aka.

768
00:33:43,039 --> 00:33:46,079
NIF del profesor, 1, 2, 3 y 4.

769
00:33:46,079 --> 00:33:52,160
Vale, vamos a mostrar los alumnos alfabéticamente ordenados

770
00:33:52,160 --> 00:33:56,099
¿De quién? De 1, de 2, de 3 y de 4

771
00:33:56,099 --> 00:33:58,980
Vale, aquí los tenemos

772
00:33:58,980 --> 00:34:01,460
Ordenados alfabéticamente

773
00:34:01,460 --> 00:34:05,759
Primero el AK, aunque yo le puse después

774
00:34:05,759 --> 00:34:08,760
Yo le puse después, pero al ordenar la lista

775
00:34:08,760 --> 00:34:10,639
Pues ahí se ha quedado

776
00:34:10,639 --> 00:34:18,369
Ahí está ordenadito

777
00:34:18,369 --> 00:34:27,949
Bueno, pues paramos unos minutos

778
00:34:27,949 --> 00:34:29,690
Y luego el plan B, para ordenar

779
00:34:29,690 --> 00:34:31,510
Cuando yo no puedo hacer el comparable

780
00:34:31,510 --> 00:34:32,530
¿Qué puede ocurrir?

781
00:34:33,590 --> 00:34:34,730
Venga, paramos unos minutos