Saltar navegación

Clase 20-05-24 - 3 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 25 de mayo de 2024 por Raquel G.

8 visualizaciones

Más información Transcripción

Descargar la transcripción

¿Vale? Si yo ahora vuelvo a escribirlo con este parámetro a true, ¿lo vuelvo a ejecutar? 00:00:01
Un segundito. Vale, líneas. Líneas, que existe. Vale. 00:00:12
Introduzca texto. Esto, esto y esto. Tres líneas nuevas he metido. Fin. 00:00:17
Vamos a ver ahora qué tiene líneas. 00:00:24
Nos vamos a líneas y efectivamente las ha añadido. 00:00:27
no ha sobrescrito lo de antes 00:00:31
lo ha añadido 00:00:34
porque este parámetro está 00:00:35
porque este parámetro está a true 00:00:37
no, no, porque estoy trabajando 00:00:41
con el nombre, con lo cual asume que es 00:00:48
la raíz del proyecto 00:00:49
en la raíz del proyecto, aquí 00:00:50
tú dale a refresh, si no lo ves, dale a F5 00:00:53
a refresh, y lo verás ahí colgando 00:00:55
directamente de la raíz del proyecto 00:00:57
porque esa es la ruta por defecto 00:00:59
si tú no especificas nada 00:01:03
lo que tú pongas, cuelga de ahí 00:01:05
vale, y hay más variantes de constructor 00:01:07
también le puedes pasar 00:01:13
en lugar de un string, un objeto file 00:01:15
hay variantes de constructor 00:01:17
y variantes del método 00:01:19
de escribir, bueno 00:01:21
mil cosas, pero lo básico para 00:01:22
escribir texto en un archivo sería esto 00:01:25
bueno, pues ahora vámonos a leer 00:01:27
que esto es un pelinín 00:01:29
un pelinín más útil 00:01:31
vamos ahora a leer 00:01:33
el contenido de un fichero 00:01:35
vale 00:01:36
A ver 00:01:37
Vale, pues 00:01:43
¿Qué métodos? 00:02:00
No, hombre, es que si leo, se escribe 00:02:11
Pero para 00:02:13
Escribir es file writer 00:02:17
Y para leer es la otra 00:02:19
Pero son dos fases distintas 00:02:20
Lo que no se hace es leer 00:02:22
Y escribir simultáneamente 00:02:25
Porque como he dicho antes 00:02:26
que se podrían generar efectos secundarios 00:02:27
un poquito 00:02:29
porque tú has leído 00:02:29
se ha quedado posicionado en un sitio, escribes donde 00:02:32
en la mitad, tienes que volver el puntero 00:02:34
arriba, hay muy pocas clases 00:02:37
que te admitan ambas cosas a la vez 00:02:39
porque no se 00:02:43
suelen usar, vale, está en la pizarra 00:02:44
bueno, pues a ver, leer es un poquito 00:02:46
más útil 00:02:53
repito 00:02:59
vale 00:03:00
pues a ver, en cualquier caso 00:03:03
la lectura y escritura 00:03:06
siempre va de variables 00:03:07
al fichero 00:03:10
o del fichero a variables 00:03:15
si fuera una base de datos 00:03:18
pues sería una base de datos, me da igual 00:03:20
en este caso es un fichero 00:03:22
entonces escribir está claro 00:03:23
escribir es 00:03:28
yo mediante el método write correspondiente 00:03:30
el método write 00:03:33
que yo elija 00:03:34
paso de aquí a aquí 00:03:35
entonces en la primera escritura 00:03:38
escribo donde esté posicionado 00:03:40
el puntero interno, un puntero 00:03:42
que yo ni gestiono ni manejo 00:03:44
repito, si el fichero 00:03:45
para escribir lo he abierto en modo 00:03:48
añadir false, en el false 00:03:50
el puntero se queda posicionado 00:03:52
aquí, con lo cual la primera 00:03:55
escritura se escribe aquí 00:03:56
y ahora ya el puntero interno, ese que yo no manejo 00:03:57
se queda posicionado aquí 00:04:00
con lo cual la siguiente vez que haga write 00:04:02
pues se escribe aquí debajo 00:04:04
y el puntero interno se queda posicionado 00:04:06
que necesito el rato, ¿vale? Eso está claro. 00:04:08
Hay un posicionador 00:04:11
interno que yo no manejo 00:04:12
que va avanzando según hago escritura 00:04:14
para que no se escriba una cosa encima de la otra. 00:04:16
¿Vale? Bueno, pues ahora 00:04:19
vamos a leer. Leer es lo contrario. 00:04:20
Leer, yo tengo un fichero 00:04:25
que supone que tiene bytes, 00:04:26
tiene datos, o si es de texto, tiene caracteres 00:04:28
y yo quiero 00:04:30
mover 00:04:32
lo que tiene a variables, porque la aplicación 00:04:34
solo puede trabajar con lo que haya en variables, 00:04:36
no puede trabajar con nada más. 00:04:38
Bueno, pues entonces, ahora tendré que abrir el fichero con la clase que sirve para leer caracteres. 00:04:40
Pues si la de escribir a FileWriter, la de leer es FileReader. 00:04:46
¿Vale? Esa sería la de leer, FileReader. 00:04:53
Bueno, pues entonces, en cuanto hablo FileReader, ese posicionador interno del fichero, 00:04:57
que no gestionamos nosotros, ese posicionador interno se queda posicionado al principio. 00:05:01
¿Eso qué significa? Que la primera lectura se hace del primer carácter. 00:05:07
entonces la primera vez que hagamos un read 00:05:11
se cogerá el primer carácter 00:05:13
e irá a la variable 00:05:18
que yo le diga, ahora veremos 00:05:20
como usamos read 00:05:21
pero la primera lectura cogerá el primer carácter 00:05:22
que viajará a la variable 00:05:26
que yo le diga, y ahora ese posicionador 00:05:27
ese posicionador interno 00:05:30
bajará al siguiente 00:05:31
y se quedaría apuntando 00:05:32
¿que vuelvo a hacer otro read? 00:05:34
¿que vuelvo a hacer otro? 00:05:36
pues entonces ahora se lee este carácter 00:05:38
se lee este carácter que irá a la variable 00:05:40
que yo le diga 00:05:43
y el posicionador interno 00:05:44
se quedará colocado aquí abajo 00:05:47
y así 00:05:48
tanto React como caracteres que irá yo leer 00:05:51
vale 00:05:53
aquí lo que pasa es que tenemos un problema 00:05:55
cuando uno trabaja con un fichero 00:05:56
no sabe el tamaño que tiene 00:05:58
no tiene por qué saberlo la aplicación 00:06:01
entonces no sabemos 00:06:03
cuántos React hay que hacer 00:06:05
no sabemos cuántos hay que hacer 00:06:06
un bucle va a haber que hacer 00:06:08
porque hay que hacer muchos React 00:06:10
un bucle va a haber que hacer 00:06:12
¿cuántos READ? pues no sé 00:06:13
depende del tamaño 00:06:16
entonces, ¿cómo funciona esta clase? 00:06:17
esta clase funciona 00:06:21
para que READ 00:06:22
te devuelva una marca 00:06:24
que es menos uno, ahora vemos cómo se usa 00:06:25
cuando has llegado a fin de archivo 00:06:28
esa es la manera de leer 00:06:30
tendrás que hacerte un bucle 00:06:32
obligatoriamente un bucle 00:06:34
que va haciendo READ, READ, READ 00:06:36
hasta 00:06:38
que alcance la marca de fin de archivo 00:06:39
y cuando alcance la marca de fin de archivo 00:06:42
el bucle terminará porque ya no hay más que leer 00:06:44
luego el funcionamiento de file reader es ese 00:06:46
lo abres, se queda posicionado al principio 00:06:50
y ahora ya cada lectura 00:06:52
te va leyendo uno, te lee este 00:06:54
y se queda posicionado aquí 00:06:56
que le vuelves a mandar otro rea, te lee este y se queda posicionado aquí 00:06:57
que los quieres leer todos 00:07:01
pues un bucle 00:07:03
te queda más remedio, un bucle de rea 00:07:03
ese bucle cuando acabará 00:07:06
cuando alcancemos la marca de fin de archivo 00:07:08
vale 00:07:11
bueno pues ahora hay que ver 00:07:12
como se escribe en java esto 00:07:15
esto es read y todo eso 00:07:17
bueno pues a ver 00:07:19
como se escribe en java 00:07:24
todo esto, bueno pues el método 00:07:27
nosotros tenemos el file reader este 00:07:35
que lo habremos instanciado 00:07:37
a un objeto fichero 00:07:38
un file 00:07:41
o al nombre del fichero 00:07:41
tengo constructores con las dos variantes 00:07:44
bueno, pues al file reader le pasamos un objeto file 00:07:47
o un nombre del fichero 00:07:54
porque el constructor te admite tanto un objeto file 00:07:56
que guarde ese fichero 00:07:59
o el string con el nombre, lo que sea 00:08:00
bueno, pues abrimos el file reader 00:08:02
y ahora ya 00:08:06
¿qué hace cada read? 00:08:07
pues el read no tiene parámetros 00:08:13
el read no tiene parámetros 00:08:15
lo que te hace es lo que hemos dicho 00:08:17
te lee un carácter 00:08:19
de donde esté posicionado el puntero interno 00:08:24
te lee un carácter 00:08:27
y te devuelve ese carácter como valor de retorno 00:08:27
entonces lo que sí 00:08:30
que tenemos que hacer, sí o sí 00:08:32
es guardar ese valor de retorno 00:08:34
en algún sitio 00:08:36
FRA, lee el carácter de donde esté 00:08:37
posicionado el puntero 00:08:40
te lo devuelve como valor de retorno 00:08:42
vosotros podéis pensar 00:08:43
como es un carácter 00:08:46
lo natural será 00:08:47
que el FRA te devuelva 00:08:50
un char que tú puedas guardar 00:08:52
en una variable char? Pues no. 00:08:54
El frrear 00:08:57
no te devuelve un char. 00:08:58
El frrear, ¿qué hace? 00:09:00
Coge este carácter, 00:09:02
que sí que es un char que tiene 8 bits, 00:09:04
coge este carácter, imaginaos que es el carácter a, 00:09:06
lo coge 00:09:09
y lo mete en una variable int 00:09:09
y lo coloca 00:09:12
en el byte menos significativo. 00:09:14
Y el resto lo deja limpio. 00:09:16
Todo a ceros, ahí sin tocar. 00:09:18
Es decir, esto es lo que 00:09:21
hace, te construye un int 00:09:22
mete 00:09:24
el char en el menos significativo 00:09:26
y el resto lo deja 00:09:28
a cero, y tú ya te quedas 00:09:30
con ese int, porque eso es lo que te 00:09:32
devuelve 00:09:34
ya vemoslo como quedamos 00:09:35
luego te devuelve, te devuelve el int, FR te lo devuelve 00:09:37
el int, entonces hay que guardarlo en int 00:09:40
que tú lo quieres ya como 00:09:41
char, no pasa nada, le haces el casting 00:09:44
y al hacer el casting se queda con este 00:09:46
¿vale? 00:09:47
si uno ya hace el casting de esto 00:09:50
char carácter igual a 00:09:52
char de c 00:09:57
pues ya está, ya tiene el carácter car 00:10:00
que estaba guardado aquí 00:10:03
en este int 00:10:05
que me ha devuelto el fread 00:10:06
y luego además el fread ya se encarga 00:10:08
repito, de bajar el posicionador aquí 00:10:10
para que en el siguiente fread 00:10:12
se lea el siguiente que haya 00:10:15
el siguiente 00:10:16
¿vale? 00:10:17
para que lea, si o si 00:10:18
hay que hacer el cast 00:10:21
Bueno, más que para que lea 00:10:23
Para obtenerlo en variable char 00:10:26
O sea, ha leído, lo ha leído 00:10:28
Y lo ha guardado aquí 00:10:30
Otra cosa es que tú, si lo quieres en char 00:10:31
Tienes que hacer el casting 00:10:33
¿Vale? 00:10:35
Porque está guardado de esta manera 00:10:38
Está guardado en un int 00:10:40
Y está guardado en la parte menos significativa 00:10:41
Entonces, si lo quieres en char, tienes que hacer el casting 00:10:43
Para que te lo muestre en consola 00:10:46
Por ejemplo 00:10:49
O para pasarlo a un stream, para lo que quieras 00:10:49
¿Vale? 00:10:51
si lo quieres en chat 00:10:53
lo tienes que hacer el casting 00:10:54
¿vale? 00:10:57
el casting también se hace de forma implícita 00:10:59
pero cuando tú pasas a system.out.printl 00:11:01
en una variable, como ella siempre unita caracteres 00:11:03
él te hace el casting de forma implícita 00:11:05
pero porque lo haga el método 00:11:07
de forma implícita, porque lo hagas tú 00:11:09
el casting lo tiene que hacer alguien 00:11:10
porque ahora mismo el f-react te lo deja guardado 00:11:12
aquí, en el byte menos significativo 00:11:15
de unit 00:11:17
y luego además te posiciona para quedarse 00:11:18
preparado para la siguiente lectura 00:11:21
Bueno, con lo cual la pregunta sería, pues, ¿y para qué hace esta tontería de meterlo en un int si lo único que cuenta es este? No lo hace precisamente para habilitarse la opción de avisar de cuándo has llegado al final, para avisar de cuándo has llegado al final. 00:11:23
porque él, cuando ha llegado al final 00:11:46
lo que hace Ferrea es devolverte menos uno 00:11:49
el numerito menos uno 00:11:52
y claro, si tú no has llegado al final 00:11:55
y has leído cualquier otro carácter 00:11:58
es imposible que este int sea menos uno 00:12:00
porque aquí hay ceros en todas partes 00:12:03
aquí está el carácter y aquí hay ceros 00:12:05
y el menos uno es un número negativo 00:12:06
y el negativo se codifica con el bit de signo uno 00:12:09
con lo cual, si el resultado de Ferrea 00:12:12
este int, tú lo comparas 00:12:16
con doble o igual 00:12:19
y resulta que es menos uno 00:12:20
estás en fin de archivo 00:12:22
y si no es menos uno 00:12:24
no estás en fin de archivo 00:12:26
si no es menos uno, habrás leído un carácter 00:12:27
que habrás bajado para apuntar al siguiente 00:12:30
y ese carácter estará ahí 00:12:32
luego lo de meterlo en un int 00:12:34
es para habilitar esta forma de avisar 00:12:37
de que estás en fin de 00:12:40
de fichero 00:12:42
porque si devolviera un char no habría manera 00:12:44
¿vale? entonces te habilita 00:12:47
estos bits extra para con estos bits 00:12:52
extra en función de si esto es 0 o 1 00:12:54
avisarte de si es fin de fichero 00:12:56
entonces 00:12:58
ahora ya con esto 00:13:00
podemos ya meter esto en el bucle 00:13:01
pues tranquilamente, podríamos hacer un bucle 00:13:03
pues por ejemplo así 00:13:06
que es el bucle habitual para leer del fichero 00:13:07
aquí 00:13:12
vamos a, esta va a ser nuestra variable 00:13:13
para guardar lo que hemos leído 00:13:15
y ahora hacemos 00:13:17
pues mientras C 00:13:19
siendo C 00:13:22
el resultado de leerlo 00:13:24
mientras C sea diferente 00:13:26
de menos uno, y este sería mi bucle 00:13:28
ahora yo ya hago aquí con 00:13:30
C lo que me dé la gana 00:13:32
¿vale? este es un bucle 00:13:33
que está, C lo leo 00:13:36
es diferente de menos uno, entro 00:13:38
y hago con C lo que quiera 00:13:40
mostrarlo, haciendo el casting a char 00:13:41
lo que a mí me dé la gana, concatenarlo con 00:13:44
otro lo que quiera 00:13:46
lo que quiera 00:13:47
¿ahí estás teniendo esas condiciones así? 00:13:49
igual que en el if de antes 00:13:52
¿eso es como hacer una ternaria? 00:13:53
no, no es como hacer una ternaria 00:13:56
esto es como 00:13:58
en el momento de usar una variable 00:13:59
para compararlo con algo, en ese momento le asigno 00:14:02
valor 00:14:04
es decir, esto es una condición 00:14:04
es una condición que compara c con esto 00:14:07
como podríamos decir una condición 00:14:10
que compara f con otra cosa 00:14:12
lo que fuera 00:14:14
entonces cuando uno usa una variable 00:14:16
aquí, aquí, en una condición 00:14:17
aunque sea una condición muy compleja 00:14:19
cuando usas una variable dentro de esa condición 00:14:22
puedes en el momento de usarla 00:14:24
en ese momento darle un valor 00:14:26
¿vale? por ejemplo, esta condición también es válida 00:14:27
si f siendo f 00:14:30
igual a 3 00:14:32
resulta que es distinto de 5 00:14:33
esta condición sería siempre true 00:14:35
obviamente, porque en el momento de usar f 00:14:37
le estoy dando el valor 3 00:14:39
¿vale? luego en una condición 00:14:41
cualquier variable puedes además 00:14:43
darle un valor, entonces se le da primero 00:14:45
el valor y luego se evalúa la condición 00:14:47
entonces se usa mucho 00:14:49
esa, porque te ahorras 00:14:51
líneas 00:14:53
bueno, pues si c es diferente de menos uno 00:14:54
siendo c 00:14:57
el resultado de haberla leído del fichero 00:14:58
pues ahora yo hago con c lo que me dé la gana 00:15:01
y ya está, y ese es el famoso 00:15:03
buque de lectura de ficheros 00:15:05
y ahí ya podemos hacer lo que 00:15:07
queramos 00:15:10
entonces, por ejemplo 00:15:11
por ejemplo, vamos a hacer nuestro método 00:15:15
de leer fichero 00:16:00
le pasamos un nombre de fichero 00:16:00
y que nos muestre 00:16:03
por consola el contenido 00:16:06
¿vale? entonces este método, ¿qué haría? 00:16:07
pues este método 00:16:16
recibe un 00:16:17
nombre de fichero 00:16:19
que se supone que es de texto, porque si no va a funcionar 00:16:20
porque es file reader y nos haría 00:16:27
cosas raras si no tiene texto 00:16:29
y muestra 00:16:30
por consola el contenido 00:16:33
lo que sea que tenga 00:16:39
pues ala, pues entonces 00:16:42
como vamos a leer 00:16:46
¿qué necesitamos? un file reader 00:16:47
asociado a ese 00:16:49
nombre de archivo 00:16:53
aquí lo mismo, file reader, de nuevo 00:16:54
sobrecargado, el constructor, le podemos pasar un string 00:17:02
un objeto file 00:17:05
con que le pasemos una referencia 00:17:06
a esa ruta 00:17:09
vale, importamos 00:17:10
y de nuevo el throwsio exception 00:17:13
no, en este caso file not found 00:17:15
pues throws para que sea 00:17:17
¿vale? porque este método 00:17:19
si tratamos de leer, de abrir para leer 00:17:23
uno que no exista nos va a salir una excepción 00:17:25
file not found exception 00:17:27
entonces le hacemos el throws y ya está 00:17:28
¿vale? pues aquí 00:17:30
esta va a ser la variable que habilitamos 00:17:32
para leer los caracteres y ahora ya hacemos 00:17:35
el bucle, mientras c 00:17:37
siendo c 00:17:41
el resultado 00:17:42
de hacer una lectura 00:17:44
del fichero 00:17:46
sea diferente del numerito menos uno 00:17:48
pues en ese caso vamos a mostrar por consola 00:17:52
ese carácter que hemos leído 00:17:56
que lo extraemos de ese int 00:18:01
haciendo el casting 00:18:05
que se quedará con el byte menos significativo 00:18:06
que es el que nos importa 00:18:09
el frr de nuevo una excepción 00:18:10
pues otro throws 00:18:12
println le vamos a poner print 00:18:13
para que no nos saque todo el contenido 00:18:18
cada carácter una línea 00:18:21
queremos que todos los caracteres salgan tal cual 00:18:22
y ahora ya lo mismo 00:18:25
un recurso que se ha abierto 00:18:31
pues deberíamos cerrarlo 00:18:33
al apagar el programa 00:18:35
al cerrar el programa se cierran solos 00:18:37
pero podría a lo mejor no cerrarse 00:18:39
entonces se queda ese recurso bloqueado, etc 00:18:40
pues ya está 00:18:42
este va leyendo ese fichero 00:18:44
y ahora 00:18:46
en el main nuestro 00:18:49
hemos escrito ya un fichero 00:18:55
y ahora vamos a mostrar por consola el contenido 00:18:57
Vamos a ponerlo aquí 00:18:59
El contenido del fichero es 00:19:01
Y ese mismo fichero que acabamos de escribir 00:19:09
Que nos lo muestre 00:19:11
Leer fichero 00:19:12
Se llama el método, ¿no? 00:19:17
Leer fichero 00:19:19
Y el nombre del fichero es este 00:19:20
Es el que acabamos de crear 00:19:22
¿Vale? Es decir, este método 00:19:27
Ha creado un fichero f 00:19:38
con el nombre fgetname 00:19:39
y vamos ahora a leerlo 00:19:42
ese fichero con ese nombre getname 00:19:44
venga, nombre del fichero 00:19:46
líneas 00:19:52
vamos a escribir cualquier cosa que se va a concatenar 00:19:53
al otro 00:19:56
porque estaba con true, creo 00:19:57
fin, ya no escribimos más 00:20:00
y el contenido del fichero es 00:20:03
pues efectivamente 00:20:05
es el contenido del fichero 00:20:06
con las nuevas líneas 00:20:08
que hemos incorporado 00:20:12
vale, pues vamos a poner aquí unos métodos vacíos 00:20:13
para que hagáis vosotros 00:20:48
un poco de más 00:20:50
sencillo y más complicado 00:20:52
por ejemplo 00:20:54
este método 00:20:55
pues un método que dado un objeto file 00:20:56
te cuente 00:21:05
cuantas líneas tiene 00:21:10
yo pongo esto así para 00:21:11
que tiene que devolver las líneas que tiene ese fichero 00:21:18
vale 00:21:21
otro 00:21:24
un método 00:21:25
para concatenar dos ficheros 00:21:46
y generar un tercero con la concatenación 00:21:48
de los otros 00:21:50
se le pasa un fichero 00:21:51
y se le pasa un fichero F2 00:21:58
y tiene que devolver 00:22:00
otro fichero 00:22:02
cuyo contenido sea la concatenación 00:22:03
de estos 00:22:07
luego le da de este, le da de este 00:22:08
irá escribiendo en uno 00:22:11
y ahora otro 00:22:13
que en lugar de 00:22:21
coger los dos y concatear uno detrás de otro 00:22:23
vaya intercalando las líneas 00:22:26
que este es más 00:22:28
complicado 00:22:39
vale, este está claro 00:22:42
no hay que hacer 00:22:52
que devuelve este 00:22:53
devuelve el 00:23:02
número de líneas 00:23:04
del fichero 00:23:08
vale 00:23:10
este otro 00:23:11
primer fichero 00:23:13
segundo fichero 00:23:20
que devuelve 00:23:26
un fichero 00:23:28
cuyo contenido 00:23:31
es la concatenación de los anteriores 00:23:33
anteriores 00:23:35
y ahora 00:23:46
el de intercala líneas 00:23:48
pues es un fichero, otro fichero 00:23:50
prácticamente lo mismo 00:23:54
un fichero 00:23:59
que tiene la concatenación de los anteriores 00:24:01
pero intercalando sus líneas 00:24:02
sus líneas 00:24:05
pues ahora ya tenéis esos tres métodos 00:24:13
como ejemplo para practicar con FileReader 00:24:18
FileWriter 00:24:20
el de 00:24:20
leer fichero 00:24:26
¿has dicho? 00:24:28
esto 00:24:28
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
8
Fecha:
25 de mayo de 2024 - 17:54
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
24′ 39″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
445.94 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid