1
00:00:00,560 --> 00:00:03,439
Ya sabemos que la forma más cómoda siempre es un file chooser

2
00:00:03,439 --> 00:00:06,940
y eso ya más o menos casi nos lo sabemos de memoria.

3
00:00:07,879 --> 00:00:09,720
Que es instanciar el objeto.

4
00:00:15,050 --> 00:00:16,789
Primero instanciamos el objeto.

5
00:00:23,809 --> 00:00:25,769
Una vez que tenemos instanciado el objeto,

6
00:00:27,070 --> 00:00:29,870
ahora ya tenemos que abrir el cuadro de diálogo.

7
00:00:30,789 --> 00:00:33,890
Abrir el cuadro de diálogo se hacía con un método

8
00:00:33,890 --> 00:00:37,649
que empezaría por show, digo yo,

9
00:00:37,649 --> 00:00:39,670
open o save

10
00:00:39,670 --> 00:00:41,750
pues depende si queremos

11
00:00:41,750 --> 00:00:43,710
que aparezca open o save

12
00:00:43,710 --> 00:00:45,609
en el botoncito, como en este caso es para abrir

13
00:00:45,609 --> 00:00:46,649
pues open mejor

14
00:00:46,649 --> 00:00:49,030
vale

15
00:00:49,030 --> 00:00:51,909
esto le pasamos null

16
00:00:51,909 --> 00:00:53,750
porque es la ventana padre

17
00:00:53,750 --> 00:00:55,670
a la que va anclada, solo tenemos una

18
00:00:55,670 --> 00:00:56,950
ventana padre, pues nada

19
00:00:56,950 --> 00:01:01,320
y ahora esto nos devolvía

20
00:01:01,320 --> 00:01:03,219
¿verdad? un numerito

21
00:01:03,219 --> 00:01:07,060
entero que estaba

22
00:01:07,060 --> 00:01:08,939
relacionado con la opción

23
00:01:08,939 --> 00:01:10,980
que hubiera marcado el usuario en esa ventana

24
00:01:10,980 --> 00:01:12,799
de diálogo, si había marcado open

25
00:01:12,799 --> 00:01:14,319
o había marcado cancel

26
00:01:14,319 --> 00:01:16,400
¿vale? entonces

27
00:01:16,400 --> 00:01:19,180
ahora ya esa opción

28
00:01:19,180 --> 00:01:20,900
podía ser

29
00:01:20,900 --> 00:01:22,159
la de aprobar

30
00:01:22,159 --> 00:01:25,000
entonces si la opción que han marcado

31
00:01:25,000 --> 00:01:26,900
resulta que es

32
00:01:26,900 --> 00:01:27,980
igual a

33
00:01:27,980 --> 00:01:32,659
approve option, es porque ha dado la de open

34
00:01:32,659 --> 00:01:34,459
y en este caso

35
00:01:34,459 --> 00:01:36,579
ya podemos coger el nombre del fichero

36
00:01:36,579 --> 00:01:38,379
¿vale? el nombre del fichero

37
00:01:38,379 --> 00:01:40,659
el nombre del fichero

38
00:01:40,659 --> 00:01:44,459
Lo tenemos que tener guardado

39
00:01:44,459 --> 00:01:46,480
En algún sitio de ámbito global

40
00:01:46,480 --> 00:01:48,400
Porque el resto de la aplicación

41
00:01:48,400 --> 00:01:50,000
Va a trabajar con ese fichero

42
00:01:50,000 --> 00:01:51,140
Para

43
00:01:51,140 --> 00:01:54,159
Para abrirlo, para lo que sea

44
00:01:54,159 --> 00:01:56,480
Entonces, ¿tenemos alguna variable para guardar ese fichero?

45
00:01:57,079 --> 00:01:58,280
Pues no, todavía no

46
00:01:58,280 --> 00:02:00,120
Todavía no

47
00:02:00,120 --> 00:02:02,519
Pues venga, vamos a crearla

48
00:02:02,519 --> 00:02:03,239
Aquí, por ejemplo

49
00:02:03,239 --> 00:02:06,890
Bueno, podemos

50
00:02:06,890 --> 00:02:09,669
Puede ser file, puede ser string

51
00:02:09,669 --> 00:02:12,629
¿Vale? Nombre del fichero

52
00:02:12,629 --> 00:02:15,169
csv, nombre del fichero csv

53
00:02:15,169 --> 00:02:16,909
que vamos a abrir, bueno pues

54
00:02:16,909 --> 00:02:19,009
el nombre del fichero csv que vamos a

55
00:02:19,009 --> 00:02:20,669
abrir, ahora ya si que podemos

56
00:02:20,669 --> 00:02:22,849
obtenerlo en este

57
00:02:22,849 --> 00:02:23,289
momento

58
00:02:23,289 --> 00:02:25,750
porque será

59
00:02:25,750 --> 00:02:33,080
no lo he llamado así seguro, verdad

60
00:02:33,080 --> 00:02:34,780
non-fich csv

61
00:02:34,780 --> 00:02:43,060
será de mir file chooser

62
00:02:43,060 --> 00:02:49,060
el get

63
00:02:49,060 --> 00:02:53,289
bueno como me lo devuelve en file

64
00:02:53,289 --> 00:02:55,189
pues efectivamente como me lo

65
00:02:55,189 --> 00:02:57,370
devuelve en file, vamos a declararlo como file

66
00:02:57,370 --> 00:02:58,090
y ya está

67
00:02:58,090 --> 00:03:06,139
fichero csv

68
00:03:06,139 --> 00:03:08,219
el objeto

69
00:03:08,219 --> 00:03:09,939
file asociado a ese fichero

70
00:03:09,939 --> 00:03:12,400
ya lo

71
00:03:12,400 --> 00:03:13,360
tengo aquí

72
00:03:13,360 --> 00:03:20,729
vale, ala

73
00:03:20,729 --> 00:03:22,810
entonces, ese evento era

74
00:03:22,810 --> 00:03:24,990
para abrir el objeto

75
00:03:24,990 --> 00:03:26,270
file con el que vamos a trabajar

76
00:03:26,270 --> 00:03:28,849
y luego ya la aplicación

77
00:03:29,430 --> 00:03:35,069
tiene que hacer algo más este evento

78
00:03:35,069 --> 00:03:37,229
pues en principio

79
00:03:37,229 --> 00:03:38,530
no, me ha habilitado esa variable

80
00:03:38,530 --> 00:03:41,069
y ahora con esa variable que ya está habilitada

81
00:03:41,069 --> 00:03:43,189
global, accesible para todo el mundo

82
00:03:43,189 --> 00:03:44,750
ahora yo ya puedo

83
00:03:44,750 --> 00:03:46,990
hacer las opciones de serializar

84
00:03:46,990 --> 00:03:48,930
que ahora ya sí que es

85
00:03:48,930 --> 00:03:50,689
leer del fichero y construir los objetos

86
00:03:50,689 --> 00:03:52,990
¿cierto? bueno pues este evento

87
00:03:52,990 --> 00:03:53,830
ya no tiene nada más

88
00:03:53,830 --> 00:03:56,909
podemos poner el nombre del fichero seleccionado

89
00:03:56,909 --> 00:03:58,169
en una etiqueta debajo

90
00:03:58,169 --> 00:04:00,909
pues que de hecho habíamos puesto una etiqueta ahí

91
00:04:00,909 --> 00:04:02,370
para poner el nombre del fichero seleccionado

92
00:04:02,370 --> 00:04:04,610
pues vamos a poner la etiqueta se llama

93
00:04:04,610 --> 00:04:06,370
nombre fichero, pues entonces

94
00:04:06,370 --> 00:04:07,310
que ese evento

95
00:04:07,310 --> 00:04:12,550
eso, que ese evento

96
00:04:12,550 --> 00:04:14,889
en nuestra etiqueta que se llamaba

97
00:04:14,889 --> 00:04:16,870
se me ha olvidado como se llamaba

98
00:04:16,870 --> 00:04:18,230
nombre fichero seguramente

99
00:04:18,230 --> 00:04:22,470
punto

100
00:04:22,470 --> 00:04:23,649
set test

101
00:04:23,649 --> 00:04:25,829
y ahora

102
00:04:25,829 --> 00:04:28,129
mi fichero que es este

103
00:04:28,129 --> 00:04:33,600
como este es el objeto file

104
00:04:33,600 --> 00:04:35,860
lo que queremos es una de las propiedades del objeto

105
00:04:35,860 --> 00:04:37,259
file que es su nombre

106
00:04:37,259 --> 00:04:40,259
pues lo sacamos con get name

107
00:04:40,259 --> 00:04:42,500
por ejemplo

108
00:04:42,500 --> 00:04:44,639
o con

109
00:04:44,639 --> 00:04:46,540
depende si es lo que

110
00:04:46,540 --> 00:04:48,540
queramos mostrar toda la ruta, vamos a poner get name

111
00:04:48,540 --> 00:04:49,620
a ver que me saca

112
00:04:49,620 --> 00:04:52,259
nombre fichero

113
00:04:52,259 --> 00:04:54,500
lo tengo declarado aquí

114
00:04:54,500 --> 00:04:56,519
debajo, entonces la vamos a subir arriba

115
00:04:56,519 --> 00:05:01,160
y ya está

116
00:05:01,160 --> 00:05:03,500
subida arriba

117
00:05:03,500 --> 00:05:05,819
vale, pues ese evento ya está entero

118
00:05:05,819 --> 00:05:07,779
está claro

119
00:05:07,779 --> 00:05:09,519
¿no? recordad que en general

120
00:05:09,519 --> 00:05:12,379
las clases internas, las clases anónimas

121
00:05:12,379 --> 00:05:13,420
que son los eventos

122
00:05:13,420 --> 00:05:16,379
sirven para cambiar valores

123
00:05:16,379 --> 00:05:18,220
de variables que están

124
00:05:18,220 --> 00:05:20,259
accesibles por parte

125
00:05:20,259 --> 00:05:21,480
del resto de eventos

126
00:05:21,480 --> 00:05:24,079
entonces yo tendré, siempre tengo que tener claro

127
00:05:24,079 --> 00:05:26,160
con qué datos trabaja mi aplicación, esta aplicación

128
00:05:26,160 --> 00:05:28,339
trabaja con un objeto file

129
00:05:28,339 --> 00:05:29,480
bueno, pues objeto file

130
00:05:29,480 --> 00:05:32,100
lo declaro en espacio global para cualquiera

131
00:05:32,100 --> 00:05:33,980
de las clases anónimas, puedo trabajar con él

132
00:05:33,980 --> 00:05:36,399
bueno, pues ahora ya serializar

133
00:05:36,399 --> 00:05:38,000
tendrá

134
00:05:38,000 --> 00:05:40,300
una respuesta a evento

135
00:05:40,300 --> 00:05:42,959
y va a necesitar

136
00:05:42,959 --> 00:05:43,660
ese objeto file.

137
00:05:44,120 --> 00:05:45,259
Bueno, pues, ¿qué tiene que hacer este?

138
00:05:45,920 --> 00:05:46,699
Tiene que,

139
00:05:48,139 --> 00:05:50,540
de ese CSV, que se supone que tiene esta estructura,

140
00:05:51,319 --> 00:05:52,160
tiene que construir

141
00:05:52,160 --> 00:05:54,420
un objeto

142
00:05:54,420 --> 00:05:55,519
persona

143
00:05:55,519 --> 00:05:57,439
por cada línea.

144
00:05:58,660 --> 00:05:59,139
¿Vale?

145
00:05:59,459 --> 00:06:01,180
Y luego ya esos objetos persona

146
00:06:01,180 --> 00:06:02,100
guardarlos en un fichero.

147
00:06:02,560 --> 00:06:04,639
Luego la clase persona nos falta.

148
00:06:05,160 --> 00:06:07,560
Para hacer objetos persona necesitamos una clase persona.

