1
00:00:00,180 --> 00:00:19,000
Si habláis me autorizáis a que grabe vuestra voz. Hoy vamos a acabar la parte de colecciones hablando de maps. Existe una interfaz extra a la interfaz iterable collection que es la interfaz map.

2
00:00:19,000 --> 00:00:35,979
Si os fijáis, la interfaz map no hereda de colecciones, es una interfaz distinta, aparte, pero es una interfaz que sostanzialmente se utiliza igualmente para guardar objetos y para guardar colecciones de objetos.

3
00:00:35,979 --> 00:00:40,619
Por lo tanto, es parecida a las ideas que tenemos ahora mismo, ¿vale?

4
00:00:41,619 --> 00:00:51,859
En particular, desde aquí, tenemos Ashtable, Ashmap y Trimap, que son tres implementaciones del concepto de mapa.

5
00:00:53,200 --> 00:00:54,640
¿Qué es el concepto de mapa?

6
00:00:55,280 --> 00:01:01,740
Sustancialmente es guardar un conjunto de objetos, pero en vez de guardarlos directamente como hemos hecho hasta ahora,

7
00:01:01,740 --> 00:01:12,420
en una lista y que se pongan allí creo una clave vale es decir que los objetos en vez de guardarlos

8
00:01:12,420 --> 00:01:19,319
simplemente en una colección lo que hago lo que hago es crear una pareja de una clave y el objeto

9
00:01:19,319 --> 00:01:25,680
al que se refiere otra clave y el objeto al que se refiere un poco parecido a las claves que

10
00:01:25,680 --> 00:01:31,420
utilizáis en bases de datos vale sabéis que cada registro en base de datos tiene que tener una

11
00:01:31,420 --> 00:01:34,719
primary key y cosas por el estilo

12
00:01:34,719 --> 00:01:37,319
que me permite identificar un determinado

13
00:01:37,319 --> 00:01:40,879
elemento, un determinado record de la base de datos

14
00:01:40,879 --> 00:01:43,359
pues esto en un cierto sentido va por allí

15
00:01:43,359 --> 00:01:45,799
la idea es que yo tengo esta estructura

16
00:01:45,799 --> 00:01:49,719
lo que voy a hacer es para buscar un objeto de esta estructura

17
00:01:49,719 --> 00:01:52,239
en vez de buscar el objeto directamente busco su clave

18
00:01:52,239 --> 00:01:55,859
busco algo que yo he establecido

19
00:01:55,859 --> 00:01:58,180
ser una clave para poder encontrarlo

20
00:01:58,180 --> 00:02:04,200
La clave puede ser o un propio atributo del objeto, ¿vale?

21
00:02:04,200 --> 00:02:10,240
Si yo tengo la persona con dentro del campo nie, pues podría poner dentro de la propia persona,

22
00:02:10,319 --> 00:02:14,479
o sea, usar el atributo de la propia persona como clave, ¿vale?

23
00:02:15,539 --> 00:02:19,560
O podría ser algo externo. A lo mejor yo tengo personas, ¿vale?

24
00:02:19,719 --> 00:02:23,939
Tengo conceptos de personas que no tienen un nie,

25
00:02:23,939 --> 00:02:31,759
y yo puedo utilizar un mapa para, en un cierto sentido, añadir el concepto de NIE que sea único

26
00:02:31,759 --> 00:02:35,180
para luego poder diferenciar las personas entre ellas.

27
00:02:35,539 --> 00:02:42,180
Entonces yo tengo dos personas que a lo mejor la característica de persona, el nombre, la edad y la altura son las mismas,

28
00:02:42,180 --> 00:02:47,879
pero luego las pongo en una estructura de mapa en la que digo, este NIE se refiere a este objeto,

29
00:02:47,879 --> 00:02:49,919
este NIE se refiere a un objeto distinto

30
00:02:49,919 --> 00:02:51,259
entonces es definido

31
00:02:51,259 --> 00:02:52,439
dos distintos

32
00:02:52,439 --> 00:02:55,620
dos distintas personas

33
00:02:55,620 --> 00:02:57,919
identificables entre ellas

34
00:02:57,919 --> 00:02:58,719
a través del

35
00:02:58,719 --> 00:03:02,599
de la clave

36
00:03:02,599 --> 00:03:05,699
la clave como en base a datos

37
00:03:05,699 --> 00:03:07,879
y como en otro contexto debería ser única

38
00:03:07,879 --> 00:03:09,879
no nos

39
00:03:09,879 --> 00:03:11,319
permite el HMAP

40
00:03:11,319 --> 00:03:12,919
introducir dos veces

41
00:03:12,919 --> 00:03:15,740
objetos con la misma clave

42
00:03:15,740 --> 00:03:17,620
no deberíamos poder

43
00:03:17,620 --> 00:03:24,460
hacer cosas por el estilo entonces el primer la primera implementación de mapa podemos ir a ver

44
00:03:24,460 --> 00:03:39,210
el java vale luego una cosa más o menos el java api map es este de aquí veis que tiene un clear

45
00:03:39,210 --> 00:03:54,270
tiene un get para pillar fijaos que pilla una clave y que te devolverá te devolverá el objeto

46
00:03:54,270 --> 00:03:56,469
asociado con esta clave, en nuestro ejemplo

47
00:03:56,469 --> 00:03:57,949
si yo tengo como clave los nies

48
00:03:57,949 --> 00:03:59,870
cuando yo pongo el nie de

49
00:03:59,870 --> 00:04:02,409
Stefano, pues haré

50
00:04:02,409 --> 00:04:04,189
un get del objeto

51
00:04:04,189 --> 00:04:06,530
nie y él me devolverá

52
00:04:06,530 --> 00:04:08,129
un objeto que es

53
00:04:08,129 --> 00:04:09,750
el objeto que se había guardado

54
00:04:09,750 --> 00:04:12,229
en la mapa, o sea

55
00:04:12,229 --> 00:04:14,250
una persona que es Stefano en este caso

56
00:04:14,250 --> 00:04:16,529
fijaos también

57
00:04:16,529 --> 00:04:18,370
que cuando hago un add

58
00:04:18,370 --> 00:04:20,329
no existe el add, existe el put

59
00:04:20,329 --> 00:04:22,430
y el put

60
00:04:22,430 --> 00:04:24,569
tiene una clave y un valor.

61
00:04:24,829 --> 00:04:26,649
Siempre que añado una nueva cosa

62
00:04:26,649 --> 00:04:28,509
a mi colección, pues la añado

63
00:04:28,509 --> 00:04:30,449
como pareja de esta es su clave,

64
00:04:30,829 --> 00:04:32,810
esta de aquí es el valor asociado

65
00:04:32,810 --> 00:04:34,470
con esta clave. Luego buscaré

66
00:04:34,470 --> 00:04:36,649
por claves y obtendré

67
00:04:36,649 --> 00:04:36,970
valores.

68
00:04:38,310 --> 00:04:40,529
¿Sí? ¿Dudas?

69
00:04:41,990 --> 00:04:42,589
Fijaos

70
00:04:42,589 --> 00:04:43,029
también

71
00:04:43,029 --> 00:04:46,029
que este señor

72
00:04:46,029 --> 00:04:48,470
trabaja con dos

73
00:04:48,470 --> 00:04:50,769
tipos

74
00:04:50,769 --> 00:04:54,430
genéricos. Un tipo genérico que representa la clave

75
00:04:54,430 --> 00:04:58,410
y un tipo genérico que representa el valor. O sea, yo puedo usar como clave

76
00:04:58,410 --> 00:05:02,730
strings y obtener como valores persona. Puedo utilizar

77
00:05:02,730 --> 00:05:06,490
como variables gatos y tener como valores

78
00:05:06,490 --> 00:05:08,649
casas. No lo sé.

79
00:05:10,850 --> 00:05:14,649
Cuando yo defino un map, cuando creo un map, le tendré que

80
00:05:14,649 --> 00:05:17,769
definir cuáles son los tipos de sus dos

81
00:05:17,769 --> 00:05:21,089
tipos de las claves y los tipos de los valores

82
00:05:21,089 --> 00:05:22,750
y luego los usaré

83
00:05:22,750 --> 00:05:24,730
con los tipos apropiados

84
00:05:24,730 --> 00:05:27,069
antes en la otra tenía

85
00:05:27,069 --> 00:05:28,910
un solo valor genérico, un solo tipo

86
00:05:28,910 --> 00:05:31,410
genérico, ahora tengo dos tipos genéricos

87
00:05:31,410 --> 00:05:32,750
entonces

88
00:05:32,750 --> 00:05:34,930
luego haremos ejemplos para ver

89
00:05:34,930 --> 00:05:36,850
un poquito como se usa, una cosa

90
00:05:36,850 --> 00:05:38,930
interesante es que

91
00:05:38,930 --> 00:05:41,009
pregunta

92
00:05:41,009 --> 00:05:43,029
para vosotros, a ver si me habéis seguido

93
00:05:43,029 --> 00:05:44,689
¿existe

94
00:05:44,689 --> 00:05:47,029
el método

95
00:05:47,029 --> 00:05:49,189
iterator

96
00:05:49,189 --> 00:05:51,670
en map

97
00:05:51,670 --> 00:05:59,319
casi

98
00:05:59,319 --> 00:06:02,759
no porque no extiende de iterable

99
00:06:02,759 --> 00:06:06,779
este iterable no está en maps

100
00:06:06,779 --> 00:06:08,300
entonces iterable

101
00:06:08,300 --> 00:06:09,899
era el que me permite hacer

102
00:06:09,899 --> 00:06:12,620
el comando iterator que me daba un iterador

