1
00:00:00,300 --> 00:00:06,320
Voy a grabar esta clase, por lo tanto, si habláis, me dais vuestro consentimiento de grabar vuestro.

2
00:00:07,299 --> 00:00:11,400
Entonces, hoy vamos a empezar a ver lo que es la persistencia de datos.

3
00:00:11,599 --> 00:00:12,820
¿Qué es la persistencia de datos?

4
00:00:13,000 --> 00:00:16,239
Nosotros hemos tenido un problema desde el principio de este curso,

5
00:00:16,800 --> 00:00:22,179
que es que nuestros programas funcionan sólo al darle el play

6
00:00:22,179 --> 00:00:25,519
y que se acuerdan de todo mientras que el programa funcione,

7
00:00:25,519 --> 00:00:29,820
pero en cuanto el programa se acaba, todo lo que he hecho se destruye.

8
00:00:30,300 --> 00:00:40,159
Ahora, si mi programa es, te doy un número y me dices si es par o impar, ¿qué más me da? ¿Vale? Se apaga, lo lanzo otra vez y le digo otro número para saber si es par o impar. Interesantísimo.

9
00:00:40,159 --> 00:00:55,880
Si mi sistema es una escuela donde tiene tu menú que dice, ¿qué quieres hacer? ¿Quieres añadir un alumno? ¿Quieres asignar una materia a un alumno? ¿Quieres asignar una nota a una materia de un alumno? Y cosas por el estilo.

10
00:00:55,880 --> 00:01:13,680
Tú cuando lo has creado y empiezas a poner alumnos, cada vez que apagas y reenciendes, tu sistema es sin alumnos. Es a cero. Y eso es feo. Entonces, nosotros necesitamos un modo para, sustancialmente, hacer persistir los datos entre ejecuciones.

11
00:01:13,680 --> 00:01:19,859
ahora nosotros sabemos que dentro del mundo de la informática hay una cosa que se llama jerarquía de

12
00:01:19,859 --> 00:01:28,209
memoria donde empezamos desde la memoria más pequeña pequeña pequeña pequeña y más rápida

13
00:01:28,209 --> 00:01:45,019
rápida rápida vida que son los registros gracias no sé quién ha dicho luego vamos un poquito más

14
00:01:45,019 --> 00:01:56,859
grande llegamos a un pollo más grande un poquito más lento llegamos a saltar un par más caché

15
00:01:56,859 --> 00:02:08,639
la que pone cuando te compras un procesador y te pone memoria de caché de nivel 2 de 64 mega

16
00:02:08,639 --> 00:02:20,099
y luego hay nivel 3 pues esas son todas siempre memorias más grandes pero más lentas que se alejan

17
00:02:20,099 --> 00:02:24,740
del procesador vale los registros son los más cercanos luego están los que están en el chip

18
00:02:24,740 --> 00:02:30,500
del procesador que son estas memorias caché vale de dos o tres niveles y luego se llega

19
00:02:30,500 --> 00:02:44,789
a la ram y hasta aquí todas estas son exactos volátiles qué quiere decir que cada vez que

20
00:02:44,789 --> 00:02:51,629
apago el ordenador todo el contenido de estas memorias desaparece la ram en particular que es

21
00:02:51,629 --> 00:02:57,150
mi memoria de trabajo es donde he trabajado hasta ahora vale todos mis programas han utilizado la

22
00:02:57,150 --> 00:03:04,349
y cuando yo apago el ordenador y lo enciendo, no hay nada. Virtualmente hablando, cuando yo cierro

23
00:03:04,349 --> 00:03:09,750
la java virtual machine, o sea, cuando vosotros le dais al botón verde y se enciende la java virtual machine

24
00:03:09,750 --> 00:03:15,569
e interpreta vuestro programa y hay el botón rojo abajo, que a veces cuando hacéis un while eterno

25
00:03:15,569 --> 00:03:22,229
se queda ahí rojo y le tenéis que pinchar para pararlo. A ver, que vos lo paráis, borráis el proceso y el

26
00:03:22,229 --> 00:03:35,659
proceso es? Es un proceso. Esta pregunta te la he hecho ya hace un momento, efectivamente. O sea, cuando he ejecutado el

27
00:03:35,659 --> 00:03:40,879
programa, entonces se ha creado el proceso con todos los recursos. Cuando el proceso se quita, se le

28
00:03:40,879 --> 00:03:45,979
desasigna también el trozo de RAM que se le había dado al proceso y por lo tanto toda

29
00:03:45,979 --> 00:03:56,979
mi memoria se ha borrado. Si sigo con la jerarquía de memoria, la siguiente memoria sería el escuduro.

30
00:03:56,979 --> 00:04:03,400
la memoria secundaria. Disco duro sea como sea, de qué tipo sea, pero eso sí que es la primera memoria

31
00:04:03,400 --> 00:04:11,259
no volátil. La memoria que cuando apago e enciendo mi ordenador pues sigue allí. De lo que hemos

32
00:04:11,259 --> 00:04:28,069
hecho nosotros, ¿qué está en la memoria no volátil? El programa como tal, el código fuente. El código se

33
00:04:28,069 --> 00:04:36,269
se escribe en disco duro. Cuando yo arranco el programa, en realidad lo que escribimos

34
00:04:36,269 --> 00:04:40,750
nosotros está en el punto java, pero lo que se utiliza para arrancar no es el punto java,

35
00:04:40,750 --> 00:04:45,569
es el punto class, se hace la compilación, se escribe el punto class por algún lado,

36
00:04:45,569 --> 00:04:49,750
cuando arranco la java de esta máquina, arranco mi programa, el programa va a pillar este

37
00:04:49,750 --> 00:04:59,120
punto clas lo carga en memoria ram y empieza a trabajar con todos los datos

38
00:04:59,120 --> 00:05:05,839
que yo creo las variables la cosa así que creo dentro de mi programa se crean

39
00:05:05,839 --> 00:05:11,040
donde

40
00:05:11,500 --> 00:05:18,189
en la memoria ram en un espacio dedicado porque al ejecutar el programa y

41
00:05:18,189 --> 00:05:22,069
transformándose en un proceso se hace una llamada de sistema al sistema

42
00:05:22,069 --> 00:05:28,069
operativo que le dice oye mira de toda la RAM que tienes reserva un poquito de RAM para mí por favor

43
00:05:28,069 --> 00:05:34,430
y él dice toma esta es tu RAM entonces yo trabajo allí dentro vale ese es mi trozo de memoria si

44
00:05:34,430 --> 00:05:42,310
necesito más tendré posibilidad de pedir más al sistema operativo si necesito sólo esa me quedo

45
00:05:42,310 --> 00:05:49,009
con esa allí pero tengo mi RAM dedicada otros procesos no pueden acceder a mi RAM si no es un

46
00:05:49,009 --> 00:05:54,170
problema. Es un problema que en C se puede lograr a veces con una segmentation fault,

47
00:05:54,170 --> 00:05:59,889
cosa por el estilo, que es un enemigo malvado de C, porque aparece siempre que os equivocáis con

48
00:05:59,889 --> 00:06:11,129
algo de malloc o de gestión de memoria mal hecha. Dicho todo esto, dentro del espacio de RAM que yo

49
00:06:11,129 --> 00:06:17,689
tengo, por un lado cargaré los trozos de código o el código de mi programa y lo tendré allí,

50
00:06:17,689 --> 00:06:21,230
Ahí trabajo dónde están las instrucciones que tengo que ejecutar.

51
00:06:21,689 --> 00:06:22,170
Fenomenal.

52
00:06:22,550 --> 00:06:25,430
Que copiaré, si este es todo mi programa,

53
00:06:25,509 --> 00:06:27,290
un trocito lo copiaré en nivel 3,

54
00:06:27,509 --> 00:06:29,709
un trocito de este nivel 3 en nivel 2,

55
00:06:29,810 --> 00:06:33,389
un trocito de este nivel 2 me lo cargo en los registros

56
00:06:33,389 --> 00:06:36,430
y desde los registros lo ejecuto en el procesador.

57
00:06:37,269 --> 00:06:37,470
¿Vale?

58
00:06:37,790 --> 00:06:41,050
Siempre tengo como trocitos siempre más grandes

59
00:06:41,050 --> 00:06:43,449
cerca del procesador para que sea mucho más rápido

60
00:06:43,449 --> 00:06:45,170
cambiar de ejecución y cosas por el estilo.

61
00:06:45,569 --> 00:06:45,810
Ahí.

62
00:06:45,810 --> 00:06:48,069
funcionalidad. Esto lo habéis estudiado, ¿no?

63
00:06:49,250 --> 00:06:49,410
¿No?

64
00:06:50,149 --> 00:06:51,670
Sistema informático, ¿no?

65
00:06:52,730 --> 00:06:54,230
Hay todo un mecanismo en el

66
00:06:54,230 --> 00:06:55,970
ordenador para que prevea

67
00:06:55,970 --> 00:06:58,170
lo que tú vas a utilizar y lo

68
00:06:58,170 --> 00:07:00,009
cargue en las zonas

69
00:07:00,009 --> 00:07:02,310
de memoria más cercana

70
00:07:02,310 --> 00:07:04,230
al procesador. Si lo hace bien

71
00:07:04,230 --> 00:07:06,310
tu programa va bien, si lo hace mal

72
00:07:06,310 --> 00:07:08,129
llega un momento en que tiene que

73
00:07:08,129 --> 00:07:10,089
pararse a buscar esta información

74
00:07:10,089 --> 00:07:11,930
en un lado o en el otro, en el caso peor

75
00:07:11,930 --> 00:07:13,750
desde el disco duro y por lo tanto

76
00:07:13,750 --> 00:07:14,910
ralentiza todo el proceso.

77
00:07:15,810 --> 00:07:23,910
Mi ram, parte, está allí con el código del OJD, y lo de otra parte de la ram, donde

78
00:07:23,910 --> 00:07:26,089
yo creo las variables que yo creo.

79
00:07:26,089 --> 00:07:45,959
Y aquí hay dos cosas, hay el heap, que es donde se crean los objetos, no todas las variables,

80
00:07:45,959 --> 00:07:55,339
Y el stack, la pila.

81
00:07:56,540 --> 00:07:59,100
¿Sabéis cuando se decía llamada de métodos?

82
00:07:59,399 --> 00:08:00,980
Era la pila de la llamada de métodos.

83
00:08:01,139 --> 00:08:03,040
Pues a esta está asociada una pila en la memoria

84
00:08:03,040 --> 00:08:07,240
donde en cada bloque que yo apilo en esta pila

85
00:08:07,240 --> 00:08:09,939
creo las variables locales de ese método.

86
00:08:10,800 --> 00:08:13,480
Las llamadas de métodos corresponden a

87
00:08:13,480 --> 00:08:16,240
construcción de variables locales a ese método.

88
00:08:16,420 --> 00:08:19,139
Cuando yo quito ese método, pues toda la variable local

89
00:08:19,139 --> 00:08:20,220
de ese método se pierde.

90
00:08:21,279 --> 00:08:22,939
Esto lo vimos con los scope

91
00:08:22,939 --> 00:08:25,139
de las variables en

92
00:08:25,139 --> 00:08:28,189
octubre.

93
00:08:30,189 --> 00:08:31,430
Entonces, todo esto

94
00:08:31,430 --> 00:08:32,710
memoria volátil.

95
00:08:33,429 --> 00:08:35,049
Ahora lo que queremos hacer nosotros

96
00:08:35,049 --> 00:08:37,029
es hacer que persistan estos datos. Quiere decir

97
00:08:37,029 --> 00:08:39,049
que cuando llegue un momento

98
00:08:39,049 --> 00:08:40,990
determinado, yo puedo decirle

99
00:08:40,990 --> 00:08:43,210
a mi programa, vale, muy bien, lo que tú

