1
00:00:00,770 --> 00:00:05,509
Hola, vamos a comenzar a hacer una serie de programas relacionados con ficheros.

2
00:00:06,790 --> 00:00:11,250
Iba a seguir todo esto que hay aquí, todos los apuntes que tenemos en Code&Coke,

3
00:00:11,890 --> 00:00:16,809
pero realmente, bueno, después, antes de empezar, voy a hacer algún ejemplo previo, ¿vale?

4
00:00:16,929 --> 00:00:19,910
Y además así vamos cogiendo un poco la idea de cómo funciona esto.

5
00:00:20,670 --> 00:00:24,170
Me voy a mi entorno Eclipse, lo podemos hacer en IntelliJ o en Eclipse,

6
00:00:24,289 --> 00:00:26,929
o en el entorno que más rápido nos manejemos.

7
00:00:26,929 --> 00:00:33,689
A mí me gusta Eclipse porque es muy ligerito frente a IntelliJ, pero IntelliJ también tiene sus ventajas, sobre todo en ORM.

8
00:00:34,490 --> 00:00:43,689
Y voy a hacer un pequeño programita en el cual vea características de una de las clases más importantes que hay relativas a ficheros, que se llama File, como no podía ser de otra manera.

9
00:00:44,789 --> 00:00:55,310
Así que vamos a empezar. Voy a crear aquí un método estático que nos muestre, por ejemplo, las características de un fichero.

10
00:00:55,310 --> 00:00:59,950
y si es un directorio que me muestre los ficheros que hay dentro, con esas características, algo así.

11
00:01:00,630 --> 00:01:07,469
Vamos a ver qué nos va saliendo. Voy a darle un nombrecito, voy a llamarle myls, por ejemplo,

12
00:01:08,489 --> 00:01:15,650
y al cual a este método le pasamos la ruta del fichero o directorio que queramos visualizar.

13
00:01:16,150 --> 00:01:21,030
Vale, se nos pueden dar, cuando pasamos una ruta, se nos pueden dar dos situaciones, que sea un directorio o que no.

14
00:01:21,670 --> 00:01:25,109
Así que de momento vamos a indagar sobre este fichero.

15
00:01:25,310 --> 00:01:32,290
Voy a llamar file f, por ejemplo, y voy a abrir este fichero, esta ruta con file.

16
00:01:33,510 --> 00:01:43,310
Bien, pues lo primero que nos va a avisar claramente es que esta librería, esta clase, no la tenemos todavía funcionando.

17
00:01:43,310 --> 00:01:51,870
¿Vale? Si yo, a ver, si yo pinto ahí donde está el error, me dice que importe el fichero.

18
00:01:51,870 --> 00:02:17,629
Está claro que en esta cosa tan larga no va a ser, lo que queremos es importar java.io, input, output, ¿de acuerdo? Bueno, una vez que tengo esta ruta, ya este fichero activado, pues la clase file, si vamos al API de Java, veremos un montón de características, pero yo en este caso lo primero que quiero preguntar es si f es un directorio.

19
00:02:17,629 --> 00:02:19,909
entonces, curiosamente, simplemente habiendo

20
00:02:19,909 --> 00:02:22,330
tecleado el punto

21
00:02:22,330 --> 00:02:23,909
ya vemos que aquí hay un montón de cosas

22
00:02:23,909 --> 00:02:25,310
que van a aparecer, por ejemplo

23
00:02:25,310 --> 00:02:27,150
voy a preguntar si es un directorio

24
00:02:27,150 --> 00:02:29,030
muy bien

25
00:02:29,030 --> 00:02:31,250
pues si es un directorio

26
00:02:31,250 --> 00:02:33,330
yo lo que querré

27
00:02:33,330 --> 00:02:35,169
es que me muestre lo que hay dentro

28
00:02:35,169 --> 00:02:36,710
de ese directorio

29
00:02:36,710 --> 00:02:38,590
¿cómo puedo hacer eso?

30
00:02:39,229 --> 00:02:41,330
pues tengo dos formas

31
00:02:41,330 --> 00:02:43,349
una, que me devuelva

32
00:02:43,349 --> 00:02:45,430
un montón de

33
00:02:45,430 --> 00:02:45,849
files

34
00:02:45,849 --> 00:02:48,849
que serían los archivos que están dentro

35
00:02:48,849 --> 00:02:50,650
archivos que están dentro

36
00:02:50,650 --> 00:02:54,490
con f.listfiles

37
00:02:54,490 --> 00:02:56,050
ya vemos ahí además que automáticamente

38
00:02:56,050 --> 00:02:57,330
en el momento que he decidido

39
00:02:57,330 --> 00:03:00,650
que lo que voy a obtener es una radio ficheros

40
00:03:00,650 --> 00:03:02,330
ya me devuelve esta opción

41
00:03:02,330 --> 00:03:04,669
tendría otra que era pasarle

42
00:03:04,669 --> 00:03:05,969
pasarle directamente

43
00:03:05,969 --> 00:03:07,629
la ruta

44
00:03:07,629 --> 00:03:10,469
y entonces me devolvería un string

45
00:03:10,469 --> 00:03:13,509
bien, pues aquí están todos los ficheros

46
00:03:13,509 --> 00:03:21,629
Si tengo todos estos ficheros que me devuelve, yo ahora sobre cada uno de ellos puedo hacer otra vez mi ls

47
00:03:21,629 --> 00:03:25,409
Con lo cual recursivamente voy recorriendo todo el árbol de directorios

48
00:03:25,409 --> 00:03:26,229
Vamos a por ello

49
00:03:26,229 --> 00:03:37,330
Pues una manera cómoda de hacerlo es con un for en el cual yo devuelvo cada archivo de todos los archivos que me pasa

50
00:03:37,330 --> 00:03:40,689
Esta sería una manera muy rápida y muy cómoda de manejar esto

51
00:03:40,689 --> 00:04:03,949
¿Vale? Entonces ahora para cada archivo puedo mostrar sus características. ¿De acuerdo? Sus características. Bueno, o directamente llamar a mi ls de ese archivo, pero no de ese archivo tal cual, porque archivo pide, mi ls nos pide un string, con lo cual me hace falta convertir eso a string.

52
00:04:03,949 --> 00:04:07,750
muy bien, con lo cual lo tendría hecho

53
00:04:07,750 --> 00:04:09,610
¿qué ocurre si no es un directorio?

54
00:04:09,750 --> 00:04:14,030
pues que directamente quiero ver características que tiene el fichero correspondiente

55
00:04:14,030 --> 00:04:17,569
entonces yo puedo perfectamente, voy a ver

56
00:04:17,569 --> 00:04:21,189
cómo lo hago, por ejemplo, así

57
00:04:21,189 --> 00:04:24,350
bueno, aquí voy a pintar las características de ese fichero

58
00:04:24,350 --> 00:04:29,810
voy a quitarme el println y voy a utilizar el printf para darle un poco de formato a la salida

59
00:04:29,810 --> 00:04:33,250
voy a darle tres caracteres, ahora veremos para qué

60
00:04:33,250 --> 00:04:37,990
voy a darle un numerito de 10 posiciones

61
00:04:37,990 --> 00:04:39,629
perdón, de 10 posiciones

62
00:04:39,629 --> 00:04:41,509
el nombre del ficherito

63
00:04:41,509 --> 00:04:43,089
y el salto de línea

64
00:04:43,089 --> 00:04:44,730
y ahora vamos a ir viendo

65
00:04:44,730 --> 00:04:46,910
que le pongo a cada uno de esos elementos

66
00:04:46,910 --> 00:04:49,189
lo primero que quiero ver es si este fichero

67
00:04:49,189 --> 00:04:50,910
este programa lo puede leer

68
00:04:50,910 --> 00:04:53,110
entonces, casi seguro que sí, ¿no?

69
00:04:53,170 --> 00:04:54,970
pero bueno, lo puedo leer

70
00:04:54,970 --> 00:04:55,970
can read

