Tema 1 Acceso a Datos DAM Ilerna

¿Qué es un fichero?. Un fichero es un archivo que contendrá un conjunto de caracteres o bytes que se almacenarán en una ruta y con un nombre concretos. Un fichero es un archivo que contendrá un conjunto de caracteres o bytes que se almacenarán en una ruta y con un nombre aleatorio. Un fichero es un archivo que contendrá un conjunto de símbolos o bytes que se almacenarán en una ruta y con un nombre concretos. Un fichero es un archivo que contendrá un conjunto de caracteres o bits que se almacenarán en una ruta y con un nombre concretos.

¿Para qué usa nuestro programa el fichero?. Para almacenar, leer, escribir o gestionar información sobre el proceso que se está ejecutando. Para almacenar, leer, escribir o gestionar información sobre todas las aplicaciones del sistema. Para almacenar, leer, escribir o gestionar información sobre el proceso no se está ejecutando. Para almacenar, leer, escribir o gestionar información sobre el proceso que se ejecutará a continuación.

¿Qué tipos de ficheros hay?. Fichero estándar, directorios o carpetas y ficheros especiales. Ficheros de datos, ficheros del sistema, ficheros de aplicación. Ficheros normales, directorios, ficheros especiales. Ficheros de gestión, ficheros estándar, ficheros del sistema.

¿Qué es un fichero estándar?. Es un fichero que contiene todo tipo de datos. Es un fichero que contiene todo tipo de datos en formato binario. Es un fichero que contiene los datos para arrancar el sistema. Es un fichero que contiene todo tipo de datos de una aplicación concreta.

¿Qué es un directorio o carpeta?. Ficheros que albergan más archivos en su interior. Su principal utilidad es mantener un orden o jerarquía en nuestro sistema. Ficheros que albergan más archivos en su interior. Su única utilidad es mantener un orden o jerarquía en nuestro sistema. Ficheros que albergan más archivos en su interior de manera limitada. Su principal utilidad es mantener un orden o jerarquía en nuestro sistema. Ficheros que albergan hasta diez archivos en su interior. Su principal utilidad es mantener un orden o jerarquía en nuestro sistema.

¿Qué son los ficheros especiales?. Ficheros que se usan para controlar los dispositivos o periféricos de nuestro ordenador. Ficheros que contienen información de cualquier tipo. Ficheros que contienen información de todos los programas del sistema. Ficheros que contienen información del sistema operativo.

Tipos de ficheros de datos: Ficheros de bytes, ficheros de caracteres. Ficheros de programa, ficheros de sistema. Ficheros alfabéticos, ficheros numéricos. Ficheros estándar, ficheros especiales.

Un fichero se caracteriza por: Estar formado por la ruta en la que está almacenado, el nombre y una extensión, siguiendo este orden. Estar formado por el nombre, la ruta en la que está almacenado y una extensión, siguiendo este orden. Estar formado por la ruta en la que está almacenado, una extensión y el nombre, siguiendo este orden. Ninguna de las demás es correcta.

Para acceder a un archivo determinado, se utiliza: Una ruta o path. Una ruta o dir. Una ruta o file. Una ruta o folder.

¿Cómo separamos los distintos niveles jerárquicos de una ruta en Windows?. Carácter \. Carácter /. Carácter . Todos son correctos.

¿Cómo separamos los distintos niveles jerárquicos de una ruta en Unix?. Carácter /. Carácter \. Carácter . / o \, indistintamente.

¿Cómo separamos los distintos niveles jerárquicos de una ruta en Eclipse?. / o \, indistintamente. Carácter \. Carácter . Carácter /.

¿Cómo definimos una ruta independientemente del sistema operativo?. //Ejemplo con la ruta directa al string File archivoNoseguro = new File(“carpeta/ejemplo.txt”); //Ruta que asegura el separador correcto segun plataforma File archivo = new File(“carpeta”+File.separator+”ejemplo.txt”);. //Ejemplo con la ruta directa al string File archivoNoseguro = new File(“carpeta/ejemplo.txt”); //Ruta que asegura el separador correcto segun plataforma File archivo = new File(“carpeta”,File.separator,”ejemplo.txt”);. //Ejemplo con la ruta directa al string File archivoNoseguro = new File(“carpeta/ejemplo.txt”); //Ruta que asegura el separador correcto segun plataforma File archivo = new File(“carpeta”+“File.separator”+”ejemplo.txt”);. //Ejemplo con la ruta directa al string File archivoNoseguro = new File(“carpeta/ejemplo.txt”); //Ruta que asegura el separador correcto segun plataforma File archivo = new File(“carpeta”,“File.separator”,”ejemplo.txt”);.

¿Qué dos tipos de ruta hay en la gestión de ficheros?. Ruta absoluta y ruta relativa. Ruta absoluta y ruta directa. Ruta absoluta y ruta indirecta. Ruta directa y ruta indirecta.

¿Cuál es la ruta absoluta?. Ruta desde la carpeta padre del sistema. Ruta que tiene como referencia el directorio actual. Ruta desde la carpeta anterior a la que me encuentro. Ruta desde la carpeta padre más cercana.

¿Cuál es la ruta relativa?. Ruta que tiene como referencia el directorio actual. Ruta que tiene como referencia el directorio actual y el directorio padre. Ruta que tiene como referencia el directorio actual y el directorio hijo. Ruta que tiene como referencia el directorio actual y el directorio al que me dirijo.

Ejemplo de ruta relativa: . /tema1/ejercicio.txt. C:/Ilerna/accesoDatos/tema1/ejercicio.txt. C::/Ilerna/accesoDatos/tema1/ejercicio.txt. .../tema1/ejercicio.txt.

Ejemplo de ruta absoluta: C:/Ilerna/accesoDatos/tema1/ejercicio.txt. . /tema1/ejercicio.txt. C::/Ilerna/accesoDatos/tema1/ejercicio.txt. .../tema1/ejercicio.txt.

La extensión del archivo nos permite diferenciar: Qué programa puede utilizar el fichero. Qué programa ha creado el fichero. Qué programa ha ejecutado el fichero. Qué programa ha usado el fichero.

Se considera extensión a: Todo lo que podemos encontrar después del punto que ponemos al final del nombre. Todo lo que podemos encontrar después del punto que ponemos al principio del nombre. Todo lo que podemos encontrar antes del punto que ponemos al final del nombre. Todo lo que podemos encontrar antes del punto que ponemos al principio del nombre.

El fichero se guarda según: La codificación del dispositivo que estamos usando. La carpeta padre en la que nos encontramos. El sistema operativo del dispositivo que estamos usando. La aplicación que estamos usando.

¿Cómo se almacenan los caracteres en nuestro ordenador?. Como uno o más bytes. Como uno o más bits. Cada carácter corresponde a un byte. Cada carácter corresponde a un bit.

¿Qué es el encoding?. Sistema utilizado para transformar los caracteres que usa cada lenguaje en un símbolo que el ordenador pueda interpretar. Sistema utilizado para transformar los caracteres que usa cada lenguaje en un símbolo que el ordenador pueda ejecutar. Sistema utilizado para transformar los caracteres que usa cada lenguaje en un tipo de dato que el ordenador pueda interpretar. Sistema utilizado para transformar los caracteres que usa cada lenguaje en un tipo de dato que el ordenador pueda ejecutar.

¿Qué es la codificación de caracteres?. Es un conjunto de asignaciones entre los bytes del ordenador y los caracteres en el conjunto de caracteres. Es un conjunto de asignaciones entre los bits del ordenador y los caracteres en un conjunto de caracteres. Es un conjunto de asignaciones entre los bits del ordenador y los caracteres en el conjunto de caracteres. Es un conjunto de asignaciones entre los bytes del ordenador y los caracteres en un conjunto de caracteres.

La codificación de caracteres: Asigna caracteres escogidos a bytes específicos en la memoria del ordenador, y luego, para mostrar el texto, lee los bytes nuevamente en caracteres. Asigna direcciones escogidas a bytes específicos en la memoria del ordenador, y luego, para mostrar el texto, lee los bytes nuevamente en caracteres. Asigna caracteres escogidos a bytes específicos en la memoria del ordenador, y luego, para mostrar el texto, lee los bits nuevamente en caracteres. Asigna direcciones escogidas a bytes específicos en la memoria del ordenador, y luego, para mostrar el texto, lee los bits nuevamente en caracteres.

La codificación de caracteres se basa en: Crear tablas de equivalencia. Crear patrones comunes. Crear patrones de equivalencia. Crear tablas de correspondencia.

¿Qué es el codigo ASCII?. Conjunto de caracteres creado por la American National Standard Code of Information (ANSI). Codifica caracteres, letras y símbolos. Conjunto de caracteres creado por la American National Standard Code of Information (ANSI). Codifica caracteres y letras únicamente. Conjunto de caracteres creado por la American National Standard Code of Information (ANSI). Codifica caracteres, letras, símbolos y patrones. Conjunto de caracteres creado por la American National Standard Code of Information (ANSII). Codifica caracteres, letras y símbolos.

¿Qué es ISO-8895?. Encoding que incluye letras, símbolos, caracteres, acentos y símbolos de interrogación y exclamación. Utiliza 8 bits, por lo que tiene capacidad para 256 caracteres. Encoding que incluye letras, símbolos, caracteres, acentos y símbolos de interrogación y exclamación. Utiliza 8 bytes, por lo que tiene capacidad para 512 caracteres. Encoding que incluye letras, símbolos, caracteres, acentos y símbolos de interrogación y exclamación. Utiliza 8 bytes, por lo que tiene capacidad para 256 palabras. Encoding que incluye letras, símbolos, caracteres, acentos y símbolos de interrogación y exclamación. Utiliza 8 bytes, por lo que tiene capacidad para 256 caracteres.

¿Qué es Unicode?. Norma para unificar los tipos de codificación creado en 1991. Norma para unificar los tipos de codificación creado en 1993. Norma para unificar los tipos de codificación creado en 1995. Norma para unificar los tipos de codificación creado en 1997.

¿Cómo funciona Unicode?. Unicode asigna un identificador numérico a cada carácter, pero también irá acompañado de información como la direccionalidad, la capitalización y otros atributos. Nuestro ordenador, según su arquitectura, utilizará diferentes bloques de 8, 16 o 32 bits para interpretar y representar los números. Unicode asigna un identificador numérico a cada carácter, pero también irá acompañado de información como la direccionalidad, la capitalización y otros atributos. Nuestro ordenador, según su arquitectura, utilizará diferentes bloques de 8 o 32 bits para interpretar y representar los números. Unicode asigna un identificador numérico a cada carácter, pero también irá acompañado de información como la direccionalidad, la capitalización y otros atributos. Nuestro ordenador, según su arquitectura, utilizará diferentes bloques de 8 o 64 bits para interpretar y representar los números. Unicode asigna un identificador numérico a cada carácter, pero también irá acompañado de información como la direccionalidad, la capitalización y otros atributos. Nuestro ordenador, según su arquitectura, utilizará diferentes bloques de 8, 16, 32 o 64 bits para interpretar y representar los números.

¿Qué tipos de codificaciones hay?. UTF-8, UTF-16 y UTF-32. UTF-8 y UTF-16. UTF-8, UTF-16, UTF-32 y UTF-64. UTF-8 y UTF-32.