100
00:08:43,210 --> 00:08:44,850
tengas ahora en memoria RAM,

101
00:08:45,330 --> 00:08:46,990
guárdalo, cópialo, escríbelo

102
00:08:46,990 --> 00:08:49,309
de alguna forma en la memoria

103
00:08:49,309 --> 00:08:51,470
secundaria para que cuando yo

104
00:08:51,470 --> 00:08:52,929
apague este programa

105
00:08:52,929 --> 00:08:54,929
los datos se queden allí

106
00:08:54,929 --> 00:08:57,370
y cuando yo vuelva a encender

107
00:08:57,370 --> 00:08:59,389
este programa, el programa mismo

108
00:08:59,389 --> 00:09:01,870
puede preguntarse, oye mira, ¿has guardado

109
00:09:01,870 --> 00:09:03,769
algo anteriormente?

110
00:09:04,169 --> 00:09:05,610
o podría decirme, oye mira

111
00:09:05,610 --> 00:09:07,730
¿quieres cargar algún fichero?

112
00:09:08,009 --> 00:09:09,450
y yo le puedo decir, mira, vete

113
00:09:09,450 --> 00:09:11,149
a este fichero de aquí, allí dentro

114
00:09:11,149 --> 00:09:13,470
encontrarás algo y con

115
00:09:13,470 --> 00:09:15,610
ese algo, sácame los datos

116
00:09:15,610 --> 00:09:17,769
para volver al mismo estado

117
00:09:17,769 --> 00:09:22,409
o un estado lo más parecido posible de cuando apague la última vez.

118
00:09:22,750 --> 00:09:25,909
Eso puede ser que lo haga de forma automática, en el sentido de que yo arranco

119
00:09:25,909 --> 00:09:29,470
y él, sin preguntarme nada, vaya a buscar un particular fichero

120
00:09:29,470 --> 00:09:31,830
y si ese fichero está, lo cargue en memoria,

121
00:09:32,210 --> 00:09:35,129
o puede ser que simplemente arranque siempre en vacío

122
00:09:35,129 --> 00:09:38,389
y que tú digas, oye, mira, lo ad este de aquí, ¿vale?

123
00:09:39,029 --> 00:09:42,210
Nosotros empezaremos ahora, porque este año lo hacemos al revés,

124
00:09:42,210 --> 00:09:44,009
con forma

125
00:09:44,009 --> 00:09:46,169
de forma, digamos, textual

126
00:09:46,169 --> 00:09:48,110
le pediremos que hagan las cosas

127
00:09:48,110 --> 00:09:49,990
mandándole comandos que creamos

128
00:09:49,990 --> 00:09:51,850
nosotros o dándole a uno para

129
00:09:51,850 --> 00:09:53,870
cargar o lo que sea, ¿vale? Como hemos hecho

130
00:09:53,870 --> 00:09:55,970
los menús. La cosa interesante

131
00:09:55,970 --> 00:09:57,950
será después, pues, todas

132
00:09:57,950 --> 00:09:59,509
estas opciones hacerlas a través de una

133
00:09:59,509 --> 00:10:01,929
interfacturación, ¿vale? El año pasado

134
00:10:01,929 --> 00:10:03,950
para quien estaba el año pasado o quien

135
00:10:03,950 --> 00:10:05,710
había visto vídeos del año pasado

136
00:10:05,710 --> 00:10:07,970
empezamos con la

137
00:10:07,970 --> 00:10:09,870
parte, digamos, antes gráfica

138
00:10:09,870 --> 00:10:11,970
y luego hicimos esta de aquí

139
00:10:11,970 --> 00:10:14,529
pues este año intentamos al revés

140
00:10:14,529 --> 00:10:15,029
porque

141
00:10:15,029 --> 00:10:18,450
no está claro si es mejor

142
00:10:18,450 --> 00:10:19,889
hacer una cosa o la otra

143
00:10:19,889 --> 00:10:22,450
¿Conceptos?

144
00:10:23,250 --> 00:10:24,429
El código en la

145
00:10:24,429 --> 00:10:26,470
programación orientada a objetos, los objetos

146
00:10:26,470 --> 00:10:27,570
sobre que se funda

147
00:10:27,570 --> 00:10:29,289
¿Vale?

148
00:10:29,850 --> 00:10:32,049
Datos y código ejecutable

149
00:10:32,049 --> 00:10:33,990
¿Vale? Esto de aquí son

150
00:10:33,990 --> 00:10:36,370
el repaso de lo que acabamos de decir toda hora

151
00:10:36,370 --> 00:10:38,450
¿Vale? Nosotros cuando

152
00:10:38,450 --> 00:10:40,429
cuando trabajamos con programación

153
00:10:40,429 --> 00:10:42,409
orientada a objetos, por un lado tenemos

154
00:10:42,409 --> 00:10:44,470
los atributos que son los datos del objeto

155
00:10:44,470 --> 00:10:46,450
por otro lado tenemos los métodos que es código

156
00:10:46,450 --> 00:10:48,309
¿vale? esto se guardará por algún lado

157
00:10:48,309 --> 00:10:50,529
el código almacenado

158
00:10:50,529 --> 00:10:52,669
en el dispositivo de almacenamiento con un disco duro

159
00:10:52,669 --> 00:10:54,429
¿vale? es el código compilado

160
00:10:54,429 --> 00:10:56,269
que se guarda allí, o sea los métodos

161
00:10:56,269 --> 00:10:58,330
no se guardan en el heap

162
00:10:58,330 --> 00:11:00,549
los métodos están guardados por otro lado

163
00:11:00,549 --> 00:11:02,710
y siguen allí, son el código que yo he

164
00:11:02,710 --> 00:11:04,889
escrito, sin embargo los atributos

165
00:11:04,889 --> 00:11:06,470
dependen de la ejecución ¿vale?

166
00:11:06,509 --> 00:11:08,269
de lo que estoy haciendo con el objeto

167
00:11:08,269 --> 00:11:18,350
O sea, que el comportamiento en un cierto sentido, una vez escrito, se compila y se queda allí, los datos sobre los que se trabaja pueden mudar durante la ejecución.

168
00:11:18,669 --> 00:11:26,330
Yo lo que no puedo modificar es cómo funciona un método mientras lo estoy ejecutando y mientras lo estoy utilizando.

169
00:11:26,450 --> 00:11:32,649
Para eso debería parar el sistema, crear un nuevo método, compilarlo y en ese punto utilizaría el nuevo método.

170
00:11:32,649 --> 00:11:39,649
Cuando ejecutamos un programa sobre una Javita Machine, el código compilado se carga en memoria RAM y se ejecuta, lo hemos dicho.

171
00:11:39,649 --> 00:11:49,649
Cuando la electricidad se apaga, el programa desaparece de la memoria, pero persiste en el disco, el programa, el código, sigue ahí.

172
00:11:49,649 --> 00:11:56,649
Los atributos. Los valores de atributos de los objetos no existen previamente en el disco, ¿vale?

173
00:11:56,649 --> 00:12:08,269
Todo lo que yo defino en el código está en el código, pero no existe una zona de memoria con la que yo pueda trabajar tanto con objetos como con variables de tipo primitivo y cosas por el estilo.

174
00:12:08,269 --> 00:12:20,509
Se van creando a la hora de ejecutar el objeto, hay algunas instrucciones como la declaración de variables o la asignación de valores a variables creadas que me permiten sostantivamente crear lo que necesito en RAM.

175
00:12:20,509 --> 00:12:28,649
Una vez en la introducción del programa, cuando se ejecuta una new, se crea en un espacio de memoria RAM, que es el int,

176
00:12:29,169 --> 00:12:35,169
toda la estructura necesaria para que este objeto exista y que pueda trabajar con él.

177
00:12:35,610 --> 00:12:44,490
El resto de datos, como variables locales, parámetros de entradas, los parámetros de los métodos que se asigna desde formal a actual, etc.

178
00:12:45,490 --> 00:12:50,389
Se guardan en una zona de memoria llamada stack, una pila, stack en inglés.

179
00:12:50,509 --> 00:12:53,610
porque efectivamente se va creando

180
00:12:53,610 --> 00:12:56,309
cuando yo llamo un método, creo todas las cosas de este método

181
00:12:56,309 --> 00:12:59,049
en un bloque que voy apilando, cada llamada

182
00:12:59,049 --> 00:13:02,090
yo siempre ejecuto la última llamada del método

183
00:13:02,090 --> 00:13:05,429
lo vimos cuando vimos la stack de llamadas a método

184
00:13:05,429 --> 00:13:07,769
yo llamo el método main, pues estoy ejecutando el main

185
00:13:07,769 --> 00:13:10,950
si desde el main se llama el método calcularArea

186
00:13:10,950 --> 00:13:15,289
dejo colgado el main

187
00:13:15,289 --> 00:13:17,389
me voy a calcular, creo un nuevo bloque

188
00:13:17,389 --> 00:13:20,269
donde aquí puede haber nuevas variables y uso estas

189
00:13:20,269 --> 00:13:26,389
que son visibles desde este método, son locales a este método. Cuando acaba este método, este nuevo

190
00:13:26,389 --> 00:13:31,070
bloque se destruye y vuelvo a donde estaba antes, que era la llamada del main, y por lo tanto,

191
00:13:31,070 --> 00:13:42,429
a la línea siguiente de la llamada al método calcular era del main. ¿Entiendes? Este contenido

192
00:13:42,429 --> 00:13:48,470
es volátil en el sentido que se libera cada vez que se acaba la ejecución y todo esto es RAM,

193
00:13:48,470 --> 00:13:50,049
vale, entonces cuando acaba

194
00:13:50,049 --> 00:13:51,870
vale

195
00:13:51,870 --> 00:13:54,490
cuando finaliza el programa los datos de los atributos

196
00:13:54,490 --> 00:13:56,529
del IP no persisten, aunque

197
00:13:56,529 --> 00:13:58,409
en muchos casos sería deseable, vale

198
00:13:58,409 --> 00:14:00,610
este es el concepto de, tengo mi escuela

199
00:14:00,610 --> 00:14:02,409
he hecho mis alumnos y ahora

200
00:14:02,409 --> 00:14:03,509
no puedo

201
00:14:03,509 --> 00:14:06,389
cruzar los dedos diciendo, mientras que

202
00:14:06,389 --> 00:14:08,429
este ordenador no se apague, tengo aquí

203
00:14:08,429 --> 00:14:10,409
los alumnos y si

204
00:14:10,409 --> 00:14:12,350
mañana se va la luz, pues tengo

205
00:14:12,350 --> 00:14:14,769
que volver a poner los 1200 alumnos de este año

206
00:14:14,769 --> 00:14:15,090
vale

207
00:14:15,090 --> 00:14:18,370
los lenguajes orientados a objetos

208
00:14:18,370 --> 00:14:21,009
no prevén de ningún mecanismo automático

209
00:14:21,009 --> 00:14:22,250
de persistencia

210
00:14:22,250 --> 00:14:23,649
por tanto debemos programar

211
00:14:23,649 --> 00:14:26,549
¿qué datos queremos que sean persistentes?

212
00:14:27,090 --> 00:14:28,789
no existe normalmente

213
00:14:28,789 --> 00:14:30,629
a nivel de programación de orientados a objetos

214
00:14:30,629 --> 00:14:32,529
un método mágico que dice

215
00:14:32,529 --> 00:14:34,289
esto cuárdame todo por ahí

216
00:14:34,289 --> 00:14:36,990
se puede lograr hasta un cierto nivel

217
00:14:36,990 --> 00:14:38,570
con estas cosas de Evernet

218
00:14:38,570 --> 00:14:39,830
facilitan

219
00:14:39,830 --> 00:14:42,850
el hacerlo

220
00:14:42,850 --> 00:14:44,029
a precio

221
00:14:44,029 --> 00:14:48,029
de tener que configurarlo y tener que saber