71
00:04:55,970 --> 00:04:59,589
si lo puedo leer, voy a poner simplemente

72
00:04:59,589 --> 00:05:02,269
que me muestre una, ahí perdón, una R

73
00:05:02,269 --> 00:05:06,110
y si no, una rayita, muy al estilo Unix

74
00:05:06,110 --> 00:05:12,949
ahora, lo mismo voy a hacer para f.can.write

75
00:05:12,949 --> 00:05:20,160
entonces aquí pongo una w, dos puntos o una rayita

76
00:05:20,160 --> 00:05:26,660
y si lo puedo ejecutar, f.can.execute

77
00:05:26,660 --> 00:05:30,959
vamos a echarlo esto para atrás, lo de intentar no es ninguna manía

78
00:05:30,959 --> 00:05:51,370
Es la única manera de que un programa sea legible. Bien, pues hasta aquí lo tenemos. En ese numerito que tenemos ahí lo que quiero contarle es la longitud, el tamaño del fichero, con lo cual pues ahí tengo el tamaño que tiene el fichero en bytes y por fin el nombre.

79
00:05:51,370 --> 00:06:07,029
Bueno, ¿cómo cojo el nombre? Pues get, y aquí tengo el nombre, ¿de acuerdo? Simplemente el nombre del fichero. Muy bien, pues esto sería nuestro programita. ¿Qué cosas me parece que tendríamos que poner más?

80
00:06:07,029 --> 00:06:13,529
Bueno, pues antes de que muestre todos los ficheros de un directorio, que muestre el nombre del directorio.

81
00:06:13,689 --> 00:06:19,569
Entonces, pues por ejemplo aquí, yo puedo decirle, vamos a darle así otra vez.

82
00:06:20,490 --> 00:06:22,689
Ay, por Dios, que ha salido esto mal.

83
00:06:23,649 --> 00:06:28,209
Bueno, pues si eso ha salido mal, tampoco nos vamos a preocupar.

84
00:06:28,949 --> 00:06:30,209
System, auto.

85
00:06:30,209 --> 00:06:33,769
y entonces vamos a ponerle printf

86
00:06:33,769 --> 00:06:37,529
para que podamos hacerlo con formato

87
00:06:37,529 --> 00:06:39,430
vamos a ponerle aquí

88
00:06:39,430 --> 00:06:41,730
que nos muestre por ejemplo

89
00:06:41,730 --> 00:06:44,449
el nombre completo del directorio

90
00:06:44,449 --> 00:06:45,850
y un salto de línea

91
00:06:45,850 --> 00:06:51,529
entonces aquí podríamos poner directamente la ruta

92
00:06:51,529 --> 00:06:53,430
y así ya tenemos la ruta

93
00:06:53,430 --> 00:06:55,529
voy a poner también dos puntitos para que se vea claro

94
00:06:55,529 --> 00:06:57,990
que este es el directorio

95
00:06:57,990 --> 00:07:04,790
Muy bien, pues con esto ya podríamos intentar ejecutar este método

96
00:07:04,790 --> 00:07:09,029
Vamos a ver, vamos a analizar cómo llamamos a esto

97
00:07:09,029 --> 00:07:11,930
Y esto se lo podría aplicar a cualquier ficherito

98
00:07:11,930 --> 00:07:15,230
Voy a quitar esta línea de aquí, el programa principal

99
00:07:15,230 --> 00:07:21,529
Y voy a llamar a mi ls, por ejemplo, del fichero 1 que todos conocemos

100
00:07:21,529 --> 00:07:25,170
Que es el fichero Power, estamos en Linux, ¿vale?

101
00:07:25,170 --> 00:07:27,610
entonces vamos a ir a este

102
00:07:27,610 --> 00:07:29,689
vamos a ver que nos ejecutaría esto

103
00:07:29,689 --> 00:07:32,490
que situación nos daría

104
00:07:32,490 --> 00:07:34,610
si ejecutamos esto

105
00:07:34,610 --> 00:07:36,569
nos dice que