149
00:06:08,000 --> 00:06:13,259
Pues, ala, vamos a hacer una clase Persona.

150
00:06:21,259 --> 00:06:28,560
Y esta clase Persona tiene como propiedades nombre NIF y lista de teléfonos.

151
00:06:28,879 --> 00:06:36,180
Como la lista de teléfonos tiene longitud variable, pues necesitamos que sea un list, ¿vale?

152
00:06:36,180 --> 00:06:38,399
o un array o un conjunto

153
00:06:38,399 --> 00:06:40,720
podría ser un conjunto porque los teléfonos

154
00:06:40,720 --> 00:06:41,699
suponen que no se repiten

155
00:06:41,699 --> 00:06:44,500
entonces como los teléfonos no se repiten

156
00:06:44,500 --> 00:06:45,600
vamos a poner un conjunto

157
00:06:45,600 --> 00:06:48,620
y de hecho vamos a poner

158
00:06:48,620 --> 00:06:50,639
hasta un triset para que

159
00:06:50,639 --> 00:06:52,319
si esta aplicación me manda

160
00:06:52,319 --> 00:06:54,240
listados del listado de teléfonos

161
00:06:54,240 --> 00:06:55,339
pues bueno, ya que por orden

162
00:06:55,339 --> 00:06:57,500
¿para qué quiere uno por orden?

163
00:06:57,839 --> 00:06:59,879
pues ya que alguien que sea muy maniático

164
00:06:59,879 --> 00:07:01,959
por ejemplo

165
00:07:01,959 --> 00:07:03,759
mi zona era 9138

166
00:07:03,759 --> 00:07:05,339
mi zona era 9138

167
00:07:05,339 --> 00:07:10,939
Bueno, por si acaso tuvieron interés

168
00:07:10,939 --> 00:07:11,579
Pues ya está

169
00:07:11,579 --> 00:07:12,980
Pues hala

170
00:07:12,980 --> 00:07:15,199
El nombre

171
00:07:15,199 --> 00:07:17,779
Y el NIF

172
00:07:17,779 --> 00:07:22,920
Sabías donde vivía

173
00:07:22,920 --> 00:07:24,220
El colega

174
00:07:24,220 --> 00:07:26,360
Vale

175
00:07:26,360 --> 00:07:27,759
Y ahora esto va a ser un

176
00:07:27,759 --> 00:07:30,759
Un conjunto

177
00:07:30,759 --> 00:07:32,699
De números de teléfono

178
00:07:32,699 --> 00:07:34,939
Los números de teléfono

179
00:07:34,939 --> 00:07:36,699
Podríamos guardarlo como ínteger

180
00:07:36,699 --> 00:07:38,519
Pero es que es un ínteger tan feo y tan largo

181
00:07:38,519 --> 00:07:40,079
Que

182
00:07:40,079 --> 00:07:48,220
Por ejemplo, pero si tienen el más

183
00:07:48,220 --> 00:07:50,379
Al guardarlo como string

184
00:07:50,379 --> 00:07:51,660
Lo va a ordenar en orden alfabético

185
00:07:51,660 --> 00:07:54,420
Que como es el de cifras, pero si pones un más

186
00:07:54,420 --> 00:07:56,660
Ya te va a cambiar

187
00:07:56,660 --> 00:07:58,819
Pero bueno, como nos gustan los trisets

188
00:07:58,819 --> 00:08:00,160
Y queremos ver las cosas ordenadas

189
00:08:00,160 --> 00:08:02,500
Según en este caso la tabla ASTI

190
00:08:02,500 --> 00:08:04,259
Al guardarlo como string lo va a ordenar

191
00:08:04,259 --> 00:08:06,439
como caracteres así, pues vamos

192
00:08:06,439 --> 00:08:07,839
a hacer un

193
00:08:07,839 --> 00:08:10,319
¿Os parece bien, no?

194
00:08:10,639 --> 00:08:12,339
Un triset de teléfonos.

195
00:08:12,660 --> 00:08:14,079
Porque nos gusta innovar.

196
00:08:14,600 --> 00:08:14,839
Vale.

197
00:08:30,920 --> 00:08:32,220
Si no pongo el new,

198
00:08:38,330 --> 00:08:38,850
vale.

199
00:08:40,230 --> 00:08:42,809
Entonces, recordad que esta estructura

200
00:08:42,809 --> 00:08:43,929
respecto

201
00:08:43,929 --> 00:08:46,409
a los sets

202
00:08:46,409 --> 00:08:48,350
siempre son mejores que las listas

203
00:08:48,350 --> 00:08:50,529
computacionalmente, está claro. Porque no tienen que

204
00:08:50,529 --> 00:08:52,750
gestionar el tema de las posiciones

205
00:08:52,750 --> 00:08:55,029
problema que no admiten

206
00:08:55,029 --> 00:08:56,389
duplicados, eso ya lo sabemos

207
00:08:56,389 --> 00:08:58,450
no se puede repetir un elemento

208
00:08:58,450 --> 00:09:00,090
varias veces en el conjunto

209
00:09:00,090 --> 00:09:03,129
si no necesitamos

210
00:09:03,129 --> 00:09:04,470
duplicados como es este caso

211
00:09:04,470 --> 00:09:06,649
porque los teléfonos van a repetir un conjunto

212
00:09:06,649 --> 00:09:08,950
dentro de las alternativas

213
00:09:08,950 --> 00:09:10,110
has set, tree set

214
00:09:10,110 --> 00:09:12,929
si vamos a generar listados

215
00:09:12,929 --> 00:09:15,070
ordenados, el orden de los elementos

216
00:09:15,070 --> 00:09:17,149
nos importa porque vamos a iterar

217
00:09:17,149 --> 00:09:18,409
y vamos a mostrar

218
00:09:18,409 --> 00:09:20,370
y nos viene muy bien que nos muestre por orden

219
00:09:20,370 --> 00:09:22,669
pues un triset, en principio no habría

220
00:09:22,669 --> 00:09:24,190
otra razón para elegir un triset