¿Cuál es el paquete más utilizado en Java?. java.io. java.stdio. java.lang. java.util.

¿Para qué sirve el paquete java.io?. Creación y eliminación de ficheros y carpetas. Creación y eliminación de carpetas únicamente. Creación y eliminación de ficheros únicamente. Únicamente creación de ficheros y carpetas.

¿Qué librerías utilizamos para la creación de archivos?. java.io.File. java.io.Dir. java.io.WriteFile. java.io.CreateFile.

¿Para qué se usa java.io.File?. Solo obtener información de un archivo o una carpeta. Obtener información de un archivo o una carpeta, entre otras funciones. Solo obtener información de un archivo únicamente. Obtener información de un archivo únicamente, entre otras funciones.

¿Qué es un stream?. Librería de java que se utiliza para gestionar flujos de datos, ya sea de ficheros, strings o dispositivos. Trata de manera ordenada una secuencia de datos con un origen y un destino. Librería de java que se utiliza para gestionar flujos de datos, ya sea de ficheros o carpetas. Trata de manera ordenada una secuencia de datos con un origen y un destino. Librería de java que se utiliza para gestionar flujos de datos, ya sea de ficheros o carpetas. Trata de manera desordenada una secuencia de datos con un origen y un destino. Librería de java que se utiliza para gestionar flujos de datos, ya sea de ficheros, strings o dispositivos. Trata de manera desordenada una secuencia de datos con un origen y un destino.

Los datos datos que se leen desde un stream: No se guardan en ningún sitio, es decir, no se guardan en caché. No se guardan en ningún sitio, es decir, no se guardan en memoria ROM. Se guardan en memoria caché. Se guardan en memoria ROM.

Para crear un nuevo objeto, debemos: Declarar una nueva instancia del objeto File, al cual le pasaremos el nombre de la ruta, el nombre del fichero que queramos crear y la extensión en un string. Declarar una nueva instancia del objeto File, al cual le pasaremos el nombre de la ruta y el nombre del fichero que queramos crear. Declarar una nueva instancia del objeto File, el nombre del fichero que queramos crear y la extensión en un string. Declarar una nueva instancia del objeto File, al cual le pasaremos el nombre de la ruta, el nombre del fichero que queramos crear y la extensión en un stream.

File (File padre, String hijo). Crea una nueva instancia File a partir de una ruta abstracta padre y una ruta abstracta hija. Crea una nueva instancia File a partir de una ruta abstracta padre y una stream abstracta hija. Crea una nueva instancia File a partir de una stream abstracta padre y una ruta abstracta hija. Ninguna es correcta.

File (String ruta). Crea una nueva instancia de File al convertir el nombre de la ruta dada en un nombre de ruta abstracta. Crea una nueva instancia de File al convertir el nombre de la ruta dada en un nombre de ruta absoluta. Crea una nueva instancia de File al convertir el nombre de la ruta dada en un nombre de ruta relativa. Crea una nueva instancia de File al convertir el nombre de la ruta dada en un nombre de ruta específica.

File (String padre, String hijo). Crea una nueva instancia de File desde una ruta padre a una ruta hija. Crea una nueva instancia de File desde una ruta hija a una ruta padre. Crea una nueva instancia de File desde una ruta padre a una ruta padre. Crea una nueva instancia de File desde una ruta hija a una ruta hija.

File (URI uri). Crea una nueva instancia de File a la cual se le pasará una URI. Una URI es una secuencia de caracteres utilizada para la identificación de un recurso en particular. Crea una nueva instancia de File a la cual se le pasará una URI. Una URI es una secuencia de símbolos utilizada para la identificación de uno o varios recursos. Crea una nueva instancia de File a la cual se le pasará una URI. Una URI es una secuencia de números utilizada para la identificación de un recurso en particular. Crea una nueva instancia de File a la cual se le pasará una URI. Una URI es una secuencia de caracteres utilizada para la identificación de uno o varios recursos.

Tipo File: createTempFile(String prefijo, String sufijo). Crea un archivo vacío en un directorio temporal, usando un prefijo y un sufijo que le pasaremos por parámetro para definir el nombre. Crea un archivo vacío en un directorio temporal, usando un prefijo y un sufijo que le pasaremos por parámetro para definir el estado. Crea un archivo vacío en un directorio temporal, usando un prefijo y un sufijo que le pasaremos por parámetro para definir el modelo. Crea un archivo vacío en un directorio temporal, usando un prefijo y un sufijo que le pasaremos por parámetro para definir la ruta.

boolean createNewFile(). Método que crea un fichero nuevo, vacío y con el nombre que le hayamos pasado al constructor al crear una instancia nueva de File. Método que crea un fichero nuevo, vacío y con la ruta que le hayamos pasado al constructor al crear una instancia nueva de File. Método que crea un fichero nuevo, vacío y con el método que le hayamos pasado al constructor al crear una instancia nueva de File. Método que crea un fichero nuevo, vacío y con la instancia que le hayamos pasado al constructor al crear una instancia nueva de File.

boolean canWrite(). Comprueba si nuestro programa puede escribir datos en el archivo. Comprueba si nuestro programa puede leer datos en el archivo. Comprueba si nuestro programa puede ejecutar datos en el archivo. Comprueba si nuestro programa puede escribir, leer o ejecutar datos en el archivo.

boolean canExecute(). Comprueba si nuestro programa puede ejecutar datos en el archivo. Comprueba si nuestro programa puede leer datos en el archivo. Comprueba si nuestro programa puede escribir datos en el archivo. Comprueba si nuestro programa puede escribir, leer o ejecutar datos en el archivo.

boolean canRead(). Comprueba si nuestro programa puede leer datos en el archivo. Comprueba si nuestro programa puede ejecutar datos en el archivo. Comprueba si nuestro programa puede escribir datos en el archivo. Comprueba si nuestro programa puede escribir, leer o ejecutar datos en el archivo.

boolean isAbsolute(). Comprueba si la ruta del fichero es absoluta. Comprueba si la ruta del fichero es relativa. Comprueba si la ruta del fichero es estándar. Comprueba si la ruta del fichero es completa.

boolean isFile(). Comprueba si la nueva instancia creada de File es un archivo o no. Comprueba si la nueva instancia creada de File es una carpeta o no. Comprueba si la nueva instancia creada de File es una ruta o no. Comprueba si la nueva instancia creada de File es un path o no.

String getName(). Devuelve el nombre del archivo o directorio creado. Modifica el nombre del archivo o directorio creado. Elimina el nombre del archivo o directorio creado. Modifica la ruta del archivo o directorio creado.

Path toPath(). Nos devuelve un objeto Path con la información de la ruta absoluta del fichero que hemos creado. Nos devuelve un objeto Path con la información de la ruta relativa del fichero que hemos creado. Nos devuelve un objeto Path con la información de la ruta absoluta del fichero que hemos modificado. Nos devuelve un objeto Path con la información de la ruta relativa del fichero que hemos modificado.

URI toURI(). Construye un objeto URI que representa la ruta abstracta del fichero creado. Construye un objeto URI que representa la ruta absoluta del fichero creado. Construye un objeto URI que representa la ruta relativa del fichero creado. Construye un objeto URI que representa la ruta concreta del fichero creado.

boolean mkdir(). Crea una carpeta con el nombre que le hemos pasado al constructor al crear una nueva instancia File. Crea un archivo con el nombre que le hemos pasado al constructor al crear una nueva instancia File. Modifica una carpeta con el nombre que le hemos pasado al constructor al crear una nueva instancia File. Modifica un archivo con el nombre que le hemos pasado al constructor al crear una nueva instancia File.

boolean delete(). Borra el fichero siempre que esté en la ruta especificada. Modifica el fichero siempre que esté en la ruta especificada. Crea el fichero siempre que esté en la ruta especificada. Abre el fichero siempre que esté en la ruta especificada.

Cuál es el código correcto: File archivo = new File(“C:\\AD\\fichero.txt”); archivo.createNewFile(); if(archivo.createNewFile()) System.out.println("Creado el fichero "+ archivo); else { System.out.println("No se ha creado el fichero"); }. File archivo = new File(“C:\AD\fichero.txt”); archivo.createNewFile(); if(archivo.createNewFile()) System.out.println("Creado el fichero "+ archivo); else { System.out.println("No se ha creado el fichero"); }. File archivo = new File(C:\\AD\\fichero.txt); archivo.createNewFile(); if(archivo.createNewFile()) System.out.println("Creado el fichero "+ archivo); else { System.out.println("No se ha creado el fichero"); }. File archivo = new File(C:\AD\fichero.txt); archivo.createNewFile(); if(archivo.createNewFile()) System.out.println("Creado el fichero "+ archivo); else { System.out.println("No se ha creado el fichero"); }.

Si queremos crear el fichero en una carpeta, deberemos ponerlo así: File directorio = new File(“c:\\AD\\Ejercicios”); directorio.mkdir(); File archivo = new File("c:\\AD\\Ejercicios\\ficheroDos.txt"); archivo.createNewFile(); if(archivo.createNewFile()) System.out.println("Creado el fichero "+ archivo); else { System.out.println("No se ha creado el fichero"); }. File directorio = new File(“c:\\AD\\Ejercicios”); directorio.dir(); File archivo = new File("c:\\AD\\Ejercicios\\ficheroDos.txt"); archivo.createNewFile(); if(archivo.createNewFile()) System.out.println("Creado el fichero "+ archivo); else { System.out.println("No se ha creado el fichero"); }. File directorio = new File(“c:\\AD\\Ejercicios”); directorio.rmdir(); File archivo = new File("c:\\AD\\Ejercicios\\ficheroDos.txt"); archivo.createNewFile(); if(archivo.createNewFile()) System.out.println("Creado el fichero "+ archivo); else { System.out.println("No se ha creado el fichero"); }. File directorio = new File(“c:\\AD\\Ejercicios”); directorio.Filedir(); File archivo = new File("c:\\AD\\Ejercicios\\ficheroDos.txt"); archivo.createNewFile(); if(archivo.createNewFile()) System.out.println("Creado el fichero "+ archivo); else { System.out.println("No se ha creado el fichero"); }.

java.nio.file.Files. Creación, copia, borrado, escritura y lectura de datos. Creación, copia y borrado de datos. Escritura y lectura de datos de un fichero. Ninguna de las demás es correcta.

java.nio.file. permite el almacenaje de la información del fichero en un búfer. permite el almacenaje de la información del fichero en un stream. permite el almacenaje de la información del fichero en un directorio. permite el almacenaje de la información del fichero en memoria RAM.

¿Qué es un búfer?. Un búfer es un bloque de memoria que permite almacenar temporalmente los datos y recorrerlos tantas veces como se desee para tratarlos. Un búfer es un bloque de memoria que permite almacenar persistentemente los datos y recorrerlos tantas veces como se desee para tratarlos. Un búfer es un bloque de memoria que permite almacenar persistentemente los datos y recorrerlos una vez para tratarlos. Un búfer es un bloque de memoria que permite almacenar temporalmente los datos y recorrerlos una vez para tratarlos.

Path createDirectory(Path ruta). Crea un directorio en la ruta indicada. Crea un directorio en la ruta indicada, únicamente absoluta. Crea un directorio en la ruta indicada, únicamente relativa. Crea un directorio en la ruta indicada, únicamente estándar.

