1
00:00:00,360 --> 00:00:04,500
Bien vamos a continuar una vez que ya hemos escrito información al archivo.

2
00:00:04,500 --> 00:00:09,750
Ahora vamos a leer la información que hemos mandado a este archivo así que para ello vamos a agregar

3
00:00:09,780 --> 00:00:10,500
otro método

4
00:00:13,420 --> 00:00:24,840
creamos el método también va a ser Public Static de tipo Veidt y se va a llamar leer archivo también

5
00:00:24,840 --> 00:00:26,250
recibe un nombre de archivo

6
00:00:32,350 --> 00:00:34,360
vamos a crear nuestro objeto de tipo File

7
00:00:39,380 --> 00:00:41,030
y le pasamos el nombre del archivo

8
00:00:46,130 --> 00:00:54,480
aquí me faltó una R Street y ahora a diferencia de lo que hemos hecho hasta el momento vamos a utilizar

9
00:00:54,510 --> 00:01:00,810
ahora la clase buffer Ridder para leer información del archivo para poder leer líneas completas y no

10
00:01:00,810 --> 00:01:02,480
solamente carácter a carácter.

11
00:01:02,970 --> 00:01:06,960
Así que utilizamos nuestra clase buffer Reeder

12
00:01:12,260 --> 00:01:22,200
la variable se va a llamar entrada y creamos un nuevo objeto de tipo buffer Reeder y este constructor

13
00:01:22,200 --> 00:01:30,390
necesita de un tipo Field Ridder así que vamos a crear un nuevo objeto de tipo Feil Rider ya que no

14
00:01:30,390 --> 00:01:36,120
le podemos pasar directamente un objeto de tipo Feil y al constructor del objeto que estamos creando

15
00:01:36,120 --> 00:01:43,590
de tipo fue el rider le pasamos el tipo FEIL que hemos creado anteriormente sin embargo esto puede arrojar

16
00:01:43,590 --> 00:01:44,710
una excepción.

17
00:01:44,730 --> 00:01:52,790
Por lo tanto la envolvemos en un bloque cazzo quitamos esta línea quitamos los importes que nos ha agregado

18
00:01:54,190 --> 00:02:03,860
y mandamos a imprimir esta actuáis en dado caso de que exista y lo mandamos a la consola estándar así

19
00:02:03,880 --> 00:02:09,290
que con esta línea lo que hemos hecho es crear un nuevo objeto de tipo buffer Rudder para poder leer

20
00:02:09,290 --> 00:02:17,170
líneas completas y lo que vamos a hacer a continuación vamos a declarar una variable llamada lectura

21
00:02:21,530 --> 00:02:23,350
utilizando nuestra variable entrada.

22
00:02:23,480 --> 00:02:29,930
Vamos a utilizar el método RedLynx como hemos comentado esta clase nos permite leer líneas completas

23
00:02:31,670 --> 00:02:37,490
sin embargo también este método puede arrojar otra excepción de tipo I o exception así que vamos a agregar

24
00:02:37,490 --> 00:02:43,160
también este caché a nuestro bloque y caché que hayamos declarado así que damos clic y podemos ver que

25
00:02:43,160 --> 00:02:50,380
ya nos agrega la excepción de tipo fue una excepción y también la excepción de tipo exception quitamos

26
00:02:50,380 --> 00:02:58,750
esta línea y mandamos a imprimir esta actuáis en dado caso de cualquier error y lo mandamos a la consola

27
00:02:58,750 --> 00:03:07,230
estándar quitamos estos Import y con eso ya tenemos nuestro bloque y caché completo.

28
00:03:07,320 --> 00:03:12,810
Ahora con esto lo que estamos haciendo es únicamente leer una línea pero si queremos leer toda la información

29
00:03:12,810 --> 00:03:15,690
del archivo entonces vamos a utilizar un ciclo cual

30
00:03:21,450 --> 00:03:29,240
mientras la línea que hayamos leído del archivo sea distinto de nulo entonces vamos a continuar y lo

31
00:03:29,240 --> 00:03:37,620
que vamos a hacer es mandar imprimir en la consola el contenido del archivo y volvemos a leer información

32
00:03:37,620 --> 00:03:38,280
del archivo