103
00:06:12,620 --> 00:06:14,300
que luego me permitía iterar

104
00:06:14,300 --> 00:06:15,100
sobre el objeto

105
00:06:15,100 --> 00:06:17,980
no puedo iterar sobre

106
00:06:17,980 --> 00:06:19,860
un map

107
00:06:19,860 --> 00:06:22,339
no puedo decir, mira tienes un mapa, sí

108
00:06:22,339 --> 00:06:24,899
quiero que me des todos sus valores y me los das

109
00:06:24,899 --> 00:06:25,860
¿vale?

110
00:06:26,379 --> 00:06:28,680
no hay una forma de hacerlo

111
00:06:28,680 --> 00:06:30,660
lo que se suele hacer en estos

112
00:06:30,660 --> 00:06:31,459
contextos

113
00:06:31,459 --> 00:06:34,319
es que tú puedes

114
00:06:34,319 --> 00:06:36,699
transformar una de las

115
00:06:36,699 --> 00:06:38,959
dos cosas del mapa

116
00:06:38,959 --> 00:06:40,379
o sea, o las claves

117
00:06:40,379 --> 00:06:42,819
o los valores en set

118
00:06:42,819 --> 00:06:43,800
¿vale?

119
00:06:44,600 --> 00:06:45,779
¿dónde estará?

120
00:06:46,540 --> 00:06:47,980
esto, esto

121
00:06:47,980 --> 00:06:49,660
y esto

122
00:06:49,660 --> 00:06:59,980
no estos son la cosa no es el valor que hay 7 y valió varios varios vale entonces si yo quiero

123
00:06:59,980 --> 00:07:07,180
yo tengo un mapa y quiero ver todas sus sus valores puedo hacer el método varios que me

124
00:07:07,180 --> 00:07:14,600
devuelve una colección entonces sobre es así que puede tirar vale o si yo quiero puedo pillar todas

125
00:07:14,600 --> 00:07:22,600
las claves transformarla en una red en un en un conjunto de claves vale porque conjunto en

126
00:07:22,600 --> 00:07:33,399
la lista exacto porque hemos dicho que la clave es única vale entonces en el set no se repiten

127
00:07:33,399 --> 00:07:42,300
valores muy bien me gusta cuando seguís el entonces luego una vez que tengo el set de

128
00:07:42,300 --> 00:07:48,259
claves puedo iterar sobre el set de claves pillar la clave por cada clave buscar su valor utilizando

129
00:07:48,259 --> 00:07:48,660
la get.

130
00:07:52,040 --> 00:07:53,920
Entonces, tengo modos igualmente

131
00:07:53,920 --> 00:07:55,759
para poder ir buscando

132
00:07:55,759 --> 00:07:58,000
todos los valores de mi

133
00:07:58,000 --> 00:07:59,699
mapa. Pero no el

134
00:07:59,699 --> 00:08:01,819
iterator directamente. El iterator no está.

135
00:08:02,439 --> 00:08:03,680
Entonces tengo que hacer este

136
00:08:03,680 --> 00:08:04,160
truquillo.

137
00:08:05,860 --> 00:08:06,920
Dudas hasta aquí.

138
00:08:07,660 --> 00:08:09,579
Vamos a ver las implementaciones.

139
00:08:11,060 --> 00:08:11,860
La primera

140
00:08:11,860 --> 00:08:13,779
implementación es, hemos dicho,

141
00:08:14,120 --> 00:08:15,480
esta de aquí,

142
00:08:15,720 --> 00:08:17,560
¿dónde está? Interfaceset.

143
00:08:18,259 --> 00:08:21,579
aquí, ashmap, ¿vale?

144
00:08:21,819 --> 00:08:26,300
Es una implementación que almacena las claves en una tabla hash, ¿vale?

145
00:08:26,379 --> 00:08:28,040
¿Os acordáis que era esto de la tabla hash?

146
00:08:28,220 --> 00:08:40,240
Que yo pillo, tengo una serie de clúster, una serie de posibles categorías,

147
00:08:40,399 --> 00:08:47,080
tú me das una clave, yo le hago una función y te digo que esta clave cae en la sección 3.

148
00:08:47,220 --> 00:08:50,100
Por lo tanto, esta clave, la clave 1, la pongo aquí.

149
00:08:50,100 --> 00:08:55,500
Ahora me das otra clave y la clave está aquí, le hago la función y me da como resultado 7

150
00:08:55,500 --> 00:08:58,480
Pues el 7 va aquí, entonces la clave 2 va aquí

151
00:08:58,480 --> 00:09:06,580
De esta forma, aquí yo insertaré otras claves, aquí va la 3, la 4 cae aquí también

152
00:09:06,580 --> 00:09:14,500
Luego está la 5 que cae aquí, luego está la 6 que cae aquí también, etc, etc, etc

153
00:09:14,500 --> 00:09:19,500
Ahora cuando por ejemplo busco una clave, como mucho tendré que hacer 3 comprobaciones

154
00:09:20,100 --> 00:09:25,600
Porque el clúster más grande es este de aquí, que tiene solo tres comprobaciones.

155
00:09:25,960 --> 00:09:31,299
Todas las claves que han caído en todos los otros clústeres, ni lo tomo en consideración.

156
00:09:31,500 --> 00:09:34,480
Por lo tanto, es mucho más rápido para buscar.

157
00:09:34,960 --> 00:09:42,500
Si mi función hash está bien hecha, este es muy disperso, o sea, hay muy pocos elementos por cada categoría,

158
00:09:42,500 --> 00:09:50,679
y por lo tanto se mejora muchísimo la velocidad con el que encuentro la clave que está buscando.

159
00:09:54,409 --> 00:10:03,389
Y luego a partir de esta clave tendrá referencia a los objetos valores que se refieren.

160
00:10:04,649 --> 00:10:11,570
Entonces una vez que encuentro la clave de aquí podré saltar a los objetos valores que quería pillar de verdad.

161
00:10:13,809 --> 00:10:17,850
Es una implementación con mejor rendimiento de todas, ¿vale?

162
00:10:17,870 --> 00:10:20,830
Pero no garantiza ningún orden a la hora de realizar iteraciones.

163
00:10:20,990 --> 00:10:26,830
Cuando yo, el orden de inserción con el que han metido las cosas, pues se mezcla todo,

164
00:10:27,269 --> 00:10:32,610
porque yo inserto el primero y el primero, hemos dicho, que puede ir en cualquiera de esta categoría,

165
00:10:32,710 --> 00:10:35,090
entonces me lo habría podido poner en la última categoría.

166
00:10:35,210 --> 00:10:36,429
No lo sé dónde va a acabar.

167
00:10:36,750 --> 00:10:41,009
Depende de la función y depende del valor de la clave que yo pongo, ¿vale?

168
00:10:41,009 --> 00:10:47,230
Entonces, si yo quiero mantener un orden, pues esto no es la estructura que tengo que buscar.

169
00:10:50,929 --> 00:10:54,250
Esta implementación proporciona tiempos constantes en las operaciones básicas, ¿vale?

170
00:10:54,250 --> 00:10:59,850
Tiempo constante, tiempo constante es bueno, es más bajo que tiempo logarítmico, que ya es bueno,

171
00:11:00,230 --> 00:11:05,269
que es mejor que tiempos lineares, que es de n, ¿vale?

172
00:11:05,789 --> 00:11:13,590
Que es bueno, aceptable, que es peor de n al cuadrado, que es peor de x a la n, ¿sí?

173
00:11:14,049 --> 00:11:32,909
Por lo tanto es bueno, es rápido. Es importante definir el tamaño inicial de la tabla porque este tamaño marcará el rendimiento de la implementación. Si yo hago una tabla hash demasiado pequeña con pocas categorías funciona peor, si la hago más grande funciona mejor, pero si la hago enorme me ocupa mucha memoria para nada.

174
00:11:32,909 --> 00:11:38,309
Hemos que tener en cuenta un factor de carga

175
00:11:38,309 --> 00:11:41,750
Cuando yo voy metiendo cosas en esta mapa

176
00:11:41,750 --> 00:11:44,269
Y llega un momento en que hay demasiados elementos

177
00:11:44,269 --> 00:11:47,649
El mapa se hace una operación

178
00:11:47,649 --> 00:11:50,149
Y se dobla en tamaño

179
00:11:50,149 --> 00:11:54,629
Para que no haya muchos clústeres pegados

180
00:11:54,629 --> 00:11:56,730
Entonces yo cuando lo creo

181
00:11:56,730 --> 00:11:59,350
Tengo que definir cuál es el tamaño inicial

182
00:11:59,350 --> 00:12:10,809
y a qué nivel de riempimiento de la tabla yo decido hacerla más grande.

183
00:12:10,970 --> 00:12:13,409
Por defecto, el tamaño es 16.

184
00:12:13,990 --> 00:12:18,409
Empieza con 16 posibles claves que se puedan almacenar.

185
00:12:18,789 --> 00:12:23,350
Y si llega al 75%, o sea, 12 llenadas,

186
00:12:24,330 --> 00:12:27,529
pues entonces hace una operación de duplicar este de aquí,

187
00:12:27,529 --> 00:12:29,610
tener 32 y ahora tengo

188
00:12:29,610 --> 00:12:31,629
32 huecos y hasta que no haya

189
00:12:31,629 --> 00:12:33,610
rellenado el 75% no pasaría

190
00:12:33,610 --> 00:12:35,169
64, ¿vale?

191
00:12:35,429 --> 00:12:37,649
Está claro que cada vez que hago esta operación