222
00:14:48,029 --> 00:14:51,929
lo que estoy haciendo. O sea, a cambio de una formación previa que me permite

223
00:14:51,929 --> 00:14:55,870
utilizarlo, luego me facilita el último. Nosotros

224
00:14:55,870 --> 00:14:59,370
no estamos a ese nivel, estaremos a un nivel mucho más bajo.

225
00:15:00,110 --> 00:15:04,370
Como muchas cosas que hemos hecho, tendemos a empezar desde niveles

226
00:15:04,370 --> 00:15:08,090
más bajos de abstracción, más cercanos a

227
00:15:08,090 --> 00:15:12,009
lo que podría ser el lenguaje máquina, aun si estamos en un lenguaje de alto

228
00:15:12,009 --> 00:15:18,110
nivel y por lo tanto muchas cosas reales se esconden y luego a partir de allí construimos

229
00:15:18,110 --> 00:15:25,950
encima clases o métodos o abstracciones que nos permiten sustancialmente hacer lo que a

230
00:15:25,950 --> 00:15:31,210
bajo nivel son muchas instrucciones con una instrucción sola que digamos esconde lo que

231
00:15:31,210 --> 00:15:35,830
hay por debajo un poco si queremos verlo con lo que hemos hecho con ArrayList nosotros antes

232
00:15:35,830 --> 00:15:38,169
hemos aprendido como funciona un array

233
00:15:38,169 --> 00:15:40,250
como se añade un elemento a un array

234
00:15:40,250 --> 00:15:42,309
y cosas por el estilo, luego hicimos un paso

235
00:15:42,309 --> 00:15:44,029
intermedio que era crear nuestra

236
00:15:44,029 --> 00:15:46,330
clase gestión

237
00:15:46,330 --> 00:15:48,149
array que me permitía hacer cosas

238
00:15:48,149 --> 00:15:50,289
mágicas sobre los arrays sin toquetear

239
00:15:50,289 --> 00:15:52,330
los arrays directamente porque lo he tocado una vez

240
00:15:52,330 --> 00:15:54,169
y a partir de ahora uso un método

241
00:15:54,169 --> 00:15:56,230
que me añade el elemento sin

242
00:15:56,230 --> 00:15:58,190
tocar el array y luego ver

243
00:15:58,190 --> 00:15:59,970
que esta cosa efectivamente es tan lista

244
00:15:59,970 --> 00:16:02,389
que alguien lo ha hecho y ha creado una clase

245
00:16:02,389 --> 00:16:04,590
arrayist que sustancialmente

246
00:16:04,590 --> 00:16:06,129
me permite añadir cosas

247
00:16:06,129 --> 00:16:07,970
sin tener que estar pendiente de lo mismo.

248
00:16:08,450 --> 00:16:08,529
¿Sí?

249
00:16:09,149 --> 00:16:11,210
Un viaje desde muy bajo nivel

250
00:16:11,210 --> 00:16:14,830
a niveles más altos de astral.

251
00:16:15,169 --> 00:16:15,610
¿Vale?

252
00:16:17,070 --> 00:16:18,909
Para conservar el valor

253
00:16:18,909 --> 00:16:21,409
un dato en un dispositivo

254
00:16:21,409 --> 00:16:22,309
de almacenamiento.

255
00:16:23,429 --> 00:16:24,909
Se puede hacer de varias maneras.

256
00:16:25,049 --> 00:16:25,129
¿Vale?

257
00:16:25,169 --> 00:16:26,409
Entonces, nosotros

258
00:16:26,409 --> 00:16:29,250
cuando tenemos un dato

259
00:16:29,250 --> 00:16:32,049
y lo queremos guardar

260
00:16:32,049 --> 00:16:34,330
en el sentido de no en RAM

261
00:16:34,330 --> 00:16:45,330
a nivel de persistencia, podemos tener varias formas de arte. Nosotros nos centraremos y tendremos en cuenta tres,

262
00:16:45,330 --> 00:16:55,330
en esta parte dos de ellas, pero para que tengáis una idea. Primero es crear un archivo. ¿Qué es un archivo?

263
00:16:55,330 --> 00:17:03,409
Es un trozo de memoria dentro de un disco duro, ¿vale?

264
00:17:03,509 --> 00:17:05,210
Habéis visto un archivo o cosa por el estilo.

265
00:17:05,690 --> 00:17:08,009
Hay dos tipos de archivos, grosso modo.

266
00:17:08,190 --> 00:17:10,849
Uno son los archivos normales con extensión que conocéis,

267
00:17:11,170 --> 00:17:12,569
y el otro son las carpetas.

268
00:17:13,029 --> 00:17:15,650
Las carpetas son archivos especiales que tienen dentro,

269
00:17:15,710 --> 00:17:17,670
sustancialmente, punteros a otros archivos.

270
00:17:18,009 --> 00:17:19,569
Pero al fin y al cabo son archivos ellos también.

271
00:17:20,730 --> 00:17:23,089
¿Vale? Entonces, yo tengo este archivo,

272
00:17:23,089 --> 00:17:27,369
tengo este espacio de memoria, quiero guardar mis datos, los guardo

273
00:17:27,369 --> 00:17:31,130
en modo row, ¿vale? crudo en inglés, es decir

274
00:17:31,130 --> 00:17:34,289
me invento un formato en el que yo pillo

275
00:17:34,289 --> 00:17:38,950
los valores que normalmente conforman mi objeto y

276
00:17:38,950 --> 00:17:42,930
escribo estos valores con un determinado formato inventado por mí

277
00:17:42,930 --> 00:17:46,089
separado por coma, entre paréntesis, lo que me dé la gana

278
00:17:46,089 --> 00:17:50,990
en un fichero, ¿vale? sea como en tipo

279
00:17:50,990 --> 00:17:57,650
texto sea en hexadecimal sea en lo que yo necesite en un formato que yo decido y cuando tengo este

280
00:17:57,650 --> 00:18:03,950
alumno que se llama stefano y que tiene todos 10 es en sus asignaturas claramente toda media

281
00:18:03,950 --> 00:18:10,789
10 pues lo que hacemos es guardar en un fichero stefano dos puntos 10 vale para mí esto punto y

282
00:18:10,789 --> 00:18:17,329
coma esto es un alumno vale y si hay otro alumno que se llama no lo sé y que tiene cinco de media

283
00:18:17,329 --> 00:18:19,089
pues después del punto y coma pondré

284
00:18:19,089 --> 00:18:21,569
no lo sé, dos puntos, cinco

285
00:18:21,569 --> 00:18:23,569
punto y coma. Y así, me invento

286
00:18:23,569 --> 00:18:25,670
un método mío. Podría no ser

287
00:18:25,670 --> 00:18:26,809
texto.

288
00:18:27,809 --> 00:18:29,450
Podría ser binario

289
00:18:29,450 --> 00:18:30,910
si hace falta.

290
00:18:31,549 --> 00:18:33,430
Pero tengo una forma para

291
00:18:33,430 --> 00:18:35,109
tengo un objeto, lo escribo así

292
00:18:35,109 --> 00:18:36,869
en un fichero.

293
00:18:37,269 --> 00:18:39,250
Cuando tenga este fichero con esta cosa escrita

294
00:18:39,250 --> 00:18:41,250
con un determinado formato, puedo leer este

295
00:18:41,250 --> 00:18:43,410
formato para reconstruir

296
00:18:43,410 --> 00:18:44,250
el objeto.

297
00:18:44,250 --> 00:18:55,250
Tenemos que controlar nosotros el formato de dicho archivo. El formato es mío, el propietario, me invento yo como sea.

298
00:18:55,250 --> 00:19:08,140
Segunda opción, pidiendo a la Llamator Machine que almacene todos los datos del objeto en un archivo, pero dejando la gestión del formato a ella.

299
00:19:08,140 --> 00:19:19,380
Esto lo hacemos serializando el objeto, lo que implementa la interfaz Serializable.

300
00:19:21,039 --> 00:19:26,299
Esto es sustancialmente, hago una extracción, esto lo estoy haciendo yo.

301
00:19:26,660 --> 00:19:33,400
Aquí voy a perder el control sobre el formato y a cambio le digo a la Javeton Machine,

302
00:19:33,400 --> 00:19:37,079
usa tus métodos para guardar estos objetos.

303
00:19:37,799 --> 00:19:40,119
¿Cómo se guardan? No lo sé, no lo quiero saber.

304
00:19:40,259 --> 00:19:45,960
Pero si te digo, guárdame este objeto, tú lo guardarás con el mecanismo que te parezca a ti,

305
00:19:46,099 --> 00:19:51,519
que alguien más habrá implementado de un formato que yo a lo mejor no sé, no quiero saber,

306
00:19:51,839 --> 00:19:54,420
porque yo no voy luego a hurgar en ese formato,

307
00:19:54,420 --> 00:19:58,700
sino que voy simplemente a trabajar con ese fichero diciendo, guárdame el objeto, recupérame el objeto.

308
00:19:58,700 --> 00:20:06,900
Finalmente, pidiéndole a un sistema gestor de bases de datos que almacene los datos en

309
00:20:06,900 --> 00:20:10,140
algunas estructuras, tablas y cosas por el estilo.

310
00:20:10,140 --> 00:20:15,440
Entonces, para que esto funcione necesitaría tener una base de datos activa, una posibilidad

311
00:20:15,440 --> 00:20:22,140
de conectarme a esta base de datos y, sustancialmente, lo que se llama un ORM, un Object Relational

312
00:20:22,140 --> 00:20:28,460
que sería sustancialmente un mecanismo entre medias

313
00:20:28,460 --> 00:20:30,619
en el que yo hablo con él diciendo

314
00:20:30,619 --> 00:20:33,220
oye mira, yo necesito guardar este objeto

315
00:20:33,220 --> 00:20:38,619
él mapea los datos de este objeto con tablas

316
00:20:38,619 --> 00:20:42,099
y con la estructura de una base de datos que guarda este objeto

317
00:20:42,099 --> 00:20:45,960
y a ese punto él en automático guarda en la base de datos

318
00:20:45,960 --> 00:20:48,759
a la que tiene que conectarse, por lo tanto la base de datos tiene que estar encendida

319
00:20:48,759 --> 00:20:50,759
guarda todos los datos de ese objeto

320
00:20:50,759 --> 00:20:59,980
En los tres casos, la parte compleja no es guardar el objeto.

321
00:21:01,039 --> 00:21:09,400
La parte compleja es el persistir de las referencias entre objetos.

322
00:21:10,299 --> 00:21:17,740
Porque mientras que yo guardo alumno con nombre Estefano y nota media 10, es muy fácil.

323
00:21:17,740 --> 00:21:20,519
pero cuando guardo profesor

324
00:21:20,519 --> 00:21:22,980
que dentro tiene una lista de alumnos

325
00:21:22,980 --> 00:21:24,480
y una lista de materias

326
00:21:24,480 --> 00:21:27,039
y estos alumnos se refieren a estas materias

327
00:21:27,039 --> 00:21:28,420
y las materias a notas

328
00:21:28,420 --> 00:21:29,519
y cosas por el estilo

329
00:21:29,519 --> 00:21:31,400
cuando guardo estas cosas

330
00:21:31,400 --> 00:21:33,240
no tengo que guardar solo los valores

331
00:21:33,240 --> 00:21:35,940
tengo que también guardar las relaciones

332
00:21:35,940 --> 00:21:37,539
que tienen estos valores

333
00:21:37,539 --> 00:21:40,220
porque cuando luego recargo esa información

334
00:21:40,220 --> 00:21:42,680
no solo quiero saber los valores

335
00:21:42,680 --> 00:21:44,400
sino que tengo también

336
00:21:44,400 --> 00:21:46,200
que las relaciones

337
00:21:46,200 --> 00:21:48,200
los punteros que trabajaban antes