33
00:03:42,250 --> 00:03:49,380
entrada punto a Ridley y eso es lo que estamos haciendo es leer toda la información del archivo mientras

34
00:03:49,380 --> 00:03:50,990
sea diferente de nulo.

35
00:03:51,060 --> 00:03:56,010
Vamos a seguir imprimiendo la información del archivo hacia consola y cuando ya no tenga más información

36
00:03:56,010 --> 00:04:00,870
que leer que ya sea la última línea de nuestro archivo entonces va a terminar este ciclo.

37
00:04:02,690 --> 00:04:08,440
Y para terminar cerramos el flujo entrada apuntó Clowes.

38
00:04:08,510 --> 00:04:12,140
Eso es todo nuestro método para leer información de un archivo.

39
00:04:12,140 --> 00:04:13,220
Vamos a ponerlo a prueba

40
00:04:20,480 --> 00:04:25,550
sin embargo debido a que ya creamos el archivo y ya escribimos información en el archivo vamos a poner

41
00:04:25,550 --> 00:04:31,010
entre comentarios estos métodos para que ya no vuelva a realizar estas operaciones de momento únicamente

42
00:04:31,010 --> 00:04:33,500
queremos leer información del archivo

43
00:04:36,810 --> 00:04:43,620
así que utilizamos el método leer información guardamos cambios y ejecutamos y podemos observar todo

44
00:04:43,620 --> 00:04:49,380
lo que contiene el archivo contenido a escribir en el archivo un salto de línea y posteriormente el

45
00:04:49,380 --> 00:04:57,270
mensaje de fin de escritura que es exactamente la misma información que contiene el archivo así que

46
00:04:57,270 --> 00:04:58,740
funcionó correctamente.

47
00:04:58,830 --> 00:05:04,800
Nuestro método leer información del archivo y por último lo que vamos a hacer es anexar información

48
00:05:04,830 --> 00:05:08,850
al archivo agregar información a un archivo ya existente.

49
00:05:08,910 --> 00:05:18,030
Para ello vamos a crear el método siguiente tenemos el método Public Static Veidt anexar archivo

50
00:05:21,640 --> 00:05:26,080
recibe un nombre de archivo creamos nuestro objeto File

51
00:05:32,190 --> 00:05:38,970
creamos nuestro objeto de tipo primero either para escribir información al archivo la variable se llama

52
00:05:38,970 --> 00:05:39,510
salida

53
00:05:42,360 --> 00:05:45,900
y le pasamos el archivo que hemos recibido.

54
00:05:45,900 --> 00:05:49,990
Esto puede arrojar una excepción la envolvemos en un bloque y.

55
00:05:50,220 --> 00:05:53,220
Quitamos esta línea quitamos estos importes

56
00:05:56,110 --> 00:05:57,910
imprimimos la pila decepciones

57
00:06:01,730 --> 00:06:07,580
y a diferencia de los métodos que utilizamos anteriormente por ejemplo para escribir información archivo

58
00:06:07,970 --> 00:06:13,710
en el cual utilizamos el constructor print Reiter y la pasamos directamente el objeto file.

59
00:06:13,790 --> 00:06:19,490
En este caso vamos a hacer un cambio en lugar de pasarle directamente el objeto File lo que vamos a

60
00:06:19,490 --> 00:06:22,850
hacer es crear un nuevo objeto de tipo FEUE Ritter

61
00:06:26,080 --> 00:06:32,350
le pasamos el nombre del archivo que es un objeto de tipo File y además vamos a indicar que vamos a

62
00:06:32,350 --> 00:06:35,530
agregar información a este archivo.

63
00:06:35,530 --> 00:06:43,170
Por ello vamos a utilizar este constructor en el cual tiene otro parámetro el parámetro de APEN que

64
00:06:43,170 --> 00:06:48,390
es un tipo booleano y si ponemos el valor de Tru entonces la información que agregamos este archivo

65
00:06:48,600 --> 00:06:55,800
se va a anexar al archivo ya existente así que ponemos Tru para que en lugar de que se escriba la información

66
00:06:55,800 --> 00:07:03,670
el archivo se anexa a la información ya existente del archivo sin embargo esto puede arrojar otra decepción.

67
00:07:03,700 --> 00:07:08,680
Así que agregamos este cacho a nuestro bloque y catch ya existente.

68
00:07:09,100 --> 00:07:18,440
Quitamos esta línea quitamos los Import y mandamos a imprimir la pila decepciones en dado caso de que

69
00:07:18,440 --> 00:07:27,090
exista y lo mandamos a la consola estándar así que con eso ya estamos procesando a un exception y también

70
00:07:27,100 --> 00:07:30,560
la acepción de tipo o Repsol.

71
00:07:30,710 --> 00:07:36,280
Y entonces con esto lo que estamos haciendo es abrir un flujo pero vamos a anexar información al archivo

72
00:07:36,820 --> 00:07:42,310
no se va sobreescribir la información sino que vamos a anexar información así que declaramos la variable

73
00:07:42,460 --> 00:07:51,670
de tipo string contenido y agregamos lo siguiente anexando información al archivo

74
00:07:54,200 --> 00:08:03,070
utilizando nuestra variable salidad usamos nuestro mismo método ln y escribimos el contenido.

75
00:08:03,140 --> 00:08:05,540
Posteriormente imprimimos un salto de línea

76
00:08:11,750 --> 00:08:21,270
y mandamos otro mensaje mandamos la cadena a fin de anexar y finalmente cerramos el flujo para que se

77
00:08:21,270 --> 00:08:23,880
escriba esta información al archivo.

78
00:08:23,880 --> 00:08:31,730
De lo contrario no se va a guardar los cambios en el archivo y mandamos el mensaje sea anexado

79
00:08:34,940 --> 00:08:43,790
la información al archivo bien con eso ya tenemos todos los cambios guardamos cambios y vamos a poner

80
00:08:43,790 --> 00:08:45,560
a prueba el método que hemos creado.

81
00:08:45,560 --> 00:08:47,440
Ponemos entre comentarios todo lo anterior

82
00:08:52,500 --> 00:09:01,430
y ahora vamos a anexar información al archivo así que mandamos a llamar el método anexar archivo le

83
00:09:01,430 --> 00:09:07,970
pasamos el mismo número de archivo y para poder saber la información que hemos agregado volvemos a llamar

84
00:09:08,330 --> 00:09:11,820
el método leer del archivo

85
00:09:20,350 --> 00:09:22,540
así que vamos a guardar cambios y ejecutamos

86
00:09:26,760 --> 00:09:31,900
y podemos observar el mensaje de que se ha anexado la información correctamente al Archivo y posteriormente

87
00:09:31,900 --> 00:09:37,810
leemos el contenido del archivo contenido a escribir en el archivo y fin de escritura que era lo que

88
00:09:37,810 --> 00:09:44,020
ya teníamos en el Archivo y posteriormente lo nuevo que se ha anexado anexando información archivo espacio

89
00:09:44,140 --> 00:09:45,160
a fin de anexar.

90
00:09:45,760 --> 00:09:48,900
Así que con esto ya se ha modificado correctamente nuestro archivo.

91
00:09:49,390 --> 00:09:56,170
Vamos a cerrar este archivo para poder ver los cambios cerramos el archivo y volvemos a abrirlo.

92
00:09:57,610 --> 00:10:03,330
Y podemos observar lo que ya teníamos anteriormente que ya habíamos escrito y ahora lo nuevo donde se

93
00:10:03,330 --> 00:10:06,110
ha anexado información al archivo ya existente

94
00:10:10,410 --> 00:10:15,450
así que con esto ya está funcionando correctamente todos los métodos que hemos programado para realizar

95
00:10:15,450 --> 00:10:21,150
varias operaciones sobre un archivo en Java bien así que con este ejercicio hemos puesto en práctica

96
00:10:21,210 --> 00:10:23,480
el concepto de manejo de archivos en Java.

97
00:10:23,640 --> 00:10:31,080
Hemos visto varias operaciones como son crear un archivo escribir leer y anexar información a un archivo.

98
00:10:31,080 --> 00:10:36,620
Con eso ya tenemos las bases para entender mejor el funcionamiento de manejo de archivos en Java eso

99
00:10:36,630 --> 00:10:39,290
es todo por esta elección y nos vemos en el siguiente video.

100
00:10:39,370 --> 00:10:39,980
Saludos.