221
00:09:24,190 --> 00:09:26,490
que no fuera que los elementos

222
00:09:26,490 --> 00:09:28,289
en algún momento voy a iterar por ellos

223
00:09:28,289 --> 00:09:30,470
y me va a venir bien que aparezcan por orden

224
00:09:30,470 --> 00:09:32,649
en este caso

225
00:09:32,649 --> 00:09:34,370
¿qué orden va a ser? repito, pues

226
00:09:34,370 --> 00:09:36,450
el orden que esté establecido entre

227
00:09:36,450 --> 00:09:38,529
los string, y entre los string

228
00:09:38,529 --> 00:09:40,129
el orden no lo decidimos nosotros

229
00:09:40,129 --> 00:09:42,490
está ya establecido como

230
00:09:42,490 --> 00:09:43,570
el alfabético

231
00:09:43,570 --> 00:09:48,710
si nosotros dijéramos

232
00:09:48,710 --> 00:09:50,289
oye, quiero ordenar

233
00:09:50,289 --> 00:09:52,370
los números, quiero tener números de teléfono

234
00:09:52,370 --> 00:09:54,210
quiero que estén ordenados

235
00:09:54,210 --> 00:09:56,509
pero no quiero el orden alfabético

236
00:09:56,509 --> 00:09:57,809
quiero otro orden

237
00:09:57,809 --> 00:10:00,529
¿qué solución

238
00:10:00,529 --> 00:10:01,289
adoptaríais?

239
00:10:01,889 --> 00:10:04,450
porque no podéis meteros en la clase

240
00:10:04,450 --> 00:10:06,409
string, a la clase string de la máquina

241
00:10:06,409 --> 00:10:08,450
virtual uno no puede meterse, cambiar

242
00:10:08,450 --> 00:10:10,169
el compare to porque se le ha puesto

243
00:10:10,169 --> 00:10:12,370
recompilarlo y volverlo a meter en la

244
00:10:12,370 --> 00:10:14,370
JRE, eso jamás lo haríamos

245
00:10:14,370 --> 00:10:17,309
y si no hacemos eso

246
00:10:17,309 --> 00:10:20,250
el triset va a iterar siempre el orden

247
00:10:20,250 --> 00:10:21,509
del string que sea alfabético

248
00:10:21,509 --> 00:10:24,250
pero a nosotros no nos interesa que el orden sea alfabético

249
00:10:24,250 --> 00:10:25,029
nos interesa otro

250
00:10:25,029 --> 00:10:27,470
¿qué solución podríamos incorporar aquí?

251
00:10:28,169 --> 00:10:30,570
un comparator

252
00:10:30,570 --> 00:10:32,350
instanciar

253
00:10:32,350 --> 00:10:32,870
el triset

254
00:10:32,870 --> 00:10:35,429
con un objeto comparador

255
00:10:35,429 --> 00:10:38,720
¿vale?

256
00:10:38,720 --> 00:10:42,600
pero tendríamos que hacer

257
00:10:42,600 --> 00:10:44,379
un objeto comparador

258
00:10:44,379 --> 00:10:46,299
el criterio de comparación que fuera

259
00:10:46,299 --> 00:10:48,100
comparador

260
00:10:48,100 --> 00:10:50,039
¿eh?

261
00:10:50,340 --> 00:10:51,480
14.000 criterios

262
00:10:51,480 --> 00:10:54,100
bueno, si yo lo llamo como quiera, la clase

263
00:10:54,100 --> 00:10:56,200
entonces

264
00:10:56,200 --> 00:10:58,500
me tendría que crear esta clase

265
00:10:58,500 --> 00:11:00,320
de tal forma

266
00:11:00,320 --> 00:11:02,679
que fuera un criterio de comparación

267
00:11:02,679 --> 00:11:04,440
y para que fuera un criterio

268
00:11:04,440 --> 00:11:05,399
de comparación

269
00:11:05,399 --> 00:11:07,919
tiene que implementar

270
00:11:07,919 --> 00:11:09,299
esto

271
00:11:09,299 --> 00:11:11,320
entonces

272
00:11:11,320 --> 00:11:18,220
ahora, aquí ya

273
00:11:18,220 --> 00:11:19,759
me invento yo

274
00:11:19,759 --> 00:11:22,200
el criterio de ordenación de string

275
00:11:22,200 --> 00:11:23,299
que me dé la gana

276
00:11:23,299 --> 00:11:26,240
el criterio de ordenación de string que me dé la gana

277
00:11:26,240 --> 00:11:28,200
porque no me gusta el alfabético

278
00:11:28,200 --> 00:11:30,279
el que quisiéramos

279
00:11:30,279 --> 00:11:32,179
¿qué otro criterio de ordenación

280
00:11:32,179 --> 00:11:32,740
de string?

281
00:11:35,059 --> 00:11:36,080
por ejemplo

282
00:11:36,080 --> 00:11:37,899
el alfabético inverso

283
00:11:37,899 --> 00:11:38,700
nos apetece

284
00:11:38,700 --> 00:11:42,179
que nos itere en alfabético inverso

285
00:11:42,179 --> 00:11:45,879
claro

286
00:11:45,879 --> 00:11:47,759
pues cambiar el signo

287
00:11:47,759 --> 00:11:49,240
a lo que me devolvería el otro

288
00:11:49,240 --> 00:11:51,000
podríamos hacer

289
00:11:51,000 --> 00:11:53,120
return

290
00:11:53,120 --> 00:11:56,440
O1, que es el primer string

291
00:11:56,440 --> 00:11:58,179
compare tú O2

292
00:11:58,179 --> 00:12:02,039
pero esto cambiado de signo

293
00:12:02,039 --> 00:12:07,639
vale, ya está

294
00:12:07,639 --> 00:12:09,299
me acabo de hacer

295
00:12:09,299 --> 00:12:10,480
el alfabético inverso

296
00:12:10,480 --> 00:12:13,220
un crítico de ordenación alfabético inverso

297
00:12:13,220 --> 00:12:15,179
porque este es el alfabético normal

298
00:12:15,179 --> 00:12:16,320
entre O1 y O2

299
00:12:16,320 --> 00:12:18,399
le multiplico por menos 1

300
00:12:18,399 --> 00:12:20,240
pues alfabético inverso

301
00:12:20,240 --> 00:12:22,860
si comparas el O2 con dentro del O1 ya te lo haces

302
00:12:22,860 --> 00:12:25,720
sí, efectivamente

303
00:12:25,720 --> 00:12:28,419
también, pongo el o2 antes que el o1

304
00:12:28,419 --> 00:12:29,600
claro, efectivamente

305
00:12:29,600 --> 00:12:32,179
vale, pero bueno

306
00:12:32,179 --> 00:12:34,399
no viene mal que recordemos que como funciona

307
00:12:34,399 --> 00:12:36,159
es, te va a devolver

308
00:12:36,159 --> 00:12:38,360
uno si este va

309
00:12:38,360 --> 00:12:39,580
antes de este otro

310
00:12:39,580 --> 00:12:41,700
cero si son el mismo

311
00:12:41,700 --> 00:12:43,980
y menos uno, perdón

312
00:12:43,980 --> 00:12:45,539
te devuelve negativo

313
00:12:45,539 --> 00:12:47,320
si este va antes

314
00:12:47,320 --> 00:12:49,159
cero si son el mismo

315
00:12:49,159 --> 00:12:51,440
y positivo si este va después

316
00:12:51,440 --> 00:12:54,179
entonces o1 compare tu o2

317
00:12:54,179 --> 00:12:56,259
te va a devolver menos 1 si este va antes

318
00:12:56,259 --> 00:12:58,159
como yo quiero que el orden sea el inverso

319
00:12:58,159 --> 00:13:00,159
multiplico por menos 1 para que me dé 1 y ya está

320
00:13:00,159 --> 00:13:02,039
bueno, pues

321
00:13:02,039 --> 00:13:03,960
¿vale? entonces

322
00:13:03,960 --> 00:13:05,980
de esta manera

323
00:13:05,980 --> 00:13:07,559
conseguimos que

324
00:13:07,559 --> 00:13:10,039
para este triset

325
00:13:10,039 --> 00:13:12,679
cuando él vaya metiendo los teléfonos

326
00:13:12,679 --> 00:13:14,200
los vaya metiendo

327
00:13:14,200 --> 00:13:15,759
en el orden que fija este

328
00:13:15,759 --> 00:13:17,399
en el orden que fija este

329
00:13:17,399 --> 00:13:19,980
no en el orden que fija el comparable de string

330
00:13:19,980 --> 00:13:21,600
es lo que conseguimos

331
00:13:21,600 --> 00:13:23,500
¿vale?

332
00:13:23,500 --> 00:13:25,799
solamente a efectos del triset

333
00:13:25,799 --> 00:13:27,799
solo a efectos del triset lo va a ordenar

334
00:13:27,799 --> 00:13:29,720
en función de este criterio

335
00:13:29,720 --> 00:13:32,100
bueno, pues vamos a incorporarlo ahí

336
00:13:32,100 --> 00:13:34,059
aunque sea una tontería, como no molesta

337
00:13:34,059 --> 00:13:36,259
lo dejamos ahí, pues nuestra clase persona

338
00:13:36,259 --> 00:13:37,879
tiene estas tres propiedades

339
00:13:37,879 --> 00:13:40,139
y ahora le ponemos los get y los set

340
00:13:40,139 --> 00:13:45,909
y por vaguería

341
00:13:45,909 --> 00:13:47,330
dejamos

342
00:13:47,330 --> 00:13:49,830
dejamos

343
00:13:49,830 --> 00:13:51,809
los constructores

344
00:13:51,809 --> 00:13:54,110
para ponerlos si nos van viniendo bien

345
00:13:54,110 --> 00:13:54,889
por vaguería

346
00:13:54,889 --> 00:13:56,490
venga, pues ahora

347
00:13:56,490 --> 00:13:59,330
estábamos haciendo

348
00:13:59,330 --> 00:14:00,409
el evento

349
00:14:00,409 --> 00:14:03,110
de este de aquí, de serializar

350
00:14:03,110 --> 00:14:04,450
este evento

351
00:14:04,450 --> 00:14:06,450
bueno, ¿este qué tiene que hacer?

352
00:14:07,929 --> 00:14:09,090
abrir el fichero

353
00:14:09,090 --> 00:14:09,929
que es de texto

354
00:14:09,929 --> 00:14:12,870
leer línea por línea

355
00:14:12,870 --> 00:14:15,490
con lo cual ahí ya automáticamente pensamos

356
00:14:15,490 --> 00:14:16,610
un buffer reader

357
00:14:16,610 --> 00:14:18,429
que me lee línea por línea de golpe

358
00:14:18,429 --> 00:14:20,250
con cada línea

359
00:14:20,250 --> 00:14:22,490
hago un split

360
00:14:22,490 --> 00:14:24,090
de los elementos

361
00:14:24,090 --> 00:14:26,049
y con esos elementos construyo

362
00:14:26,049 --> 00:14:26,929
el objeto persona

363
00:14:26,929 --> 00:14:29,429
y lo mando al fichero

364
00:14:29,429 --> 00:14:31,370
de objetos serializados

365
00:14:31,370 --> 00:14:33,450
pues venga

366
00:14:33,450 --> 00:14:35,029
vamos a hacerlo por partes

367
00:14:35,029 --> 00:14:37,789
instanciamos un buffered reader

368
00:14:37,789 --> 00:14:49,289
que el buffered reader

369
00:14:49,289 --> 00:14:51,190
siempre va asociado a un file reader

370
00:14:51,190 --> 00:14:53,210
que a su vez va asociado al objeto file

371
00:14:53,210 --> 00:15:12,100
y este

372
00:15:12,100 --> 00:15:14,440
puede que me de la excepción

373
00:15:14,440 --> 00:15:15,779
de que el fichero no existe

374
00:15:15,779 --> 00:15:18,320
pues la capturo

375
00:15:18,320 --> 00:15:29,740
entonces

376
00:15:29,740 --> 00:15:32,360
capturo la excepción

377
00:15:32,360 --> 00:15:38,029
y

378
00:15:38,029 --> 00:15:40,529
si el fichero no existe

379
00:15:40,529 --> 00:15:41,750
no hay nada que serializar

380
00:15:41,750 --> 00:15:44,049
entonces aprovechando que se ha ido rosa

381
00:15:44,049 --> 00:15:45,289
pues ponemos el return aquí

382
00:15:45,289 --> 00:15:46,909
porque ya no hay más que hacer

383
00:15:46,909 --> 00:15:49,789
si el fichero no existe no hay nada que serializar

384
00:15:49,789 --> 00:15:51,049
el evento no tiene nada más que hacer

385
00:15:51,049 --> 00:15:51,610
return

386
00:15:51,610 --> 00:15:55,750
la referencia de buffer errader

387
00:15:55,750 --> 00:15:58,350
vamos a ponerla aquí fuera

388
00:15:58,350 --> 00:16:05,700
bueno

389
00:16:05,700 --> 00:16:07,240
si hemos llegado a este punto

390
00:16:07,240 --> 00:16:12,110
si hemos llegado a este punto después del catch

391
00:16:12,110 --> 00:16:13,470
es porque hemos abierto el bafle real

392
00:16:13,470 --> 00:16:15,889
ahora que nos toca hacer

393
00:16:15,889 --> 00:16:17,429
ir leyendo línea por línea

394
00:16:17,429 --> 00:16:19,809
bucle de lectura por líneas

395
00:16:19,809 --> 00:16:22,190
que no es lo mismo

396
00:16:22,190 --> 00:16:23,929
que bucle de lectura por caracteres

397
00:16:23,929 --> 00:16:25,950
por caracteres habríamos abierto con el file real

398
00:16:25,950 --> 00:16:27,990
venga pues

399
00:16:27,990 --> 00:16:29,549
el bucle de lectura por líneas

400
00:16:29,549 --> 00:16:31,809
me permite ir leyendo

401
00:16:31,809 --> 00:16:32,549
de línea a línea

402
00:16:32,549 --> 00:16:36,230
y ahora mientras cada línea

403
00:16:36,230 --> 00:16:38,090
siendo cada línea

404
00:16:38,090 --> 00:16:38,750
igual aquí

405
00:16:38,750 --> 00:16:41,570
al resultado de leer esto

406
00:16:41,570 --> 00:16:44,149
sea diferente de null

407
00:16:44,149 --> 00:16:46,309
es decir, todavía tengo líneas

408
00:16:46,309 --> 00:16:46,850
que leer

409
00:16:46,850 --> 00:16:49,830
pues entonces, ¿qué es lo que tenemos que hacer?

410
00:16:50,570 --> 00:16:52,149
esto de nuevo puede que me salga

411
00:16:52,149 --> 00:16:54,950
¿por qué sales?

412
00:16:56,629 --> 00:16:57,370
buenas tardes

413
00:16:57,370 --> 00:17:09,460
¿cómo se cierra esta cosa?

414
00:17:10,700 --> 00:17:22,539
este puede que me dé excepción

415
00:17:22,539 --> 00:17:23,259
la capturo

416
00:17:23,259 --> 00:17:29,099
bueno pues que hacemos dentro del bucle de lectura

417
00:17:29,099 --> 00:17:31,119
tenemos que hacer un split

418
00:17:31,119 --> 00:17:33,200
lo primero de todo para tener los datos

419
00:17:33,200 --> 00:17:36,900
los datos van a ser

420
00:17:36,900 --> 00:17:38,180
un array de objetos string

421
00:17:38,180 --> 00:17:41,700
entonces

422
00:17:41,700 --> 00:17:44,140
línea punto split

423
00:17:44,140 --> 00:17:48,759
y split en torno a qué carácter

424
00:17:48,759 --> 00:17:50,460
en torno al carácter punto y coma

425
00:17:50,460 --> 00:17:53,200
y ahora

426
00:17:53,200 --> 00:17:56,799
construimos un objeto persona con los datos

427
00:17:56,799 --> 00:17:57,700
pues ya está

428
00:17:57,700 --> 00:18:01,720
persona p

429
00:18:01,720 --> 00:18:04,180
igual a

430
00:18:12,359 --> 00:18:12,960
vale

431
00:18:12,960 --> 00:18:14,559
el nombre ya lo tenemos

432
00:18:14,559 --> 00:18:17,019
porque el nombre será el primero de los datos

433
00:18:17,019 --> 00:18:20,200
datos de cero

434
00:18:20,200 --> 00:18:22,700
el nif

435
00:18:22,700 --> 00:18:24,420
también lo tenemos

436
00:18:24,420 --> 00:18:25,920
porque será el segundo

437
00:18:25,920 --> 00:18:27,400
datos de uno

438
00:18:27,400 --> 00:18:30,640
y nos faltan los teléfonos

439
00:18:30,640 --> 00:18:32,339
para eso hay que construir un set

440
00:18:32,339 --> 00:18:34,500
con todos los teléfonos

441
00:18:34,500 --> 00:18:36,519
entonces pues podemos hacer

442
00:18:36,519 --> 00:18:37,779
tranquilamente un

443
00:18:48,049 --> 00:18:50,430
Sí, pero estoy pensando, ¿no?

444
00:18:50,430 --> 00:18:53,009
Añadirlo directamente a...

445
00:18:53,009 --> 00:18:53,910
¡Qué tontería!

446
00:18:54,009 --> 00:18:55,130
Se lo vamos añadiendo a este.

447
00:18:55,750 --> 00:18:57,210
A P...

448
00:18:57,210 --> 00:18:58,789
No tengo que crearlo aquí.

449
00:18:59,869 --> 00:19:02,329
Para cada dato.