338
00:21:48,200 --> 00:21:50,440
mantengan los punteros

339
00:21:50,440 --> 00:21:52,279
a las mismas cosas, y que si

340
00:21:52,279 --> 00:21:54,460
había dos punteros que apuntaban al mismo objeto

341
00:21:54,460 --> 00:21:56,259
no quiero ahora crear dos copias

342
00:21:56,259 --> 00:21:58,140
del mismo objeto con punteros separados

343
00:21:58,140 --> 00:21:59,880
quiero crear una vez el objeto

344
00:21:59,880 --> 00:22:02,220
y luego punteros que tengan

345
00:22:02,220 --> 00:22:03,640
el mismo objeto, ¿vale?

346
00:22:03,920 --> 00:22:06,160
y esa es la parte compleja, sobre todo aquí

347
00:22:06,160 --> 00:22:07,880
¿vale?

348
00:22:08,140 --> 00:22:10,039
porque como aquí hago todo yo

349
00:22:10,039 --> 00:22:12,339
nadie me da una mano

350
00:22:12,339 --> 00:22:14,039
en preservar estas

351
00:22:14,039 --> 00:22:15,539
conexiones

352
00:22:15,539 --> 00:22:19,380
esto te estoy diciendo, no, no, el formato es mío

353
00:22:19,380 --> 00:22:21,440
lo hago yo, pues entonces tú tendrás que escribir

354
00:22:21,440 --> 00:22:24,440
cuando guardas alumno, también las referencias

355
00:22:24,440 --> 00:22:26,740
a otros objetos posibles que

356
00:22:26,740 --> 00:22:30,460
están dentro del propio alumno

357
00:22:30,460 --> 00:22:32,400
aquí a mitad

358
00:22:32,400 --> 00:22:36,319
en el sentido que le estoy dando a la Jabberton Machine

359
00:22:36,319 --> 00:22:39,680
o ya hace esto, entonces si lo hago de golpe

360
00:22:39,680 --> 00:22:42,400
o si no le pido cosas extremadamente

361
00:22:42,400 --> 00:22:45,299
complejas, más o menos lo entiende y me

362
00:22:45,299 --> 00:22:47,220
preserva él, porque como lo está haciendo

363
00:22:47,220 --> 00:22:49,220
él, pues, lo hará bien

364
00:22:49,220 --> 00:22:51,299
él, ¿vale? Entonces, más

365
00:22:51,299 --> 00:22:53,279
o menos puede funcionar. Lo mejor

366
00:22:53,279 --> 00:22:55,200
sería aquí, porque estas son cosas mucho

367
00:22:55,200 --> 00:22:57,000
más avanzadas, y cuando hace el

368
00:22:57,000 --> 00:22:59,380
ORM, el Object Relational Mapping,

369
00:22:59,779 --> 00:23:01,200
pues, debería, si está bien

370
00:23:01,200 --> 00:23:02,839
hecho, y si lo ha configurado bien,

371
00:23:03,220 --> 00:23:04,700
pues, preservar también

372
00:23:04,700 --> 00:23:07,440
las varias referencias a objetos,

373
00:23:07,819 --> 00:23:08,880
a otros objetos, ¿vale?

374
00:23:09,200 --> 00:23:11,019
También pensarlo a nivel de base de datos,

375
00:23:11,140 --> 00:23:13,079
si yo puedo crear que cada objeto, puedo

376
00:23:13,079 --> 00:23:14,240
asignarle una

377
00:23:14,240 --> 00:23:16,839
una clave primaria

378
00:23:16,839 --> 00:23:19,380
entonces cuando luego tengo desde otros

379
00:23:19,380 --> 00:23:21,240
objetos, referirme a un

380
00:23:21,240 --> 00:23:23,160
objeto de estos, puedo usar esta clave primaria

381
00:23:23,160 --> 00:23:25,420
para decir exactamente este objeto de aquí

382
00:23:25,420 --> 00:23:27,680
entonces se mantendría

383
00:23:27,680 --> 00:23:29,319
la posibilidad de

384
00:23:29,319 --> 00:23:31,299
gestionar referencias al mismo

385
00:23:31,299 --> 00:23:33,480
objeto en base a esta clave primaria

386
00:23:33,480 --> 00:23:35,140
que yo tengo, ¿vale? aún así

387
00:23:35,140 --> 00:23:37,099
no es trivial, no es trivial

388
00:23:37,099 --> 00:23:38,740
implementarlo en un sistema como este

389
00:23:38,740 --> 00:23:41,119
no lo implementamos nosotros, sería

390
00:23:41,119 --> 00:23:42,460
una buena práctica de unos

391
00:23:42,460 --> 00:23:52,779
también el hacer que arranque que funcione es lo de siempre si lo sabes hacer no es una cosa

392
00:23:52,779 --> 00:23:58,299
tremendamente difícil a lo mejor se acomoda pero llegar al nivel de saber que estoy toqueteando

393
00:23:58,299 --> 00:24:12,390
y que todo funcione bien pues requiere de su formación dudas hay una clase de java y que

394
00:24:12,390 --> 00:24:24,259
representa un muy bien, un fichero o un file. Representa el nombre de un archivo concreto o

395
00:24:24,259 --> 00:24:29,000
los nombres de archivos de un directorio. Vale, file me vale tanto por directorio como por fichero

396
00:24:29,000 --> 00:24:34,720
porque el directorio es un fichero al fin y al cabo. Dependiendo de cuando la creo le puedo

397
00:24:34,720 --> 00:24:42,160
decir si es un directorio o no y le puedo preguntar oye fichero eres un directorio o no.

398
00:24:42,160 --> 00:24:47,960
Hay una función, si no me equivoco, que es isdir, o algo por el estilo, que devuelve true si es una directory,

399
00:24:47,960 --> 00:24:50,359
y falsa si es un archivo normal y correcto.

400
00:24:55,000 --> 00:25:09,259
Cuando yo creo un objeto de tipo file, yo tengo una representación a nivel de Java de un fichero que está en el disco duro.

401
00:25:09,700 --> 00:25:10,960
Pero son dos cosas distintas.

402
00:25:12,160 --> 00:25:19,240
yo puedo tener una representación de un objeto sin tener el fichero en el disco duro.

403
00:25:20,180 --> 00:25:25,660
Está claro que si yo lo estoy leyendo, entonces voy allí y digo, este file es este fichero.

404
00:25:25,799 --> 00:25:28,440
Vale, si no está, explota. Si está, pues lo tengo.

405
00:25:28,900 --> 00:25:33,700
Pero si yo voy a crear un fichero nuevo y digo, mira, en este fichero voy a poner este texto,

406
00:25:34,400 --> 00:25:39,299
hasta que no lo haya creado el fichero, pues no está.

407
00:25:39,299 --> 00:25:56,299
Es una referencia a un objeto en Java. Es una... ¿Cómo decir? Es una abstracción, es un manejador, es la idea de un fichero.

408
00:25:57,160 --> 00:26:02,779
Pero luego hay comandos para decir, ok, yo tengo esta representación de fichero, ahora créamelo de verdad.

409
00:26:02,779 --> 00:26:08,539
y entonces hablará la Java Virtual Machine con el sistema operativo y dirá a mí en el sistema operativo

410
00:26:08,539 --> 00:26:13,400
me están solicitando de crear un fichero. Por lo tanto, pilla un trozo de memoria,

411
00:26:13,400 --> 00:26:19,400
márcalo como fichero y guárdalo para mí. Vale, entonces a ese punto sí que aparecerá el sistema.

412
00:26:19,400 --> 00:26:28,029
¿Vale? Me está claro que en el momento en que yo le digo file, vuestra mente ha pensado,

413
00:26:28,029 --> 00:26:40,230
exacto ha pensado que gana tengo de irme al api y leer todos los métodos de file para ver qué

414
00:26:40,230 --> 00:26:49,839
puede hacer qué puedo hacer con un file muy bien así piensa un programador además del file que es

415
00:26:49,839 --> 00:26:59,839
la base digamos para decir vale con esto manipuló manejo los ficheros tengo una serie de señores que

416
00:26:59,839 --> 00:27:09,859
me permiten crear stream, crear flujos de información que van desde mi programa al

417
00:27:09,859 --> 00:27:18,799
fichero o desde el fichero a mi programa dependiendo de si son input o output. Aquí

418
00:27:18,799 --> 00:27:27,079
tenéis varios ejemplos que van desde más bajo nivel a más alto nivel.

419
00:27:27,079 --> 00:27:31,339
siempre la misma idea. Hay metoditos,

420
00:27:31,519 --> 00:27:35,140
hay funciones, hay clases que me permiten hacer

421
00:27:35,140 --> 00:27:39,220
las cosas a muy bajo nivel, más cerca posible

422
00:27:39,220 --> 00:27:43,019
a los bits, a los unos y los ceros. Y una vez que yo tengo

423
00:27:43,019 --> 00:27:46,880
algo que puede hacer algo así a bajo nivel, pues le construyo encima

424
00:27:46,880 --> 00:27:50,099
métodos para que sea más sencillo manejar esa cosa.

425
00:27:50,539 --> 00:27:54,599
Porque si yo tengo que escribir un texto, hola, ¿qué tal?

426
00:27:54,599 --> 00:27:57,420
y para escribirlo tengo que ponerlo en binario,

427
00:27:57,920 --> 00:27:59,740
a mí, ser humano, me molesta.

428
00:28:00,180 --> 00:28:05,740
No me gusta para decir, hola, ¿qué tal poner 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0?

429
00:28:06,180 --> 00:28:09,339
Feo, porque no me acuerdo la H en binario.

430
00:28:09,900 --> 00:28:12,200
Sin embargo, a la máquina le flipa el binario.

431
00:28:12,400 --> 00:28:13,920
Él quiere todo en binario.

432
00:28:14,000 --> 00:28:18,380
Entonces, tengo que crear algo en el medio, ¿vale?

433
00:28:18,759 --> 00:28:22,940
Que puede ser más hacia la máquina o más hacia mí, ¿vale?

434
00:28:22,940 --> 00:28:24,059
Y es un poco esto.

435
00:28:24,599 --> 00:28:31,140
El input stream es un poco más cerca de la máquina, muy lejos de la máquina, porque

436
00:28:31,140 --> 00:28:35,880
la máquina está en binario, encima del binario está el asemblador, por encima del asemblador

437
00:28:35,880 --> 00:28:40,900
está no sé qué, por encima del no sé qué estará esto, y luego llega un momento en

438
00:28:40,900 --> 00:28:45,799
que tengo el Java y por encima del Java tengo el input stream.

439
00:28:45,799 --> 00:28:51,539
Hay niveles, pero dentro de estos tres métodos es el más cerca a la cosa.

440
00:28:51,539 --> 00:28:56,839
¿Qué quiere decir? Que sustancialmente me permite, estos son input, ¿vale?

441
00:28:56,960 --> 00:29:00,440
Pero input es recibir datos, leer datos, ¿vale?

442
00:29:00,759 --> 00:29:05,960
Pero si yo uso un input stream, leeré, tengo un flujo de información en input,

443
00:29:07,019 --> 00:29:13,119
siempre el concepto de input-output se considera desde la óptica del programa.

444
00:29:13,279 --> 00:29:17,579
Yo soy un programa, input es lo que desde fuera llega dentro del programa,

445
00:29:17,579 --> 00:29:21,799
Output es el que genera el programa y suelta afuera.

446
00:29:21,799 --> 00:29:27,500
Por eso System.out es un output a la pantalla, por ejemplo.

447
00:29:28,220 --> 00:29:35,200
Cuando nosotros teníamos el escáner, el parámetro que poníamos era System.in,

448
00:29:35,299 --> 00:29:38,859
porque es un input desde el teclado a mi programa.

449
00:29:40,059 --> 00:29:44,400
Entonces, este de aquí es un input stream, es un flujo stream de información

