6.- Archivos

Haciendo uso de libros, foros,
wikis, blogs, webquest, artículos
científicos, o algunas otras TICs, el
estudiante debe investigar:
.
.
Los conceptos básicos, sintaxis y
ejemplos de programas en
lenguajes Java y Python, acerca
de todo lo referente a archivos
.
. Debe participar investigando al
menos tres de los siguientes temas
para presentar en este Foro y en
plenaria durante alguna clase. Los
temas son:
.
.
– Definición de archivo, /
– Definición de archivos de texto y
archivos binarios, /
– Operaciones básicas en archivos
texto y binario, /
– Manejo de excepciones en
archivos (solo las exclusivas para
archivos), /
– Conceptos y metodologías para
manipular archivos de texto y
binarios en un lenguaje de
programación orientado a objetos /
– Implementar un bloc de notas
sencillo (haciendo énfasis en las
operaciones de archivos de
texto), /
– Implementar una “Mini” Hoja de
Cálculo (haciendo énfasis en el uso
de archivos binarios)...
.
.
. /////// En todos los casos debe
presentar fragmentos de código
fuente en Java o Python; así como
diseño UML (principalmente para
los últimos dos casos).
.
. ///// Procure analizar la
información de distintas fuentes
(incluyendo un segundo idioma)
para seleccionar la más
conveniente y que sea adecuada
al área de Informática. Elabore un
resumen o análisis o síntesis o
reflexión o tabla comparativa o
cuadro sinóptico (estilo inducción-
deducción) o mapa conceptual o
mapa mental, que permitan
promover el pensamiento crítico o
posición critica del estudiante, el
cual debe compartir en este Foro.
.
.
NOTA: Procure participar con
reactivos que aún no hayan sido
contestados, ya que solamente se
considerarán las primeras tres
participaciones.
.
. ATTE: M.C. Edgar Rangel Lugo.
.

Definición de archivos de texto y binarios.




fragmento codigo fuente de notepad:

import java.io.*;

class archivo {

private String nombre = "naname.txt";
private String lineas[] = new String [100];
private int numLineas;
private int MaxLineas;
private FileOutputStream out;
private DataOutputStream dout;
private FileInputStream in;
private BufferedReader din;

public archivo(){
nombre ="noname1.txt";
MaxLineas=100;
lineas = new String[MaxLineas];
numLineas=0;
}//CONSTRUCTOR

public archivo(String nombre){
this.nombre=nombre;
MaxLineas=100;
lineas= new String[MaxLineas];
numLineas=0;
}//CONTRUCTOR

public void setBuffer(int n){setLineas(n);}//VOID

public void setLineas(int n){
MaxLineas = n;
lineas = new String[MaxLineas];
numLineas=0;
}//VOID

public void crear(String nombre) {this.nombre = nombre; crear();}//VOID

public void crear(){
try{
out= new FileOutputStream(this.nombre); dout = new DataOutputStream(out);
lineas=new String[MaxLineas]; numLineas=0;}catch(Exception e){}
}//VOID

public void escribir(int dato) {agregar(String.valueOf(dato));}//VOID
public void escribir(double dato) {agregar(String.valueOf(dato));}//VOID
public void escribir(char dato) {agregar(String.valueOf(dato));}//VOID

public void escribir(String linea) {agregar(linea);}//VOID
public void agregar(String linea){
if(numLineas<MaxLineas){
try{dout.writeBytes(""+linea+"\n");}catch(Exception e){}
lineas[numLineas]= linea; numLineas++;
}else{
javax.swing.JOptionPane.showMessageDialog(null,"Nose permite agregar mas de "+MaxLineas+" lineas.","ERROR",0);
}//ELSE
}//VOID

public void abrir(String nombre) {this.nombre= nombre; abrir();}//VOID
public void abrir(){
try{
in = new FileInputStream(this.nombre);
din= new BufferedReader(new InputStreamReader(in));
numLineas=0; String cad="";
do{
cad=din.readLine();
if(cad!=null){lineas[numLineas]=cad; numLineas++;}
}while(cad!=null);
din.close(); in.close();
}catch(Exception e){ }
}//VOID

public String[] getLineasArchivo(){return lineas;}//VOID

public String getArchivo(){//MUESTRA ARCHIVO COMPLETO
String cadenota="";
for (int i=0;i<numLineas;i++){
cadenota+= (lineas[i]+"\n");
}//FOR
return cadenota;
}//Void

public void cerrar(){
try{dout.close();}catch(Exception e1){} try{out.close();}catch(Exception e2){}
}//VOID

public void borrar(int n){//BORRA UNA LINEA DEL ARCHIVO
for(int i=n;i<(numLineas-1); i++){lineas[i]=lineas[i+1];}//FOR
numLineas=numLineas-1; actualizar();
}//VOID

public void modificar(int n, String cadenita){//MODIFICA UNA LINEA DEL ARCHIVO
if (n<numLineas){lineas[n]=cadenita;}
actualizar();
}//VOID

public String consultar(int n){//REGRESA UNA LINEA DEL ARCHIVO
String cad="No se encontro"; if(n<numLineas){cad=lineas[n];}
return cad;
}//VOID

public void guardar(){
try{
FileOutputStream xout = new FileOutputStream(this.nombre);
DataOutputStream xdout = new DataOutputStream (xout);
xdout.writeBytes(""+getArchivo()+""); xdout.close(); xout.close();
}catch(Exception ex){}
}//VOID

public void elminar(String nombre2){
try{cerrar();}catch(Exception e){}
//BORRANDO FISICAMENTE EL ARCHIVO
try{ File ff= new File(this.nombre); ff.delete(); }catch(Exception e2){}
}//VOID


}//CLASS




import java.io.*;
import java.awt.*;
import java.awt.event.*;

class notepad extends archivo {

private Frame v = new Frame("notepad");
private TextArea area = new TextArea();

private MenuBar mb = new MenuBar();
private Menu m1 = new Menu("Archivo");
private MenuItem i1 = new MenuItem("Nuevo");
private MenuItem i2 = new MenuItem("Abrir");
private MenuItem i3 = new MenuItem("Guardar");
private MenuItem i4 = new MenuItem("Salir");


public notepad (){
v.setSize(400,400);
v.setLayout(new BorderLayout());
v.add(BorderLayout.CENTER, area);
mb.add(m1);
m1.add(i1); m1.add(i2); m1.add(i3);
m1.add(i4);
v.setMenuBar(mb);
v.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent ev) { System.exit(0);}
});

i1.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent ev) {
area.setText("");
String fuente = javax.swing.JOptionPane.showInputDialog("Nombre de la Letra/Fuente:");
area.setFont(new Font( fuente, Font.PLAIN, 14) );
}
});
i2.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent ev) {
archivo A = new archivo();
FileDialog fd = new FileDialog( v , "Abriendo...", FileDialog.LOAD);
fd.setVisible(true);
String nombre = ""+ fd.getDirectory() + fd.getFile() ;
v.setTitle(""+fd.getFile()+" - My Bloc de Notas");
A.setBuffer(5000);
A.abrir(nombre) ;
area.setText (A.getArchivo()) ;
A.cerrar();
}
});
i3.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent ev) {
archivo A = new archivo();
FileDialog fd = new FileDialog( v , "Guardando...", FileDialog.SAVE);
fd.setVisible(true);
String nombre = ""+ fd.getDirectory() + fd.getFile() ;
A.setBuffer(5000);
A.crear(nombre) ;
A.escribir(area.getText());
A.cerrar();
}
});
i4.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent ev) {

}
});

v.setVisible(true);
}//CONSTRUCTOR

}//CLASS



import java.io.* ;

public class principal {
public static void main(String args[]) {
notepad app = new notepad();
}//main
} //class

ARCHIVOS

APARTADOS

La clase File
Archivos tipo texto
Archivos binarios
Acceso aleatorio

La clase File

La clase file contiene una gran colección de métodos que pueden servir de gran ayuda:

Obtener información del archivo
String getName()
String getPath()

String getAbsolutePath()
String getParent()
boolean renameTo( File nuevoNombre )
long lastModified()
long length()

Propiedades del archivo
boolean exists()
boolean canWrite()
boolean canRead()
boolean isFile()
boolean isDirectory()
boolean isAbsolute()