450
00:19:04,630 --> 00:19:05,349
Bueno, no.

451
00:19:05,410 --> 00:19:08,009
Vamos a recorrer el array para todas las posiciones.

452
00:19:08,609 --> 00:19:09,470
Uno, dos.

453
00:19:09,730 --> 00:19:10,470
Desde la dos.

454
00:19:11,369 --> 00:19:12,549
Desde la dos.

455
00:19:12,549 --> 00:19:12,910
Bien.

456
00:19:22,380 --> 00:19:24,319
Vale, pues ¿qué hacemos con cada uno de esos datos?

457
00:19:24,319 --> 00:19:27,140
se lo añadimos a este, a teléfonos.

458
00:19:34,049 --> 00:19:35,569
Datos de I, ya está.

459
00:19:39,769 --> 00:19:42,509
Bueno, pues ya tenemos el objeto persona construido

460
00:19:42,509 --> 00:19:47,069
con su nombre, que es el primero de los datos del split.

461
00:19:48,430 --> 00:19:50,730
Su NIF, que es el segundo de los datos del split.

462
00:19:51,210 --> 00:19:53,549
Y ahora, para el resto de los datos del split,

463
00:19:53,650 --> 00:19:55,650
que no sé en los que son, desde el 2 en adelante,

464
00:19:55,650 --> 00:19:57,990
los que sean, desde el 2 en adelante

465
00:19:57,990 --> 00:19:59,970
los voy añadiendo

466
00:19:59,970 --> 00:20:02,089
a la propiedad teléfonos

467
00:20:02,089 --> 00:20:06,140
importante

468
00:20:06,140 --> 00:20:07,859
haberla inicializado aquí ya

469
00:20:07,859 --> 00:20:10,259
porque si no

470
00:20:10,259 --> 00:20:12,279
al añadir el primer teléfono me saldría un null pointer

471
00:20:12,279 --> 00:20:13,380
exception, lógicamente

472
00:20:13,380 --> 00:20:15,799
entonces como la he inicializado aquí ya

473
00:20:15,799 --> 00:20:18,279
no me sale un null pointer exception cuando añado

474
00:20:18,279 --> 00:20:19,539
el primero de los teléfonos

475
00:20:19,539 --> 00:20:22,220
bueno, pues ya

476
00:20:22,220 --> 00:20:24,140
tenemos la persona y ahora hay que

477
00:20:24,140 --> 00:20:25,480
pasarla a un fichero de objetos

478
00:20:25,480 --> 00:20:27,980
entonces

479
00:20:27,980 --> 00:20:30,160
vamos a abrirnos

480
00:20:30,160 --> 00:20:32,339
el fichero de objetos

481
00:20:32,339 --> 00:20:34,500
serializados

482
00:20:34,500 --> 00:20:36,339
en ningún momento me dice

483
00:20:36,339 --> 00:20:40,160
un nombre concreto y nada

484
00:20:40,160 --> 00:20:41,079
al que a mi me de la gana

485
00:20:41,079 --> 00:20:43,259
pues venga lo vamos a

486
00:20:43,259 --> 00:20:45,799
crear el fichero de objetos

487
00:20:45,799 --> 00:20:48,259
lo podemos directamente

488
00:20:48,259 --> 00:20:49,799
crear aquí

489
00:20:49,799 --> 00:20:52,759
un data

490
00:20:52,759 --> 00:20:53,640
object

491
00:20:53,640 --> 00:20:58,359
stream

492
00:20:58,359 --> 00:21:04,269
object, perdón

493
00:21:04,269 --> 00:21:05,390
object output string

494
00:21:05,390 --> 00:21:08,089
el resultado final que querías que leyésemos

495
00:21:08,089 --> 00:21:09,609
lo que es el archivo serializado

496
00:21:09,609 --> 00:21:10,630
el archivo de objetos

497
00:21:10,630 --> 00:21:13,069
que lo cargásemos y que leyésemos las personas

498
00:21:13,069 --> 00:21:16,150
que cargases el fichero de objetos

499
00:21:16,150 --> 00:21:17,109
para leer las personas

500
00:21:17,109 --> 00:21:20,269
leer el archivo así sin más

501
00:21:20,269 --> 00:21:22,109
que mostrarte el texto

502
00:21:22,109 --> 00:21:22,789
no tenía mucho sentido

503
00:21:22,789 --> 00:21:26,170
leer de objetos a ver si se ha construido bien

504
00:21:26,170 --> 00:21:26,529
etc

505
00:21:26,529 --> 00:21:30,250
Vale, pues

506
00:21:30,250 --> 00:21:32,589
Sobrecomplicando las cosas

507
00:21:32,589 --> 00:21:34,029
Claro

508
00:21:34,029 --> 00:21:42,769
Pues por ejemplo, ¿cuál?

509
00:21:43,349 --> 00:21:44,190
Personas

510
00:21:44,190 --> 00:21:46,490
Punto

511
00:21:46,490 --> 00:21:47,170
Dat

512
00:21:47,170 --> 00:21:53,369
Ala

513
00:21:53,369 --> 00:21:55,910
Pues ya hemos creado

514
00:21:55,910 --> 00:21:57,670
Un object output stream

515
00:21:57,670 --> 00:22:00,309
para escribir archivos, perdón, objetos.

516
00:22:01,289 --> 00:22:03,329
El objeto outputString va siempre asociado

517
00:22:03,329 --> 00:22:04,809
a un file outputString.

518
00:22:05,910 --> 00:22:08,549
Y el file outputString ahora ya va asociado

519
00:22:08,549 --> 00:22:10,630
al fichero que sea.

520
00:22:11,869 --> 00:22:14,230
Y esto de nuevo, como puede tener una excepción,

521
00:22:16,230 --> 00:22:16,990
pues trae cache.

522
00:22:16,990 --> 00:22:17,650
Vale.

523
00:22:22,329 --> 00:22:26,490
Lo declaramos fuera.

524
00:22:27,670 --> 00:22:32,829
Eso, tiempo del examen

525
00:22:32,829 --> 00:22:34,970
Un segundito

526
00:22:34,970 --> 00:22:35,809
Un segundo

527
00:22:35,809 --> 00:22:37,849
Vamos a acabar esto que es media línea

528
00:22:37,849 --> 00:22:40,230
Vale, entonces

529
00:22:40,230 --> 00:22:42,650
Hemos instanciado este fichero de objetos

530
00:22:42,650 --> 00:22:44,329
Porque luego vamos a ir escribiendo en él

531
00:22:44,329 --> 00:22:49,250
Si tiene un error

532
00:22:49,250 --> 00:22:49,690
De

533
00:22:49,690 --> 00:22:52,170
File not found exception

534
00:22:52,170 --> 00:22:54,009
No se para que sale ese error

535
00:22:54,009 --> 00:22:55,970
Pero bueno, vamos a poner retune

536
00:22:55,970 --> 00:23:06,130
Claro, se lo voy a pasar ahora

537
00:23:06,130 --> 00:23:10,589
No, ese es para verificar

538
00:23:10,589 --> 00:23:12,710
El fichero

539
00:23:12,710 --> 00:23:17,569
Serializar

540
00:23:17,569 --> 00:23:19,609
Serializar y comprobar

541
00:23:19,609 --> 00:23:21,349
Este es el que lo hace todo

542
00:23:21,349 --> 00:23:23,450
Te saca del de texto y te lo guarda en archivo

543
00:23:23,450 --> 00:23:24,829
Si era el de archivo, el de objetos

544
00:23:24,829 --> 00:23:27,369
Y este es para volver a abrir el de objetos

545
00:23:27,369 --> 00:23:28,369
Para asegurarse de que está

546
00:23:28,369 --> 00:23:30,170
¿Vale?

547
00:23:32,750 --> 00:23:33,269
Entonces

548
00:23:33,269 --> 00:23:36,869
Tenemos

549
00:23:36,869 --> 00:23:39,130
Hemos abierto el fichero de objetos

550
00:23:39,130 --> 00:23:40,130
Para escribir en él

551
00:23:40,130 --> 00:23:42,230
Asociado a este nombrecito

552
00:23:42,230 --> 00:23:45,650
Si me da algún error

553
00:23:45,650 --> 00:23:47,009
Retún, para que no haga nada más

554
00:23:47,009 --> 00:23:47,569
Todo retún

555
00:23:47,569 --> 00:23:51,130
Ahora estaba leyendo las líneas

556
00:23:51,130 --> 00:23:55,410
Vale

557
00:23:55,410 --> 00:23:58,750
Y ahora ya

558
00:23:58,750 --> 00:24:00,170
Para cada línea

559
00:24:00,170 --> 00:24:01,730
Construyo el objeto

560
00:24:01,730 --> 00:24:03,210
Y una vez construido el objeto

561
00:24:03,210 --> 00:24:05,910
Lo puedo escribir aquí

562
00:24:05,910 --> 00:24:07,150
Objetos.

563
00:24:09,150 --> 00:24:09,950
Objetos.

564
00:24:11,170 --> 00:24:12,569
Write object

565
00:24:12,569 --> 00:24:16,410
B

566
00:24:16,410 --> 00:24:20,269
Vale, entonces

567
00:24:20,269 --> 00:24:22,430
este bucle es el que lee la línea

568
00:24:22,430 --> 00:24:24,369
la separa, construye la persona

569
00:24:24,369 --> 00:24:26,250
y al fichero, lee la siguiente

570
00:24:26,250 --> 00:24:28,109
la separa, construye la persona y al fichero

571
00:24:28,109 --> 00:24:29,349
así todo el rato

572
00:24:29,349 --> 00:24:31,549
cuando esto ya ha terminado

573
00:24:31,549 --> 00:24:34,410
si hubiera una excepción, me piro

574
00:24:34,410 --> 00:24:38,690
y cuando esto ya ha terminado, cuando estamos en este punto

575
00:24:38,690 --> 00:24:40,130
cerramos los flujos

576
00:24:40,130 --> 00:24:42,549
que los flujos

577
00:24:42,549 --> 00:24:44,369
el buffer real se llamaba

578
00:24:44,369 --> 00:24:44,750
br

579
00:24:44,750 --> 00:24:48,910
close y el otro se llamaba

580
00:24:48,910 --> 00:24:50,970
Objetos, Close

581
00:24:50,970 --> 00:24:55,710
Y de nuevo esto puede sacar una excepción

582
00:24:55,710 --> 00:25:00,450
Pero bueno, como estamos en modo examen

583
00:25:00,450 --> 00:25:01,630
Quiero seguir improvisando

584
00:25:01,630 --> 00:25:04,150
Pero si esto luego se puede dejar más bonito

585
00:25:04,150 --> 00:25:05,529
Y no hacer tanto traicacho

586
00:25:05,529 --> 00:25:08,190
Bueno

587
00:25:08,190 --> 00:25:11,880
Este

588
00:25:11,880 --> 00:25:14,859
Esto es Retour, no le gusta

589
00:25:14,859 --> 00:25:17,299
Porque claro, no estoy cerrándolo en ese momento

590
00:25:17,299 --> 00:25:19,819
Pero como no me va a seguir una excepción

591
00:25:19,819 --> 00:25:21,240
Vale

592
00:25:21,240 --> 00:25:23,720
Y aquí esto se me queda...

593
00:25:23,720 --> 00:25:24,799
Ah, bueno, este de aquí.

594
00:25:25,440 --> 00:25:26,900
Este sí que lo voy a meter aquí.

595
00:25:27,980 --> 00:25:29,079
Esto ya es demasiado.

596
00:25:29,400 --> 00:25:29,759
Separar.

597
00:25:34,559 --> 00:25:36,619
Y ya está. Vale, vamos a parar aquí

598
00:25:36,619 --> 00:25:37,599
antes de comprobarlo.

599
00:25:38,680 --> 00:25:39,519
Un segundinín.

600
00:25:40,119 --> 00:25:41,000
Un momentito.