192
00:12:37,649 --> 00:12:39,450
de duplicar, pues

193
00:12:39,450 --> 00:12:40,309
es un trabajo

194
00:12:40,309 --> 00:12:43,529
¿sí? A lo mejor las primeras veces

195
00:12:43,529 --> 00:12:45,370
no, pero

196
00:12:45,370 --> 00:12:47,450
imaginamos que yo tengo un millón de

197
00:12:47,450 --> 00:12:49,570
entradas y de repente me añado

198
00:12:49,570 --> 00:12:51,129
una y tengo que duplicar

199
00:12:51,129 --> 00:12:53,690
pues es un buen trabajo hacer un millón

200
00:12:53,690 --> 00:12:54,750
de operaciones ahí

201
00:12:54,750 --> 00:12:57,269
moviendo cosas, ¿vale?

202
00:12:57,269 --> 00:13:07,750
Probablemente es crear una nueva HMAP grande el doble y luego pilla iterar sobre el antiguo HMAP y volver a ponerlo en el nuevo.

203
00:13:07,830 --> 00:13:12,710
Y en este punto tengo algo parecido a los arrays, pero lo hace en el automático por debajo.

204
00:13:13,210 --> 00:13:19,110
Para evitar que esto pase, yo hago un estudio antes y digo, vale, ¿cuál es mi problema?

205
00:13:19,389 --> 00:13:21,110
¿De qué voy a pagar? De alumnos, vale.

206
00:13:21,549 --> 00:13:25,549
¿Cuántos alumnos voy a poner cada año? ¿Cuántos alumnos pueden estar en una escuela?

207
00:13:25,549 --> 00:13:33,049
pues mil alumnos, pues haré una tabla que pueda tener 1.500 alumnos más o menos, ¿vale?

208
00:13:33,370 --> 00:13:34,929
Ya sería una cosa de ese estilo.

209
00:13:35,690 --> 00:13:40,450
Si en vez de alumnos estoy hablando de la población de Madrid,

210
00:13:40,730 --> 00:13:44,789
pues no hago una tabla de 1.500, tendrá que ser mucho más grande.

211
00:13:46,090 --> 00:13:46,450
¿Se entiende?

212
00:13:50,220 --> 00:13:53,460
Vale, en realidad existía antes una cosa que se llama Stable, ¿vale?

213
00:13:53,500 --> 00:13:56,100
Stable es más antigua, Ashmapa es más moderna.

214
00:13:56,100 --> 00:14:02,960
Nosotros hoy en día se utiliza más HashMap que HashTable, HashTable deriva de lo que había antes, ¿vale?

215
00:14:03,039 --> 00:14:14,100
Entonces, como algunos programas utilizaban HashTable antes, pues cuando se ha hecho HashMap, se ha dicho, vale, mantengamos también el HashTable para que, sustancialmente, los programas anteriores sigan funcionando.

216
00:14:15,200 --> 00:14:23,480
Aquí hay una comparación, ¿vale? HashMap no está sincronizado a HashTable, sí, esto solo sirve si hacéis segundo de DAW y programación paralela.

217
00:14:23,480 --> 00:14:26,899
HMAP permite una clave nula

218
00:14:26,899 --> 00:14:28,460
Y múltiples valores nulos

219
00:14:28,460 --> 00:14:30,759
Mientras HMAP

220
00:14:30,759 --> 00:14:32,440
No permite ninguna clave

221
00:14:32,440 --> 00:14:33,440
O valor nulo

222
00:14:33,440 --> 00:14:36,539
Es decir, que hay una opción en la que yo puedo poner

223
00:14:36,539 --> 00:14:37,480
Como clave nul

224
00:14:37,480 --> 00:14:41,059
Y que luego, si tú buscas clave nul

225
00:14:41,059 --> 00:14:42,940
Esto es el

226
00:14:42,940 --> 00:14:44,059
Correspondiente valor

227
00:14:44,059 --> 00:14:45,679
Que podría ser un valor por defecto

228
00:14:45,679 --> 00:14:48,740
O yo puedo tener

229
00:14:48,740 --> 00:14:51,279
Claves que apuntan a objetos nul

230
00:14:51,279 --> 00:14:52,460
En HMAP lo puedo hacer

231
00:14:52,460 --> 00:14:53,720
En Ashtable no

232
00:14:53,720 --> 00:14:55,080
¿Vale?

233
00:14:56,139 --> 00:14:58,500
Bueno, se ha introducido el juego hace mucho

234
00:14:58,500 --> 00:15:00,200
En JDK 1.2

235
00:15:00,200 --> 00:15:01,019
Pues viejo

236
00:15:01,019 --> 00:15:03,460
Cuando estudié yo ya estaba en 2

237
00:15:03,460 --> 00:15:07,019
Ashmap es rápido, Ashtable es mucho más lento

238
00:15:07,019 --> 00:15:09,100
Podemos hacer que Ashmap

239
00:15:09,100 --> 00:15:10,720
Este sincronizado llamando el método

240
00:15:10,720 --> 00:15:13,059
Esta cosa aquí, collection.synchronizeMap

241
00:15:13,059 --> 00:15:14,860
Entonces hay una forma

242
00:15:14,860 --> 00:15:17,019
De transformar esto que no está

243
00:15:17,019 --> 00:15:18,679
Sincronizado en sincronizado

244
00:15:18,679 --> 00:15:21,360
Y entonces obviar el problema

245
00:15:21,360 --> 00:15:21,919
Este de aquí

246
00:15:21,919 --> 00:15:25,379
asMap es recorrido por iterator

247
00:15:25,379 --> 00:15:26,840
se puede utilizar un iterator aquí

248
00:15:26,840 --> 00:15:28,799
mientras que asMap es recorrido por

249
00:15:28,799 --> 00:15:30,779
enumerator y iterator

250
00:15:30,779 --> 00:15:31,799
dos cosas distintas

251
00:15:31,799 --> 00:15:35,080
este asMap es a prueba de errores

252
00:15:35,080 --> 00:15:36,899
este de aquí, el numerador

253
00:15:36,899 --> 00:15:38,299
es muy lento, vale

254
00:15:38,299 --> 00:15:41,039
usad asMap

255
00:15:41,039 --> 00:15:42,919
sustancialmente, vale, esto es para que

256
00:15:42,919 --> 00:15:44,879
sepáis un poquito la diferencia

257
00:15:44,879 --> 00:15:46,840
entre los dos, no me interesa

258
00:15:46,840 --> 00:15:47,700
mucho, muchísimo

259
00:15:47,700 --> 00:15:50,639
trimap es siempre un mapa

260
00:15:50,639 --> 00:15:54,899
Siempre estamos hablando de claves y objetos relacionados con esta clave

261
00:15:54,899 --> 00:15:56,940
Que luego yo buscaré una clave y me da un objeto

262
00:15:56,940 --> 00:15:58,600
Que es el objeto relacionado con esto

263
00:15:58,600 --> 00:16:02,860
Pero lo organiza como un árbol

264
00:16:02,860 --> 00:16:03,379
Como un tree

265
00:16:03,379 --> 00:16:08,779
Entonces las claves están ordenadas en función de sus valores

266
00:16:08,779 --> 00:16:10,559
Con orden ascendente

267
00:16:10,559 --> 00:16:15,139
Entonces tendré que implementar la interfaz comparable de las claves

268
00:16:15,139 --> 00:16:18,320
Las claves tienen que poder ser comparables entre ellas

269
00:16:18,320 --> 00:16:20,320
Si no son comparables, no sé cómo ordenarlas.

270
00:16:22,279 --> 00:16:25,860
Contiene solo elementos únicos, es bastante más lento que HMAP.

271
00:16:27,440 --> 00:16:32,000
Esta implementación garantiza siempre un rendimiento de log n en las operaciones básicas.

272
00:16:32,299 --> 00:16:37,840
Entonces, en casos en los que yo tengo, de todas formas, que mantener un determinado orden en las claves,

273
00:16:38,419 --> 00:16:41,320
pues entonces este TRIMAP me puede servir de algo.

274
00:16:41,440 --> 00:16:45,799
Si en vez de no me interesa el orden de las claves, el HMAP es seguramente mejor porque va más rápido.

275
00:16:45,799 --> 00:16:48,720
está también en linkedashmap

276
00:16:48,720 --> 00:16:50,120
¿vale? que es unashmap

277
00:16:50,120 --> 00:16:52,340
hecho con esto de los nodos

278
00:16:52,340 --> 00:16:53,720
enlazados uno con otro

279
00:16:53,720 --> 00:16:56,440
pero bueno, que está por ahí

280
00:16:56,440 --> 00:16:58,919
acabamos este tema

281
00:16:58,919 --> 00:16:59,580
creo

282
00:16:59,580 --> 00:17:02,639
con este maravilloso esquema

283
00:17:02,639 --> 00:17:04,160
¿vale? que es

284
00:17:04,160 --> 00:17:06,200
lo que debería hacer vuestra mente

285
00:17:06,200 --> 00:17:08,059
cuando vosotros pensáis

286
00:17:08,059 --> 00:17:09,720
tengo que hacer una colección de objetos

287
00:17:09,720 --> 00:17:11,880
empezáis aquí, donde pone inicio

288
00:17:11,880 --> 00:17:12,940
y preguntáis

289
00:17:12,940 --> 00:17:17,420
¿Tienes pares de clave-valor o tienes solo valores?

290
00:17:18,640 --> 00:17:21,839
Si tienes solo valores, pues te vas por aquí

291
00:17:21,839 --> 00:17:27,240
Si tienes una clave que apunta un valor, pues entonces te vas por acá

