Crear un Archivo

    Esta es la parte que a la mayoria les gusta aprender, pero como todos saben siempre es bueno conocer la teoría antes de ir a la práctica.

    Primero, ¿qué es un archivo y para que sirve?

    En la informática, un archivo son un conjunto de datos agrupados y almacenados que luego pueden ser accesados desde cualquier medio (software), y sirven para poder tener toda la información de forma ordenada, accesible, forma rápida y sencilla. También seria válido decir que un archivo es como un fichero, ya que su función es muy parecida.

    Java, como cualquier otro lenguaje, puede manejar cualquier cantidad de extensiones para crear cualquier tipo archivo, las más utilizadas son vídeo, audio y texto. En esta entrada voy a explicar como crear un archivo de texto plano.

    Un archivo de texto plano es aquel que contiene sólo caracteres y no tiene un formato específico, para leerlos se puede utilizar cualquier codificación dependiendo de la lengua que se utilice. En pocas palabras es un archivo que contiene texto muy simple en el cual no existen letras en negrita o cursiva y tampoco existen tipos de letra especial como Verdana, Times o Arial.

    Para un archivo de texto simple podemos hacer una especie de arreglo, donde lo que escribamos se almacenara en el, y luego ira en el archivo. Para lograr esto utilizaremos el "FileOutputStream", que es una línea de código ubicada en la libreria "Input-Output".

    Voy a explicar dos tipos de ejemplos, uno en donde primero le indicamos al programa, por medio de una variable del tipo "String", que caracteres iran dentro de el y luego se abre el archivo, se guardan los caracteres y se cierra. Y el otro donde primero se abre el archivo, luego le decimos que ira en el y por ultimo lo guardamos.

    Para verlo mejor aqui estan los dos ejemplos, los ejemplos los veremos sin diálogos, para que comprendamos mejor como funciona la creación de un archivo en Java:

import java.io.*;

class archivocad1
{
@SuppressWarnings("deprecation")
public static void main (String [] args) throws IOException
{
String cad= "El oscuro amanecer";
byte[]s= new byte[cad.length()];
try
{
FileOutputStream F= new FileOutputStream("cadena.txt");
cad.getBytes(0,cad.length(),s,0);
F.write(s);
F.write((byte)'n');
}
catch (IOException e)
{
System.out.println("problema en flujo de salida");
}
}
}

import java.io.*;

class archivocad2
{
public static void main (String [] args)
{
byte[]s= new byte[80];
try
{
FileOutputStream F= new FileOutputStream("cadena.txt");
System.out.println("Ingrese una linea de texto: ");
int nchar;
nchar= System.in.read(s);
F.write(s,0,nchar);
}
catch (IOException e)
{
System.out.println("problema en flujo de salida");
}
}
}

    Explico las líneas de código que se encuentran en los dos ejemplos:

• byte [] s: este es un arreglo del tipo "byte" llamado "s".
• FileOutputStream F= new FileOutputStream("cadena.txt"): esta es la línea de código que genera el archivo, como su nombre lo indica es la Salida del Archivo. Lo que esta entre parentesis es el nombre y entensión del archivo. Al archivo temporal, por decirlo así, lo llamamos "F" y al archivo que se generara lo llamamos "cadena" con la extension de texto "txt".
• F.write: esto le indica al programa que va a escribir el archivo que creamos. Debe colocarse la variable del "FileOutputStream" seguida del ".write", en este caso fue llamada "F".

   Explico las líenas de código del primer ejemplo:

• @SuppressWarnings("deprecation"): esto lo hacemos para la recompilación de XLint, si lo colocamos sin esto igual corre, pero nos dara una excepción al compilar.
• String cad: indica al programa que lo que se va a almacenar en el archivo es una variable del tipo "String" con el texto "El oscuro amanecer".
• new byte[cad.length()]: indica que el tamaño o dimensión del arreglo va a ser igual a la cantidad de caracteres que se encuentran en la variable "cad".
• cad.getBytes(0,cad.length(),s,0): obitiene los bytes que se encuentran en la variable "cad" y los copia en el arreglo "s".
• F.write((byte)'\n'): indica que se escribira en el archivo caracteres del tipo "byte" y el "\n" es para que sea en la siguiente línea.

    Explico las líneas de código del segundo ejemplo:

• new byte[80]: declaramos el arreglo con una dimensión de 80.
• int nchar: declaramos una variable del tipo "int" llamada "nchar".
• nchar= System.in.read(s): indica al programa que lo que escribamos se almacenara en la variable "nchar" y que pertenecera al arreglo de bytes "s".
• F.write(s,0,nchar): indica que se escribira en el archivo anteriormente creado lo que se almaceno en el arreglo y en la variable "nchar".

    En los dos ejemplo utilizamos un "try and catch", esto es recomendado ya que al momento de crear un archivo se puede generar una excepción y asi podemos manejarla.

    Si ejecutamos los dos programas vemos la diferencia entre ellos y notamos que en uno primero se lee y luego se escribe y en el otro ocurre lo contrario.

    Al compilar y ejecutar, el archivo que estamos generando se crea donde se esta ejecutando el programa. Por ejemplo: si estamos compilando el ejemplo en c:\, el archivo sera generado en c:\. Es decir que la ubicación del archivo seria c:\cadena.txt.

Recibe notificaciones por correo