Acciones
boolean mkdir()
String[] list()

























¿Cómo crear un objeto de la clase File?. Existen dos alternativas para la creación de instancias de la clase File:

1) Se crea el objeto directamente:

File fichero;

fichero = new File("c:\fich.txt")

2) Se crea un objeto que haga referencia a un directorio y posteriormente se crea otro objeto a partir de dicho directorio:

File directorio = new File("c:\datos");

File fichero = new File(directorio, "fich.txt");

A continuación se va a ver un ejemplo sencillo de uso:

//Descripción: Ejemplo sencillo de archivos
//Autor: Daniel Leyva Cortés
//Contacto: transistor47@hotmail.com
import java.io.*;

class operacionesArchivo
{

//"throws IOException", así no habrá que usar la sentencia try.
public static void main( String args[] ) throws IOException {

//Se recoge el nombre del archivo, el cual será el único parámetro pasado en la llamada
File fichero = new File( args[0] );

//Se visualizan las propiedades del archivo
System.out.println( "Ruta: "+fichero.getPath() );
if( fichero.exists() )
{



System.out.println( "Fichero " + fichero.getName() +
" existe, y su longitud es " + fichero.length() + " bytes");

if (fichero.canRead())
System.out.println("El fichero puede leerse");
if (fichero.canWrite())
System.out.println("El fichero puede escribirse");

}
else
System.out.println( "El fichero " + args[0] + ",no existe" );
}
}
} //IMPORTANTE. Para ejecutarlo habrá que indicar el nombre del archivo, ejemplo:
//java operacionesArchivo fichero.txt
Archivos tipo texto

Para archivos de tipo texto se usan las clases "FileInputStream" y "FileOutputStream". Para lectura y escritura se usarán los métodos "read" y "write" respectivamente:

(dos ejemplos extraídos de la URL http://www.javacoffeebreak.com/java103/java103.html)

LECTURA DE ARCHIVO

import java.io.*;

class FileInputDemo
{
public static void main(String args[])
{

// args.length equivalente al "argc" del lenguaje C
if (args.length == 1)
{

try
{
//Abre el archivo indicado como primer parámetro

FileInputStream fstream = new FileInputStream(args[0]);

//Se convierte el input stream en DataInputStream

DataInputStream in = new DataInputStream(fstream);

//Lee "líneas" mientras quede contenido

while (in.available() !=0)
{

//Imprime la línea rescatada del archivo en pantalla
System.out.println (in.readLine());


}

in.close();

}
catch (Exception e)
{


System.err.println("Error en archivo de entrada");


}


}
else

System.out.println("Parámetros incorrectos");


}

}

ESCRITURA DE ARCHIVO

import java.io.*;



class FileOutputDemo
{

public static void main(String args[])
{

FileOutputStream out; // Declara archivo salida
PrintStream p; // Declara un objeto "PrintStream"

try
{


// Crea un fichero de salida llamado miArchivo.txt

out = new FileOutputStream("miArchivo.txt");

// Enlaza "PrintStream" al archivo de saloda
p = new PrintStream( out );

p.println ("Este texto se escribe en un archivo de salida");

p.close();

}
catch (Exception e)
{

System.err.println ("Error escribiendo en el archivo");
}

}
}

EJERCICIO: Realizar el comando "RENOMBRA <original> <destino>" que renombre un archivo de tipo texto utilizando el método de copia (es decir, se crea un nuevo archivo con el nombre al que se quiere renombrar y una vez copiado el contenido se destruye el original)

Archivos binarios

En los archivos binarios habrá que usar aparte de las clases ya vistas en el apartado anterior "FileInputStream" y "FileOutputStream", las clases "DataInputStream" y "DataOutputStream".

Para lectura del contenido se dispone de los siguientes métodos, prácticamente uno para cada tipo de dato:

byte readByte()
int readUnsignedByte()
short readShort()
int readUnsignedShort()
char readChar()
int readInt()
long readLong()
float readFloat()
double readDouble()
String readLine()
Para escritura se dispone de los siguientes métodos, prácticamente uno para cada tipo de dato:

void writeBoolean( boolean b );
void writeByte( int i );
void writeShort( int i );
void writeChar( int i );
void writeInt( int i );
void writeFloat( float f );
void writeDouble( double d );
void writeBytes( String s );
void writeChars( string s );
A continuación se va a ver un ejemplo de uso:

//Descripción: Archivos de entrada/salida binarios
//Autor: Daniel Leyva Cortés
//Contacto: transistor47@hotmail.com
import java.io.*;

class estructuraDatos
{

String nombre;
int edad;
long dni;
class binarioEntradaSalida
{
//Inicialmente estaba declarada de la siguiente forma:
//final int LONGITUD_LINEA=1024; pero se le ha tenido
//que añadir "static" pues sino aparecía el siguiente error:
//non-static variable LONGITUD_LINEA cannot be referenced from a static context
// byte linea[] = new byte[LONGITUD_LINEA];
static final int LONGITUD_LINEA=80;
static final String NOMBRE_ARCHIVO="prueba.dat";


public static void main( String args[] ) throws IOException
{

FileInputStream ficheroTextoEntrada;
FileOutputStream ficheroTextoSalida;
DataInputStream ficheroBinarioEntrada;
DataOutputStream ficheroBinarioSalida;
cEntrada entrada = new cEntrada();
String lineaLeida;
estructuraDatos registro = new estructuraDatos();

//ESCRITURA EN ARCHIVO BINARIO
//Para abrir un archivo binario hay que realizar dos pasos:
ficheroTextoSalida = new FileOutputStream(NOMBRE_ARCHIVO);
ficheroBinarioSalida = new DataOutputStream(ficheroTextoSalida);

System.out.print("Nombre:");
lineaLeida = entrada.leeCadena();
while(lineaLeida.compareTo("")!=0)
{
registro.nombre = new String(lineaLeida);
System.out.print("DNI:");
registro.dni = Long.parseLong(entrada.leeCadena());
System.out.print("Edad:");
registro.edad = Integer.parseInt(entrada.leeCadena());

//Ahora se escribe el contenido del registro
//MUY IMPORTANTE: Para escribir una cadena se usará el método "writeUTF"
//el cual escribirá los caracteres usando la codificación UTF-8 modificada
//totalmente independiente de la máquina
ficheroBinarioSalida.writeUTF(registro.nombre);
ficheroBinarioSalida.writeInt(registro.edad);
ficheroBinarioSalida.writeLong(registro.dni);
System.out.print("Nombre:");
lineaLeida = entrada.leeCadena();
}

//El cierre de un archivo binario se realiza en los dos siguientes pasos:
ficheroBinarioSalida.close();
ficheroTextoSalida.close();
//FIN ESCRITURA ARCHIVO BINARIO
//LECTURA DEL ARCHIVO BINARIO

ficheroTextoEntrada = new FileInputStream(NOMBRE_ARCHIVO);
ficheroBinarioEntrada = new DataInputStream(ficheroTextoEntrada);

System.out.println("Contenido del archivo " + NOMBRE_ARCHIVO);

while (ficheroBinarioEntrada.available()!=0)
{
System.out.print("Nombre:");
System.out.println(ficheroBinarioEntrada.readUTF());
System.out.print("DNI:");
System.out.println(ficheroBinarioEntrada.readInt());
System.out.print("Edad:");
System.out.println(ficheroBinarioEntrada.readLong());

}

ficheroBinarioEntrada.close();
ficheroTextoEntrada.close();

}

}

class cEntrada
{
InputStreamReader entrada;
BufferedReader bufferEntrada;

public cEntrada()
{

entrada = new InputStreamReader(System.in);
bufferEntrada = new BufferedReader(entrada);
}
public String leeCadena()
{
String cadena = new String("");
try
{
cadena = bufferEntrada.readLine();
}
catch(java.io.IOException excepcionProducida )
{
System.err.println("Problema al intertar leer de la entrada estándar...");
}
return new String(cadena);
}

}

EJERCICIO: Crear un programa en Java que genere el archivo binario "notas.dat". Este archivo contendrá las notas de 10 alumnos (de cada alumno se almacenará un número identificativo del 1 al 10, su nombre y apellidos) en las asignaturas de REDES y PROGRAMACIÓN. El programa tendrá que visualizar el contenido del archivo generado

Acceso aleatorio

Código ejemplo: cada vez que se ejecuta el programa se incorpora una nueva entrada en un archivo log. La primera vez que se ejecuta se crea el archivo log:

(Código fuente extraído de la URL: http://www.ulpgc.es/otros/tutoriales/java/Cap8/fich_al.html#accesoaleatorio)

import java.io.*;

class Log {

public static void main( String args[] ) throws IOException {


RandomAccessFile miRAFile;
String s = "Cadena a insertar en el archivo\n";

// Se abre el fichero de acceso aleatorio
miRAFile = new RandomAccessFile( "/tmp/java.log","rw" );
// En la siguiente sentencia se posiciona al final del archivo
miRAFile.seek( miRAFile.length() );
// Se escribe una cadena en el archivo
miRAFile.writeBytes( s );
// Cierre del archivo
miRAFile.close();



}

}
En el siguiente ejemplo se envía como argumento el nombre de un fichero (si no existe se crea). El usuario escribirá texto hasta que introduzca una línea en blanco. Cuando se produzca la línea en blanco se muestra en pantalla la información que se ha ido almacenando en el archivo:

(Ejemplo extraído de la URL http://metodosestadisticos.unizar.es/asignaturas/10234/mateo/FRAF2.java)

import java.io.*;


class ficherosTextoAleatorio{

public static void main(String args[]){

File f;

RandomAccessFile fichero;

int leidos;

if(args.length==0 || args.length >1){


System.out.println("Error, introducir como argumento el nombre del archivo");
System.exit(1);

}

f= new File(args[0]);

String cadena = new String(" ");

try{

//Se crea archivo
fichero = new RandomAccessFile(f,"rw");

//Se reserva un espacio de memoria
byte buffer[] = new byte[250];

while(cadena.length()>1)

{

leidos=System.in.read(buffer); //Se lee de la entrada estándar
cadena = new String(buffer,0,leidos); //Se copia en una cadena los caracteres leídos

//Se presenta en pantalla información de la cadena leída
System.out.print(""+leidos+":"+cadena.length()+": "+cadena);

//Si es una cadena vacía se escribe la cadena en el archivo
if(cadena.length()>1)

fichero.writeChars(cadena);

}


fichero.close();


}
catch(IOException e){


System.out.println("Error en el proceso");
System.exit(1);


}


System.out.println("Se ha cerrado el archivo");

try{

//Apertura archivo
fichero = new RandomAccessFile(f,"r");
int i=1;
while(true){

//Lectura de una línea del archivo
cadena=fichero.readLine();

//Si la cadena está vacía quiere decir que el archivo

//no tiene más contenido
if(cadena==null)

throw new EOFException();

//Se visualiza la cadena leída

System.out.println(""+i+": "+cadena);
i++;

}


}
catch(EOFException e)

{

System.out.println("Se ha llegado al final del archivo");

}
catch(IOException e){

System.out.println("Error en proceso");

}

}



}

¿Que es un Archivo?

Un archivo JAR (por sus siglas en inglés, Java ARchive) es un tipo de archivo que permite ejecutar aplicaciones escritas en el lenguaje Java. Las siglas están deliberadamente escogidas para que coincidan con la palabra inglesa "jar" (tarro). Los archivos JAR están comprimidos con el formato ZIP y cambiada su extensión a .jar. Existen tres operaciones básicas con este tipo de archivos: ver contenido, comprimir y descomprimir.

Instrucciones:

Ver contenido: $ jar -tvf archivo.jar
Comprimir: $ jar -cvf archivo.jar archivo_1 archivo_2 archivo_3 ... archivo_n
Descomprimir: $ jar -xvf archivos.jar
Un vínculo de descarga a .jar es .jad, y pesa muy poco. Estos archivos se utilizan normalmente para aplicaciones en teléfonos móviles.

Los archivos de texto plano son aquellos que están compuestos únicamente por texto sin formato, solo caracteres. estos caracteres se pueden codificar de distintos modos dependiendo de la lengua usada. Se les conoce también como archivos de texto llano o texto simple por carecer de información destinada a generar formatos y tipos de letra.

[center]¿Que es un Archivo de Texto?[/center]
Un archivo binario es una archivo informático que contiene información de cualquier tipo, codificada en forma binaria para el propósito de almacenamiento y procesamiento de ordenadores.
Muchos formatos binarios contienen partes que pueden ser interpretados como texto. Un archivo binario que solo contiene información de tipo textual sin información sobre el formato del mismo, se dice que es un archivo de texto plano. Habitualmente se contraponen los términos archivo binario y archivo de texto de forma que los primeros no contienen solamentente texto.



archivo.java
import java.io.*;

class archivo {

private String nombre = "naname.txt";
private String lineas[] = new String [100];
private int numLineas;
private int MaxLineas;
private FileOutputStream out;
private DataOutputStream dout;
private FileInputStream in;
private BufferedReader din;

public archivo(){
nombre ="noname1.txt";
MaxLineas=100;
lineas = new String[MaxLineas];
numLineas=0;
}//CONSTRUCTOR

public archivo(String nombre){
this.nombre=nombre;
MaxLineas=100;
lineas= new String[MaxLineas];
numLineas=0;
}//CONTRUCTOR

public void setBuffer(int n){setLineas(n);}//VOID
public void setLineas(int n){
MaxLineas = n;
lineas = new String[MaxLineas];
numLineas=0;
}//VOID

public void crear(String nombre) {this.nombre = nombre; crear();}//VOID

public void crear(){
try{
out= new FileOutputStream(this.nombre); dout = new DataOutputStream(out);
lineas=new String[MaxLineas]; numLineas=0;}catch(Exception e){}
}//VOID

public void escribir(int dato) {agregar(String.valueOf(dato));}//VOID
public void escribir(double dato) {agregar(String.valueOf(dato));}//VOID
public void escribir(char dato) {agregar(String.valueOf(dato));}//VOID

public void escribir(String linea) {agregar(linea);}//VOID
public void agregar(String linea){
if(numLineas<MaxLineas){
try{dout.writeBytes(""+linea+"\n");}catch(Exception e){}
lineas[numLineas]= linea; numLineas++;
}else{
javax.swing.JOptionPane.showMessageDialog(null,"Nose permite agregar mas de "+MaxLineas+" lineas.","ERROR",0);
}//ELSE
}//VOID

public void abrir(String nombre) {this.nombre= nombre; abrir();}//VOID
public void abrir(){
try{
in = new FileInputStream(this.nombre);
din= new BufferedReader(new InputStreamReader(in));
numLineas=0; String cad="";
do{
cad=din.readLine();
if(cad!=null){lineas[numLineas]=cad; numLineas++;}
}while(cad!=null);
din.close(); in.close();
}catch(Exception e){ }
}//VOID

public String[] getLineasArchivo(){return lineas;}//VOID

public String getArchivo(){//MUESTRA ARCHIVO COMPLETO
String cadenota="";
for (int i=0;i<numLineas;i++){
cadenota+= (lineas[i]+"\n");
}//FOR
return cadenota;
}//Void

public void cerrar(){
try{dout.close();}catch(Exception e1){} try{out.close();}catch(Exception e2){}
}//VOID

public void borrar(int n){//BORRA UNA LINEA DEL ARCHIVO
for(int i=n;i<(numLineas-1); i++){lineas[i]=lineas[i+1];}//FOR
numLineas=numLineas-1; actualizar();
}//VOID

public void modificar(int n, String cadenita){//MODIFICA UNA LINEA DEL ARCHIVO
if (n<numLineas){lineas[n]=cadenita;}
actualizar();
}//VOID
public String consultar(int n){//REGRESA UNA LINEA DEL ARCHIVO
String cad="No se encontro"; if(n<numLineas){cad=lineas[n];}
return cad;
}//VOID

public void guardar(){
try{
FileOutputStream xout = new FileOutputStream(this.nombre);
DataOutputStream xdout = new DataOutputStream (xout);
xdout.writeBytes(""+getArchivo()+""); xdout.close(); xout.close();
}catch(Exception ex){}
}//VOID

public void elminar(String nombre2){
try{cerrar();}catch(Exception e){}
//BORRANDO FISICAMENTE EL ARCHIVO
try{ File ff= new File(this.nombre); ff.delete(); }catch(Exception e2){}
}//VOID


}//CLASS

ATTE:CARLOS ALBERTO CRUZ MARCELO
2A6
ING EN INFORMATICA

la bibliografia es la sguiente:
http://es.wikipedia.org/wiki/Java_Archive
http://xtremepoo.blogspot.mx/2009/06/definicion-de-archivos-de-texto-y.html


ATTE:CARLOS ALBERTO CRUZ MARCELO
2A6
ING EN INFORMATICA

¿Que es un Archivo?

Un archivo JAR (por sus siglas en inglés, Java ARchive) es un tipo de archivo que permite ejecutar aplicaciones escritas en el lenguaje Java. Las siglas están deliberadamente escogidas para que coincidan con la palabra inglesa "jar" (tarro). Los archivos JAR están comprimidos con el formato ZIP y cambiada su extensión a .jar. Existen tres operaciones básicas con este tipo de archivos: ver contenido, comprimir y descomprimir.

Instrucciones:

Ver contenido: $ jar -tvf archivo.jar
Comprimir: $ jar -cvf archivo.jar archivo_1 archivo_2 archivo_3 ... archivo_n
Descomprimir: $ jar -xvf archivos.jar
Un vínculo de descarga a .jar es .jad, y pesa muy poco. Estos archivos se utilizan normalmente para aplicaciones en teléfonos móviles.

¿Que es un Archivo de Texto?
Los archivos de texto plano son aquellos que están compuestos únicamente por texto sin formato, solo caracteres. estos caracteres se pueden codificar de distintos modos dependiendo de la lengua usada. Se les conoce también como archivos de texto llano o texto simple por carecer de información destinada a generar formatos y tipos de letra.

Un archivo binario es una archivo informático que contiene información de cualquier tipo, codificada en forma binaria para el propósito de almacenamiento y procesamiento de ordenadores.
Muchos formatos binarios contienen partes que pueden ser interpretados como texto. Un archivo binario que solo contiene información de tipo textual sin información sobre el formato del mismo, se dice que es un archivo de texto plano. Habitualmente se contraponen los términos archivo binario y archivo de texto de forma que los primeros no contienen solamentente texto.


codigo en JAVA

archivo.java
import java.io.*;

class archivo {

private String nombre = "naname.txt";
private String lineas[] = new String [100];
private int numLineas;
private int MaxLineas;
private FileOutputStream out;
private DataOutputStream dout;
private FileInputStream in;
private BufferedReader din;

public archivo(){
nombre ="noname1.txt";
MaxLineas=100;
lineas = new String[MaxLineas];
numLineas=0;
}//CONSTRUCTOR

public archivo(String nombre){
this.nombre=nombre;
MaxLineas=100;
lineas= new String[MaxLineas];
numLineas=0;
}//CONTRUCTOR

public void setBuffer(int n){setLineas(n);}//VOID
public void setLineas(int n){
MaxLineas = n;
lineas = new String[MaxLineas];
numLineas=0;
}//VOID

public void crear(String nombre) {this.nombre = nombre; crear();}//VOID

public void crear(){
try{
out= new FileOutputStream(this.nombre); dout = new DataOutputStream(out);
lineas=new String[MaxLineas]; numLineas=0;}catch(Exception e){}
}//VOID

public void escribir(int dato) {agregar(String.valueOf(dato));}//VOID
public void escribir(double dato) {agregar(String.valueOf(dato));}//VOID
public void escribir(char dato) {agregar(String.valueOf(dato));}//VOID

public void escribir(String linea) {agregar(linea);}//VOID
public void agregar(String linea){
if(numLineas<MaxLineas){
try{dout.writeBytes(""+linea+"\n");}catch(Exception e){}
lineas[numLineas]= linea; numLineas++;
}else{
javax.swing.JOptionPane.showMessageDialog(null,"Nose permite agregar mas de "+MaxLineas+" lineas.","ERROR",0);
}//ELSE
}//VOID

public void abrir(String nombre) {this.nombre= nombre; abrir();}//VOID
public void abrir(){
try{
in = new FileInputStream(this.nombre);
din= new BufferedReader(new InputStreamReader(in));
numLineas=0; String cad="";
do{
cad=din.readLine();
if(cad!=null){lineas[numLineas]=cad; numLineas++;}
}while(cad!=null);
din.close(); in.close();
}catch(Exception e){ }
}//VOID

public String[] getLineasArchivo(){return lineas;}//VOID

public String getArchivo(){//MUESTRA ARCHIVO COMPLETO
String cadenota="";
for (int i=0;i<numLineas;i++){
cadenota+= (lineas[i]+"\n");
}//FOR
return cadenota;
}//Void

public void cerrar(){
try{dout.close();}catch(Exception e1){} try{out.close();}catch(Exception e2){}
}//VOID

public void borrar(int n){//BORRA UNA LINEA DEL ARCHIVO
for(int i=n;i<(numLineas-1); i++){lineas[i]=lineas[i+1];}//FOR
numLineas=numLineas-1; actualizar();
}//VOID

public void modificar(int n, String cadenita){//MODIFICA UNA LINEA DEL ARCHIVO
if (n<numLineas){lineas[n]=cadenita;}
actualizar();
}//VOID
public String consultar(int n){//REGRESA UNA LINEA DEL ARCHIVO
String cad="No se encontro"; if(n<numLineas){cad=lineas[n];}
return cad;
}//VOID

public void guardar(){
try{
FileOutputStream xout = new FileOutputStream(this.nombre);
DataOutputStream xdout = new DataOutputStream (xout);
xdout.writeBytes(""+getArchivo()+""); xdout.close(); xout.close();
}catch(Exception ex){}
}//VOID

public void elminar(String nombre2){
try{cerrar();}catch(Exception e){}
//BORRANDO FISICAMENTE EL ARCHIVO
try{ File ff= new File(this.nombre); ff.delete(); }catch(Exception e2){}
}//VOID


}//CLASS

Un archivo JAR (por sus siglas en inglés, Java ARchive) es un tipo de archivo que permite ejecutar aplicaciones escritas en el lenguaje Java. Las siglas están deliberadamente escogidas para que coincidan con la palabra inglesa "jar" (tarro). Los archivos JAR están comprimidos con el formato ZIP y cambiada su extensión a .jar. Existen tres operaciones básicas con este tipo de archivos: ver contenido, comprimir y descomprimir.

Instrucciones:

Ver contenido: $ jar -tvf archivo.jar
Comprimir: $ jar -cvf archivo.jar archivo_1 archivo_2 archivo_3 ... archivo_n
Descomprimir: $ jar -xvf archivos.jar
Un vínculo de descarga a .jar es .jad, y pesa muy poco. Estos archivos se utilizan normalmente para aplicaciones en teléfonos móviles.

¿Que es un Archivo de Texto?
Los archivos de texto plano son aquellos que están compuestos únicamente por texto sin formato, solo caracteres. estos caracteres se pueden codificar de distintos modos dependiendo de la lengua usada. Se les conoce también como archivos de texto llano o texto simple por carecer de información destinada a generar formatos y tipos de letra.

Un archivo binario es una archivo informático que contiene información de cualquier tipo, codificada en forma binaria para el propósito de almacenamiento y procesamiento de ordenadores.
Muchos formatos binarios contienen partes que pueden ser interpretados como texto. Un archivo binario que solo contiene información de tipo textual sin información sobre el formato del mismo, se dice que es un archivo de texto plano. Habitualmente se contraponen los términos archivo binario y archivo de texto de forma que los primeros no contienen solamentente texto.


codigo en JAVA

archivo.java
import java.io.*;

class archivo {

private String nombre = "naname.txt";
private String lineas[] = new String [100];
private int numLineas;
private int MaxLineas;
private FileOutputStream out;
private DataOutputStream dout;
private FileInputStream in;
private BufferedReader din;

public archivo(){
nombre ="noname1.txt";
MaxLineas=100;
lineas = new String[MaxLineas];
numLineas=0;
}//CONSTRUCTOR

public archivo(String nombre){
this.nombre=nombre;
MaxLineas=100;
lineas= new String[MaxLineas];
numLineas=0;
}//CONTRUCTOR

public void setBuffer(int n){setLineas(n);}//VOID
public void setLineas(int n){
MaxLineas = n;
lineas = new String[MaxLineas];
numLineas=0;
}//VOID

public void crear(String nombre) {this.nombre = nombre; crear();}//VOID

public void crear(){
try{
out= new FileOutputStream(this.nombre); dout = new DataOutputStream(out);
lineas=new String[MaxLineas]; numLineas=0;}catch(Exception e){}
}//VOID

public void escribir(int dato) {agregar(String.valueOf(dato));}//VOID
public void escribir(double dato) {agregar(String.valueOf(dato));}//VOID
public void escribir(char dato) {agregar(String.valueOf(dato));}//VOID

public void escribir(String linea) {agregar(linea);}//VOID
public void agregar(String linea){
if(numLineas<MaxLineas){
try{dout.writeBytes(""+linea+"\n");}catch(Exception e){}
lineas[numLineas]= linea; numLineas++;
}else{
javax.swing.JOptionPane.showMessageDialog(null,"Nose permite agregar mas de "+MaxLineas+" lineas.","ERROR",0);
}//ELSE
}//VOID

public void abrir(String nombre) {this.nombre= nombre; abrir();}//VOID
public void abrir(){
try{
in = new FileInputStream(this.nombre);
din= new BufferedReader(new InputStreamReader(in));
numLineas=0; String cad="";
do{
cad=din.readLine();
if(cad!=null){lineas[numLineas]=cad; numLineas++;}
}while(cad!=null);
din.close(); in.close();
}catch(Exception e){ }
}//VOID

public String[] getLineasArchivo(){return lineas;}//VOID

public String getArchivo(){//MUESTRA ARCHIVO COMPLETO
String cadenota="";
for (int i=0;i<numLineas;i++){
cadenota+= (lineas[i]+"\n");
}//FOR
return cadenota;
}//Void

public void cerrar(){
try{dout.close();}catch(Exception e1){} try{out.close();}catch(Exception e2){}
}//VOID

public void borrar(int n){//BORRA UNA LINEA DEL ARCHIVO
for(int i=n;i<(numLineas-1); i++){lineas[i]=lineas[i+1];}//FOR
numLineas=numLineas-1; actualizar();
}//VOID

public void modificar(int n, String cadenita){//MODIFICA UNA LINEA DEL ARCHIVO
if (n<numLineas){lineas[n]=cadenita;}
actualizar();
}//VOID
public String consultar(int n){//REGRESA UNA LINEA DEL ARCHIVO
String cad="No se encontro"; if(n<numLineas){cad=lineas[n];}
return cad;
}//VOID

public void guardar(){
try{
FileOutputStream xout = new FileOutputStream(this.nombre);
DataOutputStream xdout = new DataOutputStream (xout);
xdout.writeBytes(""+getArchivo()+""); xdout.close(); xout.close();
}catch(Exception ex){}
}//VOID

public void elminar(String nombre2){
try{cerrar();}catch(Exception e){}
//BORRANDO FISICAMENTE EL ARCHIVO
try{ File ff= new File(this.nombre); ff.delete(); }catch(Exception e2){}
}//VOID


}//CLASS


2A6
ING EN INFORMATICA

Un archivo JAR (por sus siglas en inglés, Java ARchive) es un tipo de archivo que permite ejecutar aplicaciones escritas en el lenguaje Java. Las siglas están deliberadamente escogidas para que coincidan con la palabra inglesa "jar" (tarro). Los archivos JAR están comprimidos con el formato ZIP y cambiada su extensión a .jar. Existen tres operaciones básicas con este tipo de archivos: ver contenido, comprimir y descomprimir.

Instrucciones:

Ver contenido: $ jar -tvf archivo.jar
Comprimir: $ jar -cvf archivo.jar archivo_1 archivo_2 archivo_3 ... archivo_n
Descomprimir: $ jar -xvf archivos.jar
Un vínculo de descarga a .jar es .jad, y pesa muy poco. Estos archivos se utilizan normalmente para aplicaciones en teléfonos móviles.

Los archivos de texto plano son aquellos que están compuestos únicamente por texto sin formato, solo caracteres. estos caracteres se pueden codificar de distintos modos dependiendo de la lengua usada. Se les conoce también como archivos de texto llano o texto simple por carecer de información destinada a generar formatos y tipos de letra.

Un archivo binario es una archivo informático que contiene información de cualquier tipo, codificada en forma binaria para el propósito de almacenamiento y procesamiento de ordenadores.
codigo en JAVA

archivo.java
import java.io.*;

class archivo {

private String nombre = "naname.txt";
private String lineas[] = new String [100];
private int numLineas;
private int MaxLineas;
private FileOutputStream out;
private DataOutputStream dout;
private FileInputStream in;
private BufferedReader din;

public archivo(){
nombre ="noname1.txt";
MaxLineas=100;
lineas = new String[MaxLineas];
numLineas=0;
}//CONSTRUCTOR

public archivo(String nombre){
this.nombre=nombre;
MaxLineas=100;
lineas= new String[MaxLineas];
numLineas=0;
}//CONTRUCTOR

public void setBuffer(int n){setLineas(n);}//VOID
public void setLineas(int n){
MaxLineas = n;
lineas = new String[MaxLineas];
numLineas=0;
}//VOID

public void crear(String nombre) {this.nombre = nombre; crear();}//VOID

public void crear(){
try{
out= new FileOutputStream(this.nombre); dout = new DataOutputStream(out);
lineas=new String[MaxLineas]; numLineas=0;}catch(Exception e){}
}//VOID

public void escribir(int dato) {agregar(String.valueOf(dato));}//VOID
public void escribir(double dato) {agregar(String.valueOf(dato));}//VOID
public void escribir(char dato) {agregar(String.valueOf(dato));}//VOID

public void escribir(String linea) {agregar(linea);}//VOID
public void agregar(String linea){
if(numLineas<MaxLineas){
try{dout.writeBytes(""+linea+"\n");}catch(Exception e){}
lineas[numLineas]= linea; numLineas++;
}else{
javax.swing.JOptionPane.showMessageDialog(null,"Nose permite agregar mas de "+MaxLineas+" lineas.","ERROR",0);
}//ELSE
}//VOID

public void abrir(String nombre) {this.nombre= nombre; abrir();}//VOID
public void abrir(){
try{
in = new FileInputStream(this.nombre);
din= new BufferedReader(new InputStreamReader(in));
numLineas=0; String cad="";
do{
cad=din.readLine();
if(cad!=null){lineas[numLineas]=cad; numLineas++;}
}while(cad!=null);
din.close(); in.close();
}catch(Exception e){ }
}//VOID

public String[] getLineasArchivo(){return lineas;}//VOID

public String getArchivo(){//MUESTRA ARCHIVO COMPLETO
String cadenota="";
for (int i=0;i<numLineas;i++){
cadenota+= (lineas[i]+"\n");
}//FOR
return cadenota;
}//Void

public void cerrar(){
try{dout.close();}catch(Exception e1){} try{out.close();}catch(Exception e2){}
}//VOID

public void borrar(int n){//BORRA UNA LINEA DEL ARCHIVO
for(int i=n;i<(numLineas-1); i++){lineas[i]=lineas[i+1];}//FOR
numLineas=numLineas-1; actualizar();
}//VOID

public void modificar(int n, String cadenita){//MODIFICA UNA LINEA DEL ARCHIVO
if (n<numLineas){lineas[n]=cadenita;}
actualizar();
}//VOID
public String consultar(int n){//REGRESA UNA LINEA DEL ARCHIVO
String cad="No se encontro"; if(n<numLineas){cad=lineas[n];}
return cad;
}//VOID

public void guardar(){
try{
FileOutputStream xout = new FileOutputStream(this.nombre);
DataOutputStream xdout = new DataOutputStream (xout);
xdout.writeBytes(""+getArchivo()+""); xdout.close(); xout.close();
}catch(Exception ex){}
}//VOID

public void elminar(String nombre2){
try{cerrar();}catch(Exception e){}
//BORRANDO FISICAMENTE EL ARCHIVO
try{ File ff= new File(this.nombre); ff.delete(); }catch(Exception e2){}
}//VOID


}//CLASS

att: Andrea pineda osorio:) ING.EN INFORMATICA
[/font]

Un archivo o fichero informático es un conjunto de bits que son almacenados en un dispositivo. Un archivo es identificado por un nombre y la descripción de la carpeta o directorio que lo contiene. A los archivos informáticos se les llama así porque son los equivalentes digitales de los archivos escritos en libros, tarjetas, libretas, papel o microfichas del entorno de oficina tradicional.


ATT: RAFAEL CHARCO FERNANDEZ

Los archivos de texto plano son aquellos que están compuestos únicamente por texto sin formato, solo caracteres. estos caracteres se pueden codificar de distintos modos dependiendo de la lengua usada. Se les conoce también como archivos de texto llano o texto simple por carecer de información destinada a generar formatos y tipos de letra.

Un archivo binario es una archivo informático que contiene información de cualquier tipo, codificada en forma binaria para el propósito de almacenamiento y procesamiento de ordenadores.

Muchos formatos binarios contienen partes que pueden ser interpretados como texto. Un archivo binario que solo contiene información de tipo textual sin información sobre el formato del mismo, se dice que es un archivo de texto plano. Habitualmente se contraponen los términos archivo binario y archivo de texto de forma que los primeros no contienen solamente texto.

Las clases presistentes son clases en una aplicación que implementan las entidades del problema empresarial (por ejemplo, Customer y Order en una aplicación de comercio electrónico). No se considera que todas las instancias de una clase persistente estén en estado persistente. Por ejemplo, una instancia puede ser transitoria o separada.

Hibernate funciona mejor si estas clases siguen algunas reglas simples, también conocidas como el modelo de programación POJO (Plain Old Java Object). Sin embargo, ninguna de estas reglas son requerimientos rígidos. De hecho, Hibernate3 asume muy poco acerca de la naturaleza de sus objetos persistentes.


Manejo de Objetos Persistentes
Normalmente, cuando se codifica un programa, se hace con la intención de que ese programa pueda interactuar con los usuarios del mismo, es decir, que el usuario pueda pedirle que realice cosas y pueda suministrarle datos con los que se quiere que haga algo. Una vez introducidos los datos y las órdenes, se espera que el programa manipule de alguna forma esos datos para proporcionarnos una respuesta a lo solicitado.

Además, en muchas ocasiones interesa que el programa guarde los datos que se le han introducido, de forma que si el programa termina los datos no se pierdan y puedan ser recuperados en una sesión posterior. La forma más normal de hacer esto es mediante la utilización de ficheros que se guardarán en un dispositivo de memoria no volátil (normalmente un disco).

A todas estas operaciones, que constituyen un flujo de información del programa con el exterior, se les conoce como Entrada/Salida (E/S).

Existen dos tipos de E/S; la E/S estándar que se realiza con el terminal del usuario y la E/S a través de fichero, en la que se trabaja con ficheros de disco.

Todas las operaciones de E/S en Java vienen proporcionadas por el paquete estándar de la API de Java denominado java.io que incorpora interfaces, clases y excepciones para acceder a todo tipo de ficheros. En este tutorial sólo se van a dar algunas pinceladas de la potencia de este paquete.

TIPOS DE FLUJOS

Existen dos tipos de Flujos:

-Los que trabajan con Bytes
-Los que trabajan con Caracteres

Las clases mas importantes a tener en cuenta son las siguientes, donde el sangrado de las líneas indica la herencia, es decir, DataInputStream hereda de FilterInputStream que, a su vez, hereda de InputStream.
Entrada/Salida estándar

Aquí sólo trataremos la entrada/salida que se comunica con el usuario a través de la pantalla o de la ventana del terminal.

Si creamos una applet no se utilizarán normalmente estas funciones, ya que su resultado se mostrará en la ventana del terminal y no en la ventana de la applet. La ventana de la applet es una ventana gráfica y para poder realizar una entrada o salida a través de ella será necesario utilizar el AWT.

El acceso a la entrada y salida estándar es controlado por tres objetos que se crean automáticamente al iniciar la aplicación: System.in, System.out y System.err
Entrada/Salida por fichero

En Java es posible utilizar dos tipos de ficheros (de texto o binarios) y dos tipos de acceso a los ficheros (secuencial o aleatorio).

Los ficheros de texto están compuestos de caracteres legibles, mientras que los binarios pueden almacenar cualquier tipo de datos (int, float, boolean,...).

Una lectura secuencial implica tener que acceder a un elemento antes de acceder al siguiente, es decir, de una manera lineal (sin saltos). Sin embargo los ficheros de acceso aleatorio permiten acceder a sus datos de una forma aleatoria, esto es indicando una determinada posición desde la que leer/escribir.
import java.util.Set;
import java.util.Date;

public class Cat {
private Long id; // identifier
private Date birthdate;
private Color color;
private char sex;
private float weight;
private int litterId;
private Cat mother;
private Set kittens = new HashSet();
private void setId(Long id) {
this.id=id;
}
public Long getId() {
return id;
}
void setBirthdate(Date date) {
birthdate = date;
}
public Date getBirthdate() {
return birthdate;
}
void setWeight(float weight) {
this.weight = weight;
}
public float getWeight() {
return weight;
}
public Color getColor() {
return color;
}
void setColor(Color color) {
this.color = color;
}
void setSex(char sex) {
this.sex=sex;
}
public char getSex() {
return sex;
}
void setLitterId(int id) {
this.litterId = id;
}
public int getLitterId() {
return litterId;
}
void setMother(Cat mother) {
this.mother = mother;
}
public Cat getMother() {
return mother;
}
void setKittens(Set kittens) {
this.kittens = kittens;
}
public Set getKittens() {
return kittens;
}
public void addKitten(Cat kitten) {
kitten.setMother(this);
kitten.setLitterId( kittens.size() );
kittens.add(kitten);
}
}

Un Archivo o fichero informático es una entidad lógica compuesta por una secuencia finita de bytes, almacenada en un sistema de archivos ubicada en la memoria secundaria de un ordenador (disco duro, unidad extraíble, CD ROM, etc.) ó Colección de información relacionada a la que se le asigna un nombre y se almacena en un disco. Los archivos son agrupados en directorios dentro del sistema de archivos y son identificados por un nombre de archivo y una extensión. El nombre forma la identificación única en relación a los otros archivos en el mismo directorio.

Instrucciones:

Ver contenido: $ jar -tvf archivo.jar
Comprimir: $ jar -cvf archivo.jar archivo_1 archivo_2 archivo_3 ... archivo_n
Descomprimir: $ jar -xvf archivos.jar
Un vínculo de descarga a .jar es .jad, y pesa muy poco. Estos archivos se utilizan normalmente para aplicaciones en teléfonos móviles.

Los archivos de texto plano son aquellos que están compuestos únicamente por texto sin formato, solo caracteres. estos caracteres se pueden codificar de distintos modos dependiendo de la lengua usada. Se les conoce también como archivos de texto llano o texto simple por carecer de información destinada a generar formatos y tipos de letra.

Un archivo binario es una archivo informático que contiene información de cualquier tipo, codificada en forma binaria para el propósito de almacenamiento y procesamiento de ordenadores.
codigo en JAVA

archivo.java
import java.io.*;

class archivo {

private String nombre = "naname.txt";
private String lineas[] = new String [100];
private int numLineas;
private int MaxLineas;
private FileOutputStream out;
private DataOutputStream dout;
private FileInputStream in;
private BufferedReader din;

public archivo(){
nombre ="noname1.txt";
MaxLineas=100;
lineas = new String[MaxLineas];
numLineas=0;
}//CONSTRUCTOR

public archivo(String nombre){
this.nombre=nombre;
MaxLineas=100;
lineas= new
String[MaxLineas];
numLineas=0;

Att: RAFAEL CHARCO FERNANDEZ 2A6

Ing. Informatica

¿Qué son?
-Mecanismo de control de errores en tiempo de ejecución
-Una forma de hacer que la aplicación continúe la ejecución si se produce un error

¿Para qué sirven?
-A veces se usan para detectar situaciones inusuales en la ejecución
-Si se controlan todos los posibles errores directamente, el código se puede volver ilegible
-Con las excepciones se separa el código de un método del código que controla los errores

Como casi todo lo demás en java, las excepciones son objetos (que se crean cuando ocurre una situación anómala).

Se lanzan para que otra parte del código las capture y las trate.


Las excepciones que se derivan de Error suelen estar relacionadas con la máquina  virtual y no se espera que se capturen ni  se traten.

Las Excepciones deriv adas de Exception sí que deben ser tratadas, y en algunos casos es obligatorio hacerlo para que el programa compile.



El código que puede generar la excepción debe encerrarse dentro de un bloque
try

try
{
// Código que puede generar la excepción
}

A continuación, la excepción se captura con un
bloque  catch

catch (Exception e)
{
// Código para tratar el error
}



El código dentro del try puede generar más de una excepción, y se pueden capturar todas ellas:

try
{
//Código que puede provocar el error
}
catch(IOException ioe)
{
//Código para tratar la IOException
}
catch(Exception e)
{
//Código para tratar la Exception
}


Se puede capturar una excepción utilizando un tipo de excepción más general

try
{
//Código que produce una excepción de tipo IOException
}
catch (Exception e)
{
//Código para tratar una Exception
}

CUIDADO: Si un bloque de código lanza varias excepciones y se usan varios catch

-La excepción se captura en el primer catch que se ajusta a la excepción
-Los catch deben capturar las excepciones más concretas en primer lugar, y las más generales al final
-Si no lo hacemos así, hay bloques catch en los que no se entrará nunca

Lanzar Excepciones

Parte del tratamiento de una excepción puede incluir la propagación de la misma para que también la traten los métodos  llamantes.

También puede suceder que queramos que nuestro código lance una excepción en una situación determinada. En ambos casos es necesario decir que el método puede lanzar una excepción.

Lanzar Excepciones

Esto se hace utilizando la palabra reservada throws en la cabecera del método

public void miMetodo() throws ArithmeticException

Posteriormente, en el código, se puede lanzar una excepción usando la palabra reservada throw

catch (IOException ioe)
{...
throw ioe; throw new NullPointerException();
}

Crear Nuevas Excepciones

-Se pueden crear nuevas excepciones creando una nueva clase que herede de Exception
-Se suele añadir un constructor por defecto y otro que acepta un String
-Llamar al constructor de Exception desde el constructor de la nueva clase
-Si hace falta, añadir atributos, otros constructores y otros métodos.


Bibliografía
http://ocw.udl.cat/enginyeria-i-arquitectura/programacio-2/continguts-1/4-manejo-bai81sico-de-archivos-en-java.pdf

Julio César González Aguirre
Luís Adrian Pineda Herrera
Andy Hatzuri Alcaraz Milian
David Santana Alvarez

¿Que es un Archivo?

Un archivo JAR (por sus siglas en inglés, Java ARchive) es un tipo de archivo que permite ejecutar aplicaciones escritas en el lenguaje Java. Las siglas están deliberadamente escogidas para que coincidan con la palabra inglesa "jar" (tarro). Los archivos JAR están comprimidos con el formato ZIP y cambiada su extensión a .jar. Existen tres operaciones básicas con este tipo de archivos: ver contenido, comprimir y descomprimir.

¿Qué son?
-Mecanismo de control de errores en tiempo de ejecución
-Una forma de hacer que la aplicación continúe la ejecución si se produce un error

¿Para qué sirven?
-A veces se usan para detectar situaciones inusuales en la ejecución
-Si se controlan todos los posibles errores directamente, el código se puede volver ilegible
-Con las excepciones se separa el código de un método del código que controla los errores

¿Que es un Archivo de Texto?
Los archivos de texto plano son aquellos que están compuestos únicamente por texto sin formato, solo caracteres. estos caracteres se pueden codificar de distintos modos dependiendo de la lengua usada. Se les conoce también como archivos de texto llano o texto simple por carecer de información destinada a generar formatos y tipos de letra.

Un archivo binario es una archivo informático que contiene información de cualquier tipo, codificada en forma binaria para el propósito de almacenamiento y procesamiento de ordenadores.
Muchos formatos binarios contienen partes que pueden ser interpretados como texto. Un archivo binario que solo contiene información de tipo textual sin información sobre el formato del mismo, se dice que es un archivo de texto plano. Habitualmente se contraponen los términos archivo binario y archivo de texto de forma que los primeros no contienen solamentente texto.


codigo en JAVA

archivo.java
import java.io.*;

class archivo {

private String nombre = "naname.txt";
private String lineas[] = new String [100];
private int numLineas;
private int MaxLineas;
private FileOutputStream out;
private DataOutputStream dout;
private FileInputStream in;
private BufferedReader din;

public archivo(){
nombre ="noname1.txt";
MaxLineas=100;
lineas = new String[MaxLineas];
numLineas=0;
}//CONSTRUCTOR

public archivo(String nombre){
this.nombre=nombre;
MaxLineas=100;
lineas= new String[MaxLineas];
numLineas=0;
}//CONTRUCTOR

public void setBuffer(int n){setLineas(n);}//VOID
public void setLineas(int n){
MaxLineas = n;
lineas = new String[MaxLineas];
numLineas=0;
}//VOID

public void crear(String nombre) {this.nombre = nombre; crear();}//VOID

public void crear(){
try{
out= new FileOutputStream(this.nombre); dout = new DataOutputStream(out);
lineas=new String[MaxLineas]; numLineas=0;}catch(Exception e){}
}//VOID

public void escribir(int dato) {agregar(String.valueOf(dato));}//VOID
public void escribir(double dato) {agregar(String.valueOf(dato));}//VOID
public void escribir(char dato) {agregar(String.valueOf(dato));}//VOID

public void escribir(String linea) {agregar(linea);}//VOID
public void agregar(String linea){
if(numLineas<MaxLineas){
try{dout.writeBytes(""+linea+"\n");}catch(Exception e){}
lineas[numLineas]= linea; numLineas++;
}else{
javax.swing.JOptionPane.showMessageDialog(null,"Nose permite agregar mas de "+MaxLineas+" lineas.","ERROR",0);
}//ELSE
}//VOID

public void abrir(String nombre) {this.nombre= nombre; abrir();}//VOID
public void abrir(){
try{
in = new FileInputStream(this.nombre);
din= new BufferedReader(new InputStreamReader(in));
numLineas=0; String cad="";
do{
cad=din.readLine();
if(cad!=null){lineas[numLineas]=cad; numLineas++;}
}while(cad!=null);
din.close(); in.close();
}catch(Exception e){ }
}//VOID

public String[] getLineasArchivo(){return lineas;}//VOID

public String getArchivo(){//MUESTRA ARCHIVO COMPLETO
String cadenota="";
for (int i=0;i<numLineas;i++){
cadenota+= (lineas[i]+"\n");
}//FOR
return cadenota;
}//Void

public void cerrar(){
try{dout.close();}catch(Exception e1){} try{out.close();}catch(Exception e2){}
}//VOID

public void borrar(int n){//BORRA UNA LINEA DEL ARCHIVO
for(int i=n;i<(numLineas-1); i++){lineas[i]=lineas[i+1];}//FOR
numLineas=numLineas-1; actualizar();
}//VOID

public void modificar(int n, String cadenita){//MODIFICA UNA LINEA DEL ARCHIVO
if (n<numLineas){lineas[n]=cadenita;}
actualizar();
}//VOID
public String consultar(int n){//REGRESA UNA LINEA DEL ARCHIVO
String cad="No se encontro"; if(n<numLineas){cad=lineas[n];}
return cad;
}//VOID

public void guardar(){
try{
FileOutputStream xout = new FileOutputStream(this.nombre);
DataOutputStream xdout = new DataOutputStream (xout);
xdout.writeBytes(""+getArchivo()+""); xdout.close(); xout.close();
}catch(Exception ex){}
}//VOID

public void elminar(String nombre2){
try{cerrar();}catch(Exception e){}
//BORRANDO FISICAMENTE EL ARCHIVO
try{ File ff= new File(this.nombre); ff.delete(); }catch(Exception e2){}
}//VOID


}//CLASS

Muchas gracias por sus respuestas

Las operaciones básicas con archivos son:

Creacion
Apertura
Lectura
Escritura
Recorrido
Cierre

Archivos de texto.
El manejo de archivos de texto se puede llevar a cabo por medio de dos tipos de flujos: de bytes y de caracteres .

Archivos de Texto con Flujos de Bytes.
Para escribir o leer datos de tipo byte en un archivo se declara un flujo de la clase FileStream , cuyos constructores son:

- FileStream (string nombre , FileMode modo )

- FileStream (string nombre , FileMode modo , FileAccess acceso )

donde:

nombre es el nombre del archivo en disco, incluyendo la trayectoria.

Ejemplo:
modo es un valor del tipo enumerado FileMode ; puede tomar uno de los siguientes valores:

CreateNew
Crea un nuevo archivo. Si el archivo existe, lanzará una excepción del tipo IOException.

Create
Crea un nuevo archivo. Si el archivo existe, será sobreescrito.

Open
Abre un archivo existente.

OpenOrCreate
Abre un archivo, si existe;en caso contrario, se crea un nuevo archivo.

Truncate
Abre un archivo existente y lo trunca a cero bytes de longitud.

Append
Abre un archivo para agregarle datos al final.Si el archivo no existe, lo crea.

acceso es un valor del tipo enumerado FileAccess ; puede tomar uno de los siguientes valores:

Read
Permite leer un archivo.

ReadWrite
Permite leer o escribir en el archivo.

Write
permite escribir en el archivo.

¿Que es un Archivo?


Un archivo JAR (por sus siglas en inglés, Java ARchive) es un tipo de archivo que permite ejecutar aplicaciones escritas en el lenguaje Java. Las siglas están deliberadamente escogidas para que coincidan con la palabra inglesa "jar" (tarro). Los archivos JAR están comprimidos con el formato ZIP y cambiada su extensión a .jar. Existen tres operaciones básicas con este tipo de archivos: ver contenido, comprimir y descomprimir.

Instrucciones:

Ver contenido: $ jar -tvf archivo.jar
Comprimir: $ jar -cvf archivo.jar archivo_1 archivo_2 archivo_3 ... archivo_n
Descomprimir: $ jar -xvf archivos.jar
Un vínculo de descarga a .jar es .jad, y pesa muy poco. Estos archivos se utilizan normalmente para aplicaciones en teléfonos móviles.

Los archivos de texto plano son aquellos que están compuestos únicamente por texto sin formato, solo caracteres. estos caracteres se pueden codificar de distintos modos dependiendo de la lengua usada. Se les conoce también como archivos de texto llano o texto simple por carecer de información destinada a generar formatos y tipos de letra.

[center]¿Que es un Archivo de Texto?[/center]
Un archivo binario es una archivo informático que contiene información de cualquier tipo, codificada en forma binaria para el propósito de almacenamiento y procesamiento de ordenadores.
Muchos formatos binarios contienen partes que pueden ser interpretados como texto. Un archivo binario que solo contiene información de tipo textual sin información sobre el formato del mismo, se dice que es un archivo de texto plano. Habitualmente se contraponen los términos archivo binario y archivo de texto de forma que los primeros no contienen solamentente texto.



archivo.java
import java.io.*; 

class archivo {

private String nombre = "naname.txt";
private String lineas[] = new String [100];
private int numLineas;
private int MaxLineas;
private FileOutputStream out;
private DataOutputStream dout;
private FileInputStream in;
private BufferedReader din;

public archivo(){
nombre ="noname1.txt"; 
MaxLineas=100;
lineas = new String[MaxLineas];
numLineas=0;
}//CONSTRUCTOR

public archivo(String nombre){
this.nombre=nombre; 
MaxLineas=100;
lineas= new String[MaxLineas];
numLineas=0;
}//CONTRUCTOR

public void setBuffer(int n){setLineas(n);}//VOID
public void setLineas(int n){
MaxLineas = n;
lineas = new String[MaxLineas];
numLineas=0;
}//VOID

public void crear(String nombre) {this.nombre = nombre; crear();}//VOID

public void crear(){
try{
out= new FileOutputStream(this.nombre); dout = new DataOutputStream(out);
lineas=new String[MaxLineas]; numLineas=0;}catch(Exception e){}
}//VOID

public void escribir(int dato) {agregar(String.valueOf(dato));}//VOID
public void escribir(double dato) {agregar(String.valueOf(dato));}//VOID
public void escribir(char dato) {agregar(String.valueOf(dato));}//VOID

public void escribir(String linea) {agregar(linea);}//VOID
public void agregar(String linea){
if(numLineas<MaxLineas){
try{dout.writeBytes(""+linea+"\n");}catch(Exception e){}
lineas[numLineas]= linea; numLineas++;
}else{
javax.swing.JOptionPane.showMessageDialog(null,"Nose permite agregar mas de "+MaxLineas+" lineas.","ERROR",0);
}//ELSE
}//VOID

public void abrir(String nombre) {this.nombre= nombre; abrir();}//VOID
public void abrir(){
try{
in = new FileInputStream(this.nombre);
din= new BufferedReader(new InputStreamReader(in));
numLineas=0; String cad="";
do{
cad=din.readLine();
if(cad!=null){lineas[numLineas]=cad; numLineas++;}
}while(cad!=null);
din.close(); in.close(); 
}catch(Exception e){ }
}//VOID

public String[] getLineasArchivo(){return lineas;}//VOID

public String getArchivo(){//MUESTRA ARCHIVO COMPLETO
String cadenota="";
for (int i=0;i<numLineas;i++){
cadenota+= (lineas[i]+"\n");
}//FOR
return cadenota;
}//Void

public void cerrar(){
try{dout.close();}catch(Exception e1){} try{out.close();}catch(Exception e2){}
}//VOID

public void borrar(int n){//BORRA UNA LINEA DEL ARCHIVO
for(int i=n;i<(numLineas-1); i++){lineas[i]=lineas[i+1];}//FOR
numLineas=numLineas-1; actualizar();
}//VOID

public void modificar(int n, String cadenita){//MODIFICA UNA LINEA DEL ARCHIVO
if (n<numLineas){lineas[n]=cadenita;}
actualizar();
}//VOID
public String consultar(int n){//REGRESA UNA LINEA DEL ARCHIVO
String cad="No se encontro"; if(n<numLineas){cad=lineas[n];}
return cad;
}//VOID

public void guardar(){
try{
FileOutputStream xout = new FileOutputStream(this.nombre);
DataOutputStream xdout = new DataOutputStream (xout);
xdout.writeBytes(""+getArchivo()+""); xdout.close(); xout.close();
}catch(Exception ex){}
}//VOID

public void elminar(String nombre2){
try{cerrar();}catch(Exception e){}
//BORRANDO FISICAMENTE EL ARCHIVO
try{ File ff= new File(this.nombre); ff.delete(); }catch(Exception e2){}
}//VOID


}//CLASS




att: jose alfredo sanchez estrada. ing. informatica 2° semestre

Las operaciones básicas con archivos son:

Creacion
Apertura
Lectura
Escritura
Recorrido
Cierre

Archivos de texto.
El manejo de archivos de texto se puede llevar a cabo por medio de dos tipos de flujos: de bytes y de caracteres .

Archivos de Texto con Flujos de Bytes.
Para escribir o leer datos de tipo byte en un archivo se declara un flujo de la clase FileStream , cuyos constructores son:

- FileStream (string nombre , FileMode modo )

- FileStream (string nombre , FileMode modo , FileAccess acceso )

donde:

nombre es el nombre del archivo en disco, incluyendo la trayectoria.

Ejemplo:
modo es un valor del tipo enumerado FileMode ; puede tomar uno de los siguientes valores:

CreateNew
Crea un nuevo archivo. Si el archivo existe, lanzará una excepción del tipo IOException.

Create
Crea un nuevo archivo. Si el archivo existe, será sobreescrito.

Open
Abre un archivo existente.

OpenOrCreate
Abre un archivo, si existe;en caso contrario, se crea un nuevo archivo.

Truncate
Abre un archivo existente y lo trunca a cero bytes de longitud.

Append
Abre un archivo para agregarle datos al final.Si el archivo no existe, lo crea.

acceso es un valor del tipo enumerado FileAccess ; puede tomar uno de los siguientes valores:

Read
Permite leer un archivo.

ReadWrite
Permite leer o escribir en el archivo.

Write
permite escribir en el archivo.


att: arisender maldona urieta