292
00:17:27,240 --> 00:17:30,519
Vamos para la derecha por ahora

293
00:17:30,519 --> 00:17:32,700
Tengo solo valores, no me interesan claves

294
00:17:32,700 --> 00:17:34,460
¿Contiene duplicado?

295
00:17:35,700 --> 00:17:37,559
Si sí, usa la relist

296
00:17:37,559 --> 00:17:41,579
Si no contiene duplicados, hazte otra pregunta

297
00:17:41,579 --> 00:17:43,700
que es, su tarea principal es buscar

298
00:17:43,700 --> 00:17:45,839
elementos, la contains

299
00:17:45,839 --> 00:17:46,579
y la remove

300
00:17:46,579 --> 00:17:49,539
si no, si la tarea

301
00:17:49,539 --> 00:17:51,359
principal es otras cosas, vete a

302
00:17:51,359 --> 00:17:53,059
relist, si sí

303
00:17:53,059 --> 00:17:55,440
vete aquí y pregúntate, el orden

304
00:17:55,440 --> 00:17:57,420
es importante, si no

305
00:17:57,420 --> 00:17:59,539
quieres mantener el orden, hset

306
00:17:59,539 --> 00:18:01,720
si quieres mantener el orden

307
00:18:01,720 --> 00:18:03,519
pues vete aquí, orden de

308
00:18:03,519 --> 00:18:05,299
inserción o orden de elemento

309
00:18:05,299 --> 00:18:07,579
¿qué te interesa más? o sea, ¿te interesa

310
00:18:07,579 --> 00:18:09,579
la orden con que has insertado

311
00:18:09,579 --> 00:18:11,440
que se preserve o el orden de

312
00:18:11,440 --> 00:18:13,660
un determinado valor que tienes

313
00:18:13,660 --> 00:18:15,480
dentro de los objetos que tienen que ser

314
00:18:15,480 --> 00:18:17,000
ordenados según este criterio.

315
00:18:17,440 --> 00:18:19,339
Pues si es de inserción, usa una link

316
00:18:19,339 --> 00:18:21,380
hset. Si en vez

317
00:18:21,380 --> 00:18:23,380
es de ordenación, pues usa un

318
00:18:23,380 --> 00:18:27,490
triset. Por otro lado,

319
00:18:27,990 --> 00:18:29,950
¿qué eros pares en vez que valores? Vale.

320
00:18:30,109 --> 00:18:31,869
¿Es importante el orden? Pues

321
00:18:31,869 --> 00:18:33,829
si no es importante el orden,

322
00:18:33,990 --> 00:18:35,970
usa una shmap. Ya está. Si en vez

323
00:18:35,970 --> 00:18:38,069
el orden es importante, pues pregúntate

324
00:18:38,069 --> 00:18:39,849
¿es el orden de inserción o

325
00:18:39,849 --> 00:18:41,769
el orden de la clave? Que la clave tiene un

326
00:18:41,769 --> 00:18:43,730
orden especial suyo y tienes que mantener

327
00:18:43,730 --> 00:18:45,170
ordenada la clave según ese orden

328
00:18:45,170 --> 00:18:47,569
si es de inserción usa un link dash map

329
00:18:47,569 --> 00:18:49,750
si es de ordenación

330
00:18:49,750 --> 00:18:51,890
de la clave pues entonces usa un trimap

331
00:18:51,890 --> 00:18:55,049
entonces esto es

332
00:18:55,049 --> 00:18:57,069
que voy a usar

333
00:18:57,069 --> 00:18:58,970
en base a mis necesidades

334
00:18:58,970 --> 00:19:00,670
estas son las preguntas

335
00:19:00,670 --> 00:19:02,509
que deberíais

336
00:19:02,509 --> 00:19:05,049
tener claras

337
00:19:05,049 --> 00:19:07,529
a la hora de elegir

338
00:19:07,529 --> 00:19:09,230
una de estas colecciones

339
00:19:09,230 --> 00:19:11,609
y deberíais

340
00:19:11,609 --> 00:19:13,529
entender después de toda esta

341
00:19:13,529 --> 00:19:14,609
como se dice

342
00:19:14,609 --> 00:19:16,650
teoría

343
00:19:16,650 --> 00:19:18,690
por qué

344
00:19:18,690 --> 00:19:21,269
la respuesta sí y no de cada una

345
00:19:21,269 --> 00:19:23,250
de estas preguntas os lleva

346
00:19:23,250 --> 00:19:37,480
a lo que os lleva. No.

347
00:19:38,680 --> 00:19:39,779
LinkedList no es dicho

348
00:19:39,779 --> 00:19:41,500
que es la más importante. Es dicho que es la más

349
00:19:41,500 --> 00:19:43,619
flexible. Porque

350
00:19:43,619 --> 00:19:45,680
LinkedList tú la puedes usar

351
00:19:45,680 --> 00:19:47,599
de varias formas distintas. Ahora

352
00:19:47,599 --> 00:19:48,799
si has mirado la cosa así

353
00:19:48,799 --> 00:19:51,940
no es muy eficiente.

354
00:19:52,500 --> 00:19:53,940
Entra a ser eficiente

355
00:19:53,940 --> 00:19:55,839
en el momento en el que

356
00:19:55,839 --> 00:19:58,140
tú lo que haces es muchas

357
00:19:58,140 --> 00:19:59,940
remociones y cosas por el estilo

358
00:19:59,940 --> 00:20:01,960
entonces estarías por aquí

359
00:20:01,960 --> 00:20:02,799
¿vale?

360
00:20:04,220 --> 00:20:06,160
¿contiene duplicados?

361
00:20:06,819 --> 00:20:08,200
sí, o sea, aquí

362
00:20:08,200 --> 00:20:10,660
faltaría él, si contiene duplicados

363
00:20:10,660 --> 00:20:12,299
y su tarea principal es

364
00:20:12,299 --> 00:20:14,599
contains remove, entonces sería una link allí

365
00:20:14,599 --> 00:20:16,359
¿vale? faltaría aquí

366
00:20:16,359 --> 00:20:18,200
él te manda hacia aquí

367
00:20:18,200 --> 00:20:20,039
pero por aquí estaría pasando

368
00:20:20,039 --> 00:20:21,259
por otra cosa

369
00:20:21,259 --> 00:20:23,619
lo que yo dije es que

370
00:20:23,619 --> 00:20:26,299
si tú no sabes, no tienes idea

371
00:20:26,299 --> 00:20:28,140
pues pillar una linked list

372
00:20:28,140 --> 00:20:29,980
te da la posibilidad en cierto momento de

373
00:20:29,980 --> 00:20:31,339
usarla como

374
00:20:31,339 --> 00:20:34,220
una cosa como otra, entonces a lo mejor

375
00:20:34,220 --> 00:20:35,819
te da más

376
00:20:35,819 --> 00:20:37,900
amplio espectro

377
00:20:37,900 --> 00:20:39,920
dudas

378
00:20:39,920 --> 00:20:47,390
vale

379
00:20:47,390 --> 00:20:50,410
ahora haremos un

380
00:20:50,410 --> 00:20:52,269
ejemplito de algo de esto

381
00:20:52,269 --> 00:20:54,130
para ver como funciona y cosas por el estilo

382
00:20:54,130 --> 00:20:56,390
pero quiero empezar por

383
00:20:56,390 --> 00:20:57,430
otra cosa, vale

384
00:20:57,430 --> 00:21:02,690
Vamos a ver, estamos en estructuras dinámicas

385
00:21:02,690 --> 00:21:03,890
Pongámoslos aquí, venga

386
00:21:03,890 --> 00:21:06,630
Hacemos otro ejemplo

387
00:21:06,630 --> 00:21:16,720
Vale

388
00:21:16,720 --> 00:21:18,740
Entonces

389
00:21:18,740 --> 00:21:22,869
Las

390
00:21:22,869 --> 00:21:25,730
¿Cómo se llaman?

391
00:21:25,849 --> 00:21:27,609
Las estructuras que hemos visto ahora

392
00:21:27,609 --> 00:21:30,390
Sostancialmente son versiones

393
00:21:30,390 --> 00:21:32,170
Digo duda, nadie

394
00:21:32,170 --> 00:21:33,829
Duda

395
00:21:33,829 --> 00:21:40,380
Vale

396
00:21:40,380 --> 00:21:44,559
Imagínate una rubrica telefónica

397
00:21:44,559 --> 00:21:46,700
rubrica telefónica

398
00:21:46,700 --> 00:21:47,079
se dice

399
00:21:47,079 --> 00:21:54,880
sí, una cosa así

400
00:21:54,880 --> 00:21:56,779
tú en casa tienes un cuaderno

401
00:21:56,779 --> 00:21:59,180
donde pones Stefano y su número de teléfono

402
00:21:59,180 --> 00:21:59,559
no sé qué

403
00:21:59,559 --> 00:22:02,819
pues eso es una pareja, a ti no te interesa

404
00:22:02,819 --> 00:22:04,480
Stefano, Stefano es una clave

405
00:22:04,480 --> 00:22:06,900
¿vale? y cuando tú encuentras

406
00:22:06,900 --> 00:22:08,579
Stefano ordenado por Stefano

407
00:22:08,579 --> 00:22:10,680
porque tú no ordenas por

408
00:22:10,680 --> 00:22:12,559
número de teléfono, porque si no te deberías

409
00:22:12,559 --> 00:22:14,519
recordar el número de teléfono para poder encontrarlo

410
00:22:14,519 --> 00:22:16,900
tú lo estás ordenando por una clave

411
00:22:16,900 --> 00:22:19,640
Y cuando has encontrado la clave