450
00:29:44,400 --> 00:29:49,480
que va desde fuera, desde no sé qué, hacia mi programa.

451
00:29:50,180 --> 00:29:54,599
Si yo este de aquí lo asocio con un fichero, tendré un fichero en el disco duro

452
00:29:54,599 --> 00:29:58,859
y cuando aquí le digo lee, pues estará leyendo datos desde el fichero.

453
00:29:59,599 --> 00:30:03,420
Si yo en vez de un fichero aquí conecto otro proceso de mi programa,

454
00:30:03,819 --> 00:30:07,900
cuando le diré lee, pues recibiré datos desde este otro proceso.

455
00:30:08,319 --> 00:30:12,859
Si yo aquí en vez de ponerle un proceso de otro programa le pongo un socket,

456
00:30:12,859 --> 00:30:16,220
Pues tendré una lectura desde Internet.

457
00:30:16,480 --> 00:30:19,819
Y cuando otro ordenador se conecte a ese socket y me mande datos,

458
00:30:20,160 --> 00:30:23,200
yo leeré desde este socket con InputStream.

459
00:30:24,440 --> 00:30:29,579
Cuando vosotros otra vez estaréis en segundo de DAM,

460
00:30:30,220 --> 00:30:33,480
en programación de procesos y servicios,

461
00:30:33,960 --> 00:30:36,619
veréis, reutilizaréis estas cosas de aquí,

462
00:30:36,980 --> 00:30:40,059
diciendo, es que en primero no lo hemos dado, ¿vale?

463
00:30:40,059 --> 00:30:42,059
Pero sí, lo habéis dado ahora.

464
00:30:42,059 --> 00:30:48,740
grabado. Y usaréis los mismos métodos, pero en vez de conectarnos a ficheros os

465
00:30:48,740 --> 00:30:59,500
conectaréis a otros procesos o a software, a otros, digamos, programas en red.

466
00:30:59,500 --> 00:31:04,720
Encapsula un flujo de bits para leer que pueden provenir del teclado de un

467
00:31:04,720 --> 00:31:10,000
fichero de una conexión de red. Proporciona métodos para leerlos byte a byte. Es muy

468
00:31:10,000 --> 00:31:15,279
bajo nivel. Aquí estamos trabajando con bytes. Tú puedes decir, léeme un byte. ¿Y qué es este byte?

469
00:31:15,279 --> 00:31:20,500
No tengo ni idea. Podría ser un carácter, entonces luego lo puedo leer como una letra,

470
00:31:20,500 --> 00:31:29,319
puede ser un trocito de un fichero de audio, podría ser un trocito de un objeto que luego

471
00:31:29,319 --> 00:31:34,599
tendré que reconstruir, no lo sé. Pero voy leyendo byte a byte. Estamos muy a bajo nivel porque lo

472
00:31:34,599 --> 00:31:40,779
que voy a hacer es trabajar con binario. Voy leyendo los bytes, cuando tengo cuatro bytes

473
00:31:40,779 --> 00:31:52,960
los puedo juntar y hacer un entero, por ejemplo. ¿Os acordáis que un entero ocupa cuatro bytes?

474
00:31:52,960 --> 00:31:59,059
Si hubiese leído cuatro bytes, podría hacer un entero. O leo ocho bytes y con estos ocho bytes puedo sacar un...

475
00:31:59,059 --> 00:32:10,400
por ejemplo no lo sé pero aquí yo estoy trabajando le puedo decir oye leme un string

476
00:32:11,400 --> 00:32:23,039
y esperar o saber cuántos bytes tengo que leer para leer el string entero cuando lo

477
00:32:23,039 --> 00:32:30,019
he leído decir y este es un string y porque en mi formato por ejemplo he almacenado string de

478
00:32:30,019 --> 00:32:38,079
10 bytes siempre. Si tengo un texto más largo, lo debo a 10 bytes, 10 bytes, 10 bytes. Entonces luego leo de 10 bytes en 10 bytes, por ejemplo.

479
00:32:38,940 --> 00:32:50,799
Depende de mi formulario. Sí, ahora yo sé, pero, que voy a trabajar con letras, con carácteres, porque he almacenado ficheros de texto,

480
00:32:51,539 --> 00:33:00,460
ficheros binarios, ahora pasamos a ficheros de texto. En vez de utilizar un input stream más secas, puedo usar un input stream reader.

481
00:33:00,460 --> 00:33:02,759
esta parte de Reader

482
00:33:02,759 --> 00:33:04,599
me está diciendo, oye mira

483
00:33:04,599 --> 00:33:06,660
no eres un input stream de más bajo

484
00:33:06,660 --> 00:33:08,819
nivel posible, eres un poquito

485
00:33:08,819 --> 00:33:10,660
más abstracto, asumes

486
00:33:10,660 --> 00:33:12,740
que aquí dentro tú no has puesto

487
00:33:12,740 --> 00:33:14,619
byte por byte, mas has puesto

488
00:33:14,619 --> 00:33:16,720
caracteres, que serán siempre byte

489
00:33:16,720 --> 00:33:18,859
por byte, por debajo este va

490
00:33:18,859 --> 00:33:20,519
a leer byte por byte, pero

491
00:33:20,519 --> 00:33:22,740
tendrá algunos métodos

492
00:33:22,740 --> 00:33:25,099
más que un input stream básico

493
00:33:25,099 --> 00:33:26,779
que me permitan, en vez de

494
00:33:26,779 --> 00:33:28,980
decir lee y me da un byte

495
00:33:28,980 --> 00:33:31,359
decir lee y me da un char

496
00:33:31,359 --> 00:33:34,200
directamente

497
00:33:34,200 --> 00:33:35,339
yo interpretaré

498
00:33:35,339 --> 00:33:38,339
leeré cuantos bytes tengo que leer

499
00:33:38,339 --> 00:33:39,759
para que sea un char

500
00:33:39,759 --> 00:33:41,960
y te devuelvo el char directamente

501
00:33:41,960 --> 00:33:43,980
¿se entiende?

502
00:33:45,720 --> 00:33:46,079
vale

503
00:33:46,079 --> 00:33:49,359
si yo trabajo

504
00:33:49,359 --> 00:33:50,960
con file

505
00:33:50,960 --> 00:33:54,299
en vez de utilizar input stream

506
00:33:54,299 --> 00:33:55,940
o input stream reader

507
00:33:55,940 --> 00:33:58,259
tengo file input stream

508
00:33:58,259 --> 00:34:04,519
y FileReader, que son mecanismos de lectura más específicos

509
00:34:04,519 --> 00:34:07,880
para trabajar no con cualquier posible input,

510
00:34:08,159 --> 00:34:09,760
sino en particular con ficheros.

511
00:34:10,300 --> 00:34:14,860
Son los que usaremos nosotros principalmente junto al último.

512
00:34:16,079 --> 00:34:18,880
Entonces, cuando el flujo de caracteres proviene de un fichero,

513
00:34:19,039 --> 00:34:22,559
podemos utilizar estas clases especializadas en ficheros

514
00:34:22,559 --> 00:34:25,579
en lugar de InputStream y InputStreamReader.

515
00:34:25,579 --> 00:34:27,739
normalmente, pero estos dentro tienen

516
00:34:27,739 --> 00:34:29,619
un input stream o un input stream reader.

517
00:34:29,860 --> 00:34:30,400
Lo veremos.

518
00:34:32,780 --> 00:34:33,340
Finalmente,

519
00:34:33,559 --> 00:34:35,860
está el buffer reader. ¿Qué es un buffer?

520
00:34:39,869 --> 00:34:40,469
No es caso.

521
00:34:43,989 --> 00:34:48,019
Es un buffer. Personaje

522
00:34:48,019 --> 00:34:50,159
que lanza hechizos

523
00:34:50,159 --> 00:34:52,079
que potencian...

524
00:34:52,079 --> 00:34:53,699
Sí, eso también es un buffer, pero

525
00:34:53,699 --> 00:34:55,019
no este buffer de aquí.

526
00:35:02,260 --> 00:35:03,940
Es el numerito que aparece

527
00:35:03,940 --> 00:35:05,900
cuando vosotros le dais al Netflix.

528
00:35:06,760 --> 00:35:07,860
Miráis vuestra serie

529
00:35:07,860 --> 00:35:09,780
y aparece un numerito que hace 0,

530
00:35:09,780 --> 00:35:12,019
un 99%? Pues ese es el

531
00:35:12,019 --> 00:35:14,019
base. ¿Qué es? Es una

532
00:35:14,019 --> 00:35:16,079
memoria temporal que se va

533
00:35:16,079 --> 00:35:17,760
llenando, ¿vale?

534
00:35:17,800 --> 00:35:20,280
Para que tú, cuando vas a procesar

535
00:35:20,280 --> 00:35:21,719
las cosas, en vez de procesar

536
00:35:21,719 --> 00:35:23,539
directamente la fuente,

537
00:35:24,280 --> 00:35:26,000
vas haciendo como

538
00:35:26,000 --> 00:35:27,500
un cojín entre

539
00:35:27,500 --> 00:35:29,920
la lectura desde la fuente y

540
00:35:29,920 --> 00:35:31,960
lo que se está reproduciendo de verdad. ¿Por qué?

541
00:35:32,340 --> 00:35:33,579
Porque si tu

542
00:35:33,579 --> 00:35:35,579
velocidad de red tiene algunas

543
00:35:35,579 --> 00:35:38,000
fluctuaciones, a veces va un poquito más rápida,

544
00:35:38,000 --> 00:35:40,119
a veces un poquito más lenta, no tienes

545
00:35:40,119 --> 00:35:42,340
un parón en tu vídeo

546
00:35:42,340 --> 00:35:44,139
o en tu audio, en tú lo que

547
00:35:44,139 --> 00:35:46,099
estás haciendo, cada vez que tu red va

548
00:35:46,099 --> 00:35:48,199
un poquito más lenta, mantiene un margen

549
00:35:48,199 --> 00:35:50,019
de unos megas

550
00:35:50,019 --> 00:35:52,079
de información, que si la

551
00:35:52,079 --> 00:35:54,400
red, por ejemplo, se bloquea un segundo

552
00:35:54,400 --> 00:35:56,079
pues tú vas tirando de este

553
00:35:56,079 --> 00:35:57,940
buffer y cuando vuelve la red

554
00:35:57,940 --> 00:35:59,079
pues lo rellena otra vez

555
00:35:59,079 --> 00:36:00,960
¿sí?

556
00:36:03,380 --> 00:36:03,940
pues

557
00:36:03,940 --> 00:36:04,860
misma cosa

558
00:36:04,860 --> 00:36:14,840
solo que aquí ahora nuestra fuente de información es el fichero o es internet o es lo que sea

559
00:36:14,840 --> 00:36:19,239
y yo cuando leo del fichero, si todo está bien, lo leo tranquilamente

560
00:36:19,239 --> 00:36:24,860
si hay muchos programas que están pidiendo de fichero, si el disco duro tiene que leer un poco de esto, un poco de esto, un poco de esto

561
00:36:24,860 --> 00:36:28,099
y cosas por el estilo, mientras que el procesador está haciendo otra cosa

562
00:36:28,099 --> 00:36:33,679
entonces un poco me puede hacer caso, pero a veces no me puede hacer caso, está haciendo otros procesos

563
00:36:33,679 --> 00:36:35,780
pues yo tenga

564
00:36:35,780 --> 00:36:37,559
la posibilidad de leer

565
00:36:37,559 --> 00:36:40,039
un trozo y sacar

566
00:36:40,039 --> 00:36:41,599
el trozo de golpe

567
00:36:41,599 --> 00:36:43,599
¿vale?

568
00:36:44,059 --> 00:36:45,119
sustancialmente es

569
00:36:45,119 --> 00:36:48,360
una abstracción más

570
00:36:48,360 --> 00:36:49,980
con respecto al reader

571
00:36:49,980 --> 00:36:52,239
que me permite en vez de leer

572
00:36:52,239 --> 00:36:53,420
carácter por carácter

573
00:36:53,420 --> 00:36:56,119
si el input stream lee byte por byte

574
00:36:56,119 --> 00:36:58,079
el reader permite leer

575
00:36:58,079 --> 00:36:59,079
carácter por carácter

576
00:36:59,079 --> 00:37:02,340
esto permite leer líneas enteras por ejemplo

577
00:37:02,340 --> 00:37:04,340
O sea, una línea entera.

578
00:37:04,340 --> 00:37:06,340
¿Sí?

579
00:37:06,340 --> 00:37:10,340
Este aquí añade uno de los métodos más cómodos para nosotros, que es el Readline.

580
00:37:10,340 --> 00:37:14,340
O sea, lee una línea entera de un fichero.

581
00:37:14,340 --> 00:37:16,340
¿Sí?

582
00:37:16,340 --> 00:37:20,340
Entonces lee todas las líneas hasta llegar a un retorno de tarra, un intro.

583
00:37:20,340 --> 00:37:23,340
¿Vale? Y todo esto me lo devuelve de golpe.

584
00:37:23,340 --> 00:37:24,340
¿Sí?

585
00:37:24,340 --> 00:37:28,340
Irá baserizando todos los caracteres.

586
00:37:28,340 --> 00:37:30,340
¿Qué lee? ¿Leo un carácter?

587
00:37:30,340 --> 00:37:34,500
Es un intro, no. Entonces leer otro. Vale. Es un intro, no. Es otro, es otro.

588
00:37:34,599 --> 00:37:38,539
Cuando encuentras un intro, dice todo lo que has leído aquí en un bonito string

589
00:37:38,539 --> 00:37:39,219
te lo das.

590
00:37:41,780 --> 00:37:46,619
Este de aquí lee bytes, este de aquí lee char, este de aquí

591
00:37:46,619 --> 00:37:47,860
lee string.

592
00:37:53,429 --> 00:37:56,909
¿Todas esas clases serán de file o de cada una de las dos?

593
00:37:56,969 --> 00:37:58,349
No, no. Ninguna es file.

594
00:37:58,349 --> 00:38:01,469
File será el parámetro

595
00:38:01,469 --> 00:38:03,130
que tú pones por algún lado aquí

596
00:38:03,130 --> 00:38:05,190
para decir, oye mira, tú eres un input stream

597
00:38:05,190 --> 00:38:07,369
sí, de qué fichero, de este file

598
00:38:07,369 --> 00:38:12,800
un puntito de la mano

599
00:38:12,800 --> 00:38:15,079
pero el file representa un fichero

600
00:38:15,079 --> 00:38:17,139
esto representa una información

601
00:38:17,139 --> 00:38:19,360
que viene de un fichero, para decirle

602
00:38:19,360 --> 00:38:21,699
para decirle

603
00:38:21,699 --> 00:38:23,619
qué fichero, tú te crearás un file

604
00:38:23,619 --> 00:38:25,079
este es el file, vale

605
00:38:25,079 --> 00:38:27,119
lo pasas como parámetro a este file reader

606
00:38:27,119 --> 00:38:29,340
y ahora tienes algo que lee de ese fichero

607
00:38:29,340 --> 00:38:34,820
estas son

608
00:38:34,820 --> 00:38:37,559
crean tubos de conexión

609
00:38:37,559 --> 00:38:39,340
entre el fichero y tu programa

610
00:38:39,340 --> 00:38:40,500
y cada vez que tu programa

611
00:38:40,500 --> 00:38:43,599
dirá, pilla algo de este tubo

612
00:38:43,599 --> 00:38:45,500
le llegará información desde el fichero

613
00:38:45,500 --> 00:38:47,239
hacia adentro

614
00:38:47,239 --> 00:38:49,519
lo que nosotros

615
00:38:49,519 --> 00:38:50,639
hacíamos con el teclado

616
00:38:50,639 --> 00:38:54,019
solo que en vez del teclado la información viene de un fichero

617
00:38:54,019 --> 00:38:57,400
pues

618
00:38:57,400 --> 00:38:59,239
preguntas

619
00:38:59,239 --> 00:39:06,050
igual que los dos anteriores, pero está mejorado

620
00:39:06,050 --> 00:39:07,570
el funcionamiento es para poder

621
00:39:07,570 --> 00:39:10,130
leer líneas enteras

622
00:39:10,130 --> 00:39:12,050
de caracteres como por ejemplo strings

623
00:39:12,050 --> 00:39:13,829
¿si?

624
00:39:14,409 --> 00:39:15,949
entonces, más o menos

625
00:39:15,949 --> 00:39:18,469
la idea es esta, yo tengo por un lado

626
00:39:18,469 --> 00:39:20,130
posibilidad de manejar

627
00:39:20,130 --> 00:39:21,809
los ficheros, por otro lado posibilidad

628
00:39:21,809 --> 00:39:24,230
de manejar canales de comunicaciones

629
00:39:24,230 --> 00:39:25,989
con este fichero, esto es input

630
00:39:25,989 --> 00:39:27,050
habrá también

631
00:39:27,050 --> 00:39:29,969
output, si input

632
00:39:29,969 --> 00:39:31,489
me permite leer desde

633
00:39:31,489 --> 00:39:39,530
teclado desde el fichero de cosas e incluirla en mi programa en mi programa lo puedo modificar y

634
00:39:39,530 --> 00:39:44,809
hacer lo que me haga cuando los quiero guardar pues lo que hago es escribirlas en un fichero

635
00:39:48,110 --> 00:39:54,809
normalmente el formato de escritura y de lectura tiene que ser el mismo si yo decido guardar mis

636
00:39:54,809 --> 00:40:01,690
mis objetos como cadenas de texto, pues tendré que escribir cadenas de textos y leer cadenas

637
00:40:01,690 --> 00:40:09,630
de textos. No puedo, o es desaconsejado, escribir una cosa y leer otra. Se puede hacer en determinados

638
00:40:09,630 --> 00:40:23,639
Por ejemplo, quiero leer un fichero .txt de la lista de la compra. ¿Qué uso?

639
00:40:23,639 --> 00:40:40,179
De los en negrita. ¿Qué uso?

640
00:40:44,039 --> 00:40:53,519
No, uso password reader. ¿Por qué? Porque en la lista, cada línea será una cosa que quiero comprar,

641
00:40:53,519 --> 00:40:58,639
y le digo, dime la primera, dime la segunda, dime la tercera. ¿Por qué uso reader?

642
00:41:03,699 --> 00:41:12,760
¿Por qué de todas estas uso un blablabla reader? No, no te oí.

643
00:41:12,760 --> 00:41:35,150
¿Y por qué uso un reader? ¿Por qué puedo usar un reader? Claro, porque hemos dicho que yo estoy

644
00:41:35,150 --> 00:41:44,869
leyendo un fichero .txt. Estoy leyendo un fichero de texto. ¿Sí? ¿Lo habéis notado?

645
00:41:44,869 --> 00:41:46,329
Está en un fichero de texto.

646
00:41:46,909 --> 00:41:48,389
Lo ha dicho el profe, pero ¿para qué?

647
00:41:51,730 --> 00:41:53,070
Las limitas soy también.

648
00:41:53,429 --> 00:41:57,289
Vale, entonces uso un líder porque como es un fichero de texto,

649
00:41:57,809 --> 00:42:00,389
voy a utilizar algo que me permite leer carácteres.

650
00:42:00,809 --> 00:42:02,789
Y como es una lista de la compra,

651
00:42:03,210 --> 00:42:05,429
¿y alguna vez en mi vida he hecho la compra?

652
00:42:07,679 --> 00:42:09,360
¿Y me he escrito una lista?

653
00:42:10,139 --> 00:42:12,340
¿Y escribo cada cosa en una línea?

654
00:42:12,340 --> 00:42:19,400
Pues qué buen binario.

655
00:42:19,400 --> 00:42:28,800
Entonces, me puedo imaginar que una lista al ordenador esté hecha de cada producto

656
00:42:28,800 --> 00:42:30,280
en una línea.

657
00:42:30,280 --> 00:42:35,980
Si no, tenéis un problema, ahí lo habláis con vuestro psicólogo.

658
00:42:35,980 --> 00:42:40,019
Por esto, el bachelor en 3D podría ser útil para decir, leo una ley hasta si la escrita

659
00:42:40,019 --> 00:42:42,099
todas separadas por coma, ¿vale?

660
00:42:42,119 --> 00:42:43,539
Que soy raro, pero no tanto.

661
00:42:43,900 --> 00:42:45,860
Pues me leo toda una línea

662
00:42:45,860 --> 00:42:48,139
y luego lo pasa a un split con

663
00:42:48,139 --> 00:42:50,179
regex coma y me la

664
00:42:50,179 --> 00:42:52,000
divide. ¿Sí? ¿Están de acuerdo?

665
00:42:52,159 --> 00:42:53,559
Pero me puede valer,

666
00:42:53,940 --> 00:42:55,940
en un fichero de este tipo, me puede valer

667
00:42:55,940 --> 00:42:57,599
poder leer una string.

668
00:42:58,119 --> 00:42:59,699
¿Vale? Lo leeré varias veces

669
00:42:59,699 --> 00:43:02,039
hasta que haya líneas y cada

670
00:43:02,039 --> 00:43:04,019
línea diré, oh, compra esto también, compra esto

671
00:43:04,019 --> 00:43:06,000
también. ¿Sí? Ahora,

672
00:43:06,239 --> 00:43:08,340
quiero leer

673
00:43:08,340 --> 00:43:09,679
un fichero

674
00:43:09,679 --> 00:43:33,010
audio. ¿Qué uso? Input string. ¿Vale? No puedo leer un reader. ¿Sí? Porque en un fichero de audio

675
00:43:33,010 --> 00:43:41,409
habrá datos, habrá bits, pero estos bits no son caracteres. ¿Vale? Representarán un formato que

676
00:43:41,409 --> 00:43:48,190
sello de la frecuencia que tiene que hacer el no sé qué para poder codificar para decodificar y

677
00:43:48,190 --> 00:43:53,889
modular un determinado sonido vale por lo tanto eso no lo puedo representar como una letra vale

678
00:43:53,889 --> 00:44:01,809
entonces una de estas dos y como es un fichero pues posiblemente optaré por file in bootstream

679
00:44:01,809 --> 00:44:03,809
Que dentro probablemente tenga un inputStream.

680
00:44:03,809 --> 00:44:05,809
¿Sí? ¿Entienden?

681
00:44:05,809 --> 00:44:07,809
Entonces, ¿cuál se usa?

682
00:44:07,809 --> 00:44:09,809
Pues depende de lo que quiero usar.

683
00:44:09,809 --> 00:44:11,809
¿Sí? Dependiendo de lo que quiero

684
00:44:11,809 --> 00:44:13,809
hacer, pues puedo utilizarlo.

685
00:44:13,809 --> 00:44:15,809
Ahora, ¿puedo yo, si tengo

686
00:44:15,809 --> 00:44:17,809
mi fichero de lista de la compra

687
00:44:17,809 --> 00:44:19,809
.txt, utilizar un inputStream?

688
00:44:19,809 --> 00:44:21,809
Sí, ¿por qué no?

689
00:44:21,809 --> 00:44:23,809
¿Vale?

690
00:44:23,809 --> 00:44:25,809
Es decir, lo leeré byte por

691
00:44:25,809 --> 00:44:27,809
byte, será un infierno

692
00:44:27,809 --> 00:44:29,809
porque luego tengo que pillar estos bytes y

693
00:44:29,809 --> 00:44:37,190
yo en mi programa castigarlos a algo que sea leíble como un char y identificar qué char era.

694
00:44:37,190 --> 00:44:48,019
¿Puedo, si yo tengo el fichero de audio, leerlo línea por línea con un buffer reader? Claro,

695
00:44:48,019 --> 00:44:57,019
pero es todavía más infernal porque lo que leeré es una string que no tiene ningún sentido y luego

696
00:44:57,019 --> 00:45:01,760
tendré que pillar char por char, transformarlo a binario y ese binario

697
00:45:01,760 --> 00:45:06,440
interpretarlo como un sonido. La transformación está ahí. Es como cuando abrís en

698
00:45:06,440 --> 00:45:12,199
formato de texto un powerpoint y salen caracteres infernales. ¿Por qué? Porque no

699
00:45:12,199 --> 00:45:19,579
es código de texto, no es texto plano y entonces el bloque de notas intenta

700
00:45:19,579 --> 00:45:27,139
interpretar cada ocho bits como una letra y salen carácteres que

701
00:45:28,139 --> 00:45:39,059
depende de las preguntas muy bien le damos un archivo de texto vale se

702
00:45:39,059 --> 00:45:43,940
utiliza la clave la clase es file reader o va a ser el reader

703
00:45:43,940 --> 00:45:48,139
entonces me creo un file reader no es necesaria aquí lo que voy a crear

704
00:45:48,139 --> 00:45:54,980
directamente aquí, pero bueno, fileReader es igual a null, va a ser el reader es igual a null, ¿vale?

705
00:45:54,980 --> 00:46:02,000
Primero hago un new fileReader con una ruta de archivo, ¿vale? Esta de aquí será el fichero.

706
00:46:02,000 --> 00:46:10,940
Si yo le pongo directamente lista.txt, asumo que el fichero esté en la carpeta principal de mi

707
00:46:10,940 --> 00:46:18,260
proyecto si en vez le pongo una ruta distinta pues

708
00:46:18,260 --> 00:46:23,380
estará donde está la ruta aquí no necesariamente le pongo lista compra

709
00:46:23,380 --> 00:46:28,460
punto txt puedo ponerse dos puntos barra no sé cuánto barra no sé cuánta ancora

710
00:46:28,460 --> 00:46:36,800
barra si para navegar cuidado con poner rutas absolutas porque es la clave para

711
00:46:36,800 --> 00:46:44,119
nos funciona y nosotros ponéis un fichero en el escritorio hacéis vuestro programa en casa luego

712
00:46:44,119 --> 00:46:50,300
lo lleváis aquí diciendo profe mira que funciona y como en el escritorio en parte de la ruta está

713
00:46:50,300 --> 00:46:56,179
vuestro usuario que aquí no tenéis nuestro programa que no funciona pero esto lo sabéis de sobra de

714
00:46:56,179 --> 00:47:02,000
lenguaje marca cuántas veces el lenguaje marca nos ha funcionado el css porque habéis puesto una

715
00:47:02,000 --> 00:47:07,909
ruta absoluta en vez de una ruta relativa

716
00:47:08,010 --> 00:47:15,710
por lo tanto aquí no lo vais a ver este de aquí me crea un file reader una

717
00:47:15,710 --> 00:47:21,630
conexión que puede leer caracteres desde un fichero y este es el fichero

718
00:47:21,630 --> 00:47:28,070
creo que aquí le puedes poner un file en vez de ponerle un string de la ruta le

719
00:47:28,070 --> 00:47:35,349
pones un objeto file. Y luego, por encima de esto, como wrapper a esto, tú dices, me

720
00:47:35,349 --> 00:47:40,050
crea un buffer reader, que es un buffer reader, es un lector que puede hacer strings, ¿vale?

721
00:47:40,349 --> 00:47:44,289
Al que le pasas este de aquí. Sostantivamente está diciendo, yo tengo algo que puede leer

722
00:47:44,289 --> 00:47:49,329
carácter por carácter, ¿vale? Ahora creo algo que usa este leer carácter por carácter,

723
00:47:49,449 --> 00:47:56,349
pero en vez de darme carácter por carácter, me da el string entero. ¿Entiendes? Entonces,

724
00:47:56,349 --> 00:47:57,730
a partir de aquí

725
00:47:57,730 --> 00:48:00,610
br es lo que va a utilizar

726
00:48:00,610 --> 00:48:02,829
es un objeto

727
00:48:02,829 --> 00:48:04,530
mágico, que si yo le digo

728
00:48:04,530 --> 00:48:06,710
léeme una línea, me lee una línea del fichero

729
00:48:06,710 --> 00:48:08,630
sean cuantas sean las líneas del fichero

730
00:48:08,630 --> 00:48:10,250
me creo string línea

731
00:48:10,250 --> 00:48:11,909
y digo, mientras

732
00:48:11,909 --> 00:48:15,190
línea es igual a br.redline

733
00:48:15,190 --> 00:48:16,230
not null

734
00:48:16,230 --> 00:48:17,309
¿qué quiere decir esto?

735
00:48:26,190 --> 00:48:28,050
si, dice, ve a este br

736
00:48:28,050 --> 00:48:29,610
lee una línea

737
00:48:29,610 --> 00:48:31,250
hay dos opciones

738
00:48:31,250 --> 00:48:33,070
o hay una línea para leer

739
00:48:33,070 --> 00:48:34,110
y me la has leído

740
00:48:34,110 --> 00:48:37,309
o no has podido leer nada

741
00:48:37,309 --> 00:48:39,389
bien porque en el fichero no estaba

742
00:48:39,389 --> 00:48:41,670
bien porque has llegado al final del fichero

743
00:48:41,670 --> 00:48:43,469
y entonces me devolverá null

744
00:48:43,469 --> 00:48:45,570
si no es null

745
00:48:45,570 --> 00:48:47,010
mientras que no sea null

746
00:48:47,010 --> 00:48:49,150
quieres decir que algo lo has leído

747
00:48:49,150 --> 00:48:51,070
y te lo has guardado en línea

748
00:48:51,070 --> 00:48:52,969
entonces ahora

749
00:48:52,969 --> 00:48:54,349
lo imprime en pantalla

750
00:48:54,349 --> 00:48:56,869
o lo parcheo

751
00:48:56,869 --> 00:48:58,670
o lo transformo en un objeto

752
00:48:58,670 --> 00:49:03,809
O le cambio la letra B por la letra S.

753
00:49:03,989 --> 00:49:05,969
Lo que tengas dentro de tu programa, ¿vale?

754
00:49:06,030 --> 00:49:08,110
Va a procesar esta línea, ¿sí?

755
00:49:10,250 --> 00:49:14,909
Touch exception, por si cuando hago algo de esto explota,

756
00:49:15,090 --> 00:49:17,690
veréis que ahora os lo pide, os aportáis que las excepciones

757
00:49:17,690 --> 00:49:20,570
había dos tipos, algunas que podías no controlar

758
00:49:20,570 --> 00:49:28,809
y algunas que sí tenías que controlar como las...

759
00:49:28,809 --> 00:49:31,889
Exacto, muy bien, hoy estáis así, ¿eh?

760
00:49:31,889 --> 00:49:33,489
la IO exception, ¿vale?

761
00:49:33,570 --> 00:49:35,110
La excepción es de input-output.

762
00:49:35,489 --> 00:49:39,329
Input-output, pues, eran de las que tenías que controlar, ¿vale?

763
00:49:39,329 --> 00:49:41,829
Entonces, si tú intentas hacer uno de estos de aquí,

764
00:49:42,429 --> 00:49:46,329
Fire Reader o Buzzer Reader, sin poner un try-catch,

765
00:49:46,429 --> 00:49:47,429
te va a decir no.

766
00:49:48,650 --> 00:49:50,070
Tienes dos posibilidades.

767
00:49:50,349 --> 00:49:57,289
O try-catch o throws.

768
00:49:57,769 --> 00:49:58,969
Para poner aquí ese throw, perdón.

769
00:49:59,449 --> 00:50:03,489
Pones que aquí, aquí no está, pero en la declaración del método,

770
00:50:03,489 --> 00:50:05,570
pones que throw esta cosa, entonces

771
00:50:05,570 --> 00:50:07,530
estás diciendo, no, la voy a gestionar yo

772
00:50:07,530 --> 00:50:09,670
esta sección, la va a gestionar quien me

773
00:50:09,670 --> 00:50:09,909
llama.

774
00:50:12,150 --> 00:50:12,969
Muy bien.

775
00:50:13,769 --> 00:50:14,849
Y aquí, finally,

776
00:50:15,369 --> 00:50:17,670
try if the error is not null

777
00:50:17,670 --> 00:50:18,730
a error.cruise.

778
00:50:19,530 --> 00:50:21,570
Esto de aquí, cada vez que abrís un

779
00:50:22,230 --> 00:50:23,469
file reader o cosa por el estilo,

780
00:50:23,590 --> 00:50:25,449
en algún momento de vuestra vida, deberías

781
00:50:25,449 --> 00:50:27,530
cerrarlo. ¿Vale? Todos estos

782
00:50:27,530 --> 00:50:29,489
recursos, lo vimos en el

783
00:50:29,489 --> 00:50:30,949
scanner.

784
00:50:31,389 --> 00:50:33,050
Nosotros hemos creado scanners en nuestra vida

785
00:50:33,050 --> 00:50:34,909
y nunca los hemos cerrado

786
00:50:34,909 --> 00:50:36,929
y hemos ignorado un warning que decía

787
00:50:36,929 --> 00:50:38,710
deberías cerrarlo. Y nosotros, ¿qué más

788
00:50:38,710 --> 00:50:40,730
debemos dar? ¿Vale? Porque nuestros

789
00:50:40,730 --> 00:50:42,550
programas duran 20 segundos, luego

790
00:50:42,550 --> 00:50:44,309
se quitan y entonces

791
00:50:44,309 --> 00:50:46,130
tampoco es un problema. ¿Vale?

792
00:50:46,349 --> 00:50:48,670
Pero si tú te metes a abrir C-Share

793
00:50:48,670 --> 00:50:50,730
o si nunca lo cierras, si nunca lo cierras,

794
00:50:50,769 --> 00:50:52,530
si nunca lo cierras, tienes lo que se llama un

795
00:50:52,530 --> 00:50:54,449
memory leak. O sea que

796
00:50:54,449 --> 00:50:56,170
tu programa

797
00:50:56,170 --> 00:50:58,550
crea recursos y no los cierra.

798
00:50:58,690 --> 00:51:00,590
Crea recursos y no los cierra. Crea recursos

799
00:51:00,590 --> 00:51:01,730
y no los cierra. Y esto,

800
00:51:01,730 --> 00:51:03,829
estos recursos van creciendo

801
00:51:03,829 --> 00:51:05,329
y creciendo y creciendo

802
00:51:05,329 --> 00:51:07,630
y en un mes nada, en tres meses nada

803
00:51:07,630 --> 00:51:09,889
en seis años tienes un programa

804
00:51:09,889 --> 00:51:10,889
que raramente

805
00:51:10,889 --> 00:51:13,610
ocupa el triplo de lo que debería ocupar

806
00:51:13,610 --> 00:51:14,710
dices, ¿por qué será?

807
00:51:15,590 --> 00:51:17,590
o un programa que cada seis meses colapsa

808
00:51:17,590 --> 00:51:19,429
porque le acaba la memoria, lo reinicias

809
00:51:19,429 --> 00:51:20,829
y va todo bien por los dos años

810
00:51:20,829 --> 00:51:24,960
¿eh? por eso

811
00:51:24,960 --> 00:51:26,420
un 95% de los

812
00:51:26,420 --> 00:51:29,199
problemas de informática se solucionan

813
00:51:29,880 --> 00:51:33,179
¡muy bien!

814
00:51:33,179 --> 00:51:35,179
¿Dudas?

815
00:51:35,179 --> 00:51:37,179
¿Se entiende esto?