Path createFile(Path ruta). Crea un fichero en la ruta indicada. Crea un directorio en la ruta indicada. Crea un fichero en la ruta indicada, únicamente relativa. Crea un directorio en la ruta indicada, únicamente estándar.

Path copy(Path origen, Path destino). Crea una copia de un fichero origen a una ruta destino que le indiquemos. Crea una copia de un directorio origen a una ruta destino que le indiquemos. Crea una copia de un fichero origen a una carpeta destino que le indiquemos. Crea una copia de una carpeta origen a una ruta destino que le indiquemos.

Path createTempDirectory(String prefijo). Crea una carpeta temporal en la aplicación con el nombre que le pasemos como string al llamar al método. Crea una carpeta temporal en la aplicación con el nombre que le pasemos como stream al llamar al método. Crea una carpeta persistente en la aplicación con el nombre que le pasemos como string al llamar al método. Crea una carpeta persistente en la aplicación con el nombre que le pasemos como stream al llamar al método.

Path createTempFile(String prefijo, String sufijo). Este método se encarga de crear un fichero temporal en la carpeta temporal del programa, usando el prefijo y el sufijo que le hemos indicado por parámetro. Este método se encarga de crear un fichero temporal en la carpeta persistente del programa, usando el prefijo y el sufijo que le hemos indicado por parámetro. Este método se encarga de crear un fichero persistente en la carpeta temporal del programa, usando el prefijo y el sufijo que le hemos indicado por parámetro. Este método se encarga de crear un fichero persistente en la carpeta persistente del programa, usando el prefijo y el sufijo que le hemos indicado por parámetro.

void delete(Path ruta). Borra un fichero de la ruta indicada. Borra un fichero con el nombre indicado. Borra un fichero del directorio indicado. Borra un directorio de la ruta indicada.

boolean deleteIfExists(Path ruta). Borra un fichero siempre que exista en la ruta indicada. Borra un fichero siempre que no exista en la ruta indicada. Borra un fichero siempre que exista en la carpeta temporal. Borra un fichero siempre que exista y tenga el nombre especificado.

boolean exists(Path ruta). Comprueba si el fichero que le indicamos existe en la ruta indicada. Comprueba si el fichero que le indicamos no existe en la ruta indicada. Comprueba si el fichero que le indicamos existe en la ruta indicada y se puede modificar. Comprueba si el fichero que le indicamos existe en la ruta indicada y se puede ejecutar.

boolean isDirectory(Path ruta). Comprueba si ese fichero indicado en la ruta es una carpeta o no. Comprueba si ese fichero indicado en la ruta es un archivo o no. Comprueba si ese fichero indicado en la ruta es un modelo o no. Comprueba si ese fichero indicado en la ruta es una carpeta temporal o no.

long size(Path ruta). Devuelve el tamaño del fichero que le indiquemos en la ruta. Comprueba el tamaño del fichero que le indiquemos en la ruta. Modifica el tamaño del fichero que le indiquemos en la ruta. Devuelve el tamaño del fichero que le indiquemos en la ruta y lo amplía.

Path walkFileTree(Path ruta). Este método se encarga de recorrer el árbol de directorios de una ruta recursivamente. Este método se encarga de recorrer el árbol de archivos de una ruta recursivamente. Este método se encarga de recorrer el árbol de ficheros de una ruta recursivamente. Ninguna es correcta.

En este ejemplo, veremos cómo crear un fichero con este paquete de Java. Path ruta = Paths.get("src/main/resources/crearFicheros/file.txt"); Path ejemploArchivo = Files.createFile(ruta); System.out.println("Hemos creado un fichero "+ ejemploArchivo);. Path ruta = Paths.set("src/main/resources/crearFicheros/file.txt"); Path ejemploArchivo = Files.createFile(ruta); System.out.println("Hemos creado un fichero "+ ejemploArchivo);. Path ruta = Paths.get("src/main/resources/crearFicheros"); Path ejemploArchivo = Files.createFile(ruta); System.out.println("Hemos creado un fichero "+ ejemploArchivo);. Path ruta = Paths.set("src/main/resources/crearFicheros"); Path ejemploArchivo = Files.createFile(ruta); System.out.println("Hemos creado un fichero "+ ejemploArchivo);.

Creación de directorios. File archivo = new File("src/main/resources/crearFicheros directorio"); if(archivo.mkdir()) { System.out.println("Creado el directorio "+ archivo); }. File archivo = new File("src/main/resources/crearFicheros"); if(archivo.dir()) { System.out.println("Creado el directorio "+ archivo); }. File archivo = new File("src/main/resources/crearFicheros directorio"); if(archivo.createFile()) { System.out.println("Creado el directorio "+ archivo); }. File archivo = new File("src/main/resources/crearFicheros"); if(archivo.createFile()) { System.out.println("Creado el directorio "+ archivo); }.

Si no existe la carpeta en la ruta especificada a mkdir: Dará un error en la ejecución de nuestro programa. Dará un error en la compilación de nuestro programa. Dará un error en la sintaxis de nuestro programa. El programa acaba normalmente.

¿Cómo controlar posibles errores de mkdir?. String nombre = " src/main/resources/crearFicheros carpetaEjemplo"; Path ruta = Paths.get(nombre); Files.createDirectories(ruta);. String nombre = " src/main/resources/crearFicheros carpetaEjemplo"; Path ruta = Paths.set(nombre); Files.createDirectories(ruta);. String nombre = " src/main/resources/crearFicheros carpetaEjemplo"; Path ruta = Paths.get(nombre); Files.createDir(ruta);. String nombre = " src/main/resources/crearFicheros carpetaEjemplo"; Path ruta = Paths.set(nombre); Files.createDir(ruta);.

java.nio.file.Files nos ofrece la posibilidad de crear directorios: A través del método createDirectories(), al cual le tendremos que pasar la ruta, como en otros objetos. A través del método createDir(), al cual le tendremos que pasar la ruta, como en otros objetos. A través del método createDirectory(), al cual le tendremos que pasar el nombre, como en otros objetos. A través del método createDirectories(), al cual le tendremos que pasar el nombre, como en otros objetos.

¿Qué es un SFTP?. Un SFTP (protocolo de transferencia de archivos) es un programa estandarizado para transferir archivos entre ordenadores de cualquier sistema operativo. Un SFTP (protocolo de transferencia de archivos) es un programa estandarizado para transferir archivos entre ordenadores del mismo sistema operativo. Un SFTP (protocolo de transferencia de archivos) es un programa estandarizado para transferir archivos entre ordenadores de distintos sistema operativos. Un SFTP (protocolo de transferencia de archivos) es un programa estandarizado para transferir archivos entre ordenadores del mismo sistema operativo en una red local.

SFTP es un protocolo: Cliente-Servidor. Cliente-Cliente. Servidor-Servidor. Exclusivamente cliente.

El método delete(): borrará el fichero que le indiquemos según la ruta o lanzará un error si no lo encuentra. borrará el fichero que le indiquemos según la ruta o finalizará el programa normalmente si no lo encuentra. borrará el fichero que le indiquemos según el nombre o lanzará un error si no lo encuentra. borrará el fichero que le indiquemos según el nombre o finalizará el programa normalmente si no lo encuentra.

Código para borrado de archivos: File archivo = new File(“src/main/resources/crearFicheros/fichero.txt “); if(archivo.delete()) { System.out.println(“Hemos borrado un fichero”); }. File archivo = new File(“src/main/resources/crearFicheros/fichero.txt “); if(archivo.del()) { System.out.println(“Hemos borrado un fichero”); }. File archivo = new File(“src/main/resources/crearFicheros/fichero.txt “); if(archivo.deleteFile()) { System.out.println(“Hemos borrado un fichero”); }. File archivo = new File(“src/main/resources/crearFicheros/fichero.txt “); if(archivo.delFile()) { System.out.println(“Hemos borrado un fichero”); }.

Para borrar un fichero, es necesario: Indicarle la ruta y el nombre del fichero, aunque también existe la posibilidad de borrar un fichero ya creado con el mismo método. Crear un nuevo objeto, indicarle la ruta y el nombre del fichero, aunque también existe la posibilidad de borrar un fichero ya creado con el mismo método. Indicarle la ruta y el nombre del fichero, no existe la posibilidad de borrar un fichero ya creado con el mismo método. Crear un nuevo objeto, indicarle la ruta y el nombre del fichero, no existe la posibilidad de borrar un fichero ya creado con el mismo método.

deleteOnExit(): borrará el fichero o el directorio que le indiquemos por ruta absoluta cuando la máquina virtual finalice. borrará el fichero o el directorio que le indiquemos por ruta relativa cuando la máquina virtual finalice. borrará el fichero o el directorio que le indiquemos por ruta estándar cuando la máquina virtual finalice. Ninguna es correcta.

Para el borrado de directorios: Se debe comprobar que esté vacío, si no, no va a borrarse y se lanzara una excepción NoSuchFileException. Se debe comprobar que esté vacío, si no, no va a borrarse y se lanzara una excepción NoSuchDirectoryException. Se debe comprobar que esté vacío, si no, no va a borrarse y se lanzara una excepción NoSuchDirException. Se debe comprobar que esté vacío, si no, va a borrarse y se lanzara una excepción NoSuchFileException.

Para el borrado de directorios: String nombrePath = " src/main/resources/crearFicheros/directorio"; Path carpeta = Paths.get(nombrePath); Files.delete(carpeta);. String nombrePath = " src/main/resources/crearFicheros/directorio"; Path carpeta = Paths.set(nombrePath); Files.del(carpeta);. String nombrePath = " src/main/resources/crearFicheros/directorio"; Path carpeta = Paths.get(nombrePath); Files.del(carpeta);. String nombrePath = " src/main/resources/crearFicheros/directorio"; Path carpeta = Paths.set(nombrePath); Files.delete(carpeta);.

La forma más fácil de copiar un archivo es: con la API de java.nio. El objeto Files utiliza el método copy(), el cual necesita que se le pase por parámetro la ruta de origen y la ruta de destino, con un objeto Path. La copia fallará si el fichero destino ya existe, pero si utilizamos la opción REPLACE_EXISTING el fichero se sobrescribirá. con la API de java.io. El objeto Files utiliza el método copy(), el cual necesita que se le pase por parámetro la ruta de origen y la ruta de destino, con un objeto Path. La copia fallará si el fichero destino ya existe, pero si utilizamos la opción REPLACE_EXIST el fichero se sobrescribirá. con la API de java.nio. El objeto Files utiliza el método copy(), el cual necesita que se le pase por parámetro la ruta de origen y la ruta de destino, con un objeto Path. La copia fallará si el fichero destino ya existe, pero si utilizamos la opción REPLACE_EXISTING el fichero se sobrescribirá. con la API de java.nio. El objeto Files utiliza el método copy(), el cual necesita que se le pase por parámetro la ruta de origen y la ruta de destino, con un objeto Path. La copia fallará si el fichero destino ya existe, pero si utilizamos la opción REPLACE_EXISTING el fichero se no sobrescribirá.

El método copy() para directorios: Solo copia la carpeta, no el contenido de esa carpeta. Copia tanto la carpeta como su contenido. Solo copia el contenido de la carpeta. No se puede usar el método copy() para directorios.

Ejemplo correcto del método copy(): Path origen = Paths.get(“src/main/resources/copiarFicheros/ejemploCopia.txt”); Path ejemploOrigen = Files.createFile(origen); Path destino = Paths.get(“src/main/resources/copiarFicheros/ /destino”); Path ejemploDestino = Files.createFile(destino); Files.copy(origen, destino, StandardCopyOption.REPLACE_EXISTING);. Path origen = Paths.get(“src/main/resources/copiarFicheros/ejemploCopia.txt”); Path ejemploOrigen = Files.createFile(origen); Path destino = Paths.get(“src/main/resources/copiarFicheros/ /destino”); Path ejemploDestino = Files.createFile(destino); Files.copy(origen, destino, StandardCopyOption.REPLACE_EXIST);. Path origen = Paths.set(“src/main/resources/copiarFicheros/ejemploCopia.txt”); Path ejemploOrigen = Files.createFile(origen); Path destino = Paths.set(“src/main/resources/copiarFicheros/ /destino”); Path ejemploDestino = Files.createFile(destino); Files.copy(origen, destino, StandardCopyOption.REPLACE_EXISTING);. Path origen = Paths.set(“src/main/resources/copiarFicheros/ejemploCopia.txt”); Path ejemploOrigen = Files.createFile(origen); Path destino = Paths.set(“src/main/resources/copiarFicheros/ /destino”); Path ejemploDestino = Files.createFile(destino); Files.copy(origen, destino, StandardCopyOption.REPLACE_EXIST);.

Para copiar ficheros con Files: Primero tendremos que crear un archivo origen y otro destino, con las rutas correspondientes. A continuación, necesitamos crear un InputStream con un nuevo BufferedInputStream, que se encargará de leer los datos del archivo de origen. Para el objeto destino, debemos crear un OutputStream que contendrá un BufferedOutputStream para albergar el resultado de la copia. Primero tendremos que crear un archivo origen y otro destino, con los streams correspondientes. A continuación, necesitamos crear un InputStream con un nuevo BufferedInputStream, que se encargará de leer los datos del archivo de origen. Para el objeto destino, debemos crear un OutputStream que contendrá un BufferedOutputStream para albergar el resultado de la copia. Primero tendremos que crear un archivo origen y otro destino, con las rutas correspondientes. A continuación, necesitamos crear un Input con un nuevo BufferedInputStream, que se encargará de leer los datos del archivo de origen. Para el objeto destino, debemos crear un OutputStream que contendrá un BufferedOutputStream para albergar el resultado de la copia. Primero tendremos que crear un archivo origen y otro destino, con las rutas correspondientes. A continuación, necesitamos crear un InputStream con un nuevo BufferedInputStream, que se encargará de escribir los datos del archivo de origen. Para el objeto destino, debemos crear un OutputStream que contendrá un BufferedOutputStream para albergar el resultado de la copia.

¿Para qué sirve el método flush()?. Se encargará de vaciar el OutputStream y se guardarán los archivos de salida en un búfer. Se encargará de vaciar el InputStream y se guardarán los archivos de salida en un búfer. Se encargará de vaciar el BufferedStream y se guardarán los archivos de salida en un búfer. Se encargará de vaciar el InputBufferedStream y se guardarán los archivos de salida en un búfer.

¿Qué API nos ofrece la forma más rápida para mover un fichero?. java.nio con el método move(). java.io con el método move(). java.File con el método move(). java.Files con el método move().

El método move() puede utilizar REPLACE_EXISTING: Verdadero. Falso.

Código correcto para mover un fichero. Path destino = Files.move(Paths.get(“c:/ejercicio/ejemplo.txt”), Paths.get(“c:/ejercicio/destinoEjemplo.txt”), StandardCopyOption.REPLACE_EXISTING);. Path destino = Files.move(Paths.set(“c:/ejercicio/ejemplo.txt”), Paths.get(“c:/ejercicio/destinoEjemplo.txt”), StandardCopyOption.REPLACE_EXISTING);. Path destino = Files.move(Paths.get(“c:/ejercicio/ejemplo.txt”), Paths.get(“c:/ejercicio/destinoEjemplo.txt”), StandardCopyOption.REPLACE_EXIST);. Path destino = Files.move(Paths.get(“c:/ejercicio/ejemplo.txt”), Paths.set(“c:/ejercicio/destinoEjemplo.txt”), StandardCopyOption.REPLACE_EXIST);.

El objeto File de java.Files, puede realizar la acción de mover el fichero: Falso. Verdadero.

El objeto File de java.io, puede realizar la acción de mover el fichero: Verdadero. Falso.

¿Qué método definido dentro de la clase File nos permite diferenciar de un objeto de dicha clase es un directorio?. isDir(). isNotFile(). isDirectory(). canDirectory().

Un archivo con acceso secuencial es. Un fichero donde se guarda la información en una secuencia de caracteres, de manera que el acceso a ellos se debe realizar en estricto orden, con base en el campo clave de su origen. Un fichero donde se guarda la información en una secuencia de caracteres, de manera que el acceso a ellos se puede realizar en distinto orden, con base en el campo clave de su origen. Un fichero donde se guarda la información en una secuencia de caracteres, de manera que el acceso a ellos se debe realizar en estricto orden, con base en el campo clave de su destino. Un fichero donde se guarda la información en una secuencia de caracteres, de manera que el acceso a ellos se debe realizar en distinto orden, con base en el campo clave de su destino.

El acceso aleatorio a archivos es. Un tipo de acceso a datos que permite al programa Java acceder a los datos sin un orden, es decir, a cualquier posición en que se encuentren los datos, sin ningún orden. Un tipo de acceso a datos que permite al programa Java acceder a los datos con un orden, es decir, a cualquier posición en que se encuentren los datos, totalmente ordenado. Un tipo de acceso a datos que permite al programa Java acceder a los datos ordenadamente, es decir, a cualquier posición en que se encuentren los datos, sin orden. Un tipo de acceso a datos que permite al programa Java acceder a los datos sin un orden, es decir, a cualquier posición en que se encuentren los datos, ordenadamente.

Diferencia entre acceso aleatorio y secuencial: Con el acceso aleatorio no es necesario empezar desde la primera línea del fichero. Se asemeja a los arrays de bytes, ya que podemos acceder a cualquier parte de los datos con un puntero de fichero, es decir, indicando al método de acceso en qué posición queremos empezar a tratar los datos. Con el acceso aleatorio es necesario empezar desde la primera línea del fichero. Se asemeja a los arrays de bytes, ya que podemos acceder a cualquier parte de los datos con un puntero de fichero, es decir, indicando al método de acceso en qué posición queremos empezar a tratar los datos. Con el acceso aleatorio no es necesario empezar desde la primera línea del fichero. Se asemeja a los arrays de bits, ya que podemos acceder a cualquier parte de los datos con un puntero de fichero, es decir, indicando al método de acceso en qué posición queremos empezar a tratar los datos. Con el acceso aleatorio es necesario empezar desde la primera línea del fichero. Se asemeja a los arrays de bits, ya que podemos acceder a cualquier parte de los datos con un puntero de fichero, es decir, indicando al método de acceso en qué posición queremos empezar a tratar los datos.

El acceso aleatorio es útil: en aquellas aplicaciones de baja latencia que necesitan persistencia. Este tipo de acceso a datos es especialmente útil para situaciones en que el programa ha sufrido un error y es necesario acceder otra vez de manera aleatoria a los datos. en aquellas aplicaciones de alta latencia que necesitan persistencia. Este tipo de acceso a datos es especialmente útil para situaciones en que el programa ha sufrido un error y es necesario acceder otra vez de manera aleatoria a los datos. en aquellas aplicaciones de alta latencia que no necesitan persistencia. Este tipo de acceso a datos es especialmente útil para situaciones en que el programa ha sufrido un error y es necesario acceder otra vez de manera aleatoria a los datos. en aquellas aplicaciones de baja latencia que no necesitan persistencia. Este tipo de acceso a datos es especialmente útil para situaciones en que el programa ha sufrido un error y es necesario acceder otra vez de manera aleatoria a los datos.

El objeto RandomAccesFile: Tiene la habilidad de leer y escribir cualquier tipo de dato en un fichero de manera aleatoria. Cuando lee el contenido del archivo, comienza con la ubicación actual del puntero del archivo y el puntero avanza más allá de cuántos bytes se leen. Tiene la habilidad de leer, escribir y ejecutar cualquier tipo de dato en un fichero de manera aleatoria. Cuando ejecuta el contenido del archivo, comienza con la ubicación actual del puntero del archivo y el puntero avanza más allá de cuántos bytes se leen. Tiene la habilidad de leer cualquier tipo de dato en un fichero de manera aleatoria. Cuando lee el contenido del archivo, comienza con la ubicación actual del puntero del archivo y el puntero avanza más allá de cuántos bytes se leen. Tiene la habilidad de escribir cualquier tipo de dato en un fichero de manera aleatoria. Cuando escribe el contenido del archivo, comienza con la ubicación actual del puntero del archivo y el puntero avanza más allá de cuántos bytes se leen.

Método seek() del objeto RandomAccesFile: Logra configurar el puntero del archivo a cualquier ubicación aleatoria. Logra configurar el puntero del archivo a cualquier ubicación concreta. Logra configurar el puntero del archivo a una ubicación preestablecida. Logra configurar el puntero del archivo a varias ubicaciones dadas.

Método getFilePointer() del objeto RandomAccesFile: Permite obtener la ubicación donde se encuentra en ese momento. Permite obtener la ubicación donde se dirige el puntero. Permite obtener la ubicación de donde proviene. Permite obtener la ubicación donde se encuentra en ese momento y de donde proviene.

Ventajas acceso secuencial: Se puede usar para persistir datos de manera más simple. Se puede usar para persistir datos de manera más compleja. Podemos elegir el punto exacto de lectura de datos, permitiendo ser mucho más rápido y ahorrar consumo de recursos en la aplicación. Podemos elegir el punto exacto de ejecución de datos, permitiendo ser mucho más rápido y ahorrar consumo de recursos en la aplicación.

Ventajas acceso aleatorio: Podemos elegir el punto exacto de lectura de datos, permitiendo ser mucho más rápido y ahorrar consumo de recursos en la aplicación. Se puede usar para persistir datos de manera más simple. Se puede usar para persistir datos de manera más compleja. Podemos elegir el punto exacto de ejecución de datos, permitiendo ser mucho más rápido y ahorrar consumo de recursos en la aplicación.

Desventajas acceso aleatorio: Puede ser un método de acceso un poco más lento en comparación con el secuencial. No es una manera de acceder a los datos de manera eficiente. Nos obliga a acceder a los datos en orden, aunque el resto de datos no nos interesen. Es una manera de acceder a los datos de manera eficiente.

Desventajas acceso secuencial: No es una manera de acceder a los datos de manera eficiente. Puede ser un método de acceso un poco más lento en comparación con el aleatorio. No nos obliga a acceder a los datos en orden, aunque el resto de datos no nos interesen. Es una manera de acceder a los datos de manera eficiente.

Un fichero binario es: Un tipo de archivo que contiene información en cualquier tipo de codificación (o encoding) representado por ceros y unos (conocidamente como binario) para ser tratado y almacenado por un programa o sistema. Un tipo de archivo que contiene información en cualquier tipo de codificación (o encoding) representado por ceros y unos (conocidamente como binario) para ser leído y ejecutado por un programa o sistema. Un tipo de archivo que contiene información en un tipo concreto de codificación (o encoding) representado por ceros y unos (conocidamente como binario) para ser tratado y almacenado por un programa o sistema. Un tipo de archivo que contiene información en un tipo concreto de codificación (o encoding) representado por ceros y unos (conocidamente como binario) para ser leído y ejecutado por un programa o sistema.

Un fichero de caracteres es: Aquel que contiene información de texto sin caracteres raros, que se encuentra con la codificación por defecto del sistema que está tratando los datos. Aquel que contiene información de texto con caracteres raros, que se encuentra con la codificación por defecto del sistema que está tratando los datos. Aquel que contiene información de texto con cualquier tipo de carácter y símbolo, que se encuentra con la codificación por defecto del sistema que está tratando los datos. Aquel que contiene información de texto con caracteres especiales, que se encuentra con la codificación por defecto del sistema que está tratando los datos.

FileReader: Es una clase muy útil para leer archivos de texto utilizando la codificación del sistema operativo. Los constructores de esta clase usan el búfer con tamaño predeterminado. Es un método muy útil para leer archivos de texto utilizando la codificación del sistema operativo. Los constructores de este método usan el búfer con tamaño predeterminado. Es una clase muy útil para leer archivos de texto utilizando la codificación del sistema operativo. Los constructores de esta clase usan el búfer con tamaño dinámico. Es un método muy útil para leer archivos de texto utilizando la codificación del sistema operativo. Los constructores de este método usan el búfer con tamaño dinámico.

BufferedReader: Lee ficheros de texto desde un stream de entrada de caracteres. Esta clase realiza una lectura de los datos mediante un búfer, lo que lo convierte en un método muy eficiente de lectura. Tiene la peculiaridad que permite definir el tamaño de su búfer o usar el tamaño predeterminado. Lee ficheros de texto desde un stream de salida de caracteres. Esta clase realiza una lectura de los datos mediante un búfer, lo que lo convierte en un método muy eficiente de lectura. Tiene la peculiaridad que permite definir el tamaño de su búfer o usar el tamaño predeterminado. Lee ficheros de texto desde un stream de entrada de caracteres. Esta clase realiza una escritura de los datos mediante un búfer, lo que lo convierte en un método muy eficiente de escritura. Tiene la peculiaridad que permite definir el tamaño de su búfer o usar el tamaño predeterminado. Lee ficheros de texto desde un stream de salida de caracteres. Esta clase realiza una escritura de los datos mediante un búfer, lo que lo convierte en un método muy eficiente de lectura. Tiene la peculiaridad que permite definir el tamaño de su búfer o usar el tamaño predeterminado.

En cuanto a BufferedReader: Cada petición de lectura que realiza un BufferedReader hace que se realice una solicitud de lectura correspondiente del flujo de bytes. Por ese motivo, es aconsejable envolver un BufferedReader alrededor de cualquier lector cuyos métodos read() puedan ser costosos, como FileReaders e InputStreamReaders. Cada petición de lectura que realiza un BufferedReader hace que se realice una solicitud de escritura correspondiente del flujo de bytes. Por ese motivo, es aconsejable envolver un BufferedReader alrededor de cualquier lector cuyos métodos read() puedan ser costosos, como FileReaders e InputStreamReaders. Cada petición de lectura que realiza un BufferedReader hace que se realice una solicitud de lectura correspondiente del flujo de bytes. Por ese motivo, es aconsejable envolver un BufferedReader alrededor de cualquier lector cuyos métodos write() puedan ser costosos, como FileReaders e InputStreamReaders. Cada petición de lectura que realiza un BufferedReader hace que se realice una solicitud de lectura correspondiente del flujo de bytes. Por ese motivo, es aconsejable envolver un BufferedReader alrededor de cualquier lector cuyos métodos read() puedan ser costosos, como FileReader e InputStreamReader.

Scanner: Clase que analiza los ficheros de caracteres y permite analizar la información del fichero y clasificarla según su tipo. Clase que analiza los ficheros de caracteres y permite analizar la información del fichero y clasificarla según su identidad. Clase que analiza los ficheros de caracteres y permite analizar la información del fichero y clasificarla según su longitud. Clase que analiza los ficheros de caracteres y permite analizar la información del fichero y clasificarla según la cantidad de bits.

La clase Scanner: Divide los datos que recibe en tokens (un token es el elemento más pequeño de un programa) utilizando un patrón delimitador que por defecto coincide con los espacios en blanco. Divide los datos que recibe en tokens (un token es el elemento más pequeño de un programa) utilizando un patrón delimitador que por defecto coincide con las comillas dobles. Divide los datos que recibe en tokens (un token es el elemento más grande de un programa) utilizando un patrón delimitador que por defecto coincide con los espacios en blanco. Divide los datos que recibe en tokens (un token es el elemento más grande de un programa) utilizando un patrón delimitador que por defecto coincide con las comillas dobles.

Atendiendo a los tokens de las clase Scanner: Los tokens obtenidos se pueden convertir en valores de diferentes tipos utilizando los métodos next(). Los tokens obtenidos se pueden convertir en valores de diferentes tipos utilizando los métodos convert(). Los tokens obtenidos se pueden convertir en valores de diferentes tipos utilizando los métodos line(). Los tokens obtenidos se pueden convertir en valores de diferentes tipos utilizando los métodos parse().

¿Qué paquete utilizamos para la lectura de ficheros binarios?. java.io. java.nio. java.File. java.Files.

InputStream: Superclase abstracta que se encarga de leer un stream de bytes. Solo es capaz de leer un byte a la vez, por lo que lo hace una opción bastante lenta. Superclase abstracta que se encarga de leer un string de bytes. Solo es capaz de leer un byte a la vez, por lo que lo hace una opción bastante lenta. Superclase abstracta que se encarga de leer un stream de bits. Solo es capaz de leer un bit a la vez, por lo que lo hace una opción bastante lenta. Superclase abstracta que se encarga de leer un string de bits. Solo es capaz de leer un bit a la vez, por lo que lo hace una opción bastante lenta.

Se considera una superclase a: Aquella clase padre de la que derivan diferentes clases, también conocidas como subclases. Las subclases derivan de la clase padre y heredan todas sus propiedades y métodos. Aquella clase padre de la que derivan diferentes clases, también conocidas como subclases. Las subclases derivan de la clase padre y heredan algunas de sus propiedades y métodos. Aquella clase padre de la que derivan diferentes clases, también conocidas como subclases. Las subclases derivan de la clase padre y heredan todas sus propiedades y algunos métodos. Aquella clase padre de la que derivan diferentes clases, también conocidas como subclases. Las subclases derivan de la clase padre y heredan algunas de sus propiedades y todos los métodos.

Una clase abstracta es: Un tipo de clase que permite la declaración de métodos, pero no su implementación. La implementación será realizada por las clases que implementen esa clase. Un tipo de clase que permite la declaración de métodos y su implementación. Un tipo de clase que no permite la declaración de métodos, pero sí su implementación. La declaración será realizada por las clases que implementen esa clase. Un tipo de clase que no permite la declaración de métodos ni su implementación. La implementación será realizada por las clases que implementen esa clase.

avaliable(). Este método se encarga de devolver los bytes disponibles en el InputStream. Este método se encarga de devolver los bytes ocupados en el InputStream. Este método se encarga de devolver los bits disponibles en el InputStream. Este método se encarga de devolver los bits ocupados en el InputStream.

close(). Es el método que se encarga de cerrar el stream. Es el método que se encarga de abrir el stream. Es el método que se encarga de cerrar el string. Es el método que se encarga de abrir el string.

mark(). Este método se encarga de marcar la posición de los bytes leídos del stream. Este método se encarga de marcar la posición de los bytes no leídos del stream. Este método se encarga de marcar la posición de los bits leídos del stream. Este método se encarga de marcar la posición de los bits no leídos del stream.

read(). Se encarga de leer los bytes de datos uno a uno. Se encarga de leer los bits de datos uno a uno. Se encarga de leer los bytes de datos en conjuntos de 16. Se encarga de leer los bits de datos en conjuntos de 16.

read(byte[] array). Se encarga de leer los bytes del stream y los almacena en un array. Se encarga de leer los bytes del string y los almacena en un array. Se encarga de leer los bytes del stream y los almacena en una lista. Se encarga de leer los bytes del string y los almacena en una lista.

reset(). Método que se encarga de quitar la marca de los bytes leídos por el método mark(). Método que se encarga de quitar la marca de los bytes leídos por el método read(). Método que se encarga de quitar la marca de los bytes leídos por el método read(byte[] array). Método que se encarga de quitar la marca de los bytes leídos por el método skips().

skips(). Este método se encarga de descartar un numero especificado de bytes del stream que este leyendo en ese momento. Este método se encarga de añadir un numero especificado de bytes del stream que este ejecutando en ese momento. Este método se encarga de descartar un numero especificado de bytes del stream que este ejecutando en ese momento. Este método se encarga de añadir un numero especificado de bytes del stream que este leyendo en ese momento.

FileInputStream: Subclase de InputStream que se utiliza para leer streams de bytes. Está enfocada al tratamiento de bytes sin procesar, como datos de imágenes, vídeo o audio. También puede leer ficheros de caracteres, pero no es el más adecuado, es mejor FileReader. Superclase de InputStream que se utiliza para leer streams de bytes. Está enfocada al tratamiento de bytes sin procesar, como datos de imágenes, vídeo o audio. También puede leer ficheros de caracteres, pero no es el más adecuado, es mejor FileReader. Subclase de InputStream que se utiliza para escribir streams de bytes. Está enfocada al tratamiento de bytes sin procesar, como datos de imágenes, vídeo o audio. También puede leer ficheros de caracteres, pero no es el más adecuado, es mejor FileReader. Subclase de InputStream que se utiliza para escribir streams de bytes. Está enfocada al tratamiento de bytes sin procesar, como datos de imágenes, vídeo o audio. También puede leer ficheros de caracteres, pero no es el más adecuado, es mejor FileWriter.

BufferedInputStream: Clase que extiende (es decir, que implementa todos los métodos) de InputStream y que se utiliza para leer streams de datos en bytes de manera más eficiente. Esta clase se caracteriza por tener un búfer interno de 8192 bytes. Durante la operación de lectura, BufferedInputStream se encargará de leer una porción de bytes del fichero que se encuentra en el disco y almacenará los bytes en el búfer interno. Una vez almacenados en el búfer interno, se leerán los bytes individualmente. Clase que extiende (es decir, que implementa todos los métodos) de InputStream y que se utiliza para leer streams de datos en bytes de manera más eficiente. Esta clase se caracteriza por tener un búfer interno de 8192 bytes. Durante la operación de lectura, BufferedInputStream se encargará de leer una porción de bytes del fichero que se encuentra en el disco y almacenará los bytes en el búfer interno. Una vez almacenados en el búfer interno, se leerán los bytes en conjunto. Clase que extiende (es decir, que implementa todos los métodos) de InputStream y que se utiliza para leer streams de datos en bytes de manera más eficiente. Esta clase se caracteriza por tener un búfer interno de 8192 bytes. Durante la operación de lectura, BufferedInputStream se encargará de leer una porción de bytes del fichero que se encuentra en el disco y almacenará los bytes en el búfer externo. Una vez almacenados en el búfer externo, se leerán los bytes individualmente. Clase que extiende (es decir, que implementa todos los métodos) de InputStream y que se utiliza para leer streams de datos en bytes de manera más eficiente. Esta clase se caracteriza por tener un búfer interno de 8192 bytes. Durante la operación de lectura, BufferedInputStream se encargará de leer una porción de bytes del fichero que se encuentra en el disco y almacenará los bytes en el búfer externo. Una vez almacenados en el búfer externo, se leerán los bytes en conjunto.

Writer: Superclase abstracta que no se usa sola por sí misma, sino que siempre va acompañada de sus subclases, como InputStream. Subclase abstracta que no se usa sola por sí misma, sino que siempre va acompañada de sus superclases, como InputStream. Superclase abstracta que se usa sola por sí misma, pero, además, siempre va acompañada de sus subclases, como InputStream. Superclase abstracta que se puede o no usar sola por sí misma, pero, además, siempre va acompañada de sus subclases, como hemos visto con InputStream.

append(char c). Este método añade el carácter que le indiquemos. Este método elimina el carácter que le indiquemos. Este método modifica el carácter que le indiquemos. Este método modifica un carácter aleatorio.

close(). El método cierra el stream que está en uso. El método abre el stream que está en uso. El método cierra el string que está en uso. El método abre el stream que está en uso.

flush(). El método obliga escribir toda la información que tenga el objeto OutputStreamWriter al destino correspondiente. El método obliga leer toda la información que tenga el objeto OutputStreamReader al destino correspondiente. El método obliga ejecutar toda la información que tenga el objeto OutputStreamWriter al destino correspondiente. El método obliga leer toda la información que tenga el objeto OutputStreamReader al destino correspondiente.

getEncoding(). Este método nos indica qué encoding se está utilizando para escribir los datos en el fichero. Este método nos indica qué encoding no se está utilizando para escribir los datos en el fichero. Este método nos indica qué encoding tenemos instalado para escribir los datos en el fichero. Este método nos indica qué encoding no se ha utilizado para escribir los datos en el fichero.

write(char c). Este método escribe en un fichero un carácter que le pasemos por parámetro. Este método lee en un fichero un carácter que le pasemos por parámetro. Este método modifica en un fichero un carácter que le pasemos por parámetro. Este método elimina en un fichero un carácter que le pasemos por parámetro.

write(char[] array). Este método escribe en un fichero el array que le pasemos por parámetro. Este método lee en un fichero el array que le pasemos por parámetro. Este método modifica en un fichero el array que le pasemos por parámetro. Este método elimina en un fichero el array que le pasemos por parámetro.

write(String data). Este método escribe en un fichero el string que le pasemos por parámetro. Este método lee en un fichero el string que le pasemos por parámetro. Este método modifica en un fichero el string que le pasemos por parámetro. Este método elimina en un fichero el string que le pasemos por parámetro.

OutputStreamWriter: Es una subclase de Writer que se usa para convertir streams de caracteres, pero también se utiliza para streams de bytes. Es una superclase de Writer que se usa para convertir strings de caracteres, pero también se utiliza para streams de bytes. Es una subclase de Writer que se usa para convertir strings de caracteres, pero también se utiliza para streams de bytes. Es una superclase de Writer que se usa para convertir streams de caracteres, pero también se utiliza para streams de bytes.

FileWriter: Es una clase que nos permitirá escribir caracteres en un archivo. Es una subclase de OutputStreamWriter. Es una clase que nos permitirá escribir números en un archivo. Es una superclase de OutputStreamWriter. Es una clase que nos permitirá escribir símbolos en un archivo. Es una subclase de OutputStreamWriter. Es una clase que nos permitirá escribir símbolos en un archivo. Es una superclase de OutputStreamWriter.

BufferedWriter: Es una subclase de Writer que también permite almacenar datos en el búfer. Es una superclase de Writer que también permite almacenar datos en el búfer. Es una superclase de Writer que no permite almacenar datos en el búfer. Es una subclase de Writer que no permite almacenar datos en el búfer.

¿Cuál es la clase más eficiente para escribir datos en un archivo?. BufferedWriter. FileWriter. OutputStreamWriter. Writer.

¿Dónde escribe los datos BufferedWriter?. Permite escribir los datos en el búfer y no en el disco. Una vez que el búfer esté lleno o se cierre, los datos se escriben en el disco. Permite escribir los datos en el disco y no en el búfer. Una vez que el disco esté lleno o se cierre, los datos se escriben en el búfer. Permite escribir los datos en el búfer y en el disco. Una vez que el búfer esté lleno o se cierre, los datos se escriben en el disco. Permite escribir los datos en el búfer y no en el disco. Una vez que el disco esté lleno o se cierre, los datos se escriben en el búfer.

La escritura de ficheros binarios consiste en: Escribir datos de tipo byte en un fichero. Escribir datos de tipo bit en un fichero. Escribir datos de tipo entero en un fichero. Escribir datos de tipo simbólico en un fichero.

¿Qué paquete utilizamos para la escritura de ficheros binarios?. java.io. java.nio. java.Write. java.Writer.

OutputStream: Pertenece al paquete java.io y es una superclase abstracta que se utiliza para escribir streams de bytes. Pertenece al paquete java.nio y es una superclase abstracta que se utiliza para escribir streams de bytes. Pertenece al paquete java.io y es una subclase abstracta que se utiliza para escribir streams de bytes. Pertenece al paquete java.nio y es una subclase abstracta que se utiliza para escribir streams de bytes.

FileOutputStream: Esta clase se encargará de escribir streams de bytes en los ficheros. Es una subclase que hereda de OutputStream. Esta clase se encargará de leer streams de bytes en los ficheros. Es una superclase que hereda de OutputStream. Esta clase se encargará de escribir streams de bytes en los ficheros. Es una superclase que hereda de OutputStream. Esta clase se encargará de leer streams de bytes en los ficheros. Es una subclase que hereda de OutputStream.

BufferedOutputStream: Es una clase que se utiliza para envolver OutputStream para dar soporte a las capacidades del búfer. Es una clase que se utiliza para envolver OutputStream para dar soporte a las capacidades del disco. Es una clase que se utiliza para envolver InputStream para dar soporte a las capacidades del disco. Es una clase que se utiliza para envolver InputStream para dar soporte a las capacidades del búfer.

BufferedOutputStream es una de las clases más eficientes en escritura de datos. Verdadero. Falso.

El método close() nos permite cerrar el flujo abierto desde nuestro programa a un fichero binario aleatorio, aunque actualmente está en desuso y no es obligatorio usarlo puesto que el flujo se cierra al finalizar la operación de lectura o escritura. Verdadero. Falso.

Podemos entender el concepto metalenguaje como: El código que utilizaremos para describir la información que queremos transmitir en un fichero XML. El código que utilizaremos para describir la información que queremos transmitir en un fichero HTML. El código que utilizaremos para describir la información que queremos transmitir en un fichero CSS. El código que utilizaremos para describir la información que queremos transmitir en un fichero XHTML.

El metalenguaje: Describe nuestro lenguaje natural en código: mediante símbolos, iremos representando la estructura de lo que se quiera representar. Describe nuestro lenguaje natural en código: mediante caracteres, iremos representando la estructura de lo que se quiera representar. Describe nuestro lenguaje natural en código: mediante números, iremos representando la estructura de lo que se quiera representar. Describe nuestro lenguaje natural en código: mediante streams, iremos representando la estructura de lo que se quiera representar.

¿Cuál será la primera línea en nuestro fichero XML?. <?xml versión= “1.0” encoding= “UTF-8”?>. <xml versión= “1.0” encoding= “UTF-8”?>. <?xml versión= “1.0” encode= “UTF-8”?>. <xml versión= “1.0” encode= “UTF-8”?>.

Un analizador sintáctico es: Un objeto que permitirá leer la información del XML y acceder a ella para extraerla. Un objeto que permitirá escribir la información del XML y acceder a ella para extraerla. Un objeto que permitirá ejecutar la información del XML y acceder a ella para extraerla. Un objeto que permitirá leer, escribir y ejecutar la información del XML y acceder a ella para extraerla.

Un DOM es: Una plataforma e interfaz de lenguaje estándar que permite a los programas y a los scripts acceder y actualizar dinámicamente el contenido, la estructura y el estilo de un documento. Se caracteriza por tener una estructura en forma de árbol. Un analizador sintáctico para XML que se encarga de verificar que la estructura de ese fichero de texto es correcta. Un analizador semántico para XML que se encarga de verificar que la estructura de ese fichero de texto es correcta. Una plataforma e interfaz de lenguaje estándar que permite a los programas y a los scripts acceder y actualizar dinámicamente el contenido, la estructura y el estilo de un documento. Se caracteriza por tener una estructura en forma de estrella.

Un parser es: Un analizador sintáctico para XML que se encarga de verificar que la estructura de ese fichero de texto es correcta. Una plataforma e interfaz de lenguaje estándar que permite a los programas y a los scripts acceder y actualizar dinámicamente el contenido, la estructura y el estilo de un documento. Se caracteriza por tener una estructura en forma de árbol. Un analizador semántico para XML que se encarga de verificar que la estructura de ese fichero de texto es correcta. Una plataforma e interfaz de lenguaje estándar que permite a los programas y a los scripts acceder y actualizar dinámicamente el contenido, la estructura y el estilo de un documento. Se caracteriza por tener una estructura en forma de estrella.

Entre las características de DOM podemos encontrar: Nos permitirá tener los datos en orden, navegar por ellos en ambas direcciones y disponer de una API de lectura y escritura de datos, así como también la manipulación del fichero XML. Nos permitirá tener los datos en orden, navegar por ellos en ambas direcciones y disponer de una API solo de lectura de datos. Nos permitirá tener los datos en orden, navegar por ellos en ambas direcciones y disponer de una API solo de escritura de datos. Nos permitirá tener los datos en orden, navegar por ellos en ambas direcciones y disponer de una API de lectura y escritura de datos, pero no permite la manipulación del fichero XML.

el parser DOM tiene un procesado de información bastante lento, lo que provoca que consuma y ocupe mucho espacio en memoria del programa al cargar o tratar el fichero XML. Falso. Verdadero.

DocumentBuilderFactory: Esta clase nos va a permitir obtener un analizador sintáctico que produce la jerarquía de objetos DOM a partir de documentos XML. Esta clase nos va a permitir obtener un analizador sintáctico que produce la jerarquía de objetos DOM a partir de documentos XHTML. Esta clase nos va a permitir crear un analizador sintáctico que produce la jerarquía de objetos DOM a partir de documentos XML. Esta clase nos va a permitir crear un analizador sintáctico que produce la jerarquía de objetos DOM a partir de documentos XHTML.

La clase Document representa: Un documento XML y nos proporcionará el acceso al contenido del documento XML. Un documento XML y nos proporcionará una vista completa del documento XML. Un documento XML y nos proporcionará un nuevo documento XML. Un documento XML y nos proporcionará una vista árbol del documento XML.

getDocumentElement(): Sirve para obtener los datos de una etiqueta. Sirve para obtener los datos de una sección. Sirve para obtener los datos de un atributo. Sirve para obtener los datos de un conjunto de atributos.

SAX (Simple API for XML): Se encarga de leer la información del XML línea por línea. Se encarga de escribir la información del XML línea por línea. Se encarga de ejecutar la información del XML línea por línea. Se encarga de eliminar la información del XML línea por línea.

SAX se caracteriza por: Estar basada en eventos para parsear los datos. Estar basada en clases para parsear los datos. Estar basada en métodos para parsear los datos. Estar basada en direcciones de memoria para parsear los datos.

SAX nos proporciona una mayor eficiencia en memoria, con acceso a los datos de bajo nivel y, en definitiva, mucho más rápida. Si la comparamos con el acceso DOM, esta es mucho menos eficiente porque no carga en memoria todo el árbol del fichero. Falso. Verdadero.

El inconveniente más destacable es que es un poco más complicada de utilizar que el resto de parsers, y que ofrece navegación bidireccional. Falso. Verdadero.

Al contrario que la API DOM, SAX no carga los ficheros en memoria, sino que lee los ficheros usando una función para informar al cliente de la estructura del documento. Por tanto, es una opción mucho más rápida de analizar el contenido de los ficheros XML que no consumirá tantos recursos de la aplicación que usemos. Falso. Verdadero.

Otro detalle que caracteriza a SAX es que es una interfaz que analiza los datos del fichero de forma secuencial, empezando al inicio del XML y acabando al cierre final. Falso. Verdadero.

Para crear un SAX parser, necesitaremos: Llamar al método newSaxParser(). Llamar al método newSax(). Llamar al método newParser(). Llamar al método newParserSax().

Un handler es: Una clase auxiliar que servirá para realizar los diferentes pasos de extracción de datos del XML. Una clase abstracta que servirá para realizar los diferentes pasos de extracción de datos del XML. Una superclase que servirá para realizar los diferentes pasos de extracción de datos del XML. Una subclase de SaxHelper que servirá para realizar los diferentes pasos de extracción de datos del XML.

Un namespace es: Una manera de indicar al XML que un elemento es diferente de otro elemento con el mismo nombre. Una manera de indicar al XML que un elemento es el mismo que otro elemento con el mismo nombre. Una manera de indicar al XML que un atributo es diferente de otro elemento con el mismo nombre. Una manera de indicar al XML que un elemento es el mismo que otro elemento con distinto nombre.

La librería Java JAXB (Java XML API Binding) nos ofrece la posibilidad de convertir un XML en un objeto Java. Verdadero. Falso.

El data binding es: El concepto para definir la voluntad de transformar un fichero XML (o cualquier otro fichero) en un objeto Java. El concepto para definir la transformación de un fichero XML (o cualquier otro fichero) en un objeto Java. El concepto para definir la voluntad de eliminar un fichero XML (o cualquier otro fichero) o un objeto Java. El concepto para definir la voluntad de añadir un fichero XML (o cualquier otro fichero) y un objeto Java.

¿Cuál no es una característica de data binding?. Es menos eficiente que DOM. Nos permite navegar por el documento en ambas direcciones. Permite la manipulación del fichero XML. Permite la conversión de tipos XML a Java. Trabaja de manera muy simple la carga, creación y manipulación de ficheros XML.

¿Cuál es un aspecto negativo de data binding?. No permite tratar un fichero XML si este no es válido, por tanto, tenemos que validarlo antes de poder transformarlo a un objeto Java. No permite navegar por el documento en ambas direcciones. Es menos eficiente que DOM. No permite la conversión de tipos XML a Java. Trabaja de manera compleja la carga, creación y manipulación de ficheros XML.

JSON (Javascript Objecto Notation) es: Un tipo de archivo de formato de texto derivado de Javascript, bastante ligero y que almacena información estructurada. Es fácil de interpretar y generar, y se utiliza para transferir información entre un cliente y un servidor. Un tipo de archivo de formato de texto derivado de XML, bastante ligero y que almacena información estructurada. Es fácil de interpretar y generar, y se utiliza para transferir información entre un cliente y un servidor. Un tipo de archivo de formato de texto derivado de Javascript, bastante ligero y que almacena información no estructurada. Es fácil de interpretar y generar, y se utiliza para transferir información entre un cliente y un servidor. Un tipo de archivo de formato de texto derivado de XML, bastante ligero y que almacena información no estructurada. Es fácil de interpretar y generar, y se utiliza para transferir información entre un cliente y un servidor.

Los archivos JSON siguen una estructura basada en: Definición de objetos, asignando un atributo y un valor. Definición de clases, asignando un atributo y un valor. Definición de objetos, asignando una etiqueta y un valor. Definición de objetos, asignando un atributo y una clave.

Un fichero JSON es capaz de definir seis tipos de valores: string, número, objeto, arrays, true, false o null. string, número, objeto, arrays, true, false o stream. string, número, objeto, arrays, true, false o char. string, número, objeto, arrays, true, false o list.

Para definir el JSON: Se abren y cierran corchetes. Los objetos se declaran entre comillas y los diferentes objetos se separan con una coma. El nombre y el valor de cada pareja van separados entre dos puntos. Cada objeto se considera un string; en cambio, los valores de los atributos pueden ser de cada tipo permitido. se abren y cierran corchetes. Los objetos se declaran entre comillas y los diferentes objetos se separan con una coma. El nombre y el valor de cada pareja van separados entre dos puntos. Cada objeto se considera un array; en cambio, los valores de los atributos pueden ser de cada tipo permitido. se abren y cierran corchetes. Los objetos se declaran entre comillas y los diferentes objetos se separan con una coma. El nombre y el valor de cada pareja van separados entre dos puntos. Cada objeto se considera un objeto; en cambio, los valores de los atributos pueden ser de cada tipo permitido. se abren y cierran corchetes. Los objetos se declaran entre comillas y los diferentes objetos se separan con una coma. El nombre y el valor de cada pareja van separados entre dos puntos. Cada objeto se considera un char; en cambio, los valores de los atributos pueden ser de cada tipo permitido.

Para convertir un archivo de XML a JSON: Tenemos que añadir la librería Jackson a nuestro proyecto. Tenemos que añadir la librería JSON a nuestro proyecto. Tenemos que añadir la librería JXML a nuestro proyecto. Tenemos que añadir la librería XMLJ a nuestro proyecto.

El tratamiento de excepciones: Es el mecanismo que nos permite controlar un proceso anómalo dentro de nuestro programa y gestionar qué ocurre cuando se produce un error. Es el mecanismo que nos permite controlar un proceso común dentro de nuestro programa y gestionar qué ocurre cuando se produce un error. Es el mecanismo que nos permite controlar un proceso anómalo dentro de nuestro programa y gestionar qué ocurre cuando el programa funciona correctamente. Es el mecanismo que nos permite controlar un proceso anómalo dentro de nuestro programa y finalizar la ejecución del programa abruptamente.

Una excepción: Es un evento que tiene lugar cuando se ejecuta un programa que interrumpe el flujo normal de ejecución del código por un error, ya sea controlado o inesperado. Es un evento que tiene lugar cuando se ejecuta un programa que interrumpe el flujo normal de ejecución del código por un error controlado. Es un evento que tiene lugar cuando se ejecuta un programa que interrumpe el flujo normal de ejecución del código por un error inesperado. Es un evento que tiene lugar cuando se ejecuta un programa que interrumpe el flujo normal de ejecución del código por un error común.

Para poder gestionar los errores, en Java utilizamos: try-catch. try-match. try-finally. try-hatch.

Podemos definir más de un catch en un mismo try. Verdadero. Falso.

Cuando se produzca el error, entrará en todos los bloques catch que coincidan con el tipo de excepción. Verdadero. Falso.

Los tipos de excepción más específicos deben aparecer primero en la estructura, seguidos de los tipos de excepción más generales. Verdadero. Falso.

Al lanzar una excepción: El proceso normal del programa se interrumpirá. El proceso normal del programa continuará hasta el final del método. El proceso normal del programa continuará hasta el final de la clase. El proceso normal del programa continuará hasta que finalice el programa.

El bloque finally en un try-catch: Se ejecutará siempre, aunque no se produzca un error, y es especialmente útil para cerrar el proceso o ejecutar algún tipo de acción necesaria. Se ejecutará cuando se produzca un error, antes del catch, y es especialmente útil para cerrar el proceso o ejecutar algún tipo de acción necesaria. Se ejecutará cuando se produzca un error, después del catch, y es especialmente útil para cerrar el proceso o ejecutar algún tipo de acción necesaria. Se ejecutará cuando se produzca un error, antes o después del catch, y es especialmente útil para cerrar el proceso o ejecutar algún tipo de acción necesaria.

Entendemos por excepciones controladas. Todas aquellas que representan errores fuera del control del programa. Estas excepciones se controlan en tiempo de ejecución. Todas aquellas que representan errores dentro del control del programa. Estas excepciones se controlan en tiempo de ejecución. Todas aquellas que representan errores fuera del control del programa. Estas excepciones se controlan en tiempo de compilación. Todas aquellas que representan errores dentro del control del programa. Estas excepciones se controlan en tiempo de compilación.

¿Cuándo utilizaremos las excepciones controladas?. Siempre que se espere que el programa puede recuperarse después de lanzarse la excepción. Son de uso obligatorio en cualquier gestión de ficheros. Siempre que se espere que el programa finalice después de lanzarse la excepción. Son de uso obligatorio en cualquier gestión de ficheros. Siempre que se espere que el programa puede recuperarse después de lanzarse la excepción. Son comunes en gestión de ficheros. Siempre que se espere que el programa finalice después de lanzarse la excepción. Son comunes en gestión de ficheros.

Las excepciones controladas: Son subclases de la clase Exception. Son superclases de la clase Exception. Son subclases de la clase ThrowException. Son superclases de la clase ThrowException.

IOexception: Es una clase de error genérico, la podemos usar siempre que queramos controlar todo tipo de excepción sin saber exactamente cuál se podrá lanzar. Subclase de Exception. Es una clase que lanza errores cuando una operación con ficheros falla en un fichero o dos. Nos indicará que la carpeta no está vacía. Nos servirá para indicar que no se ha encontrado el fichero.

FileSystemException: Es una clase que lanza errores cuando una operación con ficheros falla en un fichero o dos. Nos indicará que la carpeta no está vacía. Nos servirá para indicar que no se ha encontrado el fichero. Esta excepción es útil para controlar si el acceso al fichero está permitido.

DirectoryNotEmptyException: Nos indicará que la carpeta no está vacía. Nos servirá para indicar que no se ha encontrado el fichero. Esta excepción es útil para controlar si el acceso al fichero está permitido. Cuando se crea un fichero y ya existe se lanza esta excepción.

NoSuchFileException: Será útil para controlar si existe el fichero al cual queremos acceder. Para controlar si existe la carpeta a la cual queremos acceder o crear. Es una clase de error genérico, la podemos usar siempre que queramos controlar todo tipo de excepción sin saber exactamente cuál se podrá lanzar. Subclase de Exception. Es una clase que lanza errores cuando una operación con ficheros falla en un fichero o dos.

FileNotFoundException: Nos servirá para indicar que no se ha encontrado el fichero. Esta excepción es útil para controlar si el acceso al fichero está permitido. Cuando se crea un fichero y ya existe se lanza esta excepción. Será útil para controlar si existe el fichero al cual queremos acceder.

AccesDeniedException: Esta excepción es útil para controlar si el acceso al fichero está permitido. Cuando se crea un fichero y ya existe se lanza esta excepción. Será útil para controlar si existe el fichero al cual queremos acceder. Para controlar si existe la carpeta a la cual queremos acceder o crear.

FileAlreadyExistsException: Cuando se crea un fichero y ya existe se lanza esta excepción. Será útil para controlar si existe el fichero al cual queremos acceder. Para controlar si existe la carpeta a la cual queremos acceder o crear. Es una clase de error genérico, la podemos usar siempre que queramos controlar todo tipo de excepción sin saber exactamente cuál se podrá lanzar. Subclase de Exception.

NotDirectoryException: Para controlar si existe la carpeta a la cual queremos acceder o crear. Es una clase de error genérico, la podemos usar siempre que queramos controlar todo tipo de excepción sin saber exactamente cuál se podrá lanzar. Subclase de Exception. Es una clase que lanza errores cuando una operación con ficheros falla en un fichero o dos. Nos indicará que la carpeta no está vacía.

Hay dos maneras de controlar excepciones. throws y try-catch. throw new y try-catch. throws new y try-catch. throw new y try-hatch.

Cuando declaramos el throws en el método, quien recibe la función deberá envolver esa llamada dentro de un try-catch. Verdadero. Falso.

Las excepciones no controladas: Son aquellas que reflejan un error dentro de la lógica del programa que estamos desarrollando. Son aquellas que reflejan un error dentro de la sintaxis del programa que estamos desarrollando. Son aquellas que reflejan un error dentro de la semántica del programa que estamos desarrollando. Son aquellas que reflejan un error dentro de la ejecución del programa que estamos desarrollando.

Las excepciones no controladas no se comprueban en tiempo de compilación, por tanto, es necesario englobar este tipo de excepción en un throws o un try-catch. Verdadero. Falso.

Las excepciones no controladas en gestión de ficheros: Se tiene que tener en cuenta, porque puede que se reproduzca en algún momento si alguno de los parámetros que usemos esta vacío o null. Se tiene que tener en cuenta, porque puede que se reproduzca en algún momento si alguno de los parámetros que usemos es cero. Se tiene que tener en cuenta, porque puede que se reproduzca en algún momento si alguno de los parámetros que usemos es aleatorio. No usamos este tipo de excepciones en gestión de ficheros.

RuntimeException: Se lanza cuando se produce un error con la máquina virtual de Java. Se lanzará siempre que uno de los campos que se le pasen al programa esté vacío. Se lanzará esta excepción cuando uno de los argumentos que se le pasen a un método no sea válido. Cuando se produce algún problema de seguridad.

NullPointerException: se lanzará siempre que uno de los campos que se le pasen al programa esté vacío. se lanzará esta excepción cuando uno de los argumentos que se le pasen a un método no sea válido. cuando se produce algún problema de seguridad. cuando se produce una excepción no controlada.

IllegalArgumentException: se lanzará esta excepción cuando uno de los argumentos que se le pasen a un método no sea válido. cuando se produce algún problema de seguridad. cuando se produce una excepción no controlada. se lanza cuando se produce un error con la máquina virtual de Java.

SecurityException: cuando se produce algún problema de seguridad. cuando se produce una excepción no controlada. se lanza cuando se produce un error con la máquina virtual de Java. se lanzará siempre que uno de los campos que se le pasen al programa esté vacío.

UncheckedIOException: cuando se produce una excepción no controlada. se lanza cuando se produce un error con la máquina virtual de Java. se lanzará siempre que uno de los campos que se le pasen al programa esté vacío. se lanzará esta excepción cuando uno de los argumentos que se le pasen a un método no sea válido.

La manera más conocida de documentar el lenguaje Java es: JavaDoc. JavaCompiler. JavaDocument. JavaComp.

JavaDoc permite añadir tags HTML dentro de los comentarios. Eso es debido a que JavaDoc, a través de los comentarios, genera un documento que servirá como documentación del proyecto. Verdadero. Falso.

@author. Sirve para poner el autor del desarrollo. Indica que el método o clase es obsoleto (propio de versiones anteriores) y que no se recomienda su uso. Se usará para definir un parámetro de un método, es requerido para todos los parámetros del método. Se usa para indicar qué es lo que devuelve el método, no se usa para los métodos void.

@deprecated. Indica que el método o clase es obsoleto (propio de versiones anteriores) y que no se recomienda su uso. Se usará para definir un parámetro de un método, es requerido para todos los parámetros del método. Se usa para indicar qué es lo que devuelve el método, no se usa para los métodos void. Asocia con otro método o clase.

@param. Se usará para definir un parámetro de un método, es requerido para todos los parámetros del método. Se usa para indicar qué es lo que devuelve el método, no se usa para los métodos void. Asocia con otro método o clase. Se usa para definir la versión del método o la clase.

@return. Se usa para indicar qué es lo que devuelve el método, no se usa para los métodos void. Asocia con otro método o clase. Se usa para definir la versión del método o la clase. Sirve para poner el autor del desarrollo.

@see. Asocia con otro método o clase. Se usa para definir la versión del método o la clase. Sirve para poner el autor del desarrollo. Indica que el método o clase es obsoleto (propio de versiones anteriores) y que no se recomienda su uso.

@version. Se usa para definir la versión del método o la clase. Sirve para poner el autor del desarrollo. Indica que el método o clase es obsoleto (propio de versiones anteriores) y que no se recomienda su uso. Se usará para definir un parámetro de un método, es requerido para todos los parámetros del método.

Para generar la documentación desde línea de comandos, escribimos: javadoc –d doc src\. javadoc –c doc src\. javadoc –d doc source\. javadoc –c doc source\.

Para generar la documentación desde nuestro IDE: Project > Generate JavaDoc. Document > Generate JavaDoc. Project > Generate Document. Document > Generate Document.

@Test. Identifica un método como un método test. Indica qué se ejecuta antes de cada test. Se usa para preparar el entorno del test antes de ejecutarlo. Indica qué se ejecutará después de cada test. Se usa para limpiar el entorno después de la ejecución de cada test. Se ejecuta solo una vez, antes de que se ejecuten todos los test. Se usa, por ejemplo, para conectar la base de datos.

@Before. Indica qué se ejecuta antes de cada test. Se usa para preparar el entorno del test antes de ejecutarlo. Indica qué se ejecutará después de cada test. Se usa para limpiar el entorno después de la ejecución de cada test. Se ejecuta solo una vez, antes de que se ejecuten todos los test. Se usa, por ejemplo, para conectar la base de datos. Se ejecuta solo una vez después de ejecutar todos los test. Se usa para limpiar el entorno.

@After. Indica qué se ejecutará después de cada test. Se usa para limpiar el entorno después de la ejecución de cada test. Se ejecuta solo una vez, antes de que se ejecuten todos los test. Se usa, por ejemplo, para conectar la base de datos. Se ejecuta solo una vez después de ejecutar todos los test. Se usa para limpiar el entorno. Marca ese test como deshabilitado.

@BeforeClass. Se ejecuta solo una vez, antes de que se ejecuten todos los test. Se usa, por ejemplo, para conectar la base de datos. Se ejecuta solo una vez después de ejecutar todos los test. Se usa para limpiar el entorno. Marca ese test como deshabilitado. Establece una regla, añade funcionalidades extra a nuestro test.

@AfterClass. Se ejecuta solo una vez después de ejecutar todos los test. Se usa para limpiar el entorno. Marca ese test como deshabilitado. Establece una regla, añade funcionalidades extra a nuestro test. Identifica un método como un método test.

@Rule. Establece una regla, añade funcionalidades extra a nuestro test. Identifica un método como un método test. Indica qué se ejecuta antes de cada test. Se usa para preparar el entorno del test antes de ejecutarlo. Indica qué se ejecutará después de cada test. Se usa para limpiar el entorno después de la ejecución de cada test.

@Ignore or @Ignore (“why disabled”). Marca ese test como deshabilitado. Establece una regla, añade funcionalidades extra a nuestro test. Identifica un método como un método test. Indica qué se ejecuta antes de cada test. Se usa para preparar el entorno del test antes de ejecutarlo.

fail([message]). Se usa para hacer que el método falle y descubrir qué partes del código no se contemplan. Se suele hacer antes de desarrollar. El parámetro message es opcional. Comprueba si la condición es true. Comprueba si la condición es false. Hace test de dos valores para comprobar si son el mismo.

assertTrue([message,]boolean condition). Comprueba si la condición es true. Comprueba si la condición es false. Hace test de dos valores para comprobar si son el mismo. Comprueba si un float o double son iguales.

assertFalse([message,]boolean condition). Comprueba si la condición es false. Hace test de dos valores para comprobar si son el mismo. Comprueba si un float o double son iguales. Comprueba si un objeto es null.

assertEquals([message,] expected,actual,tolerance). Comprueba si un float o double son iguales. Comprueba si un objeto es null. Comprueba si el objeto no es null. Comprueba si las dos variables hacen referencia al mismo objeto.

assertNull([message,] object). Comprueba si un objeto es null. Comprueba si el objeto no es null. Comprueba si las dos variables hacen referencia al mismo objeto. Comprueba si las dos variables no hacen referencia al mismo objeto.

assertNotNull([message,] object). Comprueba si el objeto no es null. Comprueba si las dos variables hacen referencia al mismo objeto. Comprueba si las dos variables no hacen referencia al mismo objeto. Se usa para hacer que el método falle y descubrir qué partes del código no se contemplan. Se suele hacer antes de desarrollar. El parámetro message es opcional.

assertSame([message,] expected,actual). Comprueba si las dos variables hacen referencia al mismo objeto. Comprueba si las dos variables no hacen referencia al mismo objeto. Se usa para hacer que el método falle y descubrir qué partes del código no se contemplan. Se suele hacer antes de desarrollar. El parámetro message es opcional. Comprueba si la condición es true.

assertNotSame([message,] expected,actual). Comprueba si las dos variables no hacen referencia al mismo objeto. Se usa para hacer que el método falle y descubrir qué partes del código no se contemplan. Se suele hacer antes de desarrollar. El parámetro message es opcional. Comprueba si la condición es true. Comprueba si la condición es false.

Para añadir una librería en Eclipse: tenemos que dar botón derecho al proyecto e ir a Properties. A continuación, dirigirnos a Java Build Path y a librerías. tenemos que dar botón derecho al proyecto e ir a Properties. A continuación, dirigirnos a Java Build y a librerías. tenemos que dar botón derecho al proyecto e ir a Properties. A continuación, dirigirnos a Java Path y a librerías. tenemos que dar botón derecho al proyecto e ir a Properties. A continuación, dirigirnos a Java Libraries y a librerías.

Para ejecutar un test JUnit en Eclipse: Run As > JUnit Test. Run > JUnit Test. Run As > JUnit. Run > JUnit.

¿Cómo se conoce a la excepción que se lanza cuando uno de los argumentos que se pasan a un método no son válidos?. IllegalArgumentException. NullPointerException. SecurityException. EOFException.