412
00:22:19,640 --> 00:22:20,940
No te interesa la clave

413
00:22:20,940 --> 00:22:22,319
Te interesa el valor al que apunta

414
00:22:22,319 --> 00:22:23,500
Y tienes mi número de teléfono

415
00:22:23,500 --> 00:22:26,680
Eso es un ejemplo de

416
00:22:26,680 --> 00:22:27,980
Cómo funciona un map

417
00:22:27,980 --> 00:22:31,160
Mapea un cierto conjunto de valores

418
00:22:31,160 --> 00:22:32,900
A otros valores

419
00:22:32,900 --> 00:22:35,359
Donde tú sueles tener

420
00:22:35,359 --> 00:22:36,740
O sueles buscar por

421
00:22:36,740 --> 00:22:38,440
El valor clave

422
00:22:38,440 --> 00:22:40,359
Pero lo que te interesa obtener

423
00:22:40,359 --> 00:22:41,599
Es la parte valor

424
00:22:41,599 --> 00:22:45,799
¿Cómo se dice en español rubrica?

425
00:22:47,539 --> 00:22:48,180
Agenda

426
00:22:48,180 --> 00:23:06,640
agenda telefónica la interfaz comparable la hemos visto bien en los apuntes y tiene que

427
00:23:06,640 --> 00:23:11,599
tener sustancialmente comparable con perdú está por aquí está por aquí está por aquí

428
00:23:11,599 --> 00:23:19,700
lo que tienes que hacer es implementar este método de aquí el único método que te permite

429
00:23:19,700 --> 00:23:25,019
cuando se implementa

430
00:23:25,019 --> 00:23:26,700
se implementa cuando

431
00:23:26,700 --> 00:23:28,940
el objeto

432
00:23:28,940 --> 00:23:31,460
la colección que vas a utilizar

433
00:23:31,460 --> 00:23:33,240
hace uso del compare

434
00:23:33,240 --> 00:23:35,579
para poder organizar

435
00:23:35,579 --> 00:23:37,759
o sea ordenar los elementos

436
00:23:37,759 --> 00:23:39,619
normalmente en lo que hemos visto

437
00:23:39,619 --> 00:23:41,460
nosotros en los trialgo

438
00:23:41,460 --> 00:23:42,980
en los triset

439
00:23:42,980 --> 00:23:44,339
o en los trimap

440
00:23:44,339 --> 00:23:47,259
como el árbol cuando tú

441
00:23:47,259 --> 00:23:49,279
insertas un nuevo nodo tiene que decidir

442
00:23:49,279 --> 00:23:51,220
si ponerlo a la izquierda o a la derecha de otro nodo,

443
00:23:51,339 --> 00:23:55,519
tiene que poder comparar el nodo nuevo con el nodo actual.

444
00:23:55,920 --> 00:23:58,980
Y si es mayor, bajará por la derecha y mirará.

445
00:23:59,140 --> 00:24:00,240
Si no hay nada, lo pone allí.

446
00:24:00,380 --> 00:24:02,059
Y si hay algo, volverá a comparar.

447
00:24:02,339 --> 00:24:03,819
Si es menor, baja por la izquierda.

448
00:24:04,839 --> 00:24:07,299
Entonces, se necesita un mecanismo para decidir,

449
00:24:07,380 --> 00:24:08,140
oye, sí, vale, muy bien.

450
00:24:08,480 --> 00:24:09,500
Mayor o menor, ¿de qué?

451
00:24:09,500 --> 00:24:14,359
¿Cómo puedo comparar el nuevo nodo con el nuevo valor

452
00:24:14,359 --> 00:24:15,819
con el valor viejo que estaba allí?

453
00:24:16,200 --> 00:24:18,599
Pues eso dice, usa comparable.

454
00:24:18,599 --> 00:24:27,759
tú implementas comparable él utilizará esa forma para hacerlo sí más dudas preguntas

455
00:24:29,160 --> 00:24:35,400
luego sobre comparable también tenemos que decir algunas cosillas hoy tocan tres cosas vale hemos

456
00:24:35,400 --> 00:24:42,539
acabado ahora las map y luego habrá que hacer ejemplos ejercicios y cosas y a lo mejor mañana

457
00:24:42,539 --> 00:24:45,240
toca algo sobre

458
00:24:45,240 --> 00:24:47,099
Compertú y sobre Comparator

459
00:24:47,099 --> 00:24:49,460
que lo decimos el otro día, pero no hicimos

460
00:24:49,460 --> 00:24:51,579
un ejemplo, ¿vale? A ver si encontramos un ejemplo

461
00:24:51,579 --> 00:24:52,440
por ahí, si no, mañana

462
00:24:52,440 --> 00:24:55,480
y luego la otra cosa que quiero enseñaros

463
00:24:55,480 --> 00:24:57,279
pero es solo una pincelada, es sobre

464
00:24:57,279 --> 00:24:59,019
excepciones, ¿vale? Pero muy poco

465
00:24:59,019 --> 00:25:00,819
solo para cumplir el expediente

466
00:25:00,819 --> 00:25:05,839
y era lo que quería enseñaros ahora

467
00:25:05,839 --> 00:25:07,519
ejemplo

468
00:25:07,519 --> 00:25:09,220
¿vale?

469
00:25:09,640 --> 00:25:11,980
¿Os acordáis cuando éramos pequeños

470
00:25:11,980 --> 00:25:13,279
y leíamos

471
00:25:13,279 --> 00:25:15,259
de teclado

472
00:25:15,259 --> 00:25:17,079
¿eh?

473
00:25:17,460 --> 00:25:18,759
¿cómo se hacía esto?

474
00:25:19,279 --> 00:25:20,799
que en segundo el otro día uno me ha dicho

475
00:25:20,799 --> 00:25:22,960
no me acuerdo cómo se lee de teclado

476
00:25:22,960 --> 00:25:24,640
scanner, scanner

477
00:25:24,640 --> 00:25:26,519
igual a new, scanner

478
00:25:26,519 --> 00:25:28,460
system.in

479
00:25:28,460 --> 00:25:29,940
se os olvida de todo

480
00:25:29,940 --> 00:25:32,180
¿sí? tenía scanner

481
00:25:32,180 --> 00:25:33,619
y ahora

482
00:25:33,619 --> 00:25:36,240
yo le digo

483
00:25:36,240 --> 00:25:38,119
int

484
00:25:38,119 --> 00:25:39,180
bueno, si hizo

485
00:25:39,180 --> 00:25:41,819
dime tu edad

486
00:25:41,819 --> 00:25:45,700
y ponía int

487
00:25:45,700 --> 00:25:47,920
edad es igual

488
00:25:47,920 --> 00:25:49,819
a scan.next

489
00:25:49,819 --> 00:25:51,480
hola, que habláis mucho

490
00:25:51,480 --> 00:25:53,640
luego nos enteráis

491
00:25:53,640 --> 00:25:54,700
quién sabe por qué

492
00:25:54,700 --> 00:25:59,480
int, ¿sí? ¿de acuerdo?

493
00:26:00,160 --> 00:26:01,900
vale, y luego yo podría decir

494
00:26:01,900 --> 00:26:02,779
si eso

495
00:26:02,779 --> 00:26:04,299
tienes

496
00:26:04,299 --> 00:26:06,220
más edad

497
00:26:06,220 --> 00:26:08,440
años

498
00:26:08,440 --> 00:26:09,859
esto es

499
00:26:09,859 --> 00:26:15,380
ejercicio de septiembre

500
00:26:15,380 --> 00:26:23,299
finales de septiembre si os acordáis yo lanzaba lanzaba esta cosa aquí ponía 19

501
00:26:23,299 --> 00:26:38,549
tiene 19 años fenomenal yo lo lanzo pongo gato y explota porque explota claro input

502
00:26:38,549 --> 00:26:44,549
match exception vale que está pasando aquí él se está dando cuenta que se

503
00:26:44,549 --> 00:26:49,950
esperaba una cosa vale pero sin embargo tú le has dado otra él tiene un

504
00:26:49,950 --> 00:26:56,970
metodito que es capaz de interpretar enteros, sin embargo, no puede interpretar los enteros

505
00:26:56,970 --> 00:27:02,470
porque tú lo has puesto gato, no sabe cómo traducir gato a un entero y, por lo tanto,

506
00:27:02,869 --> 00:27:10,349
explota, ¿vale? Ahora, las excepciones son muchas cosas y son cosas variadas y distintas,

507
00:27:10,589 --> 00:27:15,490
¿vale? Pero a lo mejor lo profundizaremos un poquito más adelante sobre tipos de excepciones,

508
00:27:15,490 --> 00:27:18,630
etc. Por ahora simplemente sepáis

509
00:27:18,630 --> 00:27:21,430
que existen dos tipos de excepciones, dos tipos

510
00:27:21,430 --> 00:27:23,569
de errores en un cierto sentido.

511
00:27:23,950 --> 00:27:27,509
Las que pueden surgir, pero me da

512
00:27:27,509 --> 00:27:30,630
igual, no tienes

513
00:27:30,630 --> 00:27:33,369
obligatoriamente que gestionarlas, como

514
00:27:33,369 --> 00:27:36,390
por ejemplo esta. Esta puede surgir,

515
00:27:36,609 --> 00:27:39,470
puede explotar, pero no te pide que tú hagas

516
00:27:39,470 --> 00:27:42,730
algo por este problema.

517
00:27:42,730 --> 00:28:05,970
En vez hay otras excepciones, que cuando un método puede lanzar ese tipo de excepción, pues el programa, el mismo Eclipse, te dice, no, cuidado, si este método de aquí no me lo proteges de alguna forma, no te dejo utilizarlo.

518
00:28:05,970 --> 00:28:23,900
Por ahora nosotros no hemos visto de esas. La veremos con los ficheros. Cuando usamos los ficheros, la IO exception, input output exception, pues requiere que tú la manejes siempre. Por eso damos una pincelada de cómo se maneja.

519
00:28:23,900 --> 00:28:47,109
O sea, ¿es bonito que exploten los programas? No. ¿Gusta a los usuarios que exploten los programas? No. ¿Queremos nosotros que los usuarios no manden ticket? No. ¿Por qué? Somos vagos. Y si hacemos las cosas bien, trabajamos menos.

520
00:28:47,109 --> 00:28:49,190
por lo tanto

521
00:28:49,190 --> 00:28:51,829
esto es un sistema en el que te está

522
00:28:51,829 --> 00:28:54,089
diciendo, dime tu edad, que claramente

523
00:28:54,089 --> 00:28:55,930
es un entero, pero alguien podría decir

524
00:28:55,930 --> 00:28:57,970
no mira, oye, en vez de un entero te pongo

525
00:28:57,970 --> 00:28:59,950
mi fecha de nacimiento, pues eso no es

526
00:28:59,950 --> 00:29:01,930
un entero, sería un string, y esto

527
00:29:01,930 --> 00:29:03,950
explotaría, vale, entonces

528
00:29:03,950 --> 00:29:06,049
existe una forma

529
00:29:06,049 --> 00:29:08,390
de hacer las cosas, un comandito

530
00:29:08,390 --> 00:29:09,450
que es el comandito

531
00:29:09,450 --> 00:29:10,930
try-catch

532
00:29:10,930 --> 00:29:13,250
¿qué es el try-catch?

533
00:29:13,829 --> 00:29:14,789
es sustancialmente

534
00:29:14,789 --> 00:29:18,789
Prueba a hacer esto

535
00:29:18,789 --> 00:29:21,890
Tú inténtalo

536
00:29:21,890 --> 00:29:22,769
¿Va todo bien?

537
00:29:23,269 --> 00:29:24,829
Adelante, ningún problema

538
00:29:24,829 --> 00:29:27,589
Pero si pasa algo raro

539
00:29:27,589 --> 00:29:41,049
Pilla ese problema

540
00:29:41,049 --> 00:29:44,329
Y en vez de explotar

541
00:29:44,329 --> 00:29:47,369
Ejecuta este bloque

542
00:29:47,369 --> 00:29:49,430
este bloque

543
00:29:49,430 --> 00:29:53,029
en particular aquí le tengo que decir

544
00:29:53,029 --> 00:29:54,089
¿qué pillo?

545
00:29:54,829 --> 00:29:57,170
y aquí es una input mismatch

546
00:29:57,170 --> 00:29:57,769
exception

547
00:29:57,769 --> 00:30:01,450
input mismatch

548
00:30:01,450 --> 00:30:02,950
exception

549
00:30:02,950 --> 00:30:03,609
e

550
00:30:03,609 --> 00:30:05,829
error

551
00:30:05,829 --> 00:30:14,990
o problema, no importa

552
00:30:14,990 --> 00:30:16,730
y ya lo tengo

553
00:30:16,730 --> 00:30:20,480
entonces ¿qué pasa aquí?

554
00:30:20,640 --> 00:30:22,599
él dice, intenta hacer esta

555
00:30:22,599 --> 00:30:23,039
cosa

556
00:30:23,039 --> 00:30:25,559
si por si acaso

557
00:30:25,559 --> 00:30:28,019
aquí explota una excepción

558
00:30:28,019 --> 00:30:29,920
se lanza una excepción

559
00:30:29,920 --> 00:30:31,839
¿vale? se levanta una excepción

560
00:30:31,839 --> 00:30:32,299
rise

561
00:30:32,299 --> 00:30:35,579
pues entonces, si es

562
00:30:35,579 --> 00:30:37,200
este tipo de excepción aquí

563
00:30:37,200 --> 00:30:39,380
entra aquí dentro

564
00:30:39,380 --> 00:30:41,559
ejecuta esta cosa aquí

565
00:30:41,559 --> 00:30:43,539
ahora vamos a ver que ponemos

566
00:30:43,539 --> 00:30:44,519
ahí, ¿vale?

567
00:30:44,880 --> 00:30:47,220
tened en cuenta que aquí me da un error porque edad

568
00:30:47,220 --> 00:30:49,299
la he generado aquí dentro y ahora estoy dentro

569
00:30:49,299 --> 00:30:51,599
de este bloque y por lo tanto

570
00:30:51,599 --> 00:30:53,059
no me funciona, ¿vale? podría

571
00:30:53,059 --> 00:30:55,619
resolver esto o declarando

572
00:30:55,619 --> 00:30:57,500
edad fuera o

573
00:30:57,500 --> 00:30:58,559
metiendo esto dentro

574
00:30:58,559 --> 00:31:01,140
si lo pongo aquí

575
00:31:01,140 --> 00:31:04,819
ya está, todo dentro del block

576
00:31:04,819 --> 00:31:05,440
que trae que he hecho

577
00:31:05,440 --> 00:31:08,240
¿qué pasa ahora

578
00:31:08,240 --> 00:31:10,519
si yo pongo 9?

579
00:31:11,400 --> 00:31:12,480
porque tengo 9 años

580
00:31:12,480 --> 00:31:14,180
¿qué pasa ahora si pongo gato?

581
00:31:19,059 --> 00:31:20,299
porque me está diciendo

582
00:31:20,299 --> 00:31:22,079
si explota algo

583
00:31:22,079 --> 00:31:29,980
no hagas nada, ¿qué odia

584
00:31:29,980 --> 00:31:32,099
más el usuario

585
00:31:32,099 --> 00:31:34,740
Que le explote un programa

586
00:31:34,740 --> 00:31:37,140
Que no haga nada

587
00:31:37,140 --> 00:31:39,299
Que se quede allí y ni explote

588
00:31:39,299 --> 00:31:41,099
Por lo tanto, no

589
00:31:41,099 --> 00:31:41,940
¿Vale?

590
00:31:42,180 --> 00:31:43,240
Pero no pasa nada

591
00:31:43,240 --> 00:31:44,880
Y aquí dentro puedo hacer lo que me da la gana

592
00:31:44,880 --> 00:31:45,460
Si hizo

593
00:31:45,460 --> 00:31:48,839
Valor no válido

594
00:31:48,839 --> 00:31:50,220
Pues ya está

595
00:31:50,220 --> 00:31:53,059
Si tú le pones gato

596
00:31:53,059 --> 00:31:55,500
Valor no válido

597
00:31:55,500 --> 00:31:57,839
Pero ahora ya no explota

598
00:31:57,839 --> 00:31:59,500
Ya está

599
00:31:59,500 --> 00:32:00,579
El try catch

600
00:32:00,579 --> 00:32:02,880
a proteger este bloque

601
00:32:02,880 --> 00:32:04,940
para decir, tú inténtalo

602
00:32:04,940 --> 00:32:06,680
si pasa algo

603
00:32:06,680 --> 00:32:09,119
píllalo

604
00:32:09,119 --> 00:32:18,759
¿cómo lo hacemos?

605
00:32:20,240 --> 00:32:21,180
pues por ejemplo

606
00:32:21,180 --> 00:32:23,859
bolean

607
00:32:23,859 --> 00:32:25,900
repite

608
00:32:25,900 --> 00:32:27,380
igual extrue

609
00:32:27,380 --> 00:32:30,279
sin hacer

610
00:32:30,279 --> 00:32:30,859
sin cosa

611
00:32:30,859 --> 00:32:35,480
y ahora digo, vile

612
00:32:35,480 --> 00:32:38,740
repite

613
00:32:38,740 --> 00:32:44,230
si no repite, Dubai

614
00:32:44,230 --> 00:32:49,039
Hacemos un

615
00:32:49,039 --> 00:32:51,119
Esto lo ponemos a false

616
00:32:51,119 --> 00:32:52,579
A ver, que ahora me lío

617
00:32:52,579 --> 00:32:55,259
Esto es un

618
00:32:55,259 --> 00:32:56,200
Do

619
00:32:56,200 --> 00:33:00,569
Esta cosa aquí

620
00:33:00,569 --> 00:33:09,039
No, no, no, me estoy liando

621
00:33:09,039 --> 00:33:10,380
Lo pongo fuera

622
00:33:10,380 --> 00:33:13,519
Pongo el while aquí

623
00:33:13,519 --> 00:33:14,720
Ahora sí

624
00:33:14,720 --> 00:33:18,220
Y pongo un repite

625
00:33:18,220 --> 00:33:19,059
A true

626
00:33:19,059 --> 00:33:21,539
Me estoy liando, es un momento solo

627
00:33:21,539 --> 00:33:23,839
Esto pasa a veces

628
00:33:23,839 --> 00:33:25,839
esto lo ponga true

629
00:33:25,839 --> 00:33:28,339
nada más entrar

630
00:33:28,339 --> 00:33:30,220
lo acepto a false, ahora sí

631
00:33:30,220 --> 00:33:31,279
aquí repite

632
00:33:31,279 --> 00:33:34,420
y empiezo con este bloque aquí

633
00:33:34,420 --> 00:33:38,170
¿vale? hasta aquí

634
00:33:38,170 --> 00:33:41,900
entonces

635
00:33:41,900 --> 00:33:43,720
en teoría todo este bloque

636
00:33:43,720 --> 00:33:46,119
se repite una y otra vez