816
00:51:37,179 --> 00:51:39,179
¿Mecanismo?

817
00:51:39,179 --> 00:51:41,179
¿Sí?

818
00:51:46,619 --> 00:51:48,619
Escritura de un archivo de texto.

819
00:51:48,619 --> 00:51:50,619
¿Vale? Vamos a escribir.

820
00:51:50,619 --> 00:51:52,619
Para escribir, claramente,

821
00:51:52,619 --> 00:51:54,619
no puedo usar ni el Reader,

822
00:51:54,619 --> 00:51:56,619
ni el Input,

823
00:51:56,619 --> 00:51:58,619
ni el Buffer Reader.

824
00:51:58,619 --> 00:52:00,619
Voy a utilizar, en vez de Reader,

825
00:52:00,619 --> 00:52:02,619
Writer.

826
00:52:02,619 --> 00:52:04,500
En vez de Input,

827
00:52:04,619 --> 00:52:12,340
Aquí, por ejemplo, tenemos un FileWriter y un PrintWriter, ¿vale?

828
00:52:12,739 --> 00:52:16,719
Entonces, parecido a antes, me creo un FileWriter,

829
00:52:17,199 --> 00:52:22,139
que sustancialmente es un punto de acceso en salida a un fichero de mi sistema operativo,

830
00:52:22,139 --> 00:52:24,340
y lo involucro en un PrintWriter.

831
00:52:24,440 --> 00:52:26,599
¿Habéis visto alguna vez un PrintWriter en vuestra vida?

832
00:52:29,780 --> 00:52:33,139
Sí, desde el primer día de este curso.

833
00:52:33,139 --> 00:52:36,619
desde que pusiste System.out

834
00:52:36,619 --> 00:52:38,519
System.out

835
00:52:38,519 --> 00:52:40,260
es un objeto de clase

836
00:52:40,260 --> 00:52:41,039
PrintWrite

837
00:52:41,039 --> 00:52:44,300
y que tiene dentro el objeto

838
00:52:44,300 --> 00:52:45,139
el método

839
00:52:45,139 --> 00:52:47,739
Println

840
00:52:47,739 --> 00:52:49,420
que normalmente

841
00:52:49,420 --> 00:52:52,519
en el System.out está conectado

842
00:52:52,519 --> 00:52:52,960
con

843
00:52:52,960 --> 00:52:57,360
la consola

844
00:52:57,360 --> 00:52:59,980
y por lo tanto cuando vosotros hacéis un System.out

845
00:52:59,980 --> 00:53:01,960
Println lo veis en consola

846
00:53:01,960 --> 00:53:04,000
lo que habéis escrito, sin embargo

847
00:53:04,000 --> 00:53:13,699
Pero aquí este printwriter estará conectado con este fichero, entonces que cuando yo escribo

848
00:53:13,699 --> 00:53:19,659
println, ¿dónde escribirá?

849
00:53:19,659 --> 00:53:20,659
Muy bien.

850
00:53:20,659 --> 00:53:27,920
Entonces, por int igual a cero diez veces, tv, que es printwriter, es este objeto de

851
00:53:27,920 --> 00:53:34,760
aquí, está por un lado, este, punto println, ¿vale?, línea, más i, entonces ¿qué hará

852
00:53:34,760 --> 00:53:35,760
este señor?

853
00:53:35,760 --> 00:53:42,400
¿Escriben un fichero o qué?

854
00:53:44,139 --> 00:53:45,000
¿En qué sentido?

855
00:53:45,300 --> 00:53:46,460
No escriben nueve líneas.

856
00:53:50,139 --> 00:53:51,019
¿Qué escriben?

857
00:53:53,500 --> 00:53:57,920
Literalmente esto escribe línea 1, línea 2, línea 3, línea 4, línea 5...

858
00:53:57,920 --> 00:54:02,280
Bueno, concretamente, línea 0, línea 1, línea 2, línea 3, hasta línea 9.

859
00:54:02,280 --> 00:54:04,440
10 líneas

860
00:54:04,440 --> 00:54:06,039
y por cada línea

861
00:54:06,039 --> 00:54:07,639
escribe línea más i

862
00:54:07,639 --> 00:54:09,780
que va de 0 a 9

863
00:54:09,780 --> 00:54:12,320
¿sí? ¿lo veis?

864
00:54:13,260 --> 00:54:14,239
esto crea un fichero

865
00:54:14,239 --> 00:54:15,619
que si yo abro con el

866
00:54:15,619 --> 00:54:18,300
no hace par más más, me encuentro dentro literalmente

867
00:54:18,300 --> 00:54:20,599
línea 0 y debajo línea 1

868
00:54:20,599 --> 00:54:22,440
línea 2 hasta línea 9

869
00:54:22,440 --> 00:54:23,340
¿sí?

870
00:54:25,340 --> 00:54:26,639
bla bla bla se explota

871
00:54:26,639 --> 00:54:27,440
bla bla bla

872
00:54:27,440 --> 00:54:28,699
¿sí?

873
00:54:29,380 --> 00:54:32,099
una pregunta, va a mostrar 10 líneas

874
00:54:32,099 --> 00:54:40,079
¿Puedo mostrar siempre la misma o mostrar una y luego hacer un salto de líneas a la siguiente?

875
00:54:40,079 --> 00:54:41,079
Contéstate.

876
00:54:41,079 --> 00:54:45,579
Lm, next line, ok.

877
00:54:45,579 --> 00:54:51,519
Exactamente como si tú, piensa esto, si en vez de fuera de la prueba fuera de la system.out,

878
00:54:51,519 --> 00:54:52,519
¿qué te daría?

879
00:54:52,519 --> 00:54:57,760
Pues eso, en vez que en consola, es escrito en un fichero, ¿sí?

880
00:54:57,760 --> 00:55:02,199
Falso, esto no va a funcionar en la vida, ¿vale?

881
00:55:02,199 --> 00:55:28,199
Esta es la idea de las cosillas porque Java intenta optimizar las cosas y si vosotros tenéis una empresa de camión y de transporte y una persona, tipo Amazon, imaginaos, y una persona ordena un cepillo de dientes,

882
00:55:28,199 --> 00:55:38,519
¿Vosotros qué hacéis? ¿Lo metéis en el camión y decís, sal, llévalo esto? ¿O esperáis que se llene el camión y cuando está lleno mandáis todo?

883
00:55:39,900 --> 00:55:47,539
Misma cosa, ¿vale? Cuando tú le dices, escribe, escribe, escribe, escribe, él ni te mira, ¿vale? Lo haré, ¿vale?

884
00:55:47,920 --> 00:55:54,340
Es la diferencia entre, por un lado está el mundo de Java y la RAM, y por otro lado está el disco duro.

885
00:55:54,340 --> 00:56:00,039
Disco duro es lento. No quiero trabajar con disco duro. Quiero trabajar con disco duro lo menos

886
00:56:00,039 --> 00:56:08,559
posible. Si me pongo por cada cosa a hacerlo, mi programa va muy lento. Mucho más lento, porque con

887
00:56:08,559 --> 00:56:17,559
respecto a la RAM es horriblemente más lento el disco duro. Vosotros que sois jóvenes, ¿habéis arrancado

888
00:56:17,559 --> 00:56:29,460
alguna vez un ordenador que no tiene ssd ssd si habéis notado diferencia

889
00:56:29,460 --> 00:56:35,079
y hoy en día parece que está roto y ahora lo que hacemos nosotros por esos

890
00:56:35,079 --> 00:56:40,760
viejos toda la vida el ssd mucho más lento de la rama

891
00:56:40,760 --> 00:56:46,480
todos imaginamos todas estas cosas la rama dice ok el programa dice ok lo voy

892
00:56:46,480 --> 00:56:53,239
a hacer me lo guardo aquí y ya cuando tengo suficientes datos para hacerlo de golpe lo voy

893
00:56:53,239 --> 00:57:01,179
a hacer más de aquí por el problema es que en la vista real tú metes muchos datos llegará un

894
00:57:01,179 --> 00:57:05,800
momento que tiene todo suficiente lo guardo lo que sea nosotros no no haremos nunca datos

895
00:57:05,800 --> 00:57:11,199
suficientes entonces por aquí en algún lado habrá un momento en que tú tendrás que decirle vale lo

896
00:57:11,199 --> 00:57:18,880
que tienes guardado ejecútate esfuerzo a ejecutar lo que tú tenías pendiente que tenía marcado en

897
00:57:18,880 --> 00:57:26,619
la dama esto lo voy a escribir vale pues escríbelo de verdad porque yo tendré por un lado el fichero

898
00:57:26,619 --> 00:57:33,840
real y por otro lado una copia de este fichero en la ram y mi programa usa esta copia aquí trabaja

899
00:57:33,840 --> 00:57:38,920
sobre esto lee está inscribe está pero tengo que tener un determinado momento en que digo no

900
00:57:38,920 --> 00:57:46,059
asegúrate que esta copia aquí, ahora la copias aquí. ¿Es lento? Sí, lo sé, pero hazlo, porque si no, lo pierdo.

901
00:57:46,059 --> 00:57:58,059
Nuevamente se hace con un tv.flush, que es como decir, manda. En teoría también cuando hace una close,

902
00:57:58,059 --> 00:58:07,320
como última operación, debería hacer una flash. Pero esto es un territorio raro de Java, en el que

903
00:58:07,320 --> 00:58:09,460
a veces lo hace, a veces no, y a veces

904
00:58:09,460 --> 00:58:11,519
vosotros lo hacéis todo bien y no escribe

905
00:58:11,519 --> 00:58:13,340
nada, y luego le ponéis un flash

906
00:58:13,340 --> 00:58:14,699
por algún lado y de repente escribe.

907
00:58:23,599 --> 00:58:25,219
Vamos a probarlo, ¿vale?

908
00:58:25,320 --> 00:58:27,559
Antes de seguir. En los próximos días

909
00:58:27,559 --> 00:58:28,980
lo que vamos a hacer es

910
00:58:28,980 --> 00:58:31,699
ver otras cosas. Esto, por ejemplo, es un programa

911
00:58:31,699 --> 00:58:33,539
que copia un fichero.

912
00:58:34,199 --> 00:58:35,599
¿Vale? Esta es la copia de un fichero.

913
00:58:35,699 --> 00:58:37,300
Me das un fichero, me das

914
00:58:37,300 --> 00:58:39,539
dónde lo quieres copiar, y yo te copio

915
00:58:39,539 --> 00:58:41,559
esto en otro lado. Y para copiar

916
00:58:41,559 --> 00:58:43,159
un fichero, se usa

917
00:58:43,159 --> 00:58:45,360
input stream y output stream

918
00:58:45,360 --> 00:58:47,559
o sea, se hace byte por byte

919
00:58:47,559 --> 00:58:49,340
porque tú no sabes qué fichero

920
00:58:49,340 --> 00:58:51,280
estás copiando, no copias un fichero de texto

921
00:58:51,280 --> 00:58:53,139
puedes copiar un fichero ejecutable

922
00:58:53,139 --> 00:58:54,719
puedes copiar un fichero de audio

923
00:58:54,719 --> 00:58:56,880
entonces aquí se usa

924
00:58:56,880 --> 00:58:58,079
input stream

925
00:58:58,079 --> 00:59:00,639
luego entraceremos

926
00:59:00,639 --> 00:59:02,780
a trabajar con objetos, ¿vale?

927
00:59:02,820 --> 00:59:05,039
por ahora estamos solo en lectura y escritura de datos

928
00:59:05,039 --> 00:59:07,059
luego decimos, sí, va a ver, pero si

929
00:59:07,059 --> 00:59:09,139
lo que quiero escribir en vez de un texto es un

930
00:59:09,139 --> 00:59:10,059
objeto, ¿qué hago?

931
00:59:11,460 --> 00:59:13,039
lo veremos aquí