106
00:07:36,569 --> 00:07:37,949
vamos a decirle que siempre nos guarde

107
00:07:37,949 --> 00:07:39,990
todos los recursos antes de lanzarlos

108
00:07:39,990 --> 00:07:42,290
pues si hacemos esto

109
00:07:42,290 --> 00:07:44,209
efectivamente nos está diciendo

110
00:07:44,209 --> 00:07:45,430
que

111
00:07:45,430 --> 00:07:47,629
es un fichero de lectura

112
00:07:47,629 --> 00:07:49,470
que no se puede escribir

113
00:07:49,470 --> 00:07:52,170
el cual no se puede ejecutar y que tiene este tamaño

114
00:07:52,170 --> 00:07:53,370
ah, pues fantástico

115
00:07:53,370 --> 00:07:58,370
Digo, ¿pero qué ocurre, por ejemplo, si yo dijera simplemente ETC?

116
00:07:59,350 --> 00:08:02,089
Es decir, el directorio completo. Pues vamos a verlo.

117
00:08:04,050 --> 00:08:10,370
Bueno, vemos que es algo enorme, enorme, con montones de estructuras.

118
00:08:11,850 --> 00:08:13,910
Directorio ETC, hemos empezado aquí arriba.

119
00:08:14,910 --> 00:08:20,629
Ha ido fichero a fichero contándonos y ha entrado en cada uno de los subdirectorios contándonos también su información.

120
00:08:20,629 --> 00:08:24,389
¿vale? ¿qué ocurre? que no sabemos muy bien en qué estructura estamos

121
00:08:24,389 --> 00:08:28,629
dentro de cada subdirectorio, aparte de todo aquí hay links enlazados

122
00:08:28,629 --> 00:08:32,450
etcétera, con lo cual posiblemente de ahí proviene el último error que aparece

123
00:08:32,450 --> 00:08:36,330
al final, vamos a ir hasta el final, son muchas líneas y efectivamente

124
00:08:36,330 --> 00:08:40,330
en algún sitio pues no ha podido con eso porque algo ha ido

125
00:08:40,330 --> 00:08:44,230
a un enlace que no ha podido solucionar ¿vale? con lo cual vamos a ir a un entorno un poquito

126
00:08:44,230 --> 00:08:48,190
más controlado, donde veamos mejor nuestras cosas, por ejemplo el propio directorio

127
00:08:48,190 --> 00:08:51,570
donde estoy trabajando. ¿Y dónde estoy trabajando? Pues

128
00:08:51,570 --> 00:08:54,610
el directorio en que yo estoy trabajando es justamente

129
00:08:54,610 --> 00:09:02,009
obtener la propiedad System.getProperty

130
00:09:02,009 --> 00:09:06,710
de User.dir. El trabajo

131
00:09:06,710 --> 00:09:09,590
nuestro, el usuario nuestro. ¿Vale?

132
00:09:10,610 --> 00:09:15,210
Vamos a ejecutar esto para ver un poco con más precisión

133
00:09:15,210 --> 00:09:18,929
qué es lo que está ocurriendo. Muy bien, estamos en nuestro proyecto

134
00:09:18,929 --> 00:09:21,830
dentro de un fichero que es classpath

135
00:09:21,830 --> 00:09:24,529
dentro de un directorio bin que ha creado una clase

136
00:09:24,529 --> 00:09:28,350
también está project, pero tal como está no sabemos si pertenece

137
00:09:28,350 --> 00:09:30,389
a este directorio o al otro

138
00:09:30,389 --> 00:09:33,789
y así vamos recorriendo todos los ficheritos

139
00:09:33,789 --> 00:09:36,629
y sus características. Claro, el no saber

140
00:09:36,629 --> 00:09:39,970
a quién pertenece realmente, pues este programa nos lo hace muy eficiente

141
00:09:39,970 --> 00:09:42,309
en cambio si cada vez que llamamos

142
00:09:42,309 --> 00:09:45,610
cada vez que llamamos a mi ls, le decimos en qué nivel

143
00:09:45,610 --> 00:09:47,730
nos encontramos, mejoraremos bastante

144
00:09:47,730 --> 00:09:50,950
Podríamos decirle en qué nivel nos encontramos.

145
00:09:52,350 --> 00:09:57,090
Cuando arrancamos por primera vez, estaríamos en el nivel 0.

146
00:09:57,490 --> 00:09:58,549
Hasta ahí, bien.

147
00:09:59,250 --> 00:10:04,950
Y cada vez que pasamos de nivel, incrementamos en 1 el nivel que le pasamos.

148
00:10:04,950 --> 00:10:09,309
Hasta ahí estaría todo correcto, excepto que no hemos hecho nada para la visualización.

149
00:10:10,269 --> 00:10:12,929
Vamos a meterle tabuladores o indentación.

150
00:10:13,210 --> 00:10:17,230
Vamos a meterle un string que llamemos indentación.

151
00:10:17,730 --> 00:10:28,600
que va a ser, por ejemplo, el carácter tabulador, pues tantas veces como diga nivel.

152
00:10:29,620 --> 00:10:31,019
¿De acuerdo? Tan simple como eso.

153
00:10:31,899 --> 00:10:37,320
Entonces, cuando metamos la ruta, vamos a meterle por delante esa indentación.

154
00:10:37,320 --> 00:10:39,320
Voy a ponerlo ya como el otro para verlo igual.

155
00:10:42,190 --> 00:10:45,590
Y cuando muestro los ficheritos, voy a hacer exactamente lo mismo.

156
00:10:45,750 --> 00:10:49,210
Voy a ponerle esto por delante y lo primero que hago es indentar.

157
00:10:49,210 --> 00:11:10,700
Bueno, con este pequeño cambio vamos a ver cómo hemos solucionado esto. Si vemos el resultado, pues ahora ya sí, vemos claramente que Project pertenece a MyFirstProject, mientras que los demás ficheros cada uno pertenecen a su subdirectorio, con lo cual ahora sí es mucho más clara la información de salida.

158
00:11:10,700 --> 00:11:13,039
bueno, ¿qué más cuestiones podríamos ver?

159
00:11:13,840 --> 00:11:17,700
pues es muy feo, muy fea esta llamada que tenemos aquí debajo

160
00:11:17,700 --> 00:11:20,919
esto llamará a cero, ese cero, ¿qué significa para el programa?

161
00:11:21,519 --> 00:11:24,000
entonces yo lo que quiero llamarle así directamente a mi programa

162
00:11:24,000 --> 00:11:25,000
y que arranque en cero

163
00:11:25,000 --> 00:11:28,580
con lo cual puedo, utilizando las características

164
00:11:28,580 --> 00:11:30,679
de la programación orientada a objetos

165
00:11:30,679 --> 00:11:34,279
definir otra cabecera, static

166
00:11:34,279 --> 00:11:36,360
igual que la anterior, voy

167
00:11:36,360 --> 00:11:40,460
myls string, simplemente la ruta

168
00:11:40,460 --> 00:11:47,899
y que ésta, cuando se le llame, llame a mi LS ruta con cero.

169
00:11:49,500 --> 00:11:53,879
Con lo cual funcionaría tanto este caso como si viéramos un nivel.

170
00:11:54,940 --> 00:12:04,659
Vamos a ver si es verdad y aquí tenemos que efectivamente ha funcionado correctamente

171
00:12:04,659 --> 00:12:10,039
y tenemos dos llamadas, una incluyendo un nivel de acceso y otro que no.

172
00:12:10,039 --> 00:12:14,379
realmente si estuviéramos en una aplicación, en una clase que quisiéramos crear cosas

173
00:12:14,379 --> 00:12:19,840
este sería el public y este sería algo interno donde hubiéramos programado todo lo anterior

174
00:12:19,840 --> 00:12:24,500
bueno, pues como primer ejemplo de ver las características

175
00:12:24,500 --> 00:12:27,019
o alguna de las características que nos permite File

176
00:12:27,019 --> 00:12:30,220
creo que ya es suficiente