637
00:33:46,119 --> 00:33:47,319
y otra vez y otra vez

638
00:33:47,319 --> 00:33:50,200
mientras que repite sea true

639
00:33:50,200 --> 00:33:51,480
pero yo lo ponga false

640
00:33:51,480 --> 00:33:54,259
ahora, si yo entro aquí dentro

641
00:33:54,259 --> 00:33:56,359
le digo, dime una tu edad

642
00:33:56,359 --> 00:33:59,160
Y tú me das un valor que no me gusta

643
00:33:59,160 --> 00:34:11,579
Entonces repite, se transformará en true

644
00:34:11,579 --> 00:34:16,000
Cada vez que esto explotará porque me has dado un valor que no me gusta

645
00:34:16,000 --> 00:34:18,719
Entonces al volver aquí

646
00:34:18,719 --> 00:34:23,289
Entrará otra vez porque es true

647
00:34:23,289 --> 00:34:25,429
Lo aceptará otra vez a false

648
00:34:25,429 --> 00:34:26,849
Y lo intentará otra vez

649
00:34:26,849 --> 00:34:29,710
Entonces se quedará dando ciclos aquí

650
00:34:29,710 --> 00:34:33,809
Mientras que explote esta excepción

651
00:34:33,809 --> 00:34:36,849
Si esta excepción no explota

652
00:34:36,849 --> 00:34:41,230
no pasará por este repito igual a true y por lo tanto saldrá y seguirá adelante

653
00:34:41,230 --> 00:34:56,730
después del while que sería aquí si so a ver si funciona

654
00:34:56,730 --> 00:35:15,929
cedimetro de edad, bogato, cero en el examen, vamos a ver por qué

655
00:35:18,090 --> 00:35:22,650
hay momentos de la vida en que la programación no es lo que deberías hacer

656
00:35:22,650 --> 00:36:01,389
he cerrado esto antes, porque no relee, no vuelve a leer, donde lee, aquí lee, es como si hubiese leído

657
00:36:01,389 --> 00:36:06,989
qué cosa rara, espera, entonces lo hemos solucionado

658
00:36:06,989 --> 00:36:12,389
moviendo el escáner aquí dentro, antes estaba aquí fuera

659
00:36:12,389 --> 00:36:18,090
y lo hemos pillado y lo hemos metido aquí dentro, sospecho porque

660
00:36:18,090 --> 00:36:24,969
igualmente salta una excepción de algún tipo cuando cuando pasa por aquí pero no debería

661
00:36:24,969 --> 00:36:31,409
ser una input mismas excepciones algo raro es algo raro es lo que pasa aquí pero ahora vamos

662
00:36:31,409 --> 00:36:37,170
a explorar y luego lo decimos no sabemos exactamente por qué funcionaba así pero

663
00:36:37,170 --> 00:36:43,829
poniendo el escáner dentro del try funciona pues probablemente se acuerda de las veces anteriores

664
00:36:43,829 --> 00:36:44,369
que

665
00:36:44,369 --> 00:36:47,269
sustancialmente

666
00:36:47,269 --> 00:36:49,190
ha tenido un problema antes

667
00:36:49,190 --> 00:36:51,190
y por lo tanto vuelve a lanzar el problema

668
00:36:51,190 --> 00:36:52,750
hacemos otro ejemplo

669
00:36:52,750 --> 00:36:55,730
siempre estas cosas

670
00:36:55,730 --> 00:36:56,670
por ejemplo

671
00:36:56,670 --> 00:37:01,500
os acordaréis vuestro amigo

672
00:37:01,500 --> 00:37:03,760
el array

673
00:37:03,760 --> 00:37:11,730
entonces me creo

674
00:37:11,730 --> 00:37:13,670
un array de 10 posiciones

675
00:37:14,329 --> 00:37:15,909
y ahora te digo

676
00:37:15,909 --> 00:37:17,269
me escribes

677
00:37:17,269 --> 00:37:21,650
la posición

678
00:37:21,650 --> 00:37:23,150
11

679
00:37:23,150 --> 00:37:25,530
O la posición 10, misma

680
00:37:25,530 --> 00:37:27,690
¿Qué pasa?

681
00:37:30,880 --> 00:37:31,480
Explota

682
00:37:31,480 --> 00:37:32,559
¿Con qué explota?

683
00:37:33,099 --> 00:37:35,760
Con una array index out of bounds exception

684
00:37:35,760 --> 00:37:38,059
Pues, ¿cómo podría evitar esto?

685
00:37:38,960 --> 00:37:39,320
Pues

686
00:37:39,320 --> 00:37:41,739
Try, sí, también

687
00:37:41,739 --> 00:37:45,460
Pero no siempre puedes

688
00:37:45,460 --> 00:37:47,599
Ahora lo hacemos de otra forma

689
00:37:47,599 --> 00:37:49,619
Vale, te dice programando bien

690
00:37:49,619 --> 00:37:51,539
Entonces

691
00:37:51,539 --> 00:37:52,900
Estos son 10 posiciones

692
00:37:52,900 --> 00:37:56,119
Tú dices

693
00:37:56,119 --> 00:37:58,320
escáner

694
00:37:58,320 --> 00:38:00,360
escáner es igual a

695
00:38:00,360 --> 00:38:01,699
newscanner

696
00:38:01,699 --> 00:38:03,179
de system.in

697
00:38:03,179 --> 00:38:09,760
si eso, dame una posición

698
00:38:09,760 --> 00:38:14,659
tú dices

699
00:38:14,659 --> 00:38:18,360
scan.nextSynth

700
00:38:18,360 --> 00:38:21,079
y lo guardas

701
00:38:21,079 --> 00:38:22,159
en una entera

702
00:38:22,159 --> 00:38:22,940
en post

703
00:38:22,940 --> 00:38:24,880
¿sí?

704
00:38:24,880 --> 00:38:27,019
y ahora ¿qué hace de esa post?

705
00:38:29,420 --> 00:38:29,619
¿sí?

706
00:38:30,360 --> 00:38:32,719
entonces tú tienes esta cosa aquí

707
00:38:32,719 --> 00:38:34,519
si yo le pongo 3

708
00:38:34,519 --> 00:38:36,099
me dirá que dentro está 0

709
00:38:36,099 --> 00:38:37,940
¿y está programado bien?

710
00:38:38,239 --> 00:38:40,539
más o menos, no tiene errores

711
00:38:40,539 --> 00:38:42,320
ahora si yo le doy 11

712
00:38:42,320 --> 00:38:43,400
explota

713
00:38:43,400 --> 00:38:45,440
entonces aquí

714
00:38:45,440 --> 00:38:47,639
tenemos dos

715
00:38:47,639 --> 00:38:49,639
posibilidades

716
00:38:49,639 --> 00:38:51,460
la primera es

717
00:38:51,460 --> 00:38:54,300
si pos mayor

718
00:38:54,300 --> 00:38:55,519
que 0

719
00:38:55,519 --> 00:38:56,820
mayor o igual que 0

720
00:38:56,820 --> 00:38:59,119
pos menor

721
00:38:59,119 --> 00:39:01,460
y dame que 10

722
00:39:01,460 --> 00:39:04,179
o que R.lang

723
00:39:04,179 --> 00:39:09,389
entonces

724
00:39:09,389 --> 00:39:11,389
sí, R.com porque le he hecho

725
00:39:11,389 --> 00:39:11,909
al

726
00:39:11,909 --> 00:39:15,829
y si no

727
00:39:15,829 --> 00:39:22,300
esto es lo que hacéis vosotros

728
00:39:22,300 --> 00:39:24,599
deberíais hacer vosotros

729
00:39:24,599 --> 00:39:25,719
sí

730
00:39:25,719 --> 00:39:27,500
entonces esto funciona, sí

731
00:39:27,500 --> 00:39:29,739
si yo le pongo 11, pues error

732
00:39:29,739 --> 00:39:31,199
sí

733
00:39:31,199 --> 00:39:33,780
ahora, ¿qué problema tiene esta cosa?

734
00:39:44,460 --> 00:39:46,400
el problema de este tipo de programación

735
00:39:46,400 --> 00:39:48,559
es que se llama programación

736
00:39:48,559 --> 00:39:51,380
¿Cómo se llama?

737
00:39:53,699 --> 00:39:54,260
Pesimista

738
00:39:54,260 --> 00:39:56,500
En el sentido que estoy

739
00:39:56,500 --> 00:39:59,099
Intentando comprobar

740
00:39:59,099 --> 00:40:00,699
Que las cosas estén bien

741
00:40:00,699 --> 00:40:02,320
Antes de hacerlas

742
00:40:02,320 --> 00:40:03,980
Y se puede hacer, ningún problema

743
00:40:03,980 --> 00:40:05,340
¿Vale? Bien hecho

744
00:40:05,340 --> 00:40:08,719
Pero es pesimista porque tú te esperas

745
00:40:08,719 --> 00:40:10,539
Que siempre las cosas irán mal

746
00:40:10,539 --> 00:40:12,820
Ahora, el problema es que en informática

747
00:40:12,820 --> 00:40:14,360
El 90% de las veces

748
00:40:14,360 --> 00:40:15,300
Las cosas van bien

749
00:40:15,300 --> 00:40:19,500
o el 99% de las veces

750
00:40:19,500 --> 00:40:21,500
la gente que usará este array

751
00:40:21,500 --> 00:40:23,699
lo usará bien, porque sabe que es

752
00:40:23,699 --> 00:40:25,559
y luego

753
00:40:25,559 --> 00:40:27,599
está un 1% que por alguna razón

754
00:40:27,599 --> 00:40:28,699
pues lo ha hecho mal

755
00:40:28,699 --> 00:40:31,179
y tú estás comprobando siempre

756
00:40:31,179 --> 00:40:32,579
que esto funcione bien

757
00:40:32,579 --> 00:40:34,900
hasta en los casos

758
00:40:34,900 --> 00:40:37,679
en el que no haría falta porque todo iría bien

759
00:40:37,679 --> 00:40:39,099
estás gastando recursos

760
00:40:39,099 --> 00:40:40,800
si esto lo estoy haciendo un millón de veces

761
00:40:40,800 --> 00:40:42,860
he hecho un millón de veces esta cosa aquí

762
00:40:42,860 --> 00:40:45,239
a lo mejor no habría tenido que dar problema nunca

763
00:40:45,239 --> 00:40:49,760
Entonces, una forma un poquito distinta de hacerlo

764
00:40:49,760 --> 00:41:00,340
Es decir, tú hazlo

765
00:41:00,340 --> 00:41:03,059
¿Me has dado la posición? Vale

766
00:41:03,059 --> 00:41:05,460
Hazlo

767
00:41:05,460 --> 00:41:09,019
Y en el caso

768
00:41:09,019 --> 00:41:15,610
Arraindex

769
00:41:15,610 --> 00:41:19,449
Out of bounds

770
00:41:19,449 --> 00:41:21,289
Exception

771
00:41:21,289 --> 00:41:24,429
Y en el caso en que explote una

772
00:41:24,429 --> 00:41:34,309
error, pues entonces di error, o sea que esto es, tu intentalo y solo las veces que va mal

773
00:41:34,309 --> 00:41:41,010
te encargarás de recuperar y hacer esta cosa aquí, entonces esta es optimista, estoy pensando

774
00:41:41,010 --> 00:41:48,949
que las cosas funcionen y si van mal pues ya es el problema de alguien, esto funciona

775
00:41:48,949 --> 00:42:00,469
prácticamente igual si yo pongo 9 funciona si yo pongo 11 explota no explota me dice error

776
00:42:01,469 --> 00:42:22,079
si yo pongo gato flota porque esta excepción de aquí no la controla pero podría hacer esto y

777
00:42:22,079 --> 00:42:27,980
entonces que le ponga 22 me da error que le ponga

778
00:42:49,489 --> 00:42:54,050
claro sí porque está aquí más cifra fenomenal

779
00:42:54,050 --> 00:43:01,750
ponemos aquí ahora sí y este tanto no es una es un wild

780
00:43:01,750 --> 00:43:06,170
Claro, como esto estaba fuera del try, pues ya está, ¿vale?

781
00:43:06,630 --> 00:43:09,809
Entonces ahora, ahora sí, ¿vale?

782
00:43:10,429 --> 00:43:18,010
Pero cuidado, si yo uso esto, el problema que tengo es que estoy perdiendo granularidad.

783
00:43:18,489 --> 00:43:20,969
O sea, no estoy sabiendo qué error ha habido.

784
00:43:22,510 --> 00:43:26,949
Estoy diciendo, cualquier error, sea cual sea la causa, explota.

785
00:43:27,230 --> 00:43:30,550
Pero, y a lo mejor, o sea, recógelo y hace esto.

786
00:43:30,550 --> 00:43:35,550
Pero a lo mejor yo quiero hacer cosas distintas en excepciones distintas.

787
00:43:36,210 --> 00:43:44,230
Por ejemplo, si te digo array index out of bounds exception,

788
00:43:44,869 --> 00:43:51,449
entonces te digo no sabes usar los arrays.

789
00:43:51,449 --> 00:44:24,010
Sin embargo, si el error que sale es un mismatch input era, mismatch format, mismatch input, exception, existe, lo hacemos explotar, a ver, que explote y a ver que pasa, se llama input mismatch.

790
00:44:24,010 --> 00:44:26,550
entonces

791
00:44:26,550 --> 00:44:28,670
si tengo un

792
00:44:28,670 --> 00:44:30,750
input mismatch

793
00:44:30,750 --> 00:44:34,420
exception

794
00:44:34,420 --> 00:44:37,940
entonces

795
00:44:37,940 --> 00:44:40,699
no sabes la

796
00:44:40,699 --> 00:44:42,800
diferencia entre

797
00:44:42,800 --> 00:44:45,599
números y letras

798
00:44:45,599 --> 00:44:48,699
entonces ahora

799
00:44:48,699 --> 00:44:50,760
dependiendo de lo que pasa aquí

800
00:44:50,760 --> 00:44:52,780
si yo me equivoco

801
00:44:52,780 --> 00:44:54,920
dando una posición equivocada

802
00:44:54,920 --> 00:44:56,679
me dice que no se puede utilizar los arrays

803
00:44:56,679 --> 00:44:59,099
si yo me equivoco porque no le doy un número

804
00:44:59,099 --> 00:45:00,900
me dice la diferencia entre números

805
00:45:00,900 --> 00:45:03,159
entonces, ahora yo puedo hacer

806
00:45:03,159 --> 00:45:05,519
en base al error que ha salido

807
00:45:05,519 --> 00:45:07,360
a los posibles errores que han salido

808
00:45:07,360 --> 00:45:09,360
darle una respuesta a otra

809
00:45:09,360 --> 00:45:17,739
estas excepciones

810
00:45:17,739 --> 00:45:20,099
me las importa el

811
00:45:20,099 --> 00:45:23,900
por ejemplo, esta me la reconoce directamente

812
00:45:23,900 --> 00:45:25,960
pero esta otra la tengo que importar

813
00:45:25,960 --> 00:45:30,639
entonces, esta cosa aquí

814
00:45:30,639 --> 00:45:33,300
será más útil cuando empezaremos a utilizar

815
00:45:33,300 --> 00:45:35,420
los ficheros

816
00:45:35,420 --> 00:45:37,039
¿vale? porque en los ficheros cuando

817
00:45:37,039 --> 00:45:39,460
yo intento leer de ficheros o escribir un fichero

818
00:45:39,460 --> 00:45:40,900
al abrir el fichero

819
00:45:40,900 --> 00:45:42,880
me puede salir una

820
00:45:42,880 --> 00:45:45,239
file not found exception, me puede salir

821
00:45:45,239 --> 00:45:47,480
una IO exception, me puede salir

822
00:45:47,480 --> 00:45:49,000
una end of file exception

823
00:45:49,000 --> 00:45:51,360
etcétera, etcétera y por lo tanto

824
00:45:51,360 --> 00:45:53,480
tendré que mirar estas pequeñas

825
00:45:53,480 --> 00:45:55,380
cosas, por ahora simplemente

826
00:45:55,380 --> 00:45:57,179
que sepáis que exista una

827
00:45:57,179 --> 00:45:59,099
posibilidad de ejecutar un código

828
00:45:59,099 --> 00:46:01,280
y que si los errores que

829
00:46:01,280 --> 00:46:03,260
estáis viendo, que habéis visto alguna vez, que son

830
00:46:03,260 --> 00:46:06,340
pocos. ¿Cuál es otra excepción que hemos visto?

831
00:46:09,670 --> 00:46:11,730
Null pointer exception. Entonces yo podría

832
00:46:11,730 --> 00:46:14,829
en vez de preguntarme esto es null y luego utilizarlo

833
00:46:14,829 --> 00:46:18,070
pues utilizarlo, pero poniéndolo dentro de un try catch

834
00:46:18,070 --> 00:46:20,469
que si salta una null pointer exception pues

835
00:46:20,469 --> 00:46:23,929
intente recuperarse. El objetivo

836
00:46:23,929 --> 00:46:26,730
del catch es que

837
00:46:26,730 --> 00:46:29,610
si es posible me recupere

838
00:46:29,610 --> 00:46:32,429
del error. En vez de bloquearme y decir

839
00:46:32,429 --> 00:46:35,369
mi programa no funciona, pues intente mandar

840
00:46:35,369 --> 00:46:36,809
un mensaje al usuario

841
00:46:36,809 --> 00:46:38,389
algo ha ido mal

842
00:46:38,389 --> 00:46:41,150
ha pasado esto, has intentado hacer esto

843
00:46:41,150 --> 00:46:43,230
te has equivocado en poner esta cosa

844
00:46:43,230 --> 00:46:45,349
y en vez de decir, ya está, se ha acabado

845
00:46:45,349 --> 00:46:47,309
pues volver a intentar hacerla

846
00:46:47,309 --> 00:46:55,840
o acabar, pero acabar bien

847
00:46:55,840 --> 00:46:57,860
porque no es

848
00:46:57,860 --> 00:46:59,239
lo mismo acabar diciendo

849
00:46:59,239 --> 00:47:02,280
los datos no son correctos

850
00:47:02,280 --> 00:47:03,360
acabó el sistema

851
00:47:03,360 --> 00:47:05,420
que pantallazo rojo de

852
00:47:05,420 --> 00:47:07,760
error en el stack

853
00:47:07,760 --> 00:47:09,739
en línea 24

854
00:47:09,739 --> 00:47:15,820
el código si da una impresión distinta dudas

855
00:47:15,820 --> 00:47:20,679
esto es un tema bastante más complejo que esto pero nosotros nos paramos aquí

856
00:47:20,679 --> 00:47:26,219
simplemente puedo proteger un trozo de código poniendo un try y luego aquí

857
00:47:26,219 --> 00:47:32,380
gestionar una posible solución al problema que sale

858
00:47:32,380 --> 00:47:41,559
sí y nos quedaría ejemplos vale a este punto los ejemplos los dejamos a mañana