Saltar navegación

20260313 Ficheros_2 - 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 17 de marzo de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

bueno, pues escribir 00:00:00
es muy fácil, abro, escribo 00:00:03
y me piro, ya está 00:00:05
la mínima complicación viene 00:00:07
en leer, cuando tú abres el archivo no sabes 00:00:09
que te vas a encontrar, no sabes 00:00:12
cuántos reas tienes que hacer, no sabes 00:00:14
la complicación viene en leer, entonces 00:00:15
vamos a modificar 00:00:17
un pelín esta aplicación 00:00:20
para que cuando arranque 00:00:21
vale, pues vamos a modificar 00:00:24
ahora esta aplicación para que cuando arranque 00:00:33
en el caso de que haya 00:00:35
ya nombres, previamente 00:00:37
los cargue y luego ya 00:00:39
pues te pida más, opere lo que sea 00:00:41
entonces vamos a modificar 00:00:43
esta aplicación para que te 00:00:45
cargue los datos 00:00:47
que hubiera previamente en el fichero 00:00:49
si hubiera ya nombres de antes 00:00:51
porque tal y como lo hemos hecho, esta aplicación 00:00:52
arranca siempre con una cantidad de nombres vacío 00:00:55
Pero se está leyendo aquí todo el rato 00:00:57
¿Vale? 00:01:00
Porque arranca, lógicamente esto está vacío 00:01:02
Vale, pues vamos a modificarla 00:01:04
Para 00:01:06
Que te cargue 00:01:07
Estos nombres de aquí con los nombres 00:01:09
Que existan en el fichero de existir 00:01:12
Alguno previamente 00:01:14
Entonces la aplicación, tú la arrancas 00:01:15
Tiene ya sus nombres, haces lo que sea con ellos 00:01:17
Y te vas 00:01:19
¿Vale? 00:01:21
Bueno, con lo que toque 00:01:23
Vamos por partes 00:01:24
A ver, pues venga, entonces lo primero que haríamos aquí es, vale, pues vamos a modificar la aplicación para hacer esto, leer nombres, vamos a hacer este método, vale, vale, pues este es nuestro método leer nombres. 00:01:26
entonces leer 00:01:59
esencialmente 00:02:01
también necesita 00:02:02
sus tres partes, que es 00:02:04
abrir fichero 00:02:06
para leer, en nuestro 00:02:09
caso para leer caracteres, porque es lo que 00:02:14
tiene, hacer la lectura 00:02:16
y luego ya cerrar 00:02:20
esto es lo que va a ver que hace 00:02:26
para desbloquear 00:02:33
el recurso 00:02:41
Cuando tú abres un objeto que está asociado a un recurso externo, sea un fichero, sea un socket, sea algo, pues ese recurso se queda con el sistema de protección de procesos, con los semáforos, con todo eso, se queda bloqueado para que accedan otros procesos. 00:02:42
Entonces, si tú no cierras ese flujo y otro programa quiere acceder a ese archivo, no puedes, no puedes, ¿vale? Cerrarlo es liberarlo. Yo ya me desentiendo de ese fichero, ya se queda liberado, ¿vale? 00:03:01
Que si no lo hace, cuando la aplicación termina, se van a liberar igual todos los recursos que tenga asociados, pero la aplicación podría no terminar y hacer más cosas. 00:03:17
Vale, pues venga, abrir fichero para leer caracteres 00:03:25
Vale, pues vamos a hacerlo con la clase básica 00:03:28
Pues si FileWriter era 00:03:31
Perdón, FileWriter era para 00:03:34
Escribir caracteres 00:03:36
Pues para leer será esta, tiene toda la pinta, ¿verdad? 00:03:37
Que también la instanciamos 00:03:44
Así, vale 00:03:46
Entonces 00:03:49
Aquí lo mismo 00:03:50
Vamos a 00:03:52
Pedir el nombre del fichero 00:03:55
A ver 00:03:57
Me estoy copiando el escáner para leer el nombre del fichero. 00:04:03
Ahora voy a volver a preguntarle de qué fichero quiere. 00:04:18
Vale, nombre fichero. 00:04:30
Y yo aquí podría pasarle este nombre también directamente. 00:04:46
Entonces, estos import que estamos haciendo automáticamente, 00:05:03
mirad que son todos de javaio 00:05:06
los que estamos haciendo aquí automáticamente 00:05:08
bueno pues a ver 00:05:10
file writer ya es un poco más peliaguda 00:05:16
primero porque 00:05:18
aquí te dice oye cuidado 00:05:20
te puede salir una excepción 00:05:22
de tipo file not found 00:05:25
exception 00:05:27
claro porque file writer si el fichero no existe 00:05:27
no pasa nada lo crea 00:05:31
y ya está 00:05:32
como es para escribir yo quiero escribir 00:05:33
no existe pues te lo creo y escribes 00:05:36
pero si es para leer 00:05:38
si el fichero no existe 00:05:40
aquí sí que te da una excepción 00:05:43
no lo crea nuevo para que tú leas 00:05:44
del vacío, no lo puede crear e inventarse 00:05:47
la información 00:05:49
entonces por eso te dice, cuidado que puedes 00:05:49
lanzar una file not found exception 00:05:53
a ver, podríamos capturarla y decir 00:05:54
el fichero no existe, pero bueno 00:05:56
vamos a hacer otra cosa 00:05:58
vale, recordad la clase file 00:06:00
que hemos dicho antes, la clase file 00:06:04
tú la puedes asociar a un archivo 00:06:06
cualquiera, para sacar 00:06:08
información sobre ese archivo 00:06:10
por ejemplo, me voy a crear yo este objeto 00:06:11
file de aquí 00:06:14
asociado a este 00:06:15
vale, pues este objeto 00:06:18
file de aquí, que está asociado 00:06:31
también a ese archivo, no me vale 00:06:33
para leer y escribir, ni nada de eso 00:06:35
pero si me vale para sacar 00:06:37
información sobre ese archivo 00:06:38
por ejemplo, pues 00:06:40
si el fichero existe 00:06:43
vale 00:06:44
entonces, por ejemplo 00:06:46
Pues puedo hacer yo 00:06:48
Si el fichero 00:06:49
Vamos a ver que métodos tiene 00:06:52
Este de aquí 00:06:53
Vale, pues esta clase 00:06:54
Tiene un montón de métodos para sacar información 00:07:11
Si tienes permiso de ejecución 00:07:13
Si tienes permiso de lectura 00:07:14
Para 00:07:16
Si es un directorio 00:07:18
Si es un fichero 00:07:21
Vale, para cambiarle el nombre 00:07:22
Bueno, ya probaremos algunos 00:07:25
Pero en particular 00:07:27
tiene uno que es 00:07:29
este 00:07:31
que es para ver si existe o no 00:07:33
no sabe mucho, tiene muy buena vista 00:07:34
o las dos cosas 00:07:41
vale, pues entonces yo lo que puedo hacer es 00:07:42
si el fichero no existe 00:07:47
pues si el fichero no existe no tiene sentido 00:07:49
leer nombres, pues ya directamente 00:07:51
irme y se acabó 00:07:53
me voy, no hago nada 00:07:55
no modifico el map, no hago nada 00:07:57
vale 00:07:59
si el fichero no existe, me voy 00:08:02
y ya está, vale 00:08:06
Vale, si el fichero existe 00:08:07
Yo ya sigo por aquí 00:08:18
Yo ya sigo por aquí 00:08:19
Aquí, en cualquier caso 00:08:20
File not found, la tengo que capturar 00:08:24
O la tengo que propagar 00:08:26
Pero bueno, aquí me es mucho más cómodo 00:08:27
Sé que no me va a salir, porque ya me iría por aquí 00:08:30
Si el fichero no existe 00:08:32
Entonces me es mucho más cómodo 00:08:33
Mandar el aviso arriba y ya está 00:08:35
Vale 00:08:37
Ah, vale 00:08:38
vale, pues venga, ahora abrir el fichero para leer caracteres 00:08:50
ala, ya está abierto, entonces al constructor de FileReader como al de FileWriter 00:08:54
se le puede pasar tanto el nombre del fichero como el propio objeto file 00:08:58
vale, admite ambas variantes 00:09:02
entonces yo aquí le puedo pasar file también y ya está 00:09:05
es lo mismo, vale, un momento que voy a conectar la batería 00:09:10
aquí si vemos los métodos que tiene este 00:09:14
si vemos los métodos que tiene el file 00:09:21
reader, en particular los 00:09:28
de lectura 00:09:32
vale 00:09:33
pues a ver 00:09:35
tiene muchas posibilidades de métodos 00:09:38
esto, leer todo como si 00:09:40
fuera un único stream 00:09:42
vale, pero bueno, vamos a irnos 00:09:44
al básico para aprender 00:09:46
a hacer un bucle de lectura 00:09:48
entonces, tiene este método 00:09:49
que es el método básico para leer 00:09:52
vale, el de leer 00:09:54
Y ahora 00:09:55
Ahora, este método 00:09:57
Me dice 00:10:01
La ayuda que me devuelve 00:10:03
Esto 00:10:06
¿Vale? Esto lo vamos a meter ahora en un bucle 00:10:07
Claro, vale 00:10:10
Entonces, este me puede 00:10:13
Dar una excepción, vamos a quitarla cuanto antes 00:10:16
De ioException, vamos a, como no estamos 00:10:18
En el main todavía 00:10:20
No estamos en el main, vamos a propagarla 00:10:21
Para no emborronar 00:10:24
Mucho esto, vamos a propagarla 00:10:26
Vale 00:10:28
vale, a ver, y el rojo 00:10:28
es de arriba, vale 00:10:37
vale, entonces 00:10:39
vamos a completar 00:10:41
ahora esto, claro, a ver, ¿qué hace este método? 00:10:43
que es el método básico 00:10:45
¿qué hace este método? 00:10:46
el fichero se ha abierto para leer 00:11:01
¿vale? está posicionado internamente 00:11:03
ahí, para leer, ¿qué hace este método? 00:11:05
te coge 00:11:08
un único carácter 00:11:09
un byte de 8 bits, un único carácter 00:11:12
te lo 00:11:14
guarda en una variable 00:11:16
de tipo int 00:11:18
con lo cual tiene 00:11:19
4 bytes, ¿dónde te lo guarda? 00:11:22
aquí 00:11:24
en el menos significativo 00:11:25
y el resto lo rellena 00:11:28
todo con ceros 00:11:30
vale, y diréis 00:11:31
vosotros, ¿qué necesidad tiene 00:11:34
de devolvértelo 00:11:36
en una variable int cuando son solo 00:11:38
8 bits? podría devolvértelo en una variable 00:11:40
char, en una variable byte que tiene solo 00:11:42
8 bits, ¿qué necesidad tiene 00:11:44
devolverte una indie y completarlo toda con ceros? 00:11:45
Bueno, pues 00:11:49
esa necesidad viene 00:11:50
por el hecho de que 00:11:51
se habilita la opción de avisarte 00:11:53
si has llegado al final 00:11:56
porque la lectura 00:11:57
cada vez que se hace una lectura, tú lees 00:11:59
un carácter y lo guardas 00:12:01
e internamente te quedas posicionado 00:12:03
en el siguiente, con el siguiente 00:12:05
read que hagas, lees un carácter 00:12:07
y lo guardas, y te quedas 00:12:10
internamente posicionado en el siguiente, así 00:12:11
llegará un momento 00:12:13
en que ya haya un read 00:12:15
que buf, error 00:12:18
porque ya me he salido 00:12:20
llegará un momento en que me haya salido, tú no sabes cuándo va a ser 00:12:21
porque no sabes esto como de largo es 00:12:24
entonces 00:12:25
cuando el fread este de aquí 00:12:27
intenta leer ya fuera 00:12:30
porque se ha salido 00:12:34
lo que hace es 00:12:35
devolverte el número 00:12:38
menos 1 00:12:39
que el menos 1 00:12:41
Pues en complemento a 1, ya sabéis que es todo unos en realidad. 00:12:43
Entonces, la forma que tiene este método de avisar, 00:12:49
oye, que lo que te estoy devolviendo ya no es válido, 00:12:51
no es un carácter porque me he salido, 00:12:53
es devolviéndote todo unos aquí, 00:12:56
o lo que es lo mismo devolviéndote el entero menos 1. 00:12:58
Y en cualquier otro caso, cuando ha leído un char válido, 00:13:01
lo que te devuelve son todos ceros aquí, 00:13:05
y aquí el char que sea. 00:13:07
Y aquí el char que sea. 00:13:09
¿Vale? 00:13:13
entonces, si lo guardara 00:13:15
único char, no habría 00:13:17
forma de avisar si es un 00:13:19
char válido o estoy al final 00:13:21
salvo por excepción, por supuesto, ponernos 00:13:23
file exception que también existe 00:13:25
¿vale? pero esto es más cómodo 00:13:26
porque no tienes que capturar 00:13:29
si lo que me devuelve el fread es 00:13:30
menos uno, es que ya he terminado 00:13:33
bueno, pues vamos a meterlo en un bucle 00:13:35
entonces, vamos a meterlo en un bucle 00:13:37
de lectura 00:13:39
y nos quedaría 00:13:40
y ya vamos a terminar 00:13:44
por ejemplo, lo vamos a arreglar ahora 00:13:49
para que quede más bonito 00:13:57
vale, bueno, no, como si es muy listo 00:14:00
vamos a hacer directamente ya en el 00:14:08
dentro del bucle 00:14:10
while c 00:14:12
siendo c que el resultado 00:14:17
de leer sea 00:14:19
diferente 00:14:25
de menos uno 00:14:27
vale, pues 00:14:28
este es el bucle de lectura estándar del file 00:14:55
real, vale 00:14:57
Entonces un bucle que está todo el rato 00:14:59
Lee C, haz con él lo que sea 00:15:02
Mientras como no ha sido menos uno 00:15:04
Lee C, no ha sido menos uno 00:15:07
Haz con él lo que sea 00:15:10
Lee C, no ha sido menos uno 00:15:11
Haz con él lo que sea 00:15:13
Cuando el C que acabas de leer ya sea menos uno 00:15:14
Ya el bucle ha terminado 00:15:17
Porque has sacado el fichero 00:15:18
¿Vale? Es el típico bucle de lectura 00:15:19
Y aquí con este C 00:15:21
Irá siendo los sucesivos caracteres 00:15:23
Ese C irá siendo los sucesivos caracteres 00:15:26
¿Qué hacemos con ese C? 00:15:28
Pues lo que nos interesa a nosotros 00:15:31
En nuestro caso en particular 00:15:33
Lo que queríamos era 00:15:35
Leer todos los nombres 00:15:36
¿Vale? Pues vamos a 00:15:40
Concatenarlo en un string 00:15:41
Y de ahí ya lo sacamos 00:15:43
Por ejemplo, podemos hacer esto 00:15:44
¿Vale? 00:15:46
Entonces, vamos todos concatenándolo 00:16:00
A un string grande que los tiene todos 00:16:03
Ahora ya los vamos a separar 00:16:05
Y ya está 00:16:07
Vale, este bucle de lectura está entendido 00:16:07
Mientras C, siendo C lo que acabo de leer 00:16:13
No es la marca de fin de archivo 00:16:15
Hago con C lo que sea 00:16:17
Y luego el siguiente, luego el siguiente, luego el siguiente 00:16:19
¿Vale? Ya está, ese es el bucle de lectura 00:16:21
Y se acabó 00:16:23
Y ahora ya, en particular nosotros, ¿qué estamos haciendo? 00:16:24
Ya para practicar 00:16:27
Bueno, estamos concatenando todos 00:16:28
Entonces, este string 00:16:31
Va a ser todo esto 00:16:33
Este string va a ser 00:16:35
Esta lista de aquí 00:16:37
Este string va a ser todo esto 00:16:39
¿qué podemos hacer nosotros en nuestro caso particular? 00:16:40
vamos a hacer un split 00:16:44
con el salto de línea, un split 00:16:45
y ya está, ya tenemos los nombres 00:16:46
separados 00:16:48
es decir, vamos a hacernos 00:16:49
yo ya tendré 00:16:57
aquí en S todos los nombres 00:16:58
vale, pues S si yo me hago 00:17:00
un split en torno 00:17:02
al salto de línea 00:17:06
este split 00:17:08
¿qué me va a dar? un array 00:17:12
con todos los nombres 00:17:14
Y yo un array lo puedo convertir en lista 00:17:15
¿Verdad? 00:17:22
No hay un método de arrays 00:17:24
As list 00:17:26
Que yo le doy un array 00:17:28
Nombres 00:17:30
Y este para afuera 00:17:31
Return 00:17:34
Porque este leer nombres 00:17:35
Ah no, return no 00:17:41
Porque vamos a guardar directamente aquí en nombres 00:17:43
Pues nombres igual 00:17:45
Nombres igual 00:17:47
Ah, no, perdón 00:17:56
Claro, es que esto utiliza el mismo nombre 00:18:02
Vale, pues entonces 00:18:04
En lugar de cambiarle el nombre 00:18:06
Lo voy a hacer más bonito todavía 00:18:11
Porque ya somos todos muy listos 00:18:12
Y ya no hace falta que programemos 00:18:14
Todo el rato algo 00:18:17
¿Dónde está el salto? 00:18:17
En el bucle 00:18:30
A ver, es que cuando yo esté haciendo 00:18:31
Todos los caracteres en mi fichero 00:18:33
el salto de línea es un carácter también 00:18:36
es decir, mi string va a tener 00:18:39
esto, luego esto concatenado 00:18:41
luego esto, luego este salto de línea 00:18:43
lo va a tener ahí también concatenado 00:18:45
porque es un carácter más 00:18:47
que está leyendo y concatenando 00:18:49
luego este, luego otro 00:18:51
salto de línea que va a leer y que va a concatenar 00:18:53
entonces en este string 00:18:55
ese de aquí 00:18:57
en este string de aquí 00:18:58
van a estar todos estos 00:19:01
char concatenados 00:19:03
incluidos los saltos de línea 00:19:05
todos, que es un char más que está leyendo 00:19:08
es un char más, lo que hay aquí es otro char más 00:19:10
que estará leyendo 00:19:11
entonces este string 00:19:12
de aquí 00:19:15
vale 00:19:17
yo ahora ya lo que quiero hacer con este string 00:19:18
es hacerle un split para que lo separen cachos 00:19:21
esos cachos en torno 00:19:24
a que separador 00:19:25
pues el separador este, el carácter salto de línea 00:19:26
vale 00:19:30
entonces 00:19:32
Este split ya me saca un array 00:19:33
De nombres 00:19:35
Y ese array lo convierto en una lista 00:19:37
Y esa lista la guardo aquí 00:19:40
La guardo aquí, que es esta 00:19:41
La que yo quería rellenar 00:19:45
¿Vale? ¿Entendido más o menos? 00:19:47
¿Dónde estamos? 00:19:51
Aquí 00:19:53
¿Hasta dónde? 00:19:53
¿Dónde quieres que llegue? 00:20:01
Vale, esta es la excepción 00:20:04
¿Más? 00:20:06
¿Qué le pasa al salto de línea? 00:20:12
El salto de línea está aquí 00:20:17
Cuando yo he hecho guardar fichero 00:20:19
Aquí 00:20:21
Sí, sí 00:20:21
¿El menos uno te lo devuelve cuando la siguiente línea no hay nada? 00:20:26
No, cuando ya está 00:20:31
Cuando el archivo se ha cobrado 00:20:31
Claro, cuando ya leíste el último 00:20:33
Y ese intento ya no vale 00:20:35
Cuando ese intento ya no vale 00:20:37
Otra pregunta 00:20:39
¿El build solamente te cuenta el primer carácter? 00:20:40
Solo te lee un carácter 00:20:45
Y se queda ya posicionado internamente en el siguiente 00:20:46
por si tú quisieras hacer un siguiente read. 00:20:49
O sea, te va contando carácter por carácter. 00:20:53
Claro, carácter por carácter. 00:20:55
Cada read te pasa al siguiente. 00:20:57
Te lee ese y te pasa al siguiente. 00:20:58
Siguiente read, te lee ese y te apunta al siguiente. 00:21:00
Entonces, cada read te va leyendo 00:21:04
y se queda avanzado una posición para el siguiente read, 00:21:06
si lo hicieras. 00:21:09
La cabecera de leer nombres que está aquí. 00:21:16
file not found excepción 00:21:24
se ha cambiado 00:21:30
claro, porque file not found excepción 00:21:30
hereda de io excepción 00:21:33
entonces al propagar io excepción 00:21:34
ya no hace falta que pongas io excepción 00:21:37
como file not found, porque esa incluye la otra 00:21:39
por eso lo ha eliminado 00:21:41
¿vale? 00:21:43
de hecho si la forzáramos aquí para que propagara 00:21:45
los dos 00:21:47
file not found, algo me diría al respecto 00:21:48
excepción 00:21:55
me diría 00:21:57
File not found exception 00:22:01
Ya, pero 00:22:04
Si la 00:22:05
Pongo bien 00:22:07
Vale, dejarte deja 00:22:10
Pero es que esta hereda de esta otra 00:22:12
Con lo cual no es necesaria 00:22:14
Vale 00:22:15
La puedes quitar 00:22:16
Que cuando, antes de hacer el file 00:22:19
Reader 00:22:25
No, perdón, antes de hacer el read 00:22:26
Cuando habíamos hecho el new solamente 00:22:29
es decir, si esto no existía 00:22:31
cuando esto no existía 00:22:36
el f real no existía 00:22:37
y yo no había hecho este 00:22:40
throws todavía 00:22:44
cuando ese real no existía, la única 00:22:45
sentencia que podía provocar excepción 00:22:49
era esta, y cuál era 00:22:51
la de file not found exception 00:22:53
entonces yo la digo, venga, la propago 00:22:54
y la tengo aquí propagada 00:22:57
entonces ahora ya 00:23:00
cuando habilito este 00:23:02
esta otra parte 00:23:04
esta otra parte 00:23:06
puede provocar 00:23:09
io exception 00:23:11
entonces si yo la propago 00:23:11
si yo la propago 00:23:14
pues aquí tendría que decir 00:23:16
oye además de file not found exception 00:23:18
además puede 00:23:20
lanzar io 00:23:22
exception 00:23:24
vale 00:23:26
y lo puedo dejar así 00:23:28
y no pasa nada, pero esto es redundante 00:23:30
Porque FileNotFoundException 00:23:33
Hereda de esta otra 00:23:35
Entonces, si lanza IOSception 00:23:37
Estoy ya avisando de que puede lanzar 00:23:41
Cualquiera de las subclases también 00:23:43
Entonces esta la puedo quitar 00:23:45
Que es lo que me ha hecho el Eclipse solo 00:23:47
Lo que me ha hecho el Eclipse solo es quitar esta 00:23:48
Y aquí ya 00:23:51
En algún sitio 00:24:00
Vale 00:24:01
Entonces leer nombres 00:24:05
Pues bueno, ya está 00:24:06
Ya tiene los nombres ahí leídos 00:24:08
Vale 00:24:10
Esta ya me dice 00:24:12
Pues 00:24:17
Trycatch 00:24:18
Lee nombres, ya está 00:24:21
No se ha podido leer 00:24:22
Le ponemos aquí que no se ha podido leer 00:24:25
Lo probamos 00:24:27
Y nos damos por satisfechos 00:24:29
Hacer la lectura 00:24:31
No lo he cerrado 00:24:38
Se me ha olvidado, ¿no? 00:24:47
No, no, no, es que se me ha olvidado cerrarlo 00:24:49
Sí, sí, sí 00:24:51
vale, ahora me tocaría 00:24:53
hacer el 00:24:55
fr.close 00:24:56
vale 00:24:59
vamos a ver si hemos hecho algo mal 00:25:01
entonces voy a eliminar este 00:25:03
para ponerle 00:25:04
en lugar de añadirle 00:25:06
10 nombres, añadirle solo 2 00:25:09
para no estar 00:25:11
aquí, le vamos a añadir 00:25:13
solamente 2 00:25:18
y que cuando escriba 00:25:19
añada los que ya hubiera 00:25:23
En guardar 00:25:25
En guardar nombres 00:25:26
Guardar 00:25:29
Le voy a poner true 00:25:31
Para que me añada los que ya hubiera 00:25:33
Y voy a ver si el funcionamiento 00:25:35
Que sale es coherente o hemos hecho algo raro 00:25:37
Vale, esto es 00:25:39
Lo primero que hace es pedirme el fichero 00:25:44
Para leer los nombres iniciales 00:25:46
Vale, el fichero 00:25:49
Le voy a dar cualquier cosa, no tiene nada 00:25:50
El fichero no va a existir, con lo cual me ignora 00:25:52
Vale, me ignora 00:25:54
Esto que ha hecho ahora es, como el fichero no existe 00:25:56
Ha hecho el leer nombres 00:25:59
Ha hecho este, leer nombres 00:26:00
Pero como el fichero que le he dado no ha existido 00:26:02
Ha salido, y ya está 00:26:05
Eso es lo primero que ha hecho, leer nombres 00:26:07
Ahora, me empieza a pedir los nombres 00:26:08
Que van a ser dos solo 00:26:11
Vale 00:26:12
Este y este 00:26:14
Y en qué fichero 00:26:16
Quiere guardar, pues nombres 00:26:19
Vale 00:26:21
entonces 00:26:22
aquí están 00:26:28
perdón, aquí están 00:26:29
refresh 00:26:35
¿dónde está? 00:26:36
vale, aquí están 00:26:42
venga, ahora 00:26:43
vamos a trabajar con la aplicación 00:26:47
añadiendo otros dos nombres más 00:26:49
entonces lo primero que va a hacer 00:26:51
leer es el fichero 00:26:53
y que yo le ponga añadirlos 00:26:54
a esos 00:26:57
Añadirlos a esos 00:26:58
Pues venga, vamos a ver si hace eso 00:26:59
Nombre del fichero 00:27:02
Lo he llamado nombre sin más, no sin txt 00:27:04
Pues nombre del fichero 00:27:06
Nombres 00:27:08
Entonces, va a leer esos dos 00:27:09
Si lo hemos hecho bien, los va a guardar 00:27:12
En la lista 00:27:14
Se supone que está en la lista 00:27:15
Ahora voy a añadir otros dos 00:27:17
Pues aquí ya hay una cosa que hemos hecho mal 00:27:19
Anx 00:27:24
Que poca información me da 00:27:26
Uff, qué mal rollo estaba aquí. 00:27:29
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
1
Fecha:
17 de marzo de 2026 - 13:14
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
27′ 47″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
600.61 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid