1.- Introducción (Grupo 4A del 2013)

Participe en este Foro contestando al menos dos de los siguientes reactivos:



Atte:

M.C. Edgar - Rangel - Lugo .

Si puedes ver este mensaje, significa que este Foro ya esta listo para participar.

Atte:

M.C. Edgar Rangel Lugo.

BUENAS NOCHES, AQUÍ PRESENTO MIS RESPUESTAS, ESPERO ESTÉN CORRECTA, SINO ES ASÍ, POR FAVOR RETROALIMENTACION

1) Investigar la diferencia existente entre los diferentes tipos de archivos, así como las ventajas y desventajas. Debe elaborar un resumen o tabla comparativa para compartir en este foro.

TIPO DE ARCHIVO	CARACTERÍSTICAS	VENTAJAS	DESVENTAJAS
ARCHIVOS BINARIO	1.- Contiene información en lenguaje maquina o encriptado. 2.- No podemos darnos cuenta fácilmente del contenido de la información. 3.- Es especialmente para crear registros. 4.- Su longitud se divide en tamaños iguales de registro. 5.- Se accede igual que a un archivo de texto. 6.- puede contener información de cualquier tipo. 7.- Solo tienen sentido para los programas que lo ejecutan.	1.- Permite trabajar con registros sin necesidad de un motor de bases de datos. 2.- A medida que se agregan registros, aumenta el espacio. 3.- Ocupan menos espacio. 4.- Fácil de entender donde empiezan y donde terminan los datos. 5.- Tiene la facilidad de manipular cualquier tipo de dato. 6.- Es simple para escribir y guardar datos. 7.- Permiten guardar clases de manera sencilla. 8.- Permite utilizar más fácilmente el paradigma orientado a objetos. 9.- Evita la perdida de información y calidad.	1.- Debe conocer con precisión como se describen los datos en el archivo. 2.- No se puede observar la información del archivo con facilidad.
ARCHIVOS DE TEXTO	1.- Su formato básico es la extensión .TXT 2.- Pueden contener texto mezclado con ACSSI. 3.- Solo contiene texto sin formato. 4.- Se puede guardar en formato separado por comas o tabulaciones.	1.- Admite el uso de “fonts”, son gráficos. 2.- Permite visualizar el contenido del archivo claramente. 3.- Su contenido puede ser codificado fácilmente. 4.- Puede ser importado a programas de bases de datos.	1.- Carecen de información destinada a generar formatos. 2.- Carece de información de tipos de letra. 3.- Su contenido puede ser fácilmente plagiado.
ARCHIVO DE ACCESO SECUENCIAL	1.- Puede haber archivo secuenciales de tipo binario y de texto. 2.- Es necesario para crear una estructura en los archivos. 3.- Pueden ser de tipo acceso directo. 4.- Todos los registros tienen el mismo tamaño. 5.- Constan del mismo número de campos. 6.- Es posible leer un registro sin leer los anteriores.	1.- Permite guardar tipos definidos por el usuario. 2.- Provee mecanismos para realizar su recorrido. 3.- Es la forma básica de organizar un registro. 4.- Los registros quedan grabados consecutivamente conforme se utilizan. 5.- Proveen la mejor utilización del espacio. 6.- Su uso es de manera más rápida. 7.- Son muy sencillos de usar y aplicar.	1.- El acceso a un registro es pobre. 2.- La localización de un registro no se puede realizar individualmente. 3.- El acceso aleatorio es poco práctico. 4.- La dirección de registro está implícita. 5.- son vulnerables a fallas del sistema.

2) Haciendo uso del lenguaje de programación Java, debe implementar las diferentes operaciones que se pueden realizar para manipular información de un archivo, tales como: Abrir, leer datos, guardar, cerrar, entre otras operaciones. Escriba código fuente, mostrando un ejemplo cualquiera (como: sistema de agenda de datos, factura de ventas, o simplemente, leer y escribir variables enteras, reales y cadena), y dicho código fuente deberá compartirlo en este foro.

_______________________________________________________________________________________________________
_______________________________________________________________________________________________________
//------------------------------------------------------------------------------------------------------------------------------------
//-------------- Derechos Reservados (c) 2012. Edgar - Rangel - Lugo. Mexico
//-------------- Free Source : Codigo libre por M.C. Edgar - Rangel - Lugo.
//-------------- Puedes utilizarlo, modificarlo y adaptarlo de manera libre,
//-------------- solo debes dar el credito al autor. No tiene nada que ver
//-------------- con OpenSource, Freeware, SourceForge, GLP (GPL), EULA, ni
//-------------- algun otro. Este codigo es desarrollado con fines academicos
//-------------- y tiene los - Derechos Reservados (c) 2012. Edgar - Rangel - Lugo. Mexico.
//-------------- Este codigo no debe estar disponible en algun sitio web, si deseas hacerlo
//-------------- debes notificarlo al autor, para que te haga llegar por escrito un permiso.
//-------------- Puedes comunicarte a: erangel_lugo@hotmail . com
//--------------
//------------- Compañero docente, si utilizas este codigo, por favor, da credito al autor
//------------- y no impartas tus clases argumentando que fue extraido de libros o "bajado" de Internet .
//--------------
//------------- PROGRAMAS INDISPENSABLES PARA OPERACIONES BASICAS , VISTO EN UNIDAD
//------------- PROGRAMANDO OPERACIONES BASICAS SOBRE ARCHIVOS DE TEXTO Y BINARIOS
//------------- Atte: M.C. Edgar - Rangel - Lugo.
//-------------
//------------- Este archivo debe llevar el nombre: basicas_rangel.java (en minusculas)
//-------------
//------------------------------------------------------------------------------------------------------------------------------------
import java.io.*;
import java.awt.*;
import java.awt.event.*;
class basicas_rangel {
private FileInputStream abrir;
private FileOutputStream guardar;
private DataOutputStream escribir;
private BufferedReader Leer;
private DataInputStream leer;
private boolean R ;
private String arreglo[];
private String texto;
private boolean salida;
public basicas_rangel () { R = false; salida=true; }//constr
public void Abrir (String archivo) {
R = false;
try {
abrir = new FileInputStream (archivo);
Leer = new BufferedReader( new InputStreamReader(abrir) );
leer = new DataInputStream ( abrir ); R = true;
}catch(Exception exc) { R = false; }
}//void
public void Crear (String archivo) {
R = false;
try {
guardar = new FileOutputStream (archivo); escribir = new DataOutputStream (guardar);
R = true;
}catch(Exception exc) { R = false; }
}//void


public void Cerrar () {
if ( R == true ) {
try { escribir.close(); guardar.close(); } catch(Exception exc) { }
try { leer.close(); abrir.close(); } catch(Exception exc) { }
}//if
}//void
public int leer_entero () {
int N = 0;
try { if ( R == true ) { N = leer.readInt(); } }catch(Exception e) {}
return N;
}//void
public double leer_real () {
double N = 0;
try { if ( R == true ) { N = leer.readDouble(); } }catch(Exception e) {}
return N;
}//void
public char leer_caracter () {
char N = 0; try { if ( R == true ) { N = leer.readChar(); } }catch(Exception e) {}
return N;
}//void
public byte leer_byte () {
byte N = 0; try { if ( R == true ) { N = leer.readByte(); } }catch(Exception e) {}
return N;
}//void
public String leer_texto () {
String S = "";
try { if ( R == true ) { S = leer.readUTF (); } }catch(Exception e) {}
return S;
}//void
public String Leer_Texto () {
String S = "";
try { if ( R == true ) { S = Leer.readLine(); } }catch(Exception e) {}
return S;
}//void
public String Leer_Archivo () {
String S2 = "";
try {
if ( R == true ) {
String cadena = "";
do { cadena = Leer.readLine(); S2 = S2 + cadena + "\n"; }while(cadena != null);
}
}catch(Exception e) {}
return S2;
}//void
public void guardar_binario (int dato) {
try { if ( R == true ) { escribir.writeInt(dato); } }catch(Exception e) {}
}//void
public void guardar_binario (double dato) {
try { if ( R == true ) { escribir.writeDouble(dato); } }catch(Exception e) {}
}//void
public void guardar_binario (char dato) {
try { if ( R == true ) { escribir.writeChar(dato); } }catch(Exception e) {}
}//void


public void guardar_binario (byte dato) {
try { if ( R == true ) { escribir.writeByte(dato); } }catch(Exception e) {}
}//void
public void guardar_binario (String dato) {
try { if ( R == true ) { escribir.writeUTF (dato); } }catch(Exception e) {}
}//void
public void guardar_texto (int dato) {
try { if ( R == true ) { escribir.writeBytes(Str(dato) + "\n"); } }catch(Exception e) {}
}//void
public void guardar_texto (double dato) {
try { if ( R == true ) { escribir.writeBytes(Str(dato) + "\n"); } }catch(Exception e) {}
}//void
public void guardar_texto (char dato) {
try { if ( R == true ) { escribir.writeBytes(dato + " \n"); } }catch(Exception e) {}
}//void
public void guardar_texto (byte dato) {
try { if ( R == true ) { escribir.writeBytes(dato + " \n"); } }catch(Exception e) {}
}//void
public void guardar_texto (String dato) {
try { if ( R == true ) { escribir.writeBytes(dato + "\n"); } }catch(Exception e) {}
}//void
protected void guardar_solo_dato (String dato) {
try { if ( R == true ) { escribir.writeBytes(dato); } }catch(Exception e) {}
}//void
public void Editor_Texto (String title) {
final Frame ventana = new Frame (title);
new Thread() {
public void run() {
texto = ""; salida=false;
MenuBar mb = new MenuBar ();
Menu menu = new Menu("Archivo"); MenuItem iNuevo = new MenuItem("Nuevo");
MenuItem iAbrir = new MenuItem("Abrir"); MenuItem iGuardar = new MenuItem("Guardar");
MenuItem iSalir = new MenuItem("Salir");
mb.add(menu);
menu.add(iNuevo ); menu.add(iAbrir ); menu.add(iGuardar ); menu.add(iSalir );
final TextArea area = new TextArea();
ventana.setSize(640, 480); ventana.setLayout(new BorderLayout());
ventana.add(area, BorderLayout.CENTER);
ventana.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent ev) { ventana.setVisible(false); }
});
iSalir.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){
texto = area.getText(); salida=true; ventana.setVisible(false);
}
} );
iNuevo.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){ area.setText(""); }
} );
iAbrir.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){
try {
FileDialog fd = new FileDialog(ventana, "Open", FileDialog.LOAD);


fd.setVisible(true);
FileInputStream file1 = new FileInputStream (fd.getDirectory() + fd.getFile());
BufferedReader data1 = new BufferedReader(new InputStreamReader(file1));
area.setText("");
String cadena = "";
do {
cadena = data1.readLine();
area.append(cadena + "\n");
}while(cadena != null);
data1.close(); file1.close();
}catch(Exception exc){}
}
} );
iGuardar.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){
try {
FileDialog fd = new FileDialog(ventana, "Save", FileDialog.SAVE);
fd.setVisible(true);
FileOutputStream file1 = new FileOutputStream (fd.getDirectory() + fd.getFile());
DataOutputStream data1 = new DataOutputStream (file1);
data1.writeBytes(area.getText());
data1.close(); file1.close();
}catch(Exception exc){}
}
} );
ventana.setMenuBar(mb);
ventana.setVisible(true);
}}.start();
}//void
public String getTexto() {
do {
try {
Thread.sleep(500);
}catch(Exception exc){}
}while(salida == false);
return texto;
}
public void Capturar_Datos (String campos[], String title) {
final Dialog ventana = new Dialog (new Frame(), title);
Button boton = new Button ("Aceptar");
Label etiqueta = new Label(title);
int num = campos.length ;
Label etiquetas [] = new Label[num];
final TextField cuadros_texto [] = new TextField [num];
int X = 50; int Y = 10;
ventana.setSize(640, ((num*25)+115) );
ventana.setLayout(null);
ventana.setModal(true);
ventana.add(etiqueta); etiqueta.setBounds(X, Y, 400, 25); Y = Y + 25 ;
for(int i = 0; i < num ; i++ ){
etiquetas[i] = new Label(campos[i]);
cuadros_texto [i] = new TextField();
ventana.add(etiquetas[i]);


ventana.add(cuadros_texto [i]);
etiquetas[i].setBounds(X,Y, 250, 25); X = X + 250 ;
cuadros_texto[i].setBounds(X,Y, 250, 25); X = 50 ; Y = Y + 25 ;
}//for
X = X + 250 ; Y = Y + 25 ;
ventana.add(boton); boton.setBounds(X, Y , 80, 40);
X = 50 ;
arreglo = new String [num];
ventana.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent ev) { ventana.setVisible(false); }
});
boton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){
for(int i = 0; i < arreglo.length ; i++ ){
arreglo[i] = cuadros_texto[i].getText();
}//for
ventana.setVisible(false);
}
} );
ventana.setVisible(true);
}//void
public int getInt (int index) { return Double.valueOf(arreglo[index]).intValue(); }
public byte getByte (int index) { return Double.valueOf(arreglo[index]).byteValue(); }
public double getDouble (int index) { return Double.valueOf(arreglo[index]).doubleValue(); }
public String getString (int index) { return arreglo[index]; }
public char getChar (int index) { return (arreglo[index]).charAt(0); }
public String[] getArreglo () { return arreglo; }
private String Str (int d) { return String.valueOf(d); }
private String Str (double d) { return String.valueOf(d); }
} //class


_______________________________________________________________________________________________________
_______________________________________________________________________________________________________

//------------------------------------------------------------------------
//------------ EJEMPLOS DE: M.C. EDGAR - RANGEL - LUGO . ------------------
//------------------------------------------------------------------------
//........................................................................
//----------------------------------------------------------
//----------------------------------------------------------
//----------- ESTOS VIENEN DE APOYO , DESDE LA UNIDAD 1 ---
//----------------------------------------------------------
//----------------------------------------------------------
//----------------------------------------------------------
/// REUTILICE LA CLASE basicas_rangel.java
/// PARA COMPILAR Y EJECUTAR ESTE PROGRAMA : agenda.java
//----------------------------------------------------------
//----- Programa
//----- Para la GUARDAR DATOS DE UNA agenda empresarial ------
//----- Permite guardar datos en formatos tipo binario y tipo texto ------
//-----
import java.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class agenda {
public static void main(String args[]) {
basicas_rangel s1 = new basicas_rangel ();
String campos[] = {"Nombre del Cliente: ", "Domicilio : ",
"Telefono: ","Pais : ", "Edad: ", "Saldo: ", "Sexo:"};
//--- Guardando datos (Binarios) ---------
s1.Crear ("agenda_binario.dat");
for(int k=0;k<2;k++) {
s1.Capturar_Datos (campos, "Agenda Empresarial");
s1.guardar_binario ( s1.getInt(4) );
s1.guardar_binario ( s1.getDouble(5) );
s1.guardar_binario ( s1.getChar(6) );
s1.guardar_binario ( s1.getString(0) );
s1.guardar_binario ( s1.getString(1) );
s1.guardar_binario ( s1.getString(2) );
s1.guardar_binario ( s1.getString(3) );
}//for
s1.Cerrar();
s1.Abrir ("agenda_binario.dat"); //LEYENDO
System.out.println (" " + campos[4] + " " + s1.leer_entero () );
System.out.println (" " + campos[5] + " " + s1.leer_real () );
System.out.println (" " + campos[6] + " " + s1.leer_caracter () );
System.out.println (" " + campos[0] + " " + s1.leer_texto () );
System.out.println (" " + campos[1] + " " + s1.leer_texto () );
System.out.println (" " + campos[2] + " " + s1.leer_texto () );
System.out.println (" " + campos[3] + " " + s1.leer_texto () );
s1.Cerrar();
//--- Guardando datos (Texto) ---------
s1.Crear ("agenda_texto.txt");

for(int k=0;k<2;k++) {
s1.Capturar_Datos (campos, "Agenda Empresarial");
s1.guardar_texto ( s1.getString(0) );
s1.guardar_texto ( s1.getString(1) );
s1.guardar_texto ( s1.getString(2) );
s1.guardar_texto ( s1.getString(3) );
s1.guardar_texto ( s1.getInt(4) );
s1.guardar_texto ( s1.getDouble(5) );
s1.guardar_texto ( s1.getChar (6) );
}//for
s1.Cerrar();
s1.Abrir ("agenda_texto.txt"); //LEYENDO
System.out.println (" " + campos[0] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[1] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[2] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[3] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[4] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[5] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[6] + " " + s1.Leer_Texto () );
s1.Cerrar();
//--------------------------------------------
}//main
}//void

CABE SEÑALAR QUE SE DEBEN RESPETAR LAS LETRAS MAYÚSCULAS Y MINÚSCULAS. LOS CRÉDITOS DE LOS CÓDIGO SE DEBEN DAR AL MAESTRO EDGAR LUGO RANGEL.

BUENO COMPAÑEROS. ESPERO ESTAR BIEN EN MI APORTACION. SALUDOS

2) Haciendo uso del lenguaje de programación Java, debe implementar las diferentes operaciones que se pueden realizar para manipular información de un archivo, tales como: Abrir, leer datos, guardar, cerrar, entre otras operaciones. Escriba código fuente, mostrando un ejemplo cualquiera (como: sistema de agenda de datos, factura de ventas, o simplemente, leer y escribir variables enteras, reales y cadena), y dicho código fuente deberá compartirlo en este foro.


------------------------------------------------------------------------------------------------------------------

//------------------------------------------------------------------------------------------------------------------------------------
//-------------- Derechos Reservados (c) 2012. Edgar - Rangel - Lugo. Mexico
//-------------- Free Source : Codigo libre por M.C. Edgar - Rangel - Lugo.
//-------------- Puedes utilizarlo, modificarlo y adaptarlo de manera libre,
//-------------- solo debes dar el credito al autor. No tiene nada que ver
//-------------- con OpenSource, Freeware, SourceForge, GLP (GPL), EULA, ni
//-------------- algun otro. Este codigo es desarrollado con fines academicos
//-------------- y tiene los - Derechos Reservados (c) 2012. Edgar - Rangel - Lugo. Mexico.
//-------------- Este codigo no debe estar disponible en algun sitio web, si deseas hacerlo
//-------------- debes notificarlo al autor, para que te haga llegar por escrito un permiso.
//-------------- Puedes comunicarte a: erangel_lugo@hotmail. com
//--------------
//------------- Compañero docente, si utilizas este codigo, por favor, da credito al autor
//------------- y no impartas tus clases argumentando que fue extraido de libros o "bajado" de Internet .
//--------------
//------------- PROGRAMAS INDISPENSABLES PARA OPERACIONES BASICAS , VISTO EN UNIDAD
//------------- PROGRAMANDO OPERACIONES BASICAS SOBRE ARCHIVOS DE TEXTO Y BINARIOS
//------------- Atte: M.C. Edgar - Rangel - Lugo.
//-------------
//------------- Este archivo debe llevar el nombre: basicas_rangel.java (en minusculas)
//-------------
//------------------------------------------------------------------------------------------------------------------------------------
import java.io.*;
import java.awt.*;
import java.awt.event.*;
class basicas_rangel {
private FileInputStream abrir;
private FileOutputStream guardar;
private DataOutputStream escribir;
private BufferedReader Leer;
private DataInputStream leer;
private boolean R ;
private String arreglo[];
private String texto;
private boolean salida;
public basicas_rangel () { R = false; salida=true; }//constr
public void Abrir (String archivo) {
R = false;
try {
abrir = new FileInputStream (archivo);
Leer = new BufferedReader( new InputStreamReader(abrir) );
leer = new DataInputStream ( abrir ); R = true;
}catch(Exception exc) { R = false; }
}//void
public void Crear (String archivo) {
R = false;
try {
guardar = new FileOutputStream (archivo); escribir = new DataOutputStream (guardar);
R = true;
}catch(Exception exc) { R = false; }
}//void

public void Cerrar () {
if ( R == true ) {
try { escribir.close(); guardar.close(); } catch(Exception exc) { }
try { leer.close(); abrir.close(); } catch(Exception exc) { }
}//if
}//void
public int leer_entero () {
int N = 0;
try { if ( R == true ) { N = leer.readInt(); } }catch(Exception e) {}
return N;
}//void
public double leer_real () {
double N = 0;
try { if ( R == true ) { N = leer.readDouble(); } }catch(Exception e) {}
return N;
}//void
public char leer_caracter () {
char N = 0; try { if ( R == true ) { N = leer.readChar(); } }catch(Exception e) {}
return N;
}//void
public byte leer_byte () {
byte N = 0; try { if ( R == true ) { N = leer.readByte(); } }catch(Exception e) {}
return N;
}//void
public String leer_texto () {
String S = "";
try { if ( R == true ) { S = leer.readUTF (); } }catch(Exception e) {}
return S;
}//void
public String Leer_Texto () {
String S = "";
try { if ( R == true ) { S = Leer.readLine(); } }catch(Exception e) {}
return S;
}//void
public String Leer_Archivo () {
String S2 = "";
try {
if ( R == true ) {
String cadena = "";
do { cadena = Leer.readLine(); S2 = S2 + cadena + "\n"; }while(cadena != null);
}
}catch(Exception e) {}
return S2;
}//void
public void guardar_binario (int dato) {
try { if ( R == true ) { escribir.writeInt(dato); } }catch(Exception e) {}
}//void
public void guardar_binario (double dato) {
try { if ( R == true ) { escribir.writeDouble(dato); } }catch(Exception e) {}
}//void
public void guardar_binario (char dato) {
try { if ( R == true ) { escribir.writeChar(dato); } }catch(Exception e) {}
}//void
public void guardar_binario (byte dato) {
try { if ( R == true ) { escribir.writeByte(dato); } }catch(Exception e) {}
}//void
public void guardar_binario (String dato) {
try { if ( R == true ) { escribir.writeUTF (dato); } }catch(Exception e) {}
}//void
public void guardar_texto (int dato) {
try { if ( R == true ) { escribir.writeBytes(Str(dato) + "\n"); } }catch(Exception e) {}
}//void
public void guardar_texto (double dato) {
try { if ( R == true ) { escribir.writeBytes(Str(dato) + "\n"); } }catch(Exception e) {}
}//void
public void guardar_texto (char dato) {
try { if ( R == true ) { escribir.writeBytes(dato + " \n"); } }catch(Exception e) {}
}//void
public void guardar_texto (byte dato) {
try { if ( R == true ) { escribir.writeBytes(dato + " \n"); } }catch(Exception e) {}
}//void
public void guardar_texto (String dato) {
try { if ( R == true ) { escribir.writeBytes(dato + "\n"); } }catch(Exception e) {}
}//void
protected void guardar_solo_dato (String dato) {
try { if ( R == true ) { escribir.writeBytes(dato); } }catch(Exception e) {}
}//void
public void Editor_Texto (String title) {
final Frame ventana = new Frame (title);
new Thread() {
public void run() {
texto = ""; salida=false;
MenuBar mb = new MenuBar ();
Menu menu = new Menu("Archivo"); MenuItem iNuevo = new MenuItem("Nuevo");
MenuItem iAbrir = new MenuItem("Abrir"); MenuItem iGuardar = new MenuItem("Guardar");
MenuItem iSalir = new MenuItem("Salir");
mb.add(menu);
menu.add(iNuevo ); menu.add(iAbrir ); menu.add(iGuardar ); menu.add(iSalir );
final TextArea area = new TextArea();
ventana.setSize(640, 480); ventana.setLayout(new BorderLayout());
ventana.add(area, BorderLayout.CENTER);
ventana.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent ev) { ventana.setVisible(false); }
});
iSalir.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){
texto = area.getText(); salida=true; ventana.setVisible(false);
}
} );
iNuevo.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){ area.setText(""); }
} );
iAbrir.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){
try {
FileDialog fd = new FileDialog(ventana, "Open", FileDialog.LOAD);
fd.setVisible(true);
FileInputStream file1 = new FileInputStream (fd.getDirectory() + fd.getFile());
BufferedReader data1 = new BufferedReader(new InputStreamReader(file1));
area.setText("");
String cadena = "";
do {
cadena = data1.readLine();
area.append(cadena + "\n");
}while(cadena != null);
data1.close(); file1.close();
}catch(Exception exc){}
}
} );
iGuardar.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){
try {
FileDialog fd = new FileDialog(ventana, "Save", FileDialog.SAVE);
fd.setVisible(true);
FileOutputStream file1 = new FileOutputStream (fd.getDirectory() + fd.getFile());
DataOutputStream data1 = new DataOutputStream (file1);
data1.writeBytes(area.getText());
data1.close(); file1.close();
}catch(Exception exc){}
}
} );
ventana.setMenuBar(mb);
ventana.setVisible(true);
}}.start();
}//void
public String getTexto() {
do {
try {
Thread.sleep(500);
}catch(Exception exc){}
}while(salida == false);
return texto;
}
public void Capturar_Datos (String campos[], String title) {
final Dialog ventana = new Dialog (new Frame(), title);
Button boton = new Button ("Aceptar");
Label etiqueta = new Label(title);
int num = campos.length ;
Label etiquetas [] = new Label[num];
final TextField cuadros_texto [] = new TextField [num];
int X = 50; int Y = 10;
ventana.setSize(640, ((num*25)+115) );
ventana.setLayout(null);
ventana.setModal(true);
ventana.add(etiqueta); etiqueta.setBounds(X, Y, 400, 25); Y = Y + 25 ;
for(int i = 0; i < num ; i++ ){
etiquetas[i] = new Label(campos[i]);
cuadros_texto [i] = new TextField();
ventana.add(etiquetas[i]);

ventana.add(cuadros_texto [i]);
etiquetas[i].setBounds(X,Y, 250, 25); X = X + 250 ;
cuadros_texto[i].setBounds(X,Y, 250, 25); X = 50 ; Y = Y + 25 ;
}//for
X = X + 250 ; Y = Y + 25 ;
ventana.add(boton); boton.setBounds(X, Y , 80, 40);
X = 50 ;
arreglo = new String [num];
ventana.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent ev) { ventana.setVisible(false); }
});
boton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){
for(int i = 0; i < arreglo.length ; i++ ){
arreglo[i] = cuadros_texto[i].getText();
}//for
ventana.setVisible(false);
}
} );
ventana.setVisible(true);
}//void
public int getInt (int index) { return Double.valueOf(arreglo[index]).intValue(); }
public byte getByte (int index) { return Double.valueOf(arreglo[index]).byteValue(); }
public double getDouble (int index) { return Double.valueOf(arreglo[index]).doubleValue(); }
public String getString (int index) { return arreglo[index]; }
public char getChar (int index) { return (arreglo[index]).charAt(0); }
public String[] getArreglo () { return arreglo; }
private String Str (int d) { return String.valueOf(d); }
private String Str (double d) { return String.valueOf(d); }
} //class

------------------------------------------------------------------------------------------------------------------

//------------------------------------------------------------------------
//------------ EJEMPLOS DE: M.C. EDGAR - RANGEL - LUGO . ------------------
//------------------------------------------------------------------------
//........................................................................
//----------------------------------------------------------
//----------------------------------------------------------
//----------- ESTOS VIENEN DE APOYO , DESDE LA UNIDAD 1 ---
//----------------------------------------------------------
//----------------------------------------------------------
//----------------------------------------------------------
/// REUTILICE LA CLASE basicas_rangel.java
/// PARA COMPILAR Y EJECUTAR ESTE PROGRAMA : agenda.java
//----------------------------------------------------------
//----- Programa
//----- Para la GUARDAR DATOS DE UNA agenda empresarial ------
//----- Permite guardar datos en formatos tipo binario y tipo texto ------
//-----
import java.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class agenda {
public static void main(String args[]) {
basicas_rangel s1 = new basicas_rangel ();
String campos[] = {"Nombre del Cliente: ", "Domicilio : ",
"Telefono: ","Pais : ", "Edad: ", "Saldo: ", "Sexo:"};
//--- Guardando datos (Binarios) ---------
s1.Crear ("agenda_binario.dat");
for(int k=0;k<2;k++) {
s1.Capturar_Datos (campos, "Agenda Empresarial");
s1.guardar_binario ( s1.getInt(4) );
s1.guardar_binario ( s1.getDouble(5) );
s1.guardar_binario ( s1.getChar(6) );
s1.guardar_binario ( s1.getString(0) );
s1.guardar_binario ( s1.getString(1) );
s1.guardar_binario ( s1.getString(2) );
s1.guardar_binario ( s1.getString(3) );
}//for
s1.Cerrar();
s1.Abrir ("agenda_binario.dat"); //LEYENDO
System.out.println (" " + campos[4] + " " + s1.leer_entero () );
System.out.println (" " + campos[5] + " " + s1.leer_real () );
System.out.println (" " + campos[6] + " " + s1.leer_caracter () );
System.out.println (" " + campos[0] + " " + s1.leer_texto () );
System.out.println (" " + campos[1] + " " + s1.leer_texto () );
System.out.println (" " + campos[2] + " " + s1.leer_texto () );
System.out.println (" " + campos[3] + " " + s1.leer_texto () );
s1.Cerrar();
//--- Guardando datos (Texto) ---------
s1.Crear ("agenda_texto.txt");

for(int k=0;k<2;k++) {
s1.Capturar_Datos (campos, "Agenda Empresarial");
s1.guardar_texto ( s1.getString(0) );
s1.guardar_texto ( s1.getString(1) );
s1.guardar_texto ( s1.getString(2) );
s1.guardar_texto ( s1.getString(3) );
s1.guardar_texto ( s1.getInt(4) );
s1.guardar_texto ( s1.getDouble(5) );
s1.guardar_texto ( s1.getChar (6) );
}//for
s1.Cerrar();
s1.Abrir ("agenda_texto.txt"); //LEYENDO
System.out.println (" " + campos[0] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[1] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[2] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[3] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[4] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[5] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[6] + " " + s1.Leer_Texto () );
s1.Cerrar();
//--------------------------------------------
}//main
}//void


4) Implementar las operaciones para archivos secuenciales.

En el momento de utilizar los ficheros con organización secuencial tenemos que tener en cuenta el soporte sobre el que están grabados, pues algunas operaciones que se pueden hacer en los soportes direccionales no se pueden hacer en los soportes secuenciales, como pueden ser las modificaciones y borrado lógico de registros.
El formato de las instrucciones que nos permiten manejar los datos contenidos en un fichero con organización secuencial dependerá del lenguaje de programación con el que trabajemos. De forma general podemos resumir las instrucciones empleadas en el manejo de este tipo de ficheros en las siguientes:

Abrir (OPEN) Abrir un fichero para poder trabajar con sus registros. Se puede abrir de tres formas:

INPUT (I) Sólo para leer registros.
OUTPUT (0) Sólo para escribir registros.
INPUT OUPUT (I O) Para leer y escribir.
EXTEND (E) Para añadir registros al final del fichero
Cerrar (CLOSE) Cerrar el fichero, cuando ya no se va trabajar mas con sus registros.
Leer (READ) Pasar la información de un registro a la memoria principal del ordenador para que el programa pueda trabajar con los datos que contiene. Cada vez que se da una orden de leer se lee el siguiente registro.
Escribir (WRITE) Graba en el soporte la información de un registro con la información que tenga en la memoria principal.
Reescribir (REWRITE) Graba sobre un registro que ya existe en el fichero. Antes de utilizar esta instrucción se tiene que leer antes el registro que se va a reescribir con una orden de leer
(READ).Para poder utilizar los datos del fichero el sistema operativo utiliza un indicador, o puntero, que se coloca señalando al primer registro de datos del fichero, cuando se da la orden de Abrir (OPEN), y se va desplazando, siempre en la misma dirección, cada vez que se lee o graba un registro. La estructura del fichero se completa con un registro de cabecera que contiene información acerca del fichero y un registro que sirve de marca de final de fichero, o EOF (EOF End Of File), que el sistema utiliza para saber cual es el último registro del fichero. El registro de final de fichero (E.O.F.) se graba, por primera vez en el momento de la creación del fichero y se va desplazando cuando se añaden nuevos registros al final del mismo.

1) Investigar la diferencia existente entre los diferentes tipos de archivos, así como las ventajas y desventajas. Debe elaborar un resumen o tabla comparativa para compartir en este foro.

Tipo de archivos
* De texto
El archivo de texto es aquel que contiene caracteres válidos de la tabla
ASCII, esto quiere decir que si lo abrimos desde un procesador de texto, podremos darnos
cuenta de la información que contiene.
VENTAJAS:

* Fácil de leer
* Al abrirlos con un editor de texto común, se puede apreciar la información
* Más rápido de leer
DESVENTAJAS
*La información esta expuesta a que cualquier usuario sepa su contenido
*Si lo abrimos desde un procesador de texto, podremos darnos
cuenta de la información que contiene.
*Los signos son interpretados por el procesador de
textos.
CARACTERÍSTICAS
* Se puede apreciar la información
* No es otro que el clásico y famoso .txt
* Las fonts no son más que gráficos
que el procesador de textos.

BINARIOS
Es un archivo que contiene información en lenguaje máquina o encriptado; esto quiere decir, que si lo abrimos con un procesador de texto no podremos apreciar ni darnos cuenta de que información se trata.

VENTAJAS:
* Si lo abrimos con un procesador de texto no podremos apreciar ni darnos cuenta de que información se trata.
* Trabajar con registros sin necesidad de un motor de base de datos.
* Evitaremos tener que iniciar el motor de la base y podremos disponer de más flexibilidad en el manejo de nuestros registros
* Subdivide su longitud en espacios iguales del tamaño

DESVENTAJAS:
* No podemos interpretar gran parte de información.
* Contiene información en lenguaje máquina o encriptado.

CARACTERISTICAS
* Incorporan valores en formato de bits y/o bytes.
* Almacena registros.
* Se observan los bits o bytes como caracteres de la tabla ASCII.

SECUENCIAL
Es un tipo especial en algunos lenguajes de programación, ya
que permite guardar tipos definidos por el usuario (estructuras y/o registros) donde lenguajes de
programación los graban de manera secuencial y provee mecanismos para realizar su recorrido.

VENTAJAS:
* Guarda tipos definidos por el usuario.
*Los lenguajes de programación los graban de manera secuencial.

DESVENTAJAS:
* En la mayoría de los casos, es de tipo binario, y aveces de tipo texto.
* Eran casi siempre de acceso directo.

CARACTERÍSTICAS:
* El aspecto secuencial refiere a su organización.
* Provee mecanismos para realizar su recorrido.



2) Haciendo uso del lenguaje de programación Java, debe implementar las diferentes operaciones que se pueden realizar para manipular información de un archivo, tales como: Abrir, leer datos, guardar, cerrar, entre otras operaciones. Escriba código fuente, mostrando un ejemplo cualquiera (como: sistema de agenda de datos, factura de ventas, o simplemente, leer y escribir variables enteras, reales y cadena), y dicho código fuente deberá compartirlo en este foro.

//------------------------------------------------------------------------------------------------------------------------------------
//-------------- Derechos Reservados (c) 2012. Edgar - Rangel - Lugo. Mexico
//-------------- Free Source : Codigo libre por M.C. Edgar - Rangel - Lugo.
//-------------- Puedes utilizarlo, modificarlo y adaptarlo de manera libre,
//-------------- solo debes dar el credito al autor. No tiene nada que ver
//-------------- con OpenSource, Freeware, SourceForge, GLP (GPL), EULA, ni
//-------------- algun otro. Este codigo es desarrollado con fines academicos
//-------------- y tiene los - Derechos Reservados (c) 2012. Edgar - Rangel - Lugo. Mexico.
//-------------- Este codigo no debe estar disponible en algun sitio web, si deseas hacerlo
//-------------- debes notificarlo al autor, para que te haga llegar por escrito un permiso.
//-------------- Puedes comunicarte a: erangel_lugo@hotmail.com
//--------------
//------------- Compañero docente, si utilizas este codigo, por favor, da credito al autor
//------------- y no impartas tus clases argumentando que fue extraido de libros o "bajado" de Internet .
//--------------
//------------- PROGRAMAS INDISPENSABLES PARA OPERACIONES BASICAS , VISTO EN UNIDAD
//------------- PROGRAMANDO OPERACIONES BASICAS SOBRE ARCHIVOS DE TEXTO Y BINARIOS
//------------- Atte: M.C. Edgar - Rangel - Lugo.
//-------------
//------------- Este archivo debe llevar el nombre: basicas_rangel.java (en minusculas)
//-------------
//------------------------------------------------------------------------------------------------------------------------------------
import java.io.*;
import java.awt.*;
import java.awt.event.*;
class basicas_rangel {
private FileInputStream abrir;
private FileOutputStream guardar;
private DataOutputStream escribir;
private BufferedReader Leer;
private DataInputStream leer;
private boolean R ;
private String arreglo[];
private String texto;
private boolean salida;
public basicas_rangel () { R = false; salida=true; }//constr
public void Abrir (String archivo) {
R = false;
try {
abrir = new FileInputStream (archivo);
Leer = new BufferedReader( new InputStreamReader(abrir) );
leer = new DataInputStream ( abrir ); R = true;
}catch(Exception exc) { R = false; }
}//void
public void Crear (String archivo) {
R = false;
try {
guardar = new FileOutputStream (archivo); escribir = new DataOutputStream (guardar);
R = true;
}catch(Exception exc) { R = false; }
}//void

public void Cerrar () {
if ( R == true ) {
try { escribir.close(); guardar.close(); } catch(Exception exc) { }
try { leer.close(); abrir.close(); } catch(Exception exc) { }
}//if
}//void
public int leer_entero () {
int N = 0;
try { if ( R == true ) { N = leer.readInt(); } }catch(Exception e) {}
return N;
}//void
public double leer_real () {
double N = 0;
try { if ( R == true ) { N = leer.readDouble(); } }catch(Exception e) {}
return N;
}//void
public char leer_caracter () {
char N = 0; try { if ( R == true ) { N = leer.readChar(); } }catch(Exception e) {}
return N;
}//void
public byte leer_byte () {
byte N = 0; try { if ( R == true ) { N = leer.readByte(); } }catch(Exception e) {}
return N;
}//void
public String leer_texto () {
String S = "";
try { if ( R == true ) { S = leer.readUTF (); } }catch(Exception e) {}
return S;
}//void
public String Leer_Texto () {
String S = "";
try { if ( R == true ) { S = Leer.readLine(); } }catch(Exception e) {}
return S;
}//void
public String Leer_Archivo () {
String S2 = "";
try {
if ( R == true ) {
String cadena = "";
do { cadena = Leer.readLine(); S2 = S2 + cadena + "\n"; }while(cadena != null);
}
}catch(Exception e) {}
return S2;
}//void
public void guardar_binario (int dato) {
try { if ( R == true ) { escribir.writeInt(dato); } }catch(Exception e) {}
}//void
public void guardar_binario (double dato) {
try { if ( R == true ) { escribir.writeDouble(dato); } }catch(Exception e) {}
}//void
public void guardar_binario (char dato) {
try { if ( R == true ) { escribir.writeChar(dato); } }catch(Exception e) {}
}//void

public void guardar_binario (byte dato) {
try { if ( R == true ) { escribir.writeByte(dato); } }catch(Exception e) {}
}//void
public void guardar_binario (String dato) {
try { if ( R == true ) { escribir.writeUTF (dato); } }catch(Exception e) {}
}//void
public void guardar_texto (int dato) {
try { if ( R == true ) { escribir.writeBytes(Str(dato) + "\n"); } }catch(Exception e) {}
}//void
public void guardar_texto (double dato) {
try { if ( R == true ) { escribir.writeBytes(Str(dato) + "\n"); } }catch(Exception e) {}
}//void
public void guardar_texto (char dato) {
try { if ( R == true ) { escribir.writeBytes(dato + " \n"); } }catch(Exception e) {}
}//void
public void guardar_texto (byte dato) {
try { if ( R == true ) { escribir.writeBytes(dato + " \n"); } }catch(Exception e) {}
}//void
public void guardar_texto (String dato) {
try { if ( R == true ) { escribir.writeBytes(dato + "\n"); } }catch(Exception e) {}
}//void
protected void guardar_solo_dato (String dato) {
try { if ( R == true ) { escribir.writeBytes(dato); } }catch(Exception e) {}
}//void
public void Editor_Texto (String title) {
final Frame ventana = new Frame (title);
new Thread() {
public void run() {
texto = ""; salida=false;
MenuBar mb = new MenuBar ();
Menu menu = new Menu("Archivo"); MenuItem iNuevo = new MenuItem("Nuevo");
MenuItem iAbrir = new MenuItem("Abrir"); MenuItem iGuardar = new MenuItem("Guardar");
MenuItem iSalir = new MenuItem("Salir");
mb.add(menu);
menu.add(iNuevo ); menu.add(iAbrir ); menu.add(iGuardar ); menu.add(iSalir );
final TextArea area = new TextArea();
ventana.setSize(640, 480); ventana.setLayout(new BorderLayout());
ventana.add(area, BorderLayout.CENTER);
ventana.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent ev) { ventana.setVisible(false); }
});
iSalir.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){
texto = area.getText(); salida=true; ventana.setVisible(false);
}
} );
iNuevo.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){ area.setText(""); }
} );
iAbrir.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){
try {
FileDialog fd = new FileDialog(ventana, "Open", FileDialog.LOAD);

fd.setVisible(true);
FileInputStream file1 = new FileInputStream (fd.getDirectory() + fd.getFile());
BufferedReader data1 = new BufferedReader(new InputStreamReader(file1));
area.setText("");
String cadena = "";
do {
cadena = data1.readLine();
area.append(cadena + "\n");
}while(cadena != null);
data1.close(); file1.close();
}catch(Exception exc){}
}
} );
iGuardar.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){
try {
FileDialog fd = new FileDialog(ventana, "Save", FileDialog.SAVE);
fd.setVisible(true);
FileOutputStream file1 = new FileOutputStream (fd.getDirectory() + fd.getFile());
DataOutputStream data1 = new DataOutputStream (file1);
data1.writeBytes(area.getText());
data1.close(); file1.close();
}catch(Exception exc){}
}
} );
ventana.setMenuBar(mb);
ventana.setVisible(true);
}}.start();
}//void
public String getTexto() {
do {
try {
Thread.sleep(500);
}catch(Exception exc){}
}while(salida == false);
return texto;
}
public void Capturar_Datos (String campos[], String title) {
final Dialog ventana = new Dialog (new Frame(), title);
Button boton = new Button ("Aceptar");
Label etiqueta = new Label(title);
int num = campos.length ;
Label etiquetas [] = new Label[num];
final TextField cuadros_texto [] = new TextField [num];
int X = 50; int Y = 10;
ventana.setSize(640, ((num*25)+115) );
ventana.setLayout(null);
ventana.setModal(true);
ventana.add(etiqueta); etiqueta.setBounds(X, Y, 400, 25); Y = Y + 25 ;
for(int i = 0; i < num ; i++ ){
etiquetas[i] = new Label(campos[i]);
cuadros_texto [i] = new TextField();
ventana.add(etiquetas[i]);

ventana.add(cuadros_texto [i]);
etiquetas[i].setBounds(X,Y, 250, 25); X = X + 250 ;
cuadros_texto[i].setBounds(X,Y, 250, 25); X = 50 ; Y = Y + 25 ;
}//for
X = X + 250 ; Y = Y + 25 ;
ventana.add(boton); boton.setBounds(X, Y , 80, 40);
X = 50 ;
arreglo = new String [num];
ventana.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent ev) { ventana.setVisible(false); }
});
boton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){
for(int i = 0; i < arreglo.length ; i++ ){
arreglo[i] = cuadros_texto[i].getText();
}//for
ventana.setVisible(false);
}
} );
ventana.setVisible(true);
}//void
public int getInt (int index) { return Double.valueOf(arreglo[index]).intValue(); }
public byte getByte (int index) { return Double.valueOf(arreglo[index]).byteValue(); }
public double getDouble (int index) { return Double.valueOf(arreglo[index]).doubleValue(); }
public String getString (int index) { return arreglo[index]; }
public char getChar (int index) { return (arreglo[index]).charAt(0); }
public String[] getArreglo () { return arreglo; }
private String Str (int d) { return String.valueOf(d); }
private String Str (double d) { return String.valueOf(d); }
} //class



EJEMPLO:
//----------------------------------------------------------
/// REUTILICE LA CLASE basicas_rangel.java
/// PARA COMPILAR Y EJECUTAR ESTE PROGRAMA : sumas.java
//----------------------------------------------------------
//---------------------------------------
//--- Programa
//--- UN EDITOR DE SUMAS - GUARDA DATOS A ARCHIVO EN FORMATO TIPO TEXTO
//---
import java.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class sumas {
public static void main(String args[]) {
basicas_rangel s1 = new basicas_rangel ();
String campos[] = {"X: " , "Y: "};
s1.Crear ("sumas.txt");
for(int k=0;k<3;k++) {
s1.Capturar_Datos (campos, "Editor de Sumas");
s1.guardar_texto ( "Suma : " + s1.getString(0) + "+" + s1.getString(1) +
" = " + (s1.getDouble(0)+s1.getDouble(1)) );
}//for
s1.Cerrar();
s1.Abrir("sumas.txt");
for(int k=0;k<3;k++) {
System.out.println("->Leido: " + s1.Leer_Texto() );
}//for
s1.Cerrar();
}//main
}//void


ATTE: ERIK LAZARO TORRES

Abel_apu escribió:BUENAS NOCHES, AQUÍ PRESENTO MIS RESPUESTAS, ESPERO ESTÉN CORRECTA, SINO ES ASÍ, POR FAVOR RETROALIMENTACION

1) Investigar la diferencia existente entre los diferentes tipos de archivos, así como las ventajas y desventajas. Debe elaborar un resumen o tabla comparativa para compartir en este foro.

TIPO DE ARCHIVO	CARACTERÍSTICAS	VENTAJAS	DESVENTAJAS
ARCHIVOS BINARIO	1.- Contiene información en lenguaje maquina o encriptado. 2.- No podemos darnos cuenta fácilmente del contenido de la información. 3.- Es especialmente para crear registros. 4.- Su longitud se divide en tamaños iguales de registro. 5.- Se accede igual que a un archivo de texto. 6.- puede contener información de cualquier tipo. 7.- Solo tienen sentido para los programas que lo ejecutan.	1.- Permite trabajar con registros sin necesidad de un motor de bases de datos. 2.- A medida que se agregan registros, aumenta el espacio. 3.- Ocupan menos espacio. 4.- Fácil de entender donde empiezan y donde terminan los datos. 5.- Tiene la facilidad de manipular cualquier tipo de dato. 6.- Es simple para escribir y guardar datos. 7.- Permiten guardar clases de manera sencilla. 8.- Permite utilizar más fácilmente el paradigma orientado a objetos. 9.- Evita la perdida de información y calidad.	1.- Debe conocer con precisión como se describen los datos en el archivo. 2.- No se puede observar la información del archivo con facilidad.
ARCHIVOS DE TEXTO	1.- Su formato básico es la extensión .TXT 2.- Pueden contener texto mezclado con ACSSI. 3.- Solo contiene texto sin formato. 4.- Se puede guardar en formato separado por comas o tabulaciones.	1.- Admite el uso de “fonts”, son gráficos. 2.- Permite visualizar el contenido del archivo claramente. 3.- Su contenido puede ser codificado fácilmente. 4.- Puede ser importado a programas de bases de datos.	1.- Carecen de información destinada a generar formatos. 2.- Carece de información de tipos de letra. 3.- Su contenido puede ser fácilmente plagiado.
ARCHIVO DE ACCESO SECUENCIAL	1.- Puede haber archivo secuenciales de tipo binario y de texto. 2.- Es necesario para crear una estructura en los archivos. 3.- Pueden ser de tipo acceso directo. 4.- Todos los registros tienen el mismo tamaño. 5.- Constan del mismo número de campos. 6.- Es posible leer un registro sin leer los anteriores.	1.- Permite guardar tipos definidos por el usuario. 2.- Provee mecanismos para realizar su recorrido. 3.- Es la forma básica de organizar un registro. 4.- Los registros quedan grabados consecutivamente conforme se utilizan. 5.- Proveen la mejor utilización del espacio. 6.- Su uso es de manera más rápida. 7.- Son muy sencillos de usar y aplicar.	1.- El acceso a un registro es pobre. 2.- La localización de un registro no se puede realizar individualmente. 3.- El acceso aleatorio es poco práctico. 4.- La dirección de registro está implícita. 5.- son vulnerables a fallas del sistema.

2) Haciendo uso del lenguaje de programación Java, debe implementar las diferentes operaciones que se pueden realizar para manipular información de un archivo, tales como: Abrir, leer datos, guardar, cerrar, entre otras operaciones. Escriba código fuente, mostrando un ejemplo cualquiera (como: sistema de agenda de datos, factura de ventas, o simplemente, leer y escribir variables enteras, reales y cadena), y dicho código fuente deberá compartirlo en este foro.

AQUI PRESENTO UN CODIGO PROPORCIONADO POR EL PROFESOR EDGAR LUGO RANGEL, LA PRIMERA PARTE REPRESENTA LA CLASE "basicas_rangel.class" NECESARIA PARA CORRERLO, LA SEGUNDA PARTE REPRESENTA LA CLASE "agenda.class" DE UNA AGENDA. ESTAS CLASES FUERON PROBADAS POR SU SERVIDOR Y RESULTARON UTILIZABLES. ESTA CODIFICACION BASICAMENTE PERMITE INGRESAR DATOS EN UNA AGENDA, TALES DATOS SON, NOMBRE, APELLIDO, DIRECCION, TELEFONO, GENERO, ETC.

PRIMERA PARTE

_______________________________________________________________________________________________________
_______________________________________________________________________________________________________
//------------------------------------------------------------------------------------------------------------------------------------
//-------------- Derechos Reservados (c) 2012. Edgar - Rangel - Lugo. Mexico
//-------------- Free Source : Codigo libre por M.C. Edgar - Rangel - Lugo.
//-------------- Puedes utilizarlo, modificarlo y adaptarlo de manera libre,
//-------------- solo debes dar el credito al autor. No tiene nada que ver
//-------------- con OpenSource, Freeware, SourceForge, GLP (GPL), EULA, ni
//-------------- algun otro. Este codigo es desarrollado con fines academicos
//-------------- y tiene los - Derechos Reservados (c) 2012. Edgar - Rangel - Lugo. Mexico.
//-------------- Este codigo no debe estar disponible en algun sitio web, si deseas hacerlo
//-------------- debes notificarlo al autor, para que te haga llegar por escrito un permiso.
//-------------- Puedes comunicarte a: erangel_lugo@hotmail . com
//--------------
//------------- Compañero docente, si utilizas este codigo, por favor, da credito al autor
//------------- y no impartas tus clases argumentando que fue extraido de libros o "bajado" de Internet .
//--------------
//------------- PROGRAMAS INDISPENSABLES PARA OPERACIONES BASICAS , VISTO EN UNIDAD
//------------- PROGRAMANDO OPERACIONES BASICAS SOBRE ARCHIVOS DE TEXTO Y BINARIOS
//------------- Atte: M.C. Edgar - Rangel - Lugo.
//-------------
//------------- Este archivo debe llevar el nombre: basicas_rangel.java (en minusculas)
//-------------
//------------------------------------------------------------------------------------------------------------------------------------
import java.io.*;
import java.awt.*;
import java.awt.event.*;
class basicas_rangel {
private FileInputStream abrir;
private FileOutputStream guardar;
private DataOutputStream escribir;
private BufferedReader Leer;
private DataInputStream leer;
private boolean R ;
private String arreglo[];
private String texto;
private boolean salida;
public basicas_rangel () { R = false; salida=true; }//constr
public void Abrir (String archivo) {
R = false;
try {
abrir = new FileInputStream (archivo);
Leer = new BufferedReader( new InputStreamReader(abrir) );
leer = new DataInputStream ( abrir ); R = true;
}catch(Exception exc) { R = false; }
}//void
public void Crear (String archivo) {
R = false;
try {
guardar = new FileOutputStream (archivo); escribir = new DataOutputStream (guardar);
R = true;
}catch(Exception exc) { R = false; }
}//void


public void Cerrar () {
if ( R == true ) {
try { escribir.close(); guardar.close(); } catch(Exception exc) { }
try { leer.close(); abrir.close(); } catch(Exception exc) { }
}//if
}//void
public int leer_entero () {
int N = 0;
try { if ( R == true ) { N = leer.readInt(); } }catch(Exception e) {}
return N;
}//void
public double leer_real () {
double N = 0;
try { if ( R == true ) { N = leer.readDouble(); } }catch(Exception e) {}
return N;
}//void
public char leer_caracter () {
char N = 0; try { if ( R == true ) { N = leer.readChar(); } }catch(Exception e) {}
return N;
}//void
public byte leer_byte () {
byte N = 0; try { if ( R == true ) { N = leer.readByte(); } }catch(Exception e) {}
return N;
}//void
public String leer_texto () {
String S = "";
try { if ( R == true ) { S = leer.readUTF (); } }catch(Exception e) {}
return S;
}//void
public String Leer_Texto () {
String S = "";
try { if ( R == true ) { S = Leer.readLine(); } }catch(Exception e) {}
return S;
}//void
public String Leer_Archivo () {
String S2 = "";
try {
if ( R == true ) {
String cadena = "";
do { cadena = Leer.readLine(); S2 = S2 + cadena + "\n"; }while(cadena != null);
}
}catch(Exception e) {}
return S2;
}//void
public void guardar_binario (int dato) {
try { if ( R == true ) { escribir.writeInt(dato); } }catch(Exception e) {}
}//void
public void guardar_binario (double dato) {
try { if ( R == true ) { escribir.writeDouble(dato); } }catch(Exception e) {}
}//void
public void guardar_binario (char dato) {
try { if ( R == true ) { escribir.writeChar(dato); } }catch(Exception e) {}
}//void


public void guardar_binario (byte dato) {
try { if ( R == true ) { escribir.writeByte(dato); } }catch(Exception e) {}
}//void
public void guardar_binario (String dato) {
try { if ( R == true ) { escribir.writeUTF (dato); } }catch(Exception e) {}
}//void
public void guardar_texto (int dato) {
try { if ( R == true ) { escribir.writeBytes(Str(dato) + "\n"); } }catch(Exception e) {}
}//void
public void guardar_texto (double dato) {
try { if ( R == true ) { escribir.writeBytes(Str(dato) + "\n"); } }catch(Exception e) {}
}//void
public void guardar_texto (char dato) {
try { if ( R == true ) { escribir.writeBytes(dato + " \n"); } }catch(Exception e) {}
}//void
public void guardar_texto (byte dato) {
try { if ( R == true ) { escribir.writeBytes(dato + " \n"); } }catch(Exception e) {}
}//void
public void guardar_texto (String dato) {
try { if ( R == true ) { escribir.writeBytes(dato + "\n"); } }catch(Exception e) {}
}//void
protected void guardar_solo_dato (String dato) {
try { if ( R == true ) { escribir.writeBytes(dato); } }catch(Exception e) {}
}//void
public void Editor_Texto (String title) {
final Frame ventana = new Frame (title);
new Thread() {
public void run() {
texto = ""; salida=false;
MenuBar mb = new MenuBar ();
Menu menu = new Menu("Archivo"); MenuItem iNuevo = new MenuItem("Nuevo");
MenuItem iAbrir = new MenuItem("Abrir"); MenuItem iGuardar = new MenuItem("Guardar");
MenuItem iSalir = new MenuItem("Salir");
mb.add(menu);
menu.add(iNuevo ); menu.add(iAbrir ); menu.add(iGuardar ); menu.add(iSalir );
final TextArea area = new TextArea();
ventana.setSize(640, 480); ventana.setLayout(new BorderLayout());
ventana.add(area, BorderLayout.CENTER);
ventana.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent ev) { ventana.setVisible(false); }
});
iSalir.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){
texto = area.getText(); salida=true; ventana.setVisible(false);
}
} );
iNuevo.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){ area.setText(""); }
} );
iAbrir.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){
try {
FileDialog fd = new FileDialog(ventana, "Open", FileDialog.LOAD);


fd.setVisible(true);
FileInputStream file1 = new FileInputStream (fd.getDirectory() + fd.getFile());
BufferedReader data1 = new BufferedReader(new InputStreamReader(file1));
area.setText("");
String cadena = "";
do {
cadena = data1.readLine();
area.append(cadena + "\n");
}while(cadena != null);
data1.close(); file1.close();
}catch(Exception exc){}
}
} );
iGuardar.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){
try {
FileDialog fd = new FileDialog(ventana, "Save", FileDialog.SAVE);
fd.setVisible(true);
FileOutputStream file1 = new FileOutputStream (fd.getDirectory() + fd.getFile());
DataOutputStream data1 = new DataOutputStream (file1);
data1.writeBytes(area.getText());
data1.close(); file1.close();
}catch(Exception exc){}
}
} );
ventana.setMenuBar(mb);
ventana.setVisible(true);
}}.start();
}//void
public String getTexto() {
do {
try {
Thread.sleep(500);
}catch(Exception exc){}
}while(salida == false);
return texto;
}
public void Capturar_Datos (String campos[], String title) {
final Dialog ventana = new Dialog (new Frame(), title);
Button boton = new Button ("Aceptar");
Label etiqueta = new Label(title);
int num = campos.length ;
Label etiquetas [] = new Label[num];
final TextField cuadros_texto [] = new TextField [num];
int X = 50; int Y = 10;
ventana.setSize(640, ((num*25)+115) );
ventana.setLayout(null);
ventana.setModal(true);
ventana.add(etiqueta); etiqueta.setBounds(X, Y, 400, 25); Y = Y + 25 ;
for(int i = 0; i < num ; i++ ){
etiquetas[i] = new Label(campos[i]);
cuadros_texto [i] = new TextField();
ventana.add(etiquetas[i]);


ventana.add(cuadros_texto [i]);
etiquetas[i].setBounds(X,Y, 250, 25); X = X + 250 ;
cuadros_texto[i].setBounds(X,Y, 250, 25); X = 50 ; Y = Y + 25 ;
}//for
X = X + 250 ; Y = Y + 25 ;
ventana.add(boton); boton.setBounds(X, Y , 80, 40);
X = 50 ;
arreglo = new String [num];
ventana.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent ev) { ventana.setVisible(false); }
});
boton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){
for(int i = 0; i < arreglo.length ; i++ ){
arreglo[i] = cuadros_texto[i].getText();
}//for
ventana.setVisible(false);
}
} );
ventana.setVisible(true);
}//void
public int getInt (int index) { return Double.valueOf(arreglo[index]).intValue(); }
public byte getByte (int index) { return Double.valueOf(arreglo[index]).byteValue(); }
public double getDouble (int index) { return Double.valueOf(arreglo[index]).doubleValue(); }
public String getString (int index) { return arreglo[index]; }
public char getChar (int index) { return (arreglo[index]).charAt(0); }
public String[] getArreglo () { return arreglo; }
private String Str (int d) { return String.valueOf(d); }
private String Str (double d) { return String.valueOf(d); }
} //class

SEGUNDA PARTE

_______________________________________________________________________________________________________
_______________________________________________________________________________________________________

//------------------------------------------------------------------------
//------------ EJEMPLOS DE: M.C. EDGAR - RANGEL - LUGO . ------------------
//------------------------------------------------------------------------
//........................................................................
//----------------------------------------------------------
//----------------------------------------------------------
//----------- ESTOS VIENEN DE APOYO , DESDE LA UNIDAD 1 ---
//----------------------------------------------------------
//----------------------------------------------------------
//----------------------------------------------------------
/// REUTILICE LA CLASE basicas_rangel.java
/// PARA COMPILAR Y EJECUTAR ESTE PROGRAMA : agenda.java
//----------------------------------------------------------
//----- Programa
//----- Para la GUARDAR DATOS DE UNA agenda empresarial ------
//----- Permite guardar datos en formatos tipo binario y tipo texto ------
//-----
import java.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class agenda {
public static void main(String args[]) {
basicas_rangel s1 = new basicas_rangel ();
String campos[] = {"Nombre del Cliente: ", "Domicilio : ",
"Telefono: ","Pais : ", "Edad: ", "Saldo: ", "Sexo:"};
//--- Guardando datos (Binarios) ---------
s1.Crear ("agenda_binario.dat");
for(int k=0;k<2;k++) {
s1.Capturar_Datos (campos, "Agenda Empresarial");
s1.guardar_binario ( s1.getInt(4) );
s1.guardar_binario ( s1.getDouble(5) );
s1.guardar_binario ( s1.getChar(6) );
s1.guardar_binario ( s1.getString(0) );
s1.guardar_binario ( s1.getString(1) );
s1.guardar_binario ( s1.getString(2) );
s1.guardar_binario ( s1.getString(3) );
}//for
s1.Cerrar();
s1.Abrir ("agenda_binario.dat"); //LEYENDO
System.out.println (" " + campos[4] + " " + s1.leer_entero () );
System.out.println (" " + campos[5] + " " + s1.leer_real () );
System.out.println (" " + campos[6] + " " + s1.leer_caracter () );
System.out.println (" " + campos[0] + " " + s1.leer_texto () );
System.out.println (" " + campos[1] + " " + s1.leer_texto () );
System.out.println (" " + campos[2] + " " + s1.leer_texto () );
System.out.println (" " + campos[3] + " " + s1.leer_texto () );
s1.Cerrar();
//--- Guardando datos (Texto) ---------
s1.Crear ("agenda_texto.txt");

for(int k=0;k<2;k++) {
s1.Capturar_Datos (campos, "Agenda Empresarial");
s1.guardar_texto ( s1.getString(0) );
s1.guardar_texto ( s1.getString(1) );
s1.guardar_texto ( s1.getString(2) );
s1.guardar_texto ( s1.getString(3) );
s1.guardar_texto ( s1.getInt(4) );
s1.guardar_texto ( s1.getDouble(5) );
s1.guardar_texto ( s1.getChar (6) );
}//for
s1.Cerrar();
s1.Abrir ("agenda_texto.txt"); //LEYENDO
System.out.println (" " + campos[0] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[1] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[2] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[3] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[4] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[5] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[6] + " " + s1.Leer_Texto () );
s1.Cerrar();
//--------------------------------------------
}//main
}//void

CABE SEÑALAR QUE SE DEBEN RESPETAR LAS LETRAS MAYÚSCULAS Y MINÚSCULAS. LOS CRÉDITOS DE LOS CÓDIGO SE DEBEN DAR AL MAESTRO EDGAR LUGO RANGEL.

BUENO COMPAÑEROS. ESPERO ESTAR BIEN EN MI APORTACION. SALUDOS

ABEL PIOQUINTO UBIAS

Creo que te falto mencionar algunas extensiones que utilizan los archivos como lo son:
- Extensiones de archivos audio.(.wav, .mp3, .au, .mid)ññ
- Extensiones de archivos de imagen.(.jpg, .png, .bmp, .gif, etc.)
- Extensiones de archivos comprimidos.
- Extensiones de archivos de texto.(.text)
- Extensiones de archivos del sistema.
- Extensiones de archivos de video.(.mpg,
.avi, .asf, etc.)

REPLICA A UN COMPAÑERO COMPAÑERO: ERIK LAZARO TORRES

DE ACUERDO CON MI COMPAÑERO ERIK LAZARO TORRES AFIRMO QUE LOS TIPOS DE ARCHIVOS SON LOS ARCHIVOS DE TEXTO, ARCHIVOS EN BINARIO Y ARCHIVOS SECUENCIALES, Y ESA PEQUEÑO DESCRIPCIÓN QUE ELABORO DE CADA UNO DE ELLOS ESTA CORRECTA, PERO A MI PARECER LE FALTO EXTENDER Y EXPLICAR MAS DETALLADAMENTE CADA UNO DE ELLOS Y MENCIONAR ALGUNOS EJEMPLOS. PERO SIN DUDA ES UN MUY BUEN APORTE POR EL COMPAÑERO.

1) Investigar la diferencia existente entre los diferentes tipos de archivos, así como las ventajas y desventajas. Debe elaborar un resumen o tabla comparativa para compartir en este foro.
A continuación presento la respuesta del reactivo

Hablare los siguientes tipos de archivos:
-----archivos de texto
-----archivos binarios

.....................................................................................................................................................................
Archivos de texto
.....................................................................................................................................................................

Definición: es un archivo informático compuesto únicamente por texto sin formato, sólo caracteres, lo que lo hace también legible por humanos.

Características:

-al abrirlo con un editor de texto se vera texto mezclado con ASCII
-se puede importar en programas de bases de datos u hojas de cálculo de terceros.
Ventajas:
-El archivo puede ser usado por diferentes programas.
-fácil exportación.
-el contenido del archivo de texto plano, lo puedes
Insertar fácilmente en cualquier procesador de texto
-sirve para traspasar información de un formato de base de
Datos a otro
-fácil modificación

Desventajas:

-cualquiera puede tener acceso al archivo
De texto.
- no recomendable para guardar información confidencial.

.....................................................................................................................................................................
Archivos binarios
.....................................................................................................................................................................

Definición: es un archivo informático que contiene información de cualquier tipo codificada en binario para el propósito de almacenamiento y procesamiento en ordenadores.

Características:

-al abrirlo con un editor de texto e vera como elementos del código ASCII lo cual no siendo legible
-sólo contiene información de tipo textual sin información sobre el formato del mismo se dice que es un archivo de texto plano.
Ventajas:

-el contenido del archivo de binario no puede ser visualizado por cualquier usuario.
-ocupa menos espacio
-fácil de entender donde empieza y donde terminan los datos
-su simpleza al guardar y escribir los datos
Desventajas:
-difícil modificación.
- no legible por el humano y por tanto sin un programa para traducirlo a texto será ilegible.



2) Haciendo uso del lenguaje de programación Java, debe implementar las diferentes operaciones que se pueden realizar para manipular información de un archivo, tales como: Abrir, leer datos, guardar, cerrar, entre otras operaciones. Escriba código fuente, mostrando un ejemplo cualquiera (como: sistema de agenda de datos, factura de ventas, o simplemente, leer y escribir variables enteras, reales y cadena), y dicho código fuente deberá compartirlo en este foro.
En el comentario se muestra implementación de operaciones básicas sobre un archivo en el lenguaje de programación "java".
Como primera parte de contestación al reactivo se muestra el código fuente de algunas de las operaciones de manipulación como son:
Abrir
Leer datos
Guardar
Cerrar
Y algunas otras básicas.
....................................................................................................................................................................
Para empezar estas serán las librerías que se importaran:
.....................................................................................................................................................................
import java.io.*;
import java.awt.*;
import java.awt.event.*;//a continuacion se declara la clase operaciones_basicas
class operaciones_basicas{//se declaran las variables
private FileInputStream abrir;
private FileOutputStream guardar;
private DataOutputStream escribir;
private BufferedReader Leer;
private DataInputStream leer;
private boolean R ;
private String arreglo[];
private String texto;
private boolean salida;
public operaciones_basicas () { R = false; salida=true; }//constructor de la clase
//operacion abrir archivo
public void Abrir (String archivo) {
R = false;
try {
abrir = new FileInputStream (archivo);
Leer = new BufferedReader( new InputStreamReader(abrir) );
leer = new DataInputStream ( abrir ); R = true;
}catch(Exception exc) { R = false; }
}//void
//operacion crear archivo
public void Crear (String archivo) {
R = false;
try {
guardar = new FileOutputStream (archivo); escribir = new DataOutputStream (guardar);
R = true;
}catch(Exception exc) { R = false; }
}//void

//operacion cerrar archivo
public void Cerrar () {
if ( R == true ) {
try { escribir.close(); guardar.close(); } catch(Exception exc) { }
try { leer.close(); abrir.close(); } catch(Exception exc) { }
}//if
}//void
// otras operaciones básicas que se realizan sobre la información de una archivo, se utilizaran tomando en cuenta el tipo de archivo y la operación deseada
public int leer_entero () {
int N = 0;
try { if ( R == true ) { N = leer.readInt(); } }catch(Exception e) {}
return N;
}//void
public double leer_real () {
double N = 0;
try { if ( R == true ) { N = leer.readDouble(); } }catch(Exception e) {}
return N;
}//void
public char leer_caracter () {
char N = 0; try { if ( R == true ) { N = leer.readChar(); } }catch(Exception e) {}
return N;
}//void
public byte leer_byte () {
byte N = 0; try { if ( R == true ) { N = leer.readByte(); } }catch(Exception e) {}
return N;
}//void
public String leer_texto () {
String S = "";
try { if ( R == true ) { S = leer.readUTF (); } }catch(Exception e) {}
return S;
}//void
public String Leer_Texto () {
String S = "";
try { if ( R == true ) { S = Leer.readLine(); } }catch(Exception e) {}
return S;
}//void
public String Leer_Archivo () {
String S2 = "";
try {
if ( R == true ) {
String cadena = "";
do { cadena = Leer.readLine(); S2 = S2 + cadena + "\n"; }while(cadena != null);
}
}catch(Exception e) {}
return S2;
}//void
public void guardar_binario (int dato) {
try { if ( R == true ) { escribir.writeInt(dato); } }catch(Exception e) {}
}//void
public void guardar_binario (double dato) {
try { if ( R == true ) { escribir.writeDouble(dato); } }catch(Exception e) {}
}//void
public void guardar_binario (char dato) {
try { if ( R == true ) { escribir.writeChar(dato); } }catch(Exception e) {}
}//void
public void guardar_binario (byte dato) {
try { if ( R == true ) { escribir.writeByte(dato); } }catch(Exception e) {}
}//void
public void guardar_binario (String dato) {
try { if ( R == true ) { escribir.writeUTF (dato); } }catch(Exception e) {}
}//void
public void guardar_texto (int dato) {
try { if ( R == true ) { escribir.writeBytes(Str(dato) + "\n"); } }catch(Exception e) {}
}//void
public void guardar_texto (double dato) {
try { if ( R == true ) { escribir.writeBytes(Str(dato) + "\n"); } }catch(Exception e) {}
}//void
public void guardar_texto (char dato) {
try { if ( R == true ) { escribir.writeBytes(dato + " \n"); } }catch(Exception e) {}
}//void
public void guardar_texto (byte dato) {
try { if ( R == true ) { escribir.writeBytes(dato + " \n"); } }catch(Exception e) {}
}//void
public void guardar_texto (String dato) {
try { if ( R == true ) { escribir.writeBytes(dato + "\n"); } }catch(Exception e) {}
}//void
protected void guardar_solo_dato (String dato) {
try { if ( R == true ) { escribir.writeBytes(dato); } }catch(Exception e) {}
}//void
}
..............................................................................................................................................
Como respuesta a la segunda parte del reactivo se muestra el código fuente de un sistema de agenda de datos
...........................................................................................................................................
....................................................................................................................................................
Para empezar estas serán las librerías que se importaran:
............................................................................................................................................

import java.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class agenda {//comienza la clase que hace funcionar a la agenda empresarial
public static void main(String args[]) {
operaciones_basicas s1 = new operaciones_basicas ();//se crea un objeto tomando en cuenta la clase mencionada en la primera parte
String campos[] = {"Nombre del Cliente: ", "Domicilio : ",
"Telefono: ","Pais : ", "Edad: ", "Saldo: ", "Sexo:"};
//--- Guardando datos (Binarios) ---------
s1.Crear ("agenda_binario.dat");
for(int k=0;k<2;k++) {
s1.Capturar_Datos (campos, "Agenda Empresarial");
s1.guardar_binario ( s1.getInt(4) );
s1.guardar_binario ( s1.getDouble(5) );
s1.guardar_binario ( s1.getChar(6) );
s1.guardar_binario ( s1.getString(0) );
s1.guardar_binario ( s1.getString(1) );
s1.guardar_binario ( s1.getString(2) );
s1.guardar_binario ( s1.getString(3) );
}//for
s1.Cerrar();
s1.Abrir ("agenda_binario.dat"); //LEYENDO
System.out.println (" " + campos[4] + " " + s1.leer_entero () );
System.out.println (" " + campos[5] + " " + s1.leer_real () );
System.out.println (" " + campos[6] + " " + s1.leer_caracter () );
System.out.println (" " + campos[0] + " " + s1.leer_texto () );
System.out.println (" " + campos[1] + " " + s1.leer_texto () );
System.out.println (" " + campos[2] + " " + s1.leer_texto () );
System.out.println (" " + campos[3] + " " + s1.leer_texto () );
s1.Cerrar();
//--- Guardando datos (Texto) ---------
s1.Crear ("agenda_texto.txt");

for(int k=0;k<2;k++) {
s1.Capturar_Datos (campos, "Agenda Empresarial");
s1.guardar_texto ( s1.getString(0) );
s1.guardar_texto ( s1.getString(1) );
s1.guardar_texto ( s1.getString(2) );
s1.guardar_texto ( s1.getString(3) );
s1.guardar_texto ( s1.getInt(4) );
s1.guardar_texto ( s1.getDouble(5) );
s1.guardar_texto ( s1.getChar (6) );
}//for
s1.Cerrar();
s1.Abrir ("agenda_texto.txt"); //LEYENDO
System.out.println (" " + campos[0] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[1] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[2] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[3] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[4] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[5] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[6] + " " + s1.Leer_Texto () );
s1.Cerrar();
//--------------------------------------------
}//main
}//void

En esta ultima se muestra el uso de leer y escribir archivos del tipo texto y binario.
Cabe destacar que el código fuente es autoría del M.C Edgar Rangel Lugo facilitador de la materia.
El código fuente ha sido modificado. Por lo cual el nombre de las clases puede variar de los nombres originales, además han sido añadidos algunos comentarios al código para presentar de manera clara la respuesta al reactivo.

De esta manera finaliza mi comentario y si algo falto o lo consideran incorrecto pueden hacer replica

MI RETROALIMENTACION ESTA DIRIGIDA A MI COMPAÑERO ZERGIO ZAIR HERNANDEZ GOMEZ.

ESTOY DE ACUERDO EN SUS RESPUESTAS, LOS CÓDIGOS SON ENTENDIBLES. SOLO ME QUEDA ACLARARLE UN PUNTO IMPORTANTE, EN EL REACTIVO 1 SE DEBIA HABLAR TAMBIEN DEL TIPO DE TEXTO "SECUENCIAL", PERO CONCUERDO CON TODA SU INFORMACION, DESDE MI PUNTO DE VISTA, EN CUANTO A INTEGRIDAD Y SEGURIDAD, LOS ARCHIVOS DE TIPO BINARIO SON MAS SEGUROS YA QUE SU INFORMACION NO PUEDE SER LEGIBLE TAN FACILMENTE.

ENHORABUENA INGENIRO. FELICITACIONES.

ATTE: ABEL PIOQUINTO UBIAS

Mi replica esta dirigida a mi compañero Abel Pioquinto Ubias
La forma en que Abel aborda el rimer reactivo me parecio clara y describe muy bien
las caracteristica, entajas y desventajas de los tipos de archivos.
Solo pudiera comentar que algunas de las caracteristicas del archivo de acceso secuencial es
que no en todos los lenguajes de programacion puede ser creado.

Ademas agradesco su replica y solo comento que no inclui el arhivo de acceso secuencial ya que la considere una
forma de organizacion de archivos, pero ahora al leer otras definiciones encuentro que tambien es una forma de organizacion de ficheros y por tanto puede entrar en la respuesta al reactivo.

BUENA PARTICIPACION INGENIERO

1) Investigar la diferencia existente entre los diferentes tipos de archivos, así como las ventajas y desventajas. Debe elaborar un resumen o tabla comparativa para compartir en este foro.

Se dividen en archivo binario y de texto:
Un archivo binario es un archivo informático que contiene información de cualquier tipo codificada en binario para el propósito de almacenamiento y procesamiento en ordenadores. Por ejemplo los archivos informáticos que almacenan texto formateado o fotografías, así como los archivos ejecutables que contienen programas.
Ventajas:
• contienen partes que pueden ser interpretados como texto.
• una secuencia de bytes que es lo que implica que dígitos binarios (bits).
• su simpleza al guardar y escribir los datos
Desventajas:
• Los archivos binarios no permiten guardar clases de manera muy sencilla.
• que aparentemente es un poco mas de código
• hay muchos datos almacenados sobre los que hay que operar.
Un archivo de texto es un archivo informático compuesto únicamente por texto sin formato, sólo caracteres, lo que lo hace también legible por humanos. Estos caracteres se pueden codificar de distintos modos dependiendo de la lengua usada. Algunos de los sistemas de codificación más usados son: ASCII, ISO-8859-1 o Latín-1 y UTF-8.
Ventajas:
• Concentra de manera clara y directa información compleja
• sirve para libros, documentos de textos y gráficos, hipervínculos, etc.
• El usuario introduce de manera efectiva gracias a su legibilidad, estilo y tamaño.
Desventajas:
• Es fácil de acezar por lo cual no es recomendable guardar información personal.

4) Implementar las operaciones para archivos secuenciales.
Archivos secuenciales
Se refiere al procesamiento de los registros, no importa el orden en que se haga, para eso los registros están organizados en forma de una lista y recuperarlos y procesarlos uno por uno de principio a fin.

Rudimentos de los archivos Secuenciales; dependiendo del dispositivo de almacenamiento utilizado el archivo se puede mostrar el usuario como si fuera un sistema secuencial.

Al finalizar un archivo secuencial se denota con una marca de fin de archivo. (End end-of-file)

El usuario de un archivo secuancial puede ver los registros en un orden secuancial simple.

La única forma de recuperar registros es comenzar al principio y extraerlos en el orden contemplado.

Cuestiones de programación; la manipulación de los archivos se hace en el contexto de la programación en un lenguaje por procedimientos de alto nivel. Estos lenguajes tienden a expresar la manipulación de archivos mediante subrutinas que se definen como parte del lenguaje formal o se incluyen como extensiones del lenguaje en una biblioteca estándar.

La mayor parte de los lenguajes por procedimiento de alto nivel cuenta con características que ayudan a detectar la marca de fin de archivo.

CLASIFICACION DE ARCHIVOS SECUENCIALES

Normalmente los archivos secuenciales se da en proceso en lotes, donde hemos advertido que son eficientes cuando se llevan a cabo diversas operaciones sobre una gran cantidad de registros o de todo el archivo.

Esta eficiencia se logra con una acción: la clasificación, proceso que no es excluido, pero si imprescindible para diversas operaciones.


CLASIFICACIÓN (SORTING) EN ARCHIVOS

Es el proceso de examinar los registros en un archivo y ponerlos en una secuencia ascendente o descendente basada en el valor de un campo o campos de registros.

El campo cuyo valor es visto p/ determinar el ordenamiento y es conocido como llave de ordenamiento; los requerimientos de determinar el procesamiento apropiado.

Operaciones para archivos secuenciales

En el momento de utilizar los ficheros con organización secuencial tenemos que tener en cuenta el soporte sobre el que están grabados, pues algunas operaciones que se pueden hacer en los soportes direccionables no se pueden hacer en los soportes secuenciales, como pueden ser las modificaciones y borrado lógico de registros.


El formato de las instrucciones que nos permiten manejar los datos contenidos en un fichero con organización secuencial dependerá del lenguaje de programación con el que trabajemos. De forma general podemos resumir las instrucciones empleadas en el manejo de este tipo de ficheros en las siguientes:



Abrir (OPEN) Abrir un fichero para poder trabajar con sus registros. Se puede abrir de tres formas:

INPUT (I) ‑ Sólo para leer registros.

OUTPUT (0) ‑ Sólo para escribir registros.

INPUT‑OUPUT (I‑O) ‑ Para leer y escribir.

EXTEND (E) ‑ Para añadir registros al final del fichero

Cerrar (CLOSE) Cerrar el fichero, cuando ya no se va trabajar mas con sus registros.

Leer (READ) Pasar la información de un registro a la memoria principal del ordenador para que el programa pueda trabajar con los datos que contiene. Cada vez que se da una orden de leer se lee el siguiente registro.

Escribir (WRITE) Graba en el soporte la información de un registro con la información que tenga en la memoria principal.

Reescribir (REWRITE) Graba sobre un registro que ya existe en el fichero. Antes de utilizar esta instrucción se tiene que leer antes el registro que se va a reescribir con una orden de leer

(READ).Para poder utilizar los datos del fichero el sistema operativo utiliza un indicador, o puntero, que se coloca señalando al primer registro de datos del fichero, cuando se da la orden de Abrir (OPEN), y se va desplazando, siempre en la misma dirección, cada vez que se lee o graba un registro. La estructura del fichero se completa con un registro de cabecera que contiene información acerca del fichero y un registro que sirve de marca de final de fichero, o EOF (EOF ‑ End Of File), que el sistema utiliza para saber cual es el último registro del fichero. El registro de final de fichero (E.O.F.) se graba, por primera vez en el momento de la creación del fichero y se va desplazando cuando se añaden nuevos registros al final del mismo.

[b]HECHO POR ENRIQUE GOICOCHEA PINEDA

TIPO DE ARCHIVO	TIPO DE ARCHIVO CARACTERÍSTICAS	VENTAJAS	DESVENTAJAS
archivos binario	1.- brindarán a nuestras aplicaciones la posibilidad de trabajar con registros sin necesidad de un motor de base de datos.	1.-nos permite trabajar con registros sin necesidad de un motor de bases de datos. 2.- estos pueden ocupar menos espacio. 3.- estos son mucho mas fácil de entender donde empiezan y donde terminan los datos.	1.- en estos no se puede observar la información del archivo con facilidad ya que es un poco mas complicado por ser binario.
archivos de texto	1.- tiene un formato básico es la extensión .txt 2- se puede guardar en formato separado por comas o tabulaciones.	1.- permite visualizar el contenido del archivo claramente. 2.- puede ser importado a programas de bases de datos.	1.- su contenido de este archivo puede ser fácilmente ya que este es un archivo de texto
1.- archivo de acceso secuencial	1.- es necesario para crear una estructura en los archivos. 2.- puede haber archivo secuenciales de tipo binario y de texto. 3.- pueden ser de tipo acceso directo. 4.- es posible leer un registro sin leer los anteriores.	1.- nos permite guardar tipos definidos por el usuario. 2.- tiene un uso mucho mas rápido 3.- tiene mecanismos para realizar su recorrido.	1.- esto tiene acceso a un registro es pobre. 2.- no nos permite la localización de un registro no se puede realizar individualmente. 3.- estos suelen ser vulnerables a fallas del sistema.

2) haciendo uso del lenguaje de programación java, debe implementar las diferentes operaciones que se pueden realizar para manipular información de un archivo, tales como: abrir, leer datos, guardar, cerrar, entre otras operaciones. escriba código fuente, mostrando un ejemplo cualquiera (como: sistema de agenda de datos, factura de ventas, o simplemente, leer y escribir variables enteras, reales y cadena), y dicho código fuente deberá compartirlo en este foro.

en este documento muestro un codigo proporcionado por el profesor edgar lugo rangel, la primera parte representa la clase "basicas_rangel.class" necesaria para correrlo.

PRIMERA PARTE

_______________________________________________________________________________________________________
_______________________________________________________________________________________________________
//------------------------------------------------------------------------------------------------------------------------------------
//-------------- derechos reservados (c) 2012. edgar - rangel - lugo. mexico
//-------------- free source : codigo libre por m.c. edgar - rangel - lugo.
//-------------- puedes utilizarlo, modificarlo y adaptarlo de manera libre,
//-------------- solo debes dar el credito al autor. no tiene nada que ver
//-------------- con opensource, freeware, sourceforge, glp (gpl), eula, ni
//-------------- algun otro. este codigo es desarrollado con fines academicos
//-------------- y tiene los - derechos reservados (c) 2012. edgar - rangel - lugo. mexico.
//-------------- este codigo no debe estar disponible en algun sitio web, si deseas hacerlo
//-------------- debes notificarlo al autor, para que te haga llegar por escrito un permiso.
//-------------- puedes comunicarte a: erangel_lugo@hotmail . com
//--------------
//------------- compañero docente, si utilizas este codigo, por favor, da credito al autor
//------------- y no impartas tus clases argumentando que fue extraido de libros o "bajado" de internet .
//--------------
//------------- programas indispensables para operaciones basicas , visto en unidad
//------------- programando operaciones basicas sobre archivos de texto y binarios
//------------- atte: m.c. edgar - rangel - lugo.
//-------------
//------------- este archivo debe llevar el nombre: basicas_rangel.java (en minusculas)
//-------------
//------------------------------------------------------------------------------------------------------------------------------------
import java.io.*;
import java.awt.*;
import java.awt.event.*;
class basicas_rangel {
private fileinputstream abrir;
private fileoutputstream guardar;
private dataoutputstream escribir;
private bufferedreader leer;
private datainputstream leer;
private boolean r ;
private string arreglo[];
private string texto;
private boolean salida;
public basicas_rangel () { r = false; salida=true; }//constr
public void abrir (string archivo) {
r = false;
try {
abrir = new fileinputstream (archivo);
leer = new bufferedreader( new inputstreamreader(abrir) );
leer = new datainputstream ( abrir ); r = true;
}catch(exception exc) { r = false; }
}//void
public void crear (string archivo) {
r = false;
try {
guardar = new fileoutputstream (archivo); escribir = new dataoutputstream (guardar);
r = true;
}catch(exception exc) { r = false; }
}//void


public void cerrar () {
if ( r == true ) {
try { escribir.close(); guardar.close(); } catch(exception exc) { }
try { leer.close(); abrir.close(); } catch(exception exc) { }
}//if
}//void
public int leer_entero () {
int n = 0;
try { if ( r == true ) { n = leer.readint(); } }catch(exception e) {}
return n;
}//void
public double leer_real () {
double n = 0;
try { if ( r == true ) { n = leer.readdouble(); } }catch(exception e) {}
return n;
}//void
public char leer_caracter () {
char n = 0; try { if ( r == true ) { n = leer.readchar(); } }catch(exception e) {}
return n;
}//void
public byte leer_byte () {
byte n = 0; try { if ( r == true ) { n = leer.readbyte(); } }catch(exception e) {}
return n;
}//void
public string leer_texto () {
string s = "";
try { if ( r == true ) { s = leer.readutf (); } }catch(exception e) {}
return s;
}//void
public string leer_texto () {
string s = "";
try { if ( r == true ) { s = leer.readline(); } }catch(exception e) {}
return s;
}//void
public string leer_archivo () {
string s2 = "";
try {
if ( r == true ) {
string cadena = "";
do { cadena = leer.readline(); s2 = s2 + cadena + "\n"; }while(cadena != null);
}
}catch(exception e) {}
return s2;
}//void
public void guardar_binario (int dato) {
try { if ( r == true ) { escribir.writeint(dato); } }catch(exception e) {}
}//void
public void guardar_binario (double dato) {
try { if ( r == true ) { escribir.writedouble(dato); } }catch(exception e) {}
}//void
public void guardar_binario (char dato) {
try { if ( r == true ) { escribir.writechar(dato); } }catch(exception e) {}
}//void


public void guardar_binario (byte dato) {
try { if ( r == true ) { escribir.writebyte(dato); } }catch(exception e) {}
}//void
public void guardar_binario (string dato) {
try { if ( r == true ) { escribir.writeutf (dato); } }catch(exception e) {}
}//void
public void guardar_texto (int dato) {
try { if ( r == true ) { escribir.writebytes(str(dato) + "\n"); } }catch(exception e) {}
}//void
public void guardar_texto (double dato) {
try { if ( r == true ) { escribir.writebytes(str(dato) + "\n"); } }catch(exception e) {}
}//void
public void guardar_texto (char dato) {
try { if ( r == true ) { escribir.writebytes(dato + " \n"); } }catch(exception e) {}
}//void
public void guardar_texto (byte dato) {
try { if ( r == true ) { escribir.writebytes(dato + " \n"); } }catch(exception e) {}
}//void
public void guardar_texto (string dato) {
try { if ( r == true ) { escribir.writebytes(dato + "\n"); } }catch(exception e) {}
}//void
protected void guardar_solo_dato (string dato) {
try { if ( r == true ) { escribir.writebytes(dato); } }catch(exception e) {}
}//void
public void editor_texto (string title) {
final frame ventana = new frame (title);
new thread() {
public void run() {
texto = ""; salida=false;
menubar mb = new menubar ();
menu menu = new menu("archivo"); menuitem inuevo = new menuitem("nuevo");
menuitem iabrir = new menuitem("abrir"); menuitem iguardar = new menuitem("guardar");
menuitem isalir = new menuitem("salir");
mb.add(menu);
menu.add(inuevo ); menu.add(iabrir ); menu.add(iguardar ); menu.add(isalir );
final textarea area = new textarea();
ventana.setsize(640, 480); ventana.setlayout(new borderlayout());
ventana.add(area, borderlayout.center);
ventana.addwindowlistener(new windowadapter(){
public void windowclosing(windowevent ev) { ventana.setvisible(false); }
});
isalir.addactionlistener(new actionlistener() {
public void actionperformed(actionevent ev){
texto = area.gettext(); salida=true; ventana.setvisible(false);
}
} );
inuevo.addactionlistener(new actionlistener() {
public void actionperformed(actionevent ev){ area.settext(""); }
} );
iabrir.addactionlistener(new actionlistener() {
public void actionperformed(actionevent ev){
try {
filedialog fd = new filedialog(ventana, "open", filedialog.load);


fd.setvisible(true);
fileinputstream file1 = new fileinputstream (fd.getdirectory() + fd.getfile());
bufferedreader data1 = new bufferedreader(new inputstreamreader(file1));
area.settext("");
string cadena = "";
do {
cadena = data1.readline();
area.append(cadena + "\n");
}while(cadena != null);
data1.close(); file1.close();
}catch(exception exc){}
}
} );
iguardar.addactionlistener(new actionlistener() {
public void actionperformed(actionevent ev){
try {
filedialog fd = new filedialog(ventana, "save", filedialog.save);
fd.setvisible(true);
fileoutputstream file1 = new fileoutputstream (fd.getdirectory() + fd.getfile());
dataoutputstream data1 = new dataoutputstream (file1);
data1.writebytes(area.gettext());
data1.close(); file1.close();
}catch(exception exc){}
}
} );
ventana.setmenubar(mb);
ventana.setvisible(true);
}}.start();
}//void
public string gettexto() {
do {
try {
thread.sleep(500);
}catch(exception exc){}
}while(salida == false);
return texto;
}
public void capturar_datos (string campos[], string title) {
final dialog ventana = new dialog (new frame(), title);
button boton = new button ("aceptar");
label etiqueta = new label(title);
int num = campos.length ;
label etiquetas [] = new label[num];
final textfield cuadros_texto [] = new textfield [num];
int x = 50; int y = 10;
ventana.setsize(640, ((num*25)+115) );
ventana.setlayout(null);
ventana.setmodal(true);
ventana.add(etiqueta); etiqueta.setbounds(x, y, 400, 25); y = y + 25 ;
for(int i = 0; i < num ; i++ ){
etiquetas[i] = new label(campos[i]);
cuadros_texto [i] = new textfield();
ventana.add(etiquetas[i]);


ventana.add(cuadros_texto [i]);
etiquetas[i].setbounds(x,y, 250, 25); x = x + 250 ;
cuadros_texto[i].setbounds(x,y, 250, 25); x = 50 ; y = y + 25 ;
}//for
x = x + 250 ; y = y + 25 ;
ventana.add(boton); boton.setbounds(x, y , 80, 40);
x = 50 ;
arreglo = new string [num];
ventana.addwindowlistener(new windowadapter(){
public void windowclosing(windowevent ev) { ventana.setvisible(false); }
});
boton.addactionlistener(new actionlistener() {
public void actionperformed(actionevent ev){
for(int i = 0; i < arreglo.length ; i++ ){
arreglo[i] = cuadros_texto[i].gettext();
}//for
ventana.setvisible(false);
}
} );
ventana.setvisible(true);
}//void
public int getint (int index) { return double.valueof(arreglo[index]).intvalue(); }
public byte getbyte (int index) { return double.valueof(arreglo[index]).bytevalue(); }
public double getdouble (int index) { return double.valueof(arreglo[index]).doublevalue(); }
public string getstring (int index) { return arreglo[index]; }
public char getchar (int index) { return (arreglo[index]).charat(0); }
public string[] getarreglo () { return arreglo; }
private string str (int d) { return string.valueof(d); }
private string str (double d) { return string.valueof(d); }
} //class
SEGUNDA PARTE
la segunda parte representa la clase "suma" guarda datos a archivos en formato tipo


/// reutilice la clase basicas_rangel.java
/// para compilar y ejecutar este programa : sumas.java
//----------------------------------------------------------
//---------------------------------------
//--- programa
//--- un editor de sumas - guarda datos a archivo en formato tipo texto
//---
import java.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class sumas {
public static void main(string args[]) {
basicas_rangel s1 = new basicas_rangel ();
string campos[] = {"x: " , "y: "};
s1.crear ("sumas.txt");
for(int k=0;k<3;k++) {
s1.capturar_datos (campos, "editor de sumas");
s1.guardar_texto ( "suma : " + s1.getstring(0) + "+" + s1.getstring(1) +
" = " + (s1.getdouble(0)+s1.getdouble(1)) );
}//for
s1.cerrar();
s1.abrir("sumas.txt");
for(int k=0;k<3;k++) {
system.out.println("->leido: " + s1.leer_texto() );
}//for
s1.cerrar();
}//main
}//void

ATT: ANAYELLI TORRES JARAMILLO

1) Investigar la diferencia existente entre los diferentes tipos de archivos, así como desventajas. Debe elaborar un resumen o tabla comparativa para compartir en este foro.

TIPOS DE ARCHIVO

ARCHIVO DE TEXTO

Características

-Es aquel que contiene caracteres válidos de la tabla ASCII,
-Podremos darnos cuenta de la información que contiene.
-Al abrirlos con un editor de texto común, se puede apreciar la información


Ventajas

-podemos usar fonts u otros efectos
-puede importarse el contenido a cualquier editor de texto o bases de datos
-Se puede visualizar el contenido del archivo claramente.

Desventajas:

-El contenido puede ser visto por cualquiera
-Carece de confidencialidad
-Contenido puede ser fácilmente manipulado o modificado por terceras personas



LOS ARCHIVOS BINARIOS

Características

-Es un archivo creado especialmente para almacenar registros
-Subdivide su longitud en espacios iguales del tamaño que ocupa un registro común, y a medida que agregamos registros, añade un espacio.

Ventajas

-Trabaja con registros sin necesidad de un motor de base de datos
-Tiene información en lenguaje maquina o encriptado
-Al estar encriptado no podemos darnos cuenta de la información que contiene fácilmente
-Ocupan menos espacio
-Contiene información de cualquier tipo codificada en binario
-Los archivos binarios nos permiten guardar clases de manera muy sencilla, muy rápida y muy eficiente por lo que son extremadamente útiles al programa

Desventajas

-Debe conocer con precisión cómo los datos se escriben en el archivo para manipularlo con éxito.
-datos encriptados no legibles fácilmente

2) Haciendo uso del lenguaje de programación Java, debe implementar las diferentes operaciones que se pueden realizar para manipular información de un archivo, tales como: Abrir, leer datos, guardar, cerrar, entre otras operaciones. Escriba código fuente, mostrando un ejemplo cualquiera (como: sistema de agenda de datos, factura de ventas, o simplemente, leer y escribir variables enteras, reales y cadena), y dicho código fuente deberá compartirlo en este foro

los siguientes códigos fueron proporcionados por el Profesor Edgar Rangel Lugo autor del mismo, todos los derechos resevados a (c) 2012. Edgar - Rangel - Lugo. Mexico
//---------------------------------------------------primera parte(basicas_rangel.class)-----------------------------------------------------------------
//-------------- Derechos Reservados (c) 2012. Edgar - Rangel - Lugo. Mexico
//-------------- Free Source : Codigo libre por M.C. Edgar - Rangel - Lugo.
//-------------- Puedes utilizarlo, modificarlo y adaptarlo de manera libre,
//-------------- solo debes dar el credito al autor. No tiene nada que ver
//-------------- con OpenSource, Freeware, SourceForge, GLP (GPL), EULA, ni
//-------------- algun otro. Este codigo es desarrollado con fines academicos
//-------------- y tiene los - Derechos Reservados (c) 2012. Edgar - Rangel - Lugo. Mexico.
//-------------- Este codigo no debe estar disponible en algun sitio web, si deseas hacerlo
//-------------- debes notificarlo al autor, para que te haga llegar por escrito un permiso.
//-------------- Puedes comunicarte a: erangel_lugo@hotmail.com
//--------------
//------------- Compañero docente, si utilizas este codigo, por favor, da credito al autor
//------------- y no impartas tus clases argumentando que fue extraido de libros o "bajado" de Internet .
//--------------
//------------- PROGRAMAS INDISPENSABLES PARA OPERACIONES BASICAS , VISTO EN UNIDAD
//------------- PROGRAMANDO OPERACIONES BASICAS SOBRE ARCHIVOS DE TEXTO Y BINARIOS
//------------- Atte: M.C. Edgar - Rangel - Lugo.
//-------------
//------------- Este archivo debe llevar el nombre: basicas_rangel.java (en minusculas)
//-------------
//------------------------------------------------------------------------------------------------------------------------------------
import java.io.*;
import java.awt.*;
import java.awt.event.*;
class basicas_rangel {
private FileInputStream abrir;
private FileOutputStream guardar;
private DataOutputStream escribir;
private BufferedReader Leer;
private DataInputStream leer;
private boolean R ;
private String arreglo[];
private String texto;
private boolean salida;
public basicas_rangel () { R = false; salida=true; }//constr
public void Abrir (String archivo) {
R = false;
try {
abrir = new FileInputStream (archivo);
Leer = new BufferedReader( new InputStreamReader(abrir) );
leer = new DataInputStream ( abrir ); R = true;
}catch(Exception exc) { R = false; }
}//void
public void Crear (String archivo) {
R = false;
try {
guardar = new FileOutputStream (archivo); escribir = new DataOutputStream (guardar);
R = true;
}catch(Exception exc) { R = false; }
}//void
public void Cerrar () {
if ( R == true ) {
try { escribir.close(); guardar.close(); } catch(Exception exc) { }
try { leer.close(); abrir.close(); } catch(Exception exc) { }
}//if
}//void
public int leer_entero () {
int N = 0;
try { if ( R == true ) { N = leer.readInt(); } }catch(Exception e) {}
return N;
}//void
public double leer_real () {
double N = 0;
try { if ( R == true ) { N = leer.readDouble(); } }catch(Exception e) {}
return N;
}//void
public char leer_caracter () {
char N = 0; try { if ( R == true ) { N = leer.readChar(); } }catch(Exception e) {}
return N;
}//void
public byte leer_byte () {
byte N = 0; try { if ( R == true ) { N = leer.readByte(); } }catch(Exception e) {}
return N;
}//void
public String leer_texto () {
String S = "";
try { if ( R == true ) { S = leer.readUTF (); } }catch(Exception e) {}
return S;
}//void
public String Leer_Texto () {
String S = "";
try { if ( R == true ) { S = Leer.readLine(); } }catch(Exception e) {}
return S;
}//void
public String Leer_Archivo () {
String S2 = "";
try {
if ( R == true ) {
String cadena = "";
do { cadena = Leer.readLine(); S2 = S2 + cadena + "\n"; }while(cadena != null);
}
}catch(Exception e) {}
return S2;
}//void
public void guardar_binario (int dato) {
try { if ( R == true ) { escribir.writeInt(dato); } }catch(Exception e) {}
}//void
public void guardar_binario (double dato) {
try { if ( R == true ) { escribir.writeDouble(dato); } }catch(Exception e) {}
}//void
public void guardar_binario (char dato) {
try { if ( R == true ) { escribir.writeChar(dato); } }catch(Exception e) {}
}//void
3
public void guardar_binario (byte dato) {
try { if ( R == true ) { escribir.writeByte(dato); } }catch(Exception e) {}
}//void
public void guardar_binario (String dato) {
try { if ( R == true ) { escribir.writeUTF (dato); } }catch(Exception e) {}
}//void
public void guardar_texto (int dato) {
try { if ( R == true ) { escribir.writeBytes(Str(dato) + "\n"); } }catch(Exception e) {}
}//void
public void guardar_texto (double dato) {
try { if ( R == true ) { escribir.writeBytes(Str(dato) + "\n"); } }catch(Exception e) {}
}//void
public void guardar_texto (char dato) {
try { if ( R == true ) { escribir.writeBytes(dato + " \n"); } }catch(Exception e) {}
}//void
public void guardar_texto (byte dato) {
try { if ( R == true ) { escribir.writeBytes(dato + " \n"); } }catch(Exception e) {}
}//void
public void guardar_texto (String dato) {
try { if ( R == true ) { escribir.writeBytes(dato + "\n"); } }catch(Exception e) {}
}//void
protected void guardar_solo_dato (String dato) {
try { if ( R == true ) { escribir.writeBytes(dato); } }catch(Exception e) {}
}//void
public void Editor_Texto (String title) {
final Frame ventana = new Frame (title);
new Thread() {
public void run() {
texto = ""; salida=false;
MenuBar mb = new MenuBar ();
Menu menu = new Menu("Archivo"); MenuItem iNuevo = new MenuItem("Nuevo");
MenuItem iAbrir = new MenuItem("Abrir"); MenuItem iGuardar = new MenuItem("Guardar");
MenuItem iSalir = new MenuItem("Salir");
mb.add(menu);
menu.add(iNuevo ); menu.add(iAbrir ); menu.add(iGuardar ); menu.add(iSalir );
final TextArea area = new TextArea();
ventana.setSize(640, 480); ventana.setLayout(new BorderLayout());
ventana.add(area, BorderLayout.CENTER);
ventana.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent ev) { ventana.setVisible(false); }
});
iSalir.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){
texto = area.getText(); salida=true; ventana.setVisible(false);
}
} );
iNuevo.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){ area.setText(""); }
} );
iAbrir.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){
try {
FileDialog fd = new FileDialog(ventana, "Open", FileDialog.LOAD);

fd.setVisible(true);
FileInputStream file1 = new FileInputStream (fd.getDirectory() + fd.getFile());
BufferedReader data1 = new BufferedReader(new InputStreamReader(file1));
area.setText("");
String cadena = "";
do {
cadena = data1.readLine();
area.append(cadena + "\n");
}while(cadena != null);
data1.close(); file1.close();
}catch(Exception exc){}
}
} );
iGuardar.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){
try {
FileDialog fd = new FileDialog(ventana, "Save", FileDialog.SAVE);
fd.setVisible(true);
FileOutputStream file1 = new FileOutputStream (fd.getDirectory() + fd.getFile());
DataOutputStream data1 = new DataOutputStream (file1);
data1.writeBytes(area.getText());
data1.close(); file1.close();
}catch(Exception exc){}
}
} );
ventana.setMenuBar(mb);
ventana.setVisible(true);
}}.start();
}//void
public String getTexto() {
do {
try {
Thread.sleep(500);
}catch(Exception exc){}
}while(salida == false);
return texto;
}
public void Capturar_Datos (String campos[], String title) {
final Dialog ventana = new Dialog (new Frame(), title);
Button boton = new Button ("Aceptar");
Label etiqueta = new Label(title);
int num = campos.length ;
Label etiquetas [] = new Label[num];
final TextField cuadros_texto [] = new TextField [num];
int X = 50; int Y = 10;
ventana.setSize(640, ((num*25)+115) );
ventana.setLayout(null);
ventana.setModal(true);
ventana.add(etiqueta); etiqueta.setBounds(X, Y, 400, 25); Y = Y + 25 ;
for(int i = 0; i < num ; i++ ){
etiquetas[i] = new Label(campos[i]);
cuadros_texto [i] = new TextField();
ventana.add(etiquetas[i]);
ventana.add(cuadros_texto [i]);
etiquetas[i].setBounds(X,Y, 250, 25); X = X + 250 ;
cuadros_texto[i].setBounds(X,Y, 250, 25); X = 50 ; Y = Y + 25 ;
}//for
X = X + 250 ; Y = Y + 25 ;
ventana.add(boton); boton.setBounds(X, Y , 80, 40);
X = 50 ;
arreglo = new String [num];
ventana.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent ev) { ventana.setVisible(false); }
});
boton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){
for(int i = 0; i < arreglo.length ; i++ ){
arreglo[i] = cuadros_texto[i].getText();
}//for
ventana.setVisible(false);
}
} );
ventana.setVisible(true);
}//void
public int getInt (int index) { return Double.valueOf(arreglo[index]).intValue(); }
public byte getByte (int index) { return Double.valueOf(arreglo[index]).byteValue(); }
public double getDouble (int index) { return Double.valueOf(arreglo[index]).doubleValue(); }
public String getString (int index) { return arreglo[index]; }
public char getChar (int index) { return (arreglo[index]).charAt(0); }
public String[] getArreglo () { return arreglo; }
private String Str (int d) { return String.valueOf(d); }
private String Str (double d) { return String.valueOf(d); }
} //class
-------------------------------------- segunda parte sumas.java-------------------------
//----------------------------------------------------------
/// REUTILICE LA CLASE basicas_rangel.java
/// PARA COMPILAR Y EJECUTAR ESTE PROGRAMA : sumas.java
//----------------------------------------------------------
//---------------------------------------
//--- Programa
//--- UN EDITOR DE SUMAS - GUARDA DATOS A ARCHIVO EN FORMATO TIPO TEXTO
//---
import java.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class sumas {
public static void main(String args[]) {
basicas_rangel s1 = new basicas_rangel ();
String campos[] = {"X: " , "Y: "};
s1.Crear ("sumas.txt");
for(int k=0;k<3;k++) {
s1.Capturar_Datos (campos, "Editor de Sumas");
s1.guardar_texto ( "Suma : " + s1.getString(0) + "+" + s1.getString(1) +
" = " + (s1.getDouble(0)+s1.getDouble(1)) );
}//for
s1.Cerrar();
s1.Abrir("sumas.txt");
for(int k=0;k<3;k++) {
System.out.println("->Leido: " + s1.Leer_Texto() );
}//for
s1.Cerrar();
}//main
}//void


Att: Alberto Quiroz Albarran

Bueno en respuesta a la participación del compañero Enrique Goicochea pineda, su información es concreta y concuerdo con usted en la mayoria de los puntos que menciona a excepción del siguiente:

Desventajas:
•Los archivos binarios no permiten guardar clases de manera muy sencilla

creo yo, que usted esta equivocado de acuerdo a la información que encontré, dice: "Los archivos binarios nos permiten guardar clases de manera muy sencilla, muy rápida y muy eficiente por lo que son extremadamente útiles al programar".
y bajo ese argumento le reitero que esta equivocado en ese punto, en todo lo de mas estoy de acuerdo con usted.

si alguien opina diferente o tiene argumentos para decir que estoy equivocado favor de responder a este mensaje.
sin mas que decir me despido.

Att: Alberto Quiroz Albarran

1) Investigar la diferencia existente entre los diferentes tipos de archivos, así como las ventajas y desventajas. Debe elaborar un resumen o tabla comparativa para compartir en este foro.


TIPO DE ARCHIVO

CARACTERÍSTICAS

VENTAJAS

DESVENTAJAS
ARCHIVOS BINARIO
1.- Contiene información en lenguaje maquina o encriptado.
2.- No podemos darnos cuenta fácilmente del contenido de la información.
3.- Es especialmente para crear registros.
4.- Su longitud se divide en tamaños iguales de registro.
5.- Se accede igual que a un archivo de texto.
6.- puede contener información de cualquier tipo.
7.- Solo tienen sentido para los programas que lo ejecutan.
1.- Permite trabajar con registros sin necesidad de un motor de bases de datos.
2.- A medida que se agregan registros, aumenta el espacio.
3.- Ocupan menos espacio.
4.- Fácil de entender donde empiezan y donde terminan los datos.
5.- Tiene la facilidad de manipular cualquier tipo de dato.
6.- Es simple para escribir y guardar datos.
7.- Permiten guardar clases de manera sencilla.
8.- Permite utilizar más fácilmente el paradigma orientado a objetos.
9.- Evita la perdida de información y calidad.
1.- Debe conocer con precisión como se describen los datos en el archivo.
2.- No se puede observar la información del archivo con facilidad.
ARCHIVOS DE TEXTO
1.- Su formato básico es la extensión .TXT
2.- Pueden contener texto mezclado con ACSSI.
3.- Solo contiene texto sin formato.
4.- Se puede guardar en formato separado por comas o tabulaciones.
1.- Admite el uso de “fonts”, son gráficos.
2.- Permite visualizar el contenido del archivo claramente.
3.- Su contenido puede ser codificado fácilmente.
4.- Puede ser importado a programas de bases de datos.
1.- Carecen de información destinada a generar formatos.
2.- Carece de información de tipos de letra.
3.- Su contenido puede ser fácilmente plagiado.
ARCHIVO DE ACCESO SECUENCIAL
1.- Puede haber archivo secuenciales de tipo binario y de texto.
2.- Es necesario para crear una estructura en los archivos.
3.- Pueden ser de tipo acceso directo.
4.- Todos los registros tienen el mismo tamaño.
5.- Constan del mismo número de campos.
6.- Es posible leer un registro sin leer los anteriores.
1.- Permite guardar tipos definidos por el usuario.
2.- Provee mecanismos para realizar su recorrido.
3.- Es la forma básica de organizar un registro.
4.- Los registros quedan grabados consecutivamente conforme se utilizan.
5.- Proveen la mejor utilización del espacio.
6.- Su uso es de manera más rápida.
7.- Son muy sencillos de usar y aplicar.
1.- El acceso a un registro es pobre.
2.- La localización de un registro no se puede realizar individualmente.
3.- El acceso aleatorio es poco práctico.
4.- La dirección de registro está implícita.
5.- son vulnerables a fallas del sistema.



2) Haciendo uso del lenguaje de programación Java, debe implementar las diferentes operaciones que se pueden realizar para manipular información de un archivo, tales como: Abrir, leer datos, guardar, cerrar, entre otras operaciones. Escriba código fuente, mostrando un ejemplo cualquiera (como: sistema de agenda de datos, factura de ventas, o simplemente, leer y escribir variables enteras, reales y cadena), y dicho código fuente deberá compartirlo en este foro.


AQUI PRESENTO UN CODIGO PROPORCIONADO POR EL PROFESOR EDGAR LUGO RANGEL, LA PRIMERA PARTE REPRESENTA LA CLASE "basicas_rangel.class" NECESARIA PARA CORRERLO, LA SEGUNDA PARTE REPRESENTA LA CLASE "agenda.class" DE UNA AGENDA. ESTAS CLASES FUERON PROBADAS POR SU SERVIDOR Y RESULTARON UTILIZABLES. ESTA CODIFICACION BASICAMENTE PERMITE INGRESAR DATOS EN UNA AGENDA, TALES DATOS SON, NOMBRE, APELLIDO, DIRECCION, TELEFONO, GENERO, ETC.


PRIMERA PARTE

_______________________________________________________________________________________________________
_______________________________________________________________________________________________________
//------------------------------------------------------------------------------------------------------------------------------------
//-------------- Derechos Reservados (c) 2012. Edgar - Rangel - Lugo. Mexico
//-------------- Free Source : Codigo libre por M.C. Edgar - Rangel - Lugo.
//-------------- Puedes utilizarlo, modificarlo y adaptarlo de manera libre,
//-------------- solo debes dar el credito al autor. No tiene nada que ver
//-------------- con OpenSource, Freeware, SourceForge, GLP (GPL), EULA, ni
//-------------- algun otro. Este codigo es desarrollado con fines academicos
//-------------- y tiene los - Derechos Reservados (c) 2012. Edgar - Rangel - Lugo. Mexico.
//-------------- Este codigo no debe estar disponible en algun sitio web, si deseas hacerlo
//-------------- debes notificarlo al autor, para que te haga llegar por escrito un permiso.
//-------------- Puedes comunicarte a: erangel_lugo@hotmail . com
//--------------
//------------- Compañero docente, si utilizas este codigo, por favor, da credito al autor
//------------- y no impartas tus clases argumentando que fue extraido de libros o "bajado" de Internet .
//--------------
//------------- PROGRAMAS INDISPENSABLES PARA OPERACIONES BASICAS , VISTO EN UNIDAD
//------------- PROGRAMANDO OPERACIONES BASICAS SOBRE ARCHIVOS DE TEXTO Y BINARIOS
//------------- Atte: M.C. Edgar - Rangel - Lugo.
//-------------
//------------- Este archivo debe llevar el nombre: basicas_rangel.java (en minusculas)
//-------------
//------------------------------------------------------------------------------------------------------------------------------------
import java.io.*;
import java.awt.*;
import java.awt.event.*;
class basicas_rangel {
private FileInputStream abrir;
private FileOutputStream guardar;
private DataOutputStream escribir;
private BufferedReader Leer;
private DataInputStream leer;
private boolean R ;
private String arreglo[];
private String texto;
private boolean salida;
public basicas_rangel () { R = false; salida=true; }//constr
public void Abrir (String archivo) {
R = false;
try {
abrir = new FileInputStream (archivo);
Leer = new BufferedReader( new InputStreamReader(abrir) );
leer = new DataInputStream ( abrir ); R = true;
}catch(Exception exc) { R = false; }
}//void
public void Crear (String archivo) {
R = false;
try {
guardar = new FileOutputStream (archivo); escribir = new DataOutputStream (guardar);
R = true;
}catch(Exception exc) { R = false; }
}//void


public void Cerrar () {
if ( R == true ) {
try { escribir.close(); guardar.close(); } catch(Exception exc) { }
try { leer.close(); abrir.close(); } catch(Exception exc) { }
}//if
}//void
public int leer_entero () {
int N = 0;
try { if ( R == true ) { N = leer.readInt(); } }catch(Exception e) {}
return N;
}//void
public double leer_real () {
double N = 0;
try { if ( R == true ) { N = leer.readDouble(); } }catch(Exception e) {}
return N;
}//void
public char leer_caracter () {
char N = 0; try { if ( R == true ) { N = leer.readChar(); } }catch(Exception e) {}
return N;
}//void
public byte leer_byte () {
byte N = 0; try { if ( R == true ) { N = leer.readByte(); } }catch(Exception e) {}
return N;
}//void
public String leer_texto () {
String S = "";
try { if ( R == true ) { S = leer.readUTF (); } }catch(Exception e) {}
return S;
}//void
public String Leer_Texto () {
String S = "";
try { if ( R == true ) { S = Leer.readLine(); } }catch(Exception e) {}
return S;
}//void
public String Leer_Archivo () {
String S2 = "";
try {
if ( R == true ) {
String cadena = "";
do { cadena = Leer.readLine(); S2 = S2 + cadena + "\n"; }while(cadena != null);
}
}catch(Exception e) {}
return S2;
}//void
public void guardar_binario (int dato) {
try { if ( R == true ) { escribir.writeInt(dato); } }catch(Exception e) {}
}//void
public void guardar_binario (double dato) {
try { if ( R == true ) { escribir.writeDouble(dato); } }catch(Exception e) {}
}//void
public void guardar_binario (char dato) {
try { if ( R == true ) { escribir.writeChar(dato); } }catch(Exception e) {}
}//void


public void guardar_binario (byte dato) {
try { if ( R == true ) { escribir.writeByte(dato); } }catch(Exception e) {}
}//void
public void guardar_binario (String dato) {
try { if ( R == true ) { escribir.writeUTF (dato); } }catch(Exception e) {}
}//void
public void guardar_texto (int dato) {
try { if ( R == true ) { escribir.writeBytes(Str(dato) + "\n"); } }catch(Exception e) {}
}//void
public void guardar_texto (double dato) {
try { if ( R == true ) { escribir.writeBytes(Str(dato) + "\n"); } }catch(Exception e) {}
}//void
public void guardar_texto (char dato) {
try { if ( R == true ) { escribir.writeBytes(dato + " \n"); } }catch(Exception e) {}
}//void
public void guardar_texto (byte dato) {
try { if ( R == true ) { escribir.writeBytes(dato + " \n"); } }catch(Exception e) {}
}//void
public void guardar_texto (String dato) {
try { if ( R == true ) { escribir.writeBytes(dato + "\n"); } }catch(Exception e) {}
}//void
protected void guardar_solo_dato (String dato) {
try { if ( R == true ) { escribir.writeBytes(dato); } }catch(Exception e) {}
}//void
public void Editor_Texto (String title) {
final Frame ventana = new Frame (title);
new Thread() {
public void run() {
texto = ""; salida=false;
MenuBar mb = new MenuBar ();
Menu menu = new Menu("Archivo"); MenuItem iNuevo = new MenuItem("Nuevo");
MenuItem iAbrir = new MenuItem("Abrir"); MenuItem iGuardar = new MenuItem("Guardar");
MenuItem iSalir = new MenuItem("Salir");
mb.add(menu);
menu.add(iNuevo ); menu.add(iAbrir ); menu.add(iGuardar ); menu.add(iSalir );
final TextArea area = new TextArea();
ventana.setSize(640, 480); ventana.setLayout(new BorderLayout());
ventana.add(area, BorderLayout.CENTER);
ventana.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent ev) { ventana.setVisible(false); }
});
iSalir.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){
texto = area.getText(); salida=true; ventana.setVisible(false);
}
} );
iNuevo.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){ area.setText(""); }
} );
iAbrir.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){
try {
FileDialog fd = new FileDialog(ventana, "Open", FileDialog.LOAD);


fd.setVisible(true);
FileInputStream file1 = new FileInputStream (fd.getDirectory() + fd.getFile());
BufferedReader data1 = new BufferedReader(new InputStreamReader(file1));
area.setText("");
String cadena = "";
do {
cadena = data1.readLine();
area.append(cadena + "\n");
}while(cadena != null);
data1.close(); file1.close();
}catch(Exception exc){}
}
} );
iGuardar.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){
try {
FileDialog fd = new FileDialog(ventana, "Save", FileDialog.SAVE);
fd.setVisible(true);
FileOutputStream file1 = new FileOutputStream (fd.getDirectory() + fd.getFile());
DataOutputStream data1 = new DataOutputStream (file1);
data1.writeBytes(area.getText());
data1.close(); file1.close();
}catch(Exception exc){}
}
} );
ventana.setMenuBar(mb);
ventana.setVisible(true);
}}.start();
}//void
public String getTexto() {
do {
try {
Thread.sleep(500);
}catch(Exception exc){}
}while(salida == false);
return texto;
}
public void Capturar_Datos (String campos[], String title) {
final Dialog ventana = new Dialog (new Frame(), title);
Button boton = new Button ("Aceptar");
Label etiqueta = new Label(title);
int num = campos.length ;
Label etiquetas [] = new Label[num];
final TextField cuadros_texto [] = new TextField [num];
int X = 50; int Y = 10;
ventana.setSize(640, ((num*25)+115) );
ventana.setLayout(null);
ventana.setModal(true);
ventana.add(etiqueta); etiqueta.setBounds(X, Y, 400, 25); Y = Y + 25 ;
for(int i = 0; i < num ; i++ ){
etiquetas[i] = new Label(campos[i]);
cuadros_texto [i] = new TextField();
ventana.add(etiquetas[i]);


ventana.add(cuadros_texto [i]);
etiquetas[i].setBounds(X,Y, 250, 25); X = X + 250 ;
cuadros_texto[i].setBounds(X,Y, 250, 25); X = 50 ; Y = Y + 25 ;
}//for
X = X + 250 ; Y = Y + 25 ;
ventana.add(boton); boton.setBounds(X, Y , 80, 40);
X = 50 ;
arreglo = new String [num];
ventana.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent ev) { ventana.setVisible(false); }
});
boton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){
for(int i = 0; i < arreglo.length ; i++ ){
arreglo[i] = cuadros_texto[i].getText();
}//for
ventana.setVisible(false);
}
} );
ventana.setVisible(true);
}//void
public int getInt (int index) { return Double.valueOf(arreglo[index]).intValue(); }
public byte getByte (int index) { return Double.valueOf(arreglo[index]).byteValue(); }
public double getDouble (int index) { return Double.valueOf(arreglo[index]).doubleValue(); }
public String getString (int index) { return arreglo[index]; }
public char getChar (int index) { return (arreglo[index]).charAt(0); }
public String[] getArreglo () { return arreglo; }
private String Str (int d) { return String.valueOf(d); }
private String Str (double d) { return String.valueOf(d); }
} //class

SEGUNDA PARTE

_______________________________________________________________________________________________________
_______________________________________________________________________________________________________

//------------------------------------------------------------------------
//------------ EJEMPLOS DE: M.C. EDGAR - RANGEL - LUGO . ------------------
//------------------------------------------------------------------------
//........................................................................
//----------------------------------------------------------
//----------------------------------------------------------
//----------- ESTOS VIENEN DE APOYO , DESDE LA UNIDAD 1 ---
//----------------------------------------------------------
//----------------------------------------------------------
//----------------------------------------------------------
/// REUTILICE LA CLASE basicas_rangel.java
/// PARA COMPILAR Y EJECUTAR ESTE PROGRAMA : agenda.java
//----------------------------------------------------------
//----- Programa
//----- Para la GUARDAR DATOS DE UNA agenda empresarial ------
//----- Permite guardar datos en formatos tipo binario y tipo texto ------
//-----
import java.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class agenda {
public static void main(String args[]) {
basicas_rangel s1 = new basicas_rangel ();
String campos[] = {"Nombre del Cliente: ", "Domicilio : ",
"Telefono: ","Pais : ", "Edad: ", "Saldo: ", "Sexo:"};
//--- Guardando datos (Binarios) ---------
s1.Crear ("agenda_binario.dat");
for(int k=0;k<2;k++) {
s1.Capturar_Datos (campos, "Agenda Empresarial");
s1.guardar_binario ( s1.getInt(4) );
s1.guardar_binario ( s1.getDouble(5) );
s1.guardar_binario ( s1.getChar(6) );
s1.guardar_binario ( s1.getString(0) );
s1.guardar_binario ( s1.getString(1) );
s1.guardar_binario ( s1.getString(2) );
s1.guardar_binario ( s1.getString(3) );
}//for
s1.Cerrar();
s1.Abrir ("agenda_binario.dat"); //LEYENDO
System.out.println (" " + campos[4] + " " + s1.leer_entero () );
System.out.println (" " + campos[5] + " " + s1.leer_real () );
System.out.println (" " + campos[6] + " " + s1.leer_caracter () );
System.out.println (" " + campos[0] + " " + s1.leer_texto () );
System.out.println (" " + campos[1] + " " + s1.leer_texto () );
System.out.println (" " + campos[2] + " " + s1.leer_texto () );
System.out.println (" " + campos[3] + " " + s1.leer_texto () );
s1.Cerrar();
//--- Guardando datos (Texto) ---------
s1.Crear ("agenda_texto.txt");

for(int k=0;k<2;k++) {
s1.Capturar_Datos (campos, "Agenda Empresarial");
s1.guardar_texto ( s1.getString(0) );
s1.guardar_texto ( s1.getString(1) );
s1.guardar_texto ( s1.getString(2) );
s1.guardar_texto ( s1.getString(3) );
s1.guardar_texto ( s1.getInt(4) );
s1.guardar_texto ( s1.getDouble(5) );
s1.guardar_texto ( s1.getChar (6) );
}//for
s1.Cerrar();
s1.Abrir ("agenda_texto.txt"); //LEYENDO
System.out.println (" " + campos[0] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[1] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[2] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[3] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[4] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[5] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[6] + " " + s1.Leer_Texto () );
s1.Cerrar();
//--------------------------------------------
}//main
}//void

Bueno mi replica esta dirigida a mi compañero Alberto Quiroz Albarran, bueno a su punto de vista sobre los archivos de texto creo que es una buena respuesta ya que esta entendible tanto características, desventajas y ventajas, en los archivos binarios las desventajas y ventajas son claras pero considero que su segunda caracteristica que da no es clara espero y sea amable de explicarmela en claces, pero sin duda es un buen trabajo espero y siga asi este chavo.

ATT: Enrique Goicochea Pineda

TABLA COMPARATIVA DE LOS DIFERENCIAS ENTRE LOS TIPOS DE ARCHIVOS

TIPO DE ARCHIVO	DIFERENCIA	VENTAJAS	DESVENTAJAS
Binarios	----Contiene información en lenguaje máquina o encriptado. --Si lo abrimos con un procesador de texto no podremos apreciar ni darnos cuenta de que trata la información. ---Especial para trabajar con registros. ---Información de cualquier tipo. ----Se entra igual que a un archivo de texto.	--Posibilidad de trabajar con registros sin necesidad de un motor de base de datos. --Evita perdida de información y calidad. --Puede tener diferentes formatos y/o extensiones son: .txt, .bat, .cpp, .pas. .frm, .java, .cs, .php, .asp, .do, .js, .css, .py, .rb, .ex, .rtf, htm, html, csv, xml. --Cuando aumentas registros aumenta el espacio. --Guarda clases de manera sencilla. --Manipula cualquier tipo de dato. ---Menos espacio.	--Programar más. --La información del archivo no se observa con facilidad. --Conocimiento de cómo se describen los datos.
De Texto	---Contiene caracteres válidos de ASCII. ----Los lenguajes de programación los graban de manera secuencial y provee mecanismos para realizar su recorrido. ----Extensión .txt. ----Se relacionar otras extensiones con este tipo de archivo, como .doc (Word) o .sam (Ami pro). ---Contiene texto sin formato. ---Se puede guardar en formato separado.	--Puede tener diferentes formatos y/o extensiones son: doc, xls, .dbs, ppt, jpeg, bmp, .jpg, .png, .gif, .exe, .dll, .com, .wav, .mp3, .au, .mpg, .avi, .pdf, .asf, .mid. --Visualiza el contenido del archivo claramente. ---Importación a programas de base de datos. --Codificación fácil. --Uso de gráficos (fonts).	-- La información puede ser plagiada. --Muy poca información de tipo letra. --No tienes información para generar formatos.
Acceso Secuencial	--Tipo especial en algunos lenguajes de programación. -- Es posible leer un archivo sin leer los anteriores. --Permite guardar tipos definidos por el usuario (estructuras y/o registros). --Mismo número de campos. ---Organización: directa, secuencial, secuencial indexado. --Registros del mismo tamaño	--También se puede tener archivos secuenciales de tipo texto. --Guarda tipos definidos por el sistema. --Sencillos de usar y aplicar. --Uso más rápido. --El grabado de los archivos se haces conforme se utilizan. --Organiza registros --Mecanismos para realizar su recorrido.	--Es pobre el acceso al registro --Vulnerable a las fallas del sistema. --No se puede buscar un archivo individual.

//------------------------------------------------------------------------------------------------------------------------------------
//-------------- Derechos Reservados (c) 2012. Edgar - Rangel - Lugo. Mexico
//-------------- Free Source : Codigo libre por M.C. Edgar - Rangel - Lugo.
//-------------- Puedes utilizarlo, modificarlo y adaptarlo de manera libre,
//-------------- solo debes dar el credito al autor. No tiene nada que ver
//-------------- con OpenSource, Freeware, SourceForge, GLP (GPL), EULA, ni
//-------------- algun otro. Este codigo es desarrollado con fines academicos
//-------------- y tiene los - Derechos Reservados (c) 2012. Edgar - Rangel - Lugo. Mexico.
//-------------- Este codigo no debe estar disponible en algun sitio web, si deseas hacerlo
//-------------- debes notificarlo al autor, para que te haga llegar por escrito un permiso.
//-------------- Puedes comunicarte a: erangel_lugo@hotmail . com
//--------------
//------------- Compañero docente, si utilizas este codigo, por favor, da credito al autor
//------------- y no impartas tus clases argumentando que fue extraido de libros o "bajado" de Internet .
//--------------
//------------- PROGRAMAS INDISPENSABLES PARA OPERACIONES BASICAS , VISTO EN UNIDAD
//------------- PROGRAMANDO OPERACIONES BASICAS SOBRE ARCHIVOS DE TEXTO Y BINARIOS
//------------- Atte: M.C. Edgar - Rangel - Lugo.
//-------------
//------------- Este archivo debe llevar el nombre: basicas_rangel.java (en minusculas)
//-------------
//------------------------------------------------------------------------------------------------------------------------------------
import java.io.*;
import java.awt.*;
import java.awt.event.*;
class basicas_rangel {
private FileInputStream abrir;
private FileOutputStream guardar;
private DataOutputStream escribir;
private BufferedReader Leer;
private DataInputStream leer;
private boolean R ;
private String arreglo[];
private String texto;
private boolean salida;
public basicas_rangel () { R = false; salida=true; }//constr
public void Abrir (String archivo) {
R = false;
try {
abrir = new FileInputStream (archivo);
Leer = new BufferedReader( new InputStreamReader(abrir) );
leer = new DataInputStream ( abrir ); R = true;
}catch(Exception exc) { R = false; }
}//void
public void Crear (String archivo) {
R = false;
try {
guardar = new FileOutputStream (archivo); escribir = new DataOutputStream (guardar);
R = true;
}catch(Exception exc) { R = false; }
}//void


public void Cerrar () {
if ( R == true ) {
try { escribir.close(); guardar.close(); } catch(Exception exc) { }
try { leer.close(); abrir.close(); } catch(Exception exc) { }
}//if
}//void
public int leer_entero () {
int N = 0;
try { if ( R == true ) { N = leer.readInt(); } }catch(Exception e) {}
return N;
}//void
public double leer_real () {
double N = 0;
try { if ( R == true ) { N = leer.readDouble(); } }catch(Exception e) {}
return N;
}//void
public char leer_caracter () {
char N = 0; try { if ( R == true ) { N = leer.readChar(); } }catch(Exception e) {}
return N;
}//void
public byte leer_byte () {
byte N = 0; try { if ( R == true ) { N = leer.readByte(); } }catch(Exception e) {}
return N;
}//void
public String leer_texto () {
String S = "";
try { if ( R == true ) { S = leer.readUTF (); } }catch(Exception e) {}
return S;
}//void
public String Leer_Texto () {
String S = "";
try { if ( R == true ) { S = Leer.readLine(); } }catch(Exception e) {}
return S;
}//void
public String Leer_Archivo () {
String S2 = "";
try {
if ( R == true ) {
String cadena = "";
do { cadena = Leer.readLine(); S2 = S2 + cadena + "\n"; }while(cadena != null);
}
}catch(Exception e) {}
return S2;
}//void
public void guardar_binario (int dato) {
try { if ( R == true ) { escribir.writeInt(dato); } }catch(Exception e) {}
}//void
public void guardar_binario (double dato) {
try { if ( R == true ) { escribir.writeDouble(dato); } }catch(Exception e) {}
}//void
public void guardar_binario (char dato) {
try { if ( R == true ) { escribir.writeChar(dato); } }catch(Exception e) {}
}//void


public void guardar_binario (byte dato) {
try { if ( R == true ) { escribir.writeByte(dato); } }catch(Exception e) {}
}//void
public void guardar_binario (String dato) {
try { if ( R == true ) { escribir.writeUTF (dato); } }catch(Exception e) {}
}//void
public void guardar_texto (int dato) {
try { if ( R == true ) { escribir.writeBytes(Str(dato) + "\n"); } }catch(Exception e) {}
}//void
public void guardar_texto (double dato) {
try { if ( R == true ) { escribir.writeBytes(Str(dato) + "\n"); } }catch(Exception e) {}
}//void
public void guardar_texto (char dato) {
try { if ( R == true ) { escribir.writeBytes(dato + " \n"); } }catch(Exception e) {}
}//void
public void guardar_texto (byte dato) {
try { if ( R == true ) { escribir.writeBytes(dato + " \n"); } }catch(Exception e) {}
}//void
public void guardar_texto (String dato) {
try { if ( R == true ) { escribir.writeBytes(dato + "\n"); } }catch(Exception e) {}
}//void
protected void guardar_solo_dato (String dato) {
try { if ( R == true ) { escribir.writeBytes(dato); } }catch(Exception e) {}
}//void
public void Editor_Texto (String title) {
final Frame ventana = new Frame (title);
new Thread() {
public void run() {
texto = ""; salida=false;
MenuBar mb = new MenuBar ();
Menu menu = new Menu("Archivo"); MenuItem iNuevo = new MenuItem("Nuevo");
MenuItem iAbrir = new MenuItem("Abrir"); MenuItem iGuardar = new MenuItem("Guardar");
MenuItem iSalir = new MenuItem("Salir");
mb.add(menu);
menu.add(iNuevo ); menu.add(iAbrir ); menu.add(iGuardar ); menu.add(iSalir );
final TextArea area = new TextArea();
ventana.setSize(640, 480); ventana.setLayout(new BorderLayout());
ventana.add(area, BorderLayout.CENTER);
ventana.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent ev) { ventana.setVisible(false); }
});
iSalir.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){
texto = area.getText(); salida=true; ventana.setVisible(false);
}
} );
iNuevo.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){ area.setText(""); }
} );
iAbrir.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){
try {
FileDialog fd = new FileDialog(ventana, "Open", FileDialog.LOAD);


fd.setVisible(true);
FileInputStream file1 = new FileInputStream (fd.getDirectory() + fd.getFile());
BufferedReader data1 = new BufferedReader(new InputStreamReader(file1));
area.setText("");
String cadena = "";
do {
cadena = data1.readLine();
area.append(cadena + "\n");
}while(cadena != null);
data1.close(); file1.close();
}catch(Exception exc){}
}
} );
iGuardar.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){
try {
FileDialog fd = new FileDialog(ventana, "Save", FileDialog.SAVE);
fd.setVisible(true);
FileOutputStream file1 = new FileOutputStream (fd.getDirectory() + fd.getFile());
DataOutputStream data1 = new DataOutputStream (file1);
data1.writeBytes(area.getText());
data1.close(); file1.close();
}catch(Exception exc){}
}
} );
ventana.setMenuBar(mb);
ventana.setVisible(true);
}}.start();
}//void
public String getTexto() {
do {
try {
Thread.sleep(500);
}catch(Exception exc){}
}while(salida == false);
return texto;
}
public void Capturar_Datos (String campos[], String title) {
final Dialog ventana = new Dialog (new Frame(), title);
Button boton = new Button ("Aceptar");
Label etiqueta = new Label(title);
int num = campos.length ;
Label etiquetas [] = new Label[num];
final TextField cuadros_texto [] = new TextField [num];
int X = 50; int Y = 10;
ventana.setSize(640, ((num*25)+115) );
ventana.setLayout(null);
ventana.setModal(true);
ventana.add(etiqueta); etiqueta.setBounds(X, Y, 400, 25); Y = Y + 25 ;
for(int i = 0; i < num ; i++ ){
etiquetas[i] = new Label(campos[i]);
cuadros_texto [i] = new TextField();
ventana.add(etiquetas[i]);


ventana.add(cuadros_texto [i]);
etiquetas[i].setBounds(X,Y, 250, 25); X = X + 250 ;
cuadros_texto[i].setBounds(X,Y, 250, 25); X = 50 ; Y = Y + 25 ;
}//for
X = X + 250 ; Y = Y + 25 ;
ventana.add(boton); boton.setBounds(X, Y , 80, 40);
X = 50 ;
arreglo = new String [num];
ventana.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent ev) { ventana.setVisible(false); }
});
boton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){
for(int i = 0; i < arreglo.length ; i++ ){
arreglo[i] = cuadros_texto[i].getText();
}//for
ventana.setVisible(false);
}
} );
ventana.setVisible(true);
}//void
public int getInt (int index) { return Double.valueOf(arreglo[index]).intValue(); }
public byte getByte (int index) { return Double.valueOf(arreglo[index]).byteValue(); }
public double getDouble (int index) { return Double.valueOf(arreglo[index]).doubleValue(); }
public String getString (int index) { return arreglo[index]; }
public char getChar (int index) { return (arreglo[index]).charAt(0); }
public String[] getArreglo () { return arreglo; }
private String Str (int d) { return String.valueOf(d); }
private String Str (double d) { return String.valueOf(d); }
} //class


//----------------------------------------------------------
/// REUTILICE LA CLASE basicas_rangel.java
/// PARA COMPILAR Y EJECUTAR ESTE PROGRAMA : sumas.java
//----------------------------------------------------------
//---------------------------------------
//--- Programa
//--- UN EDITOR DE SUMAS - GUARDA DATOS A ARCHIVO EN FORMATO TIPO TEXTO
//---
import java.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class sumas {
public static void main(String args[]) {
basicas_rangel s1 = new basicas_rangel ();
String campos[] = {"X: " , "Y: "};
s1.Crear ("sumas.txt");
for(int k=0;k<3;k++) {
s1.Capturar_Datos (campos, "Editor de Sumas");
s1.guardar_texto ( "Suma : " + s1.getString(0) + "+" + s1.getString(1) +
" = " + (s1.getDouble(0)+s1.getDouble(1)) );
}//for
s1.Cerrar();
s1.Abrir("sumas.txt");
for(int k=0;k<3;k++) {
System.out.println("->Leido: " + s1.Leer_Texto() );
}//for
s1.Cerrar();
}//main
}//void


//----------------------------------------------------------
//----------------------------------------------------------
/// REUTILICE LA CLASE basicas_rangel.java
/// PARA COMPILAR Y EJECUTAR ESTE PROGRAMA : agenda.java
//----------------------------------------------------------
//----- Programa
//----- Para la GUARDAR DATOS DE UNA agenda empresarial ------
//----- Permite guardar datos en formatos tipo binario y tipo texto ------
//-----
import java.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class agenda {
public static void main(String args[]) {
basicas_rangel s1 = new basicas_rangel ();
String campos[] = {"Nombre del Cliente: ", "Domicilio : ",
"Telefono: ","Pais : ", "Edad: ", "Saldo: ", "Sexo:"};
//--- Guardando datos (Binarios) ---------
s1.Crear ("agenda_binario.dat");
for(int k=0;k<2;k++) {
s1.Capturar_Datos (campos, "Agenda Empresarial");
s1.guardar_binario ( s1.getInt(4) );
s1.guardar_binario ( s1.getDouble(5) );
s1.guardar_binario ( s1.getChar(6) );
s1.guardar_binario ( s1.getString(0) );
s1.guardar_binario ( s1.getString(1) );
s1.guardar_binario ( s1.getString(2) );
s1.guardar_binario ( s1.getString(3) );
}//for
s1.Cerrar();
s1.Abrir ("agenda_binario.dat"); //LEYENDO
System.out.println (" " + campos[4] + " " + s1.leer_entero () );
System.out.println (" " + campos[5] + " " + s1.leer_real () );
System.out.println (" " + campos[6] + " " + s1.leer_caracter () );
System.out.println (" " + campos[0] + " " + s1.leer_texto () );
System.out.println (" " + campos[1] + " " + s1.leer_texto () );
System.out.println (" " + campos[2] + " " + s1.leer_texto () );
System.out.println (" " + campos[3] + " " + s1.leer_texto () );
s1.Cerrar();
//--- Guardando datos (Texto) ---------
s1.Crear ("agenda_texto.txt");

for(int k=0;k<2;k++) {
s1.Capturar_Datos (campos, "Agenda Empresarial");
s1.guardar_texto ( s1.getString(0) );
s1.guardar_texto ( s1.getString(1) );
s1.guardar_texto ( s1.getString(2) );
s1.guardar_texto ( s1.getString(3) );
s1.guardar_texto ( s1.getInt(4) );
s1.guardar_texto ( s1.getDouble(5) );
s1.guardar_texto ( s1.getChar (6) );
}//for
s1.Cerrar();
s1.Abrir ("agenda_texto.txt"); //LEYENDO
System.out.println (" " + campos[0] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[1] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[2] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[3] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[4] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[5] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[6] + " " + s1.Leer_Texto () );
s1.Cerrar();
//--------------------------------------------
}//main
}//void

PUES YO DECIDÍ INGRESAR TRES CLASES, LA CLASE "basicas_rangel.class", "sumas.class" y "agenda.class".

ATTE: BOLIVAR PEREZ MENDOZA

REPLICA A UN COMPAÑERO: Abel Pioquinto Ubias

Estoy de acuerdo con la investigación de mi compañero que los tipos de archivos son: archivos binarios, archivos de texto, y archivos de acceso secuencial ya que con la investigación que yo hice corroboro que son correctos además estoy de acuerdo con la descripción que le coloco a cada uno de ellos en las características ventajas y desventajas ya que en la investigación que realice menciona todo lo que especifica mi compañero. Muy bien!!!

ATTE: BOLIVAR PEREZ MENDOZA

TIPO DE ARCHIVO
• ARCHIVO DE TEXTO

DIFERENCIAS
- Si nuestra aplicación requiere el almacenamiento de datos y no se trata de muchos registros , nos convendrá usar un archivo binario más que una base de datos

- Archivos de este tipo pueden crearse fácilmente o manipulados por los editores de texto.

- En un archivo de texto cada serie de 8 bits corresponde a un equivalente en el código ASCII que puede ser una letra, un número, un símbolo, etc. (También depende el tipo de codificación que se use para dicho archivo)

- Al abrirlos con un editor de texto común, se puede apreciar la información.

VENTAJAS

- Útiles, para traspasar información de un formato de base de
datos a otro, donde no existe un método directo para transferir datos entre
ambos formatos

- Constituye un estándar para el intercambio
de información

- El usuario introduce de manera efectiva gracias a su legibilidad, estilo y tamaño, dejando al usuario la toma de decisión del estilo.

DESVENTAJAS
- Carecen de información destinada a generar formatos (negritas, subrayado, cursivas, tamaño, etc.) y tipos de letra (por ejemplo, Arial, Times, Courier, etc.).

• ARCHIVO BINARIO
DIFERENCIAS
- El conjunto de bits tiene un arreglo y una longitud que puede variar de un archivo a otro, en inclusive de una longitud a otra.


- Brindarán a nuestras aplicaciones la posibilidad de trabajar con registros sin necesidad de un motor de base de datos

VENTAJAS

- Casi todas las aplicaciones pueden leer o escribir archivos de acceso secuencial


- Si nuestra aplicación requiere el almacenamiento de datos y no se trata de muchos registros , nos convendrá usar un archivo binario más que una base de datos

- Archivos de este tipo pueden crearse fácilmente o manipulados por los editores de texto.

DESVENTAJAS
- Incorporan valores en formato bits y/o bytes, es por ellos que al ser abiertos por un editor de textos común, no podemos interpretar gran parte de la información, ya que solo muestra bits y/o bytes.


- Archivos de este tipo no son ideales para almacenar grandes cantidades de datos porque todos los valores se almacenan como una cadena de caracteres.

- Incorporan valores en formato bits y/o bytes, es por ellos que al ser abiertos por un editor de textos común, no podemos interpretar gran parte de la información, ya que solo muestra bits y/o bytes.

• ARCHIVO SECUECIAL.

DIFERENCIAS

- Es de tipo binario.

- Pueden haber archivos de tipo texto.

- Se distinguen de los binarios debido a que estos eran casi siempre de acceso directo

VENTAJAS

- Es mucho más rápido a la hora de usarse.

- Guarda tipos de datos que se definen por el usuario.

DESVENTAJAS

- Muchas fallas en el sistema.

2) haciendo uso del lenguaje de programación java, debe implementar las diferentes operaciones que se pueden realizar para manipular información de un archivo, tales como: abrir, leer datos, guardar, cerrar, entre otras operaciones. Escriba código fuente, mostrando un ejemplo cualquiera (como: sistema de agenda de datos, factura de ventas, o simplemente, leer y escribir variables enteras, reales y cadena), y dicho código fuente deberá compartirlo en este foro.

Aquí se representa la clase "basicas_rangel.class" proporcionadas por el profesor Edgar Lugo Rangel.
“parte 1”
_______________________________________________________________________________________________________
_______________________________________________________________________________________________________
//------------------------------------------------------------------------------------------------------------------------------------
//-------------- derechos reservados (c) 2012. edgar - rangel - lugo. mexico
//-------------- free source : codigo libre por m.c. edgar - rangel - lugo.
//-------------- puedes utilizarlo, modificarlo y adaptarlo de manera libre,
//-------------- solo debes dar el credito al autor. no tiene nada que ver
//-------------- con opensource, freeware, sourceforge, glp (gpl), eula, ni
//-------------- algun otro. este codigo es desarrollado con fines academicos
//-------------- y tiene los - derechos reservados (c) 2012. edgar - rangel - lugo. mexico.
//-------------- este codigo no debe estar disponible en algun sitio web, si deseas hacerlo
//-------------- debes notificarlo al autor, para que te haga llegar por escrito un permiso.
//-------------- puedes comunicarte a: erangel_lugo@hotmail . com
//--------------
//------------- compañero docente, si utilizas este codigo, por favor, da credito al autor
//------------- y no impartas tus clases argumentando que fue extraido de libros o "bajado" de internet .
//--------------
//------------- programas indispensables para operaciones basicas , visto en unidad
//------------- programando operaciones basicas sobre archivos de texto y binarios
//------------- atte: m.c. edgar - rangel - lugo.
//-------------
//------------- este archivo debe llevar el nombre: basicas_rangel.java (en minusculas)
//-------------
//------------------------------------------------------------------------------------------------------------------------------------
import java.io.*;
import java.awt.*;
import java.awt.event.*;
class basicas_rangel {
private fileinputstream abrir;
private fileoutputstream guardar;
private dataoutputstream escribir;
private bufferedreader leer;
private datainputstream leer;
private boolean r ;
private string arreglo[];
private string texto;
private boolean salida;
public basicas_rangel () { r = false; salida=true; }//constr
public void abrir (string archivo) {
r = false;
try {
abrir = new fileinputstream (archivo);
leer = new bufferedreader( new inputstreamreader(abrir) );
leer = new datainputstream ( abrir ); r = true;
}catch(exception exc) { r = false; }
}//void
public void crear (string archivo) {
r = false;
try {
guardar = new fileoutputstream (archivo); escribir = new dataoutputstream (guardar);
r = true;
}catch(exception exc) { r = false; }
}//void


public void cerrar () {
if ( r == true ) {
try { escribir.close(); guardar.close(); } catch(exception exc) { }
try { leer.close(); abrir.close(); } catch(exception exc) { }
}//if
}//void
public int leer_entero () {
int n = 0;
try { if ( r == true ) { n = leer.readint(); } }catch(exception e) {}
return n;
}//void
public double leer_real () {
double n = 0;
try { if ( r == true ) { n = leer.readdouble(); } }catch(exception e) {}
return n;
}//void
public char leer_caracter () {
char n = 0; try { if ( r == true ) { n = leer.readchar(); } }catch(exception e) {}
return n;
}//void
public byte leer_byte () {
byte n = 0; try { if ( r == true ) { n = leer.readbyte(); } }catch(exception e) {}
return n;
}//void
public string leer_texto () {
string s = "";
try { if ( r == true ) { s = leer.readutf (); } }catch(exception e) {}
return s;
}//void
public string leer_texto () {
string s = "";
try { if ( r == true ) { s = leer.readline(); } }catch(exception e) {}
return s;
}//void
public string leer_archivo () {
string s2 = "";
try {
if ( r == true ) {
string cadena = "";
do { cadena = leer.readline(); s2 = s2 + cadena + "\n"; }while(cadena != null);
}
}catch(exception e) {}
return s2;
}//void
public void guardar_binario (int dato) {
try { if ( r == true ) { escribir.writeint(dato); } }catch(exception e) {}
}//void
public void guardar_binario (double dato) {
try { if ( r == true ) { escribir.writedouble(dato); } }catch(exception e) {}
}//void
public void guardar_binario (char dato) {
try { if ( r == true ) { escribir.writechar(dato); } }catch(exception e) {}
}//void


public void guardar_binario (byte dato) {
try { if ( r == true ) { escribir.writebyte(dato); } }catch(exception e) {}
}//void
public void guardar_binario (string dato) {
try { if ( r == true ) { escribir.writeutf (dato); } }catch(exception e) {}
}//void
public void guardar_texto (int dato) {
try { if ( r == true ) { escribir.writebytes(str(dato) + "\n"); } }catch(exception e) {}
}//void
public void guardar_texto (double dato) {
try { if ( r == true ) { escribir.writebytes(str(dato) + "\n"); } }catch(exception e) {}
}//void
public void guardar_texto (char dato) {
try { if ( r == true ) { escribir.writebytes(dato + " \n"); } }catch(exception e) {}
}//void
public void guardar_texto (byte dato) {
try { if ( r == true ) { escribir.writebytes(dato + " \n"); } }catch(exception e) {}
}//void
public void guardar_texto (string dato) {
try { if ( r == true ) { escribir.writebytes(dato + "\n"); } }catch(exception e) {}
}//void
protected void guardar_solo_dato (string dato) {
try { if ( r == true ) { escribir.writebytes(dato); } }catch(exception e) {}
}//void
public void editor_texto (string title) {
final frame ventana = new frame (title);
new thread() {
public void run() {
texto = ""; salida=false;
menubar mb = new menubar ();
menu menu = new menu("archivo"); menuitem inuevo = new menuitem("nuevo");
menuitem iabrir = new menuitem("abrir"); menuitem iguardar = new menuitem("guardar");
menuitem isalir = new menuitem("salir");
mb.add(menu);
menu.add(inuevo ); menu.add(iabrir ); menu.add(iguardar ); menu.add(isalir );
final textarea area = new textarea();
ventana.setsize(640, 480); ventana.setlayout(new borderlayout());
ventana.add(area, borderlayout.center);
ventana.addwindowlistener(new windowadapter(){
public void windowclosing(windowevent ev) { ventana.setvisible(false); }
});
isalir.addactionlistener(new actionlistener() {
public void actionperformed(actionevent ev){
texto = area.gettext(); salida=true; ventana.setvisible(false);
}
} );
inuevo.addactionlistener(new actionlistener() {
public void actionperformed(actionevent ev){ area.settext(""); }
} );
iabrir.addactionlistener(new actionlistener() {
public void actionperformed(actionevent ev){
try {
filedialog fd = new filedialog(ventana, "open", filedialog.load);


fd.setvisible(true);
fileinputstream file1 = new fileinputstream (fd.getdirectory() + fd.getfile());
bufferedreader data1 = new bufferedreader(new inputstreamreader(file1));
area.settext("");
string cadena = "";
do {
cadena = data1.readline();
area.append(cadena + "\n");
}while(cadena != null);
data1.close(); file1.close();
}catch(exception exc){}
}
} );
iguardar.addactionlistener(new actionlistener() {
public void actionperformed(actionevent ev){
try {
filedialog fd = new filedialog(ventana, "save", filedialog.save);
fd.setvisible(true);
fileoutputstream file1 = new fileoutputstream (fd.getdirectory() + fd.getfile());
dataoutputstream data1 = new dataoutputstream (file1);
data1.writebytes(area.gettext());
data1.close(); file1.close();
}catch(exception exc){}
}
} );
ventana.setmenubar(mb);
ventana.setvisible(true);
}}.start();
}//void
public string gettexto() {
do {
try {
thread.sleep(500);
}catch(exception exc){}
}while(salida == false);
return texto;
}
public void capturar_datos (string campos[], string title) {
final dialog ventana = new dialog (new frame(), title);
button boton = new button ("aceptar");
label etiqueta = new label(title);
int num = campos.length ;
label etiquetas [] = new label[num];
final textfield cuadros_texto [] = new textfield [num];
int x = 50; int y = 10;
ventana.setsize(640, ((num*25)+115) );
ventana.setlayout(null);
ventana.setmodal(true);
ventana.add(etiqueta); etiqueta.setbounds(x, y, 400, 25); y = y + 25 ;
for(int i = 0; i < num ; i++ ){
etiquetas[i] = new label(campos[i]);
cuadros_texto [i] = new textfield();
ventana.add(etiquetas[i]);


ventana.add(cuadros_texto [i]);
etiquetas[i].setbounds(x,y, 250, 25); x = x + 250 ;
cuadros_texto[i].setbounds(x,y, 250, 25); x = 50 ; y = y + 25 ;
}//for
x = x + 250 ; y = y + 25 ;
ventana.add(boton); boton.setbounds(x, y , 80, 40);
x = 50 ;
arreglo = new string [num];
ventana.addwindowlistener(new windowadapter(){
public void windowclosing(windowevent ev) { ventana.setvisible(false); }
});
boton.addactionlistener(new actionlistener() {
public void actionperformed(actionevent ev){
for(int i = 0; i < arreglo.length ; i++ ){
arreglo[i] = cuadros_texto[i].gettext();
}//for
ventana.setvisible(false);
}
} );
ventana.setvisible(true);
}//void
public int getint (int index) { return double.valueof(arreglo[index]).intvalue(); }
public byte getbyte (int index) { return double.valueof(arreglo[index]).bytevalue(); }
public double getdouble (int index) { return double.valueof(arreglo[index]).doublevalue(); }
public string getstring (int index) { return arreglo[index]; }
public char getchar (int index) { return (arreglo[index]).charat(0); }
public string[] getarreglo () { return arreglo; }
private string str (int d) { return string.valueof(d); }
private string str (double d) { return string.valueof(d); }
} //class
“Parte 2”
Aquí se representa la Clase "suma" guarda los datos a archivos en formato tipo.
/// reutilice la clase basicas_rangel.java
/// para compilar y ejecutar este programa : sumas.java
//----------------------------------------------------------
//---------------------------------------
//--- programa
//--- un editor de sumas - guarda datos a archivo en formato tipo texto
//---
import java.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class sumas {
public static void main(string args[]) {
basicas_rangel s1 = new basicas_rangel ();
string campos[] = {"x: " , "y: "};
s1.crear ("sumas.txt");
for(int k=0;k<3;k++) {
s1.capturar_datos (campos, "editor de sumas");
s1.guardar_texto ( "suma : " + s1.getstring(0) + "+" + s1.getstring(1) +
" = " + (s1.getdouble(0)+s1.getdouble(1)) );
}//for
s1.cerrar();
s1.abrir("sumas.txt");
for(int k=0;k<3;k++) {
system.out.println("->leido: " + s1.leer_texto() );
}//for
s1.cerrar();
}//main
}//void

saludos!

Mi replica es hacia mi compañero Enrique Goicoechea Pineda, yo creo que le hizo falta agregar un poco de ventajas y desventajas como las que mencionaré a continuación.
VENTAJAS
Los archivos secuenciales proveen la mejor utilización de espacio y son rápidos cuando los registros son accesados secuencialmente.

Los archivos con poca volatilidad, gran actividad y tamaño variable son altamente susceptibles de ser organizados secuencialmente.

La ventaja más importante de la técnica de organización secuencial de archivos es la capacidad de acceso al "siguiente" registro rápidamente: Mientras que el patrón de acceso a un archivo secuencial se conforme al ordenamiento de registros en el archivo, los tiempos de acceso serán muy buenos. Sin embargo, si el patrón de acceso al programa no se conforma al patrón de ordenamiento de los registros, entonces la eficiencia del programa puede ser terrible.

Otra ventaja de los archivos de organización secuencial es que son muy sencillos de usar y aplicar.

DESVENTAJAS:

El acceso a un registro es pobre, la localización de un determinado registro no se puede hacer individualmente no de manera rápida, y el acceso aleatorio es impráctico.

Además, en los archivos secuenciales la dirección de registro está implícita y están vulnerables a fallas del sistema.

Fuera de eso me parece que es muy buena información la que aporto mi compañero en su participación, si estoy equivocada en algo, sería bueno que me lo hicieran saber, gracias y Felicidades Enrique

1) investigar la diferencia existente entre los diferentes tipos de archivos, así como las ventajas y desventajas. Debe elaborar un resumen o tabla comparativa para compartir en este foro.

ARCHIVO BINARIOS

Características

* Información en lenguaje maquina o encriptado
* creado especialmente para almacenar registros
* Subdivide su longitud en espacios iguales del tamaño que ocupa un registro común, y a medida que agregamos registros, añade un espacio
*contiene información de cualquier tipo
* incorporan valores en formato de bits y/o bytes

Ventajas

* Información en lenguaje maquina o encriptado
*Contiene información de cualquier tipo codificada en binario
* trabaja con registros sin necesidad de un motor de bases de datos.
*ayuda a evitar el plagio de información

Desventajas

*Hay que conocer cómo los datos se escriben en el archivo para manipularlo con éxito.


ARCHIVO DE TEXTO

Características

*contiene caracteres válidos de la tabla ASCII
*se puede abrir con cualquier editor de texto y se vera de manera clara la información
* El contenido del archivo de texto plano

Ventajas

*visualización de información de manera clara
*se puede importar los datos fácilmente a BD u editores
Desventajas
*al ser fácil de visualizar, cualquiera puede ver su contenido y modificarlo, por lo que carece de confidencialidad

ARCHIVO DE ACCESO SECUENCIAL

Características

* En la mayoría de los casos es de tipo binario, también se puede tener archivos secuenciales de tipo texto
*Se distinguen de los binarios debido a que estos eran casi siempre de acceso directo

Ventajas

* permite guardar tipos definidos por el usuario
* proveen la mejor utilización de espacio y son rápidos cuando los registros son accesados secuencialmente
* Muy sencillos de usar y aplicar 

Desventajas

* La localización de un determinado registro no se puede hacer individualmente no de manera rápida, y el acceso aleatorio es impráctico.
* La dirección de registro está implícita y están vulnerables a fallas del sistema

2) Haciendo uso del lenguaje de programación Java, debe implementar las diferentes operaciones que se pueden realizar para manipular información de un archivo, tales como: Abrir, leer datos, guardar, cerrar, entre otras operaciones. Escriba código fuente, mostrando un ejemplo cualquiera (como: sistema de agenda de datos, factura de ventas, o simplemente, leer y escribir variables enteras, reales y cadena), y dicho código fuente deberá compartirlo en este foro.

Códigos proporcionados por el facilitador, los derechos quedan reservados a el M.C. Edgar - Rangel – Lugo
Se utiliza la clase basicas_rangel.class para que corra el programa

//---------------------------------------------------primera parte-----------------------------------------------------------------
//-------------- Derechos Reservados (c) 2012. Edgar - Rangel - Lugo. Mexico
//-------------- Free Source : Codigo libre por M.C. Edgar - Rangel - Lugo.
//-------------- Puedes utilizarlo, modificarlo y adaptarlo de manera libre,
//-------------- solo debes dar el credito al autor. No tiene nada que ver
//-------------- con OpenSource, Freeware, SourceForge, GLP (GPL), EULA, ni
//-------------- algun otro. Este codigo es desarrollado con fines academicos
//-------------- y tiene los - Derechos Reservados (c) 2012. Edgar - Rangel - Lugo. Mexico.
//-------------- Este codigo no debe estar disponible en algun sitio web, si deseas hacerlo
//-------------- debes notificarlo al autor, para que te haga llegar por escrito un permiso.
//-------------- Puedes comunicarte a: erangel_lugo@hotmail . com

//--------------
//------------- Compañero docente, si utilizas este codigo, por favor, da credito al autor
//------------- y no impartas tus clases argumentando que fue extraido de libros o "bajado" de Internet .
//--------------
//------------- PROGRAMAS INDISPENSABLES PARA OPERACIONES BASICAS , VISTO EN UNIDAD
//------------- PROGRAMANDO OPERACIONES BASICAS SOBRE ARCHIVOS DE TEXTO Y BINARIOS
//------------- Atte: M.C. Edgar - Rangel - Lugo.
//-------------
//------------- Este archivo debe llevar el nombre: basicas_rangel.java (en minusculas)
//-------------
//------------------------------------------------------------------------------------------------------------------------------------
import java.io.*;
import java.awt.*;
import java.awt.event.*;
class basicas_rangel {
private FileInputStream abrir;
private FileOutputStream guardar;
private DataOutputStream escribir;
private BufferedReader Leer;
private DataInputStream leer;
private boolean R ;
private String arreglo[];
private String texto;
private boolean salida;
public basicas_rangel () { R = false; salida=true; }//constr
public void Abrir (String archivo) {
R = false;
try {
abrir = new FileInputStream (archivo);
Leer = new BufferedReader( new InputStreamReader(abrir) );
leer = new DataInputStream ( abrir ); R = true;
}catch(Exception exc) { R = false; }
}//void
public void Crear (String archivo) {
R = false;
try {
guardar = new FileOutputStream (archivo); escribir = new DataOutputStream (guardar);
R = true;
}catch(Exception exc) { R = false; }
}//void
public void Cerrar () {
if ( R == true ) {
try { escribir.close(); guardar.close(); } catch(Exception exc) { }
try { leer.close(); abrir.close(); } catch(Exception exc) { }
}//if
}//void
public int leer_entero () {
int N = 0;
try { if ( R == true ) { N = leer.readInt(); } }catch(Exception e) {}
return N;
}//void
public double leer_real () {
double N = 0;
try { if ( R == true ) { N = leer.readDouble(); } }catch(Exception e) {}
return N;
}//void
public char leer_caracter () {
char N = 0; try { if ( R == true ) { N = leer.readChar(); } }catch(Exception e) {}
return N;
}//void
public byte leer_byte () {
byte N = 0; try { if ( R == true ) { N = leer.readByte(); } }catch(Exception e) {}
return N;
}//void
public String leer_texto () {
String S = "";
try { if ( R == true ) { S = leer.readUTF (); } }catch(Exception e) {}
return S;
}//void
public String Leer_Texto () {
String S = "";
try { if ( R == true ) { S = Leer.readLine(); } }catch(Exception e) {}
return S;
}//void
public String Leer_Archivo () {
String S2 = "";
try {
if ( R == true ) {
String cadena = "";
do { cadena = Leer.readLine(); S2 = S2 + cadena + "\n"; }while(cadena != null);
}
}catch(Exception e) {}
return S2;
}//void
public void guardar_binario (int dato) {
try { if ( R == true ) { escribir.writeInt(dato); } }catch(Exception e) {}
}//void
public void guardar_binario (double dato) {
try { if ( R == true ) { escribir.writeDouble(dato); } }catch(Exception e) {}
}//void
public void guardar_binario (char dato) {
try { if ( R == true ) { escribir.writeChar(dato); } }catch(Exception e) {}
}//void
3
public void guardar_binario (byte dato) {
try { if ( R == true ) { escribir.writeByte(dato); } }catch(Exception e) {}
}//void
public void guardar_binario (String dato) {
try { if ( R == true ) { escribir.writeUTF (dato); } }catch(Exception e) {}
}//void
public void guardar_texto (int dato) {
try { if ( R == true ) { escribir.writeBytes(Str(dato) + "\n"); } }catch(Exception e) {}
}//void
public void guardar_texto (double dato) {
try { if ( R == true ) { escribir.writeBytes(Str(dato) + "\n"); } }catch(Exception e) {}
}//void
public void guardar_texto (char dato) {
try { if ( R == true ) { escribir.writeBytes(dato + " \n"); } }catch(Exception e) {}
}//void
public void guardar_texto (byte dato) {
try { if ( R == true ) { escribir.writeBytes(dato + " \n"); } }catch(Exception e) {}
}//void
public void guardar_texto (String dato) {
try { if ( R == true ) { escribir.writeBytes(dato + "\n"); } }catch(Exception e) {}
}//void
protected void guardar_solo_dato (String dato) {
try { if ( R == true ) { escribir.writeBytes(dato); } }catch(Exception e) {}
}//void
public void Editor_Texto (String title) {
final Frame ventana = new Frame (title);
new Thread() {
public void run() {
texto = ""; salida=false;
MenuBar mb = new MenuBar ();
Menu menu = new Menu("Archivo"); MenuItem iNuevo = new MenuItem("Nuevo");
MenuItem iAbrir = new MenuItem("Abrir"); MenuItem iGuardar = new MenuItem("Guardar");
MenuItem iSalir = new MenuItem("Salir");
mb.add(menu);
menu.add(iNuevo ); menu.add(iAbrir ); menu.add(iGuardar ); menu.add(iSalir );
final TextArea area = new TextArea();
ventana.setSize(640, 480); ventana.setLayout(new BorderLayout());
ventana.add(area, BorderLayout.CENTER);
ventana.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent ev) { ventana.setVisible(false); }
});
iSalir.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){
texto = area.getText(); salida=true; ventana.setVisible(false);
}
} );
iNuevo.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){ area.setText(""); }
} );
iAbrir.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){
try {
FileDialog fd = new FileDialog(ventana, "Open", FileDialog.LOAD);

fd.setVisible(true);
FileInputStream file1 = new FileInputStream (fd.getDirectory() + fd.getFile());
BufferedReader data1 = new BufferedReader(new InputStreamReader(file1));
area.setText("");
String cadena = "";
do {
cadena = data1.readLine();
area.append(cadena + "\n");
}while(cadena != null);
data1.close(); file1.close();
}catch(Exception exc){}
}
} );
iGuardar.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){
try {
FileDialog fd = new FileDialog(ventana, "Save", FileDialog.SAVE);
fd.setVisible(true);
FileOutputStream file1 = new FileOutputStream (fd.getDirectory() + fd.getFile());
DataOutputStream data1 = new DataOutputStream (file1);
data1.writeBytes(area.getText());
data1.close(); file1.close();
}catch(Exception exc){}
}
} );
ventana.setMenuBar(mb);
ventana.setVisible(true);
}}.start();
}//void
public String getTexto() {
do {
try {
Thread.sleep(500);
}catch(Exception exc){}
}while(salida == false);
return texto;
}
public void Capturar_Datos (String campos[], String title) {
final Dialog ventana = new Dialog (new Frame(), title);
Button boton = new Button ("Aceptar");
Label etiqueta = new Label(title);
int num = campos.length ;
Label etiquetas [] = new Label[num];
final TextField cuadros_texto [] = new TextField [num];
int X = 50; int Y = 10;
ventana.setSize(640, ((num*25)+115) );
ventana.setLayout(null);
ventana.setModal(true);
ventana.add(etiqueta); etiqueta.setBounds(X, Y, 400, 25); Y = Y + 25 ;
for(int i = 0; i < num ; i++ ){
etiquetas[i] = new Label(campos[i]);
cuadros_texto [i] = new TextField();
ventana.add(etiquetas[i]);
ventana.add(cuadros_texto [i]);
etiquetas[i].setBounds(X,Y, 250, 25); X = X + 250 ;
cuadros_texto[i].setBounds(X,Y, 250, 25); X = 50 ; Y = Y + 25 ;
}//for
X = X + 250 ; Y = Y + 25 ;
ventana.add(boton); boton.setBounds(X, Y , 80, 40);
X = 50 ;
arreglo = new String [num];
ventana.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent ev) { ventana.setVisible(false); }
});
boton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){
for(int i = 0; i < arreglo.length ; i++ ){
arreglo[i] = cuadros_texto[i].getText();
}//for
ventana.setVisible(false);
}
} );
ventana.setVisible(true);
}//void
public int getInt (int index) { return Double.valueOf(arreglo[index]).intValue(); }
public byte getByte (int index) { return Double.valueOf(arreglo[index]).byteValue(); }
public double getDouble (int index) { return Double.valueOf(arreglo[index]).doubleValue(); }
public String getString (int index) { return arreglo[index]; }
public char getChar (int index) { return (arreglo[index]).charAt(0); }
public String[] getArreglo () { return arreglo; }
private String Str (int d) { return String.valueOf(d); }
private String Str (double d) { return String.valueOf(d); }
} //class

-------------Segunda parte, muestra un archivo de texto: mostrar.java----------------
/// REUTILICE LA CLASE basicas_rangel.java
/// PARA COMPILAR Y EJECUTAR ESTE PROGRAMA : mostrar.java
//---------------------------------------
//--- Programa
//--- MOSTRAR CONTENIDO DE UN ARCHIVO DE TEXTO.
//--- EL ARCHIVO CARTA.TXT DEBE EXISTIR EN EL DISCO
//---
import java.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class mostrar {
public static void main(String args[]) {
basicas_rangel s1 = new basicas_rangel ();
s1.Abrir("carta.txt");
System.out.println("Leyendo: " + s1.Leer_Archivo () );
s1.Cerrar();
}//main
}//void

ATT: Itzia Nuñez Pineda

abel consido contigo en las ventajas y des ventajas por que viendolo vien si nos sirve de utilidad en lo del archivo y esta muy bien contestada la pregunta con esa informacio


erick rumualdo a abel

esta es mi replica. Estoy de acuerdo con mi compañera ANAYELY de mencionar que a mi compañero Alberto le falto lo del archivos secuenciales que también existes archivos indezados y archivos dispersos que tambien son tipos de archivos bueno en mi punto de vista ala mayoría les falto mencionar estos tipos de archivo bueno compañeros espero que sigan participando

que pasen un buen dia de san valentin....

1) investigar la diferencia existente entre los diferentes tipos de archivos, así como las ventajas y desventajas. debe elaborar un resumen o tabla comparativa para compartir en este foro.

TIPO DE ARCHIVO
archivos binario
Un archivo binario es un archivo informático que contiene información de cualquier tipo codificada en binario para el propósito de almacenamiento y procesamiento en ordenadores.
CARACTERÍSTICAS**
• Es especialmente para crear registros.
• Puede contener información de cualquier tipo.
• Este contiene información en lenguaje de maquina o encriptado.
VENTAJAS**
• Estos archivos pueden ocupar menos espacio.
• Tiene la facilidad de manipular cualquier tipo de dato.
DESVENTAJAS**
• No se puede observar la información del archivo con facilidad.

archivos de texto
es un archivo informático compuesto únicamente por texto sin formato, sólo caracteres.
CARACTERÍSTICAS**
•Se puede guardar en formato separado por comas o tabulaciones.
VENTAJAS**
•Este permite visualizar el contenido del archivo claramente.
DESVENTAJAS**
•Carece de información de tipos de letra y su contenido puede ser fácilmente plagiado.

archivo de acceso secuencial

CARACTERÍSTICAS**
•Puede haber archivo secuenciales de tipo binario y de texto.
VENTAJAS
•Los registros quedan grabados consecutivamente conforme se utilizan.
•Su uso es de manera más rápida.
DESVENTAJAS**
•No nos permite la localización de un registro no se puede realizar individualmente.




2) haciendo uso del lenguaje de programación java, debe implementar las diferentes operaciones que se pueden realizar para manipular información de un archivo, tales como: abrir, leer datos, guardar, cerrar, entre otras operaciones. escriba código fuente, mostrando un ejemplo cualquiera (como: sistema de agenda de datos, factura de ventas, o simplemente, leer y escribir variables enteras, reales y cadena), y dicho código fuente deberá compartirlo en este foro.

en este documento muestro un codigo proporcionado por el profesor edgar lugo rangel, la primera parte representa la clase "basicas_rangel.class" necesaria para correrlo.
PRIMERA PARTE

_______________________________________________________________________________________________________
_______________________________________________________________________________________________________
//------------------------------------------------------------------------------------------------------------------------------------
//-------------- derechos reservados (c) 2012. edgar - rangel - lugo. mexico
//-------------- free source : codigo libre por m.c. edgar - rangel - lugo.
//-------------- puedes utilizarlo, modificarlo y adaptarlo de manera libre,
//-------------- solo debes dar el credito al autor. no tiene nada que ver
//-------------- con opensource, freeware, sourceforge, glp (gpl), eula, ni
//-------------- algun otro. este codigo es desarrollado con fines academicos
//-------------- y tiene los - derechos reservados (c) 2012. edgar - rangel - lugo. mexico.
//-------------- este codigo no debe estar disponible en algun sitio web, si deseas hacerlo
//-------------- debes notificarlo al autor, para que te haga llegar por escrito un permiso.
//-------------- puedes comunicarte a: erangel_lugo@hotmail . com
//--------------
//------------- compañero docente, si utilizas este codigo, por favor, da credito al autor
//------------- y no impartas tus clases argumentando que fue extraido de libros o "bajado" de internet .
//--------------
//------------- programas indispensables para operaciones basicas , visto en unidad
//------------- programando operaciones basicas sobre archivos de texto y binarios
//------------- atte: m.c. edgar - rangel - lugo.
//-------------
//------------- este archivo debe llevar el nombre: basicas_rangel.java (en minusculas)
//-------------
//------------------------------------------------------------------------------------------------------------------------------------
import java.io.*;
import java.awt.*;
import java.awt.event.*;
class basicas_rangel {
private fileinputstream abrir;
private fileoutputstream guardar;
private dataoutputstream escribir;
private bufferedreader leer;
private datainputstream leer;
private boolean r ;
private string arreglo[];
private string texto;
private boolean salida;
public basicas_rangel () { r = false; salida=true; }//constr
public void abrir (string archivo) {
r = false;
try {
abrir = new fileinputstream (archivo);
leer = new bufferedreader( new inputstreamreader(abrir) );
leer = new datainputstream ( abrir ); r = true;
}catch(exception exc) { r = false; }
}//void
public void crear (string archivo) {
r = false;
try {
guardar = new fileoutputstream (archivo); escribir = new dataoutputstream (guardar);
r = true;
}catch(exception exc) { r = false; }
}//void


public void cerrar () {
if ( r == true ) {
try { escribir.close(); guardar.close(); } catch(exception exc) { }
try { leer.close(); abrir.close(); } catch(exception exc) { }
}//if
}//void
public int leer_entero () {
int n = 0;
try { if ( r == true ) { n = leer.readint(); } }catch(exception e) {}
return n;
}//void
public double leer_real () {
double n = 0;
try { if ( r == true ) { n = leer.readdouble(); } }catch(exception e) {}
return n;
}//void
public char leer_caracter () {
char n = 0; try { if ( r == true ) { n = leer.readchar(); } }catch(exception e) {}
return n;
}//void
public byte leer_byte () {
byte n = 0; try { if ( r == true ) { n = leer.readbyte(); } }catch(exception e) {}
return n;
}//void
public string leer_texto () {
string s = "";
try { if ( r == true ) { s = leer.readutf (); } }catch(exception e) {}
return s;
}//void
public string leer_texto () {
string s = "";
try { if ( r == true ) { s = leer.readline(); } }catch(exception e) {}
return s;
}//void
public string leer_archivo () {
string s2 = "";
try {
if ( r == true ) {
string cadena = "";
do { cadena = leer.readline(); s2 = s2 + cadena + "\n"; }while(cadena != null);
}
}catch(exception e) {}
return s2;
}//void
public void guardar_binario (int dato) {
try { if ( r == true ) { escribir.writeint(dato); } }catch(exception e) {}
}//void
public void guardar_binario (double dato) {
try { if ( r == true ) { escribir.writedouble(dato); } }catch(exception e) {}
}//void
public void guardar_binario (char dato) {
try { if ( r == true ) { escribir.writechar(dato); } }catch(exception e) {}
}//void


public void guardar_binario (byte dato) {
try { if ( r == true ) { escribir.writebyte(dato); } }catch(exception e) {}
}//void
public void guardar_binario (string dato) {
try { if ( r == true ) { escribir.writeutf (dato); } }catch(exception e) {}
}//void
public void guardar_texto (int dato) {
try { if ( r == true ) { escribir.writebytes(str(dato) + "\n"); } }catch(exception e) {}
}//void
public void guardar_texto (double dato) {
try { if ( r == true ) { escribir.writebytes(str(dato) + "\n"); } }catch(exception e) {}
}//void
public void guardar_texto (char dato) {
try { if ( r == true ) { escribir.writebytes(dato + " \n"); } }catch(exception e) {}
}//void
public void guardar_texto (byte dato) {
try { if ( r == true ) { escribir.writebytes(dato + " \n"); } }catch(exception e) {}
}//void
public void guardar_texto (string dato) {
try { if ( r == true ) { escribir.writebytes(dato + "\n"); } }catch(exception e) {}
}//void
protected void guardar_solo_dato (string dato) {
try { if ( r == true ) { escribir.writebytes(dato); } }catch(exception e) {}
}//void
public void editor_texto (string title) {
final frame ventana = new frame (title);
new thread() {
public void run() {
texto = ""; salida=false;
menubar mb = new menubar ();
menu menu = new menu("archivo"); menuitem inuevo = new menuitem("nuevo");
menuitem iabrir = new menuitem("abrir"); menuitem iguardar = new menuitem("guardar");
menuitem isalir = new menuitem("salir");
mb.add(menu);
menu.add(inuevo ); menu.add(iabrir ); menu.add(iguardar ); menu.add(isalir );
final textarea area = new textarea();
ventana.setsize(640, 480); ventana.setlayout(new borderlayout());
ventana.add(area, borderlayout.center);
ventana.addwindowlistener(new windowadapter(){
public void windowclosing(windowevent ev) { ventana.setvisible(false); }
});
isalir.addactionlistener(new actionlistener() {
public void actionperformed(actionevent ev){
texto = area.gettext(); salida=true; ventana.setvisible(false);
}
} );
inuevo.addactionlistener(new actionlistener() {
public void actionperformed(actionevent ev){ area.settext(""); }
} );
iabrir.addactionlistener(new actionlistener() {
public void actionperformed(actionevent ev){
try {
filedialog fd = new filedialog(ventana, "open", filedialog.load);


fd.setvisible(true);
fileinputstream file1 = new fileinputstream (fd.getdirectory() + fd.getfile());
bufferedreader data1 = new bufferedreader(new inputstreamreader(file1));
area.settext("");
string cadena = "";
do {
cadena = data1.readline();
area.append(cadena + "\n");
}while(cadena != null);
data1.close(); file1.close();
}catch(exception exc){}
}
} );
iguardar.addactionlistener(new actionlistener() {
public void actionperformed(actionevent ev){
try {
filedialog fd = new filedialog(ventana, "save", filedialog.save);
fd.setvisible(true);
fileoutputstream file1 = new fileoutputstream (fd.getdirectory() + fd.getfile());
dataoutputstream data1 = new dataoutputstream (file1);
data1.writebytes(area.gettext());
data1.close(); file1.close();
}catch(exception exc){}
}
} );
ventana.setmenubar(mb);
ventana.setvisible(true);
}}.start();
}//void
public string gettexto() {
do {
try {
thread.sleep(500);
}catch(exception exc){}
}while(salida == false);
return texto;
}
public void capturar_datos (string campos[], string title) {
final dialog ventana = new dialog (new frame(), title);
button boton = new button ("aceptar");
label etiqueta = new label(title);
int num = campos.length ;
label etiquetas [] = new label[num];
final textfield cuadros_texto [] = new textfield [num];
int x = 50; int y = 10;
ventana.setsize(640, ((num*25)+115) );
ventana.setlayout(null);
ventana.setmodal(true);
ventana.add(etiqueta); etiqueta.setbounds(x, y, 400, 25); y = y + 25 ;
for(int i = 0; i < num ; i++ ){
etiquetas[i] = new label(campos[i]);
cuadros_texto [i] = new textfield();
ventana.add(etiquetas[i]);


ventana.add(cuadros_texto [i]);
etiquetas[i].setbounds(x,y, 250, 25); x = x + 250 ;
cuadros_texto[i].setbounds(x,y, 250, 25); x = 50 ; y = y + 25 ;
}//for
x = x + 250 ; y = y + 25 ;
ventana.add(boton); boton.setbounds(x, y , 80, 40);
x = 50 ;
arreglo = new string [num];
ventana.addwindowlistener(new windowadapter(){
public void windowclosing(windowevent ev) { ventana.setvisible(false); }
});
boton.addactionlistener(new actionlistener() {
public void actionperformed(actionevent ev){
for(int i = 0; i < arreglo.length ; i++ ){
arreglo[i] = cuadros_texto[i].gettext();
}//for
ventana.setvisible(false);
}
} );
ventana.setvisible(true);
}//void
public int getint (int index) { return double.valueof(arreglo[index]).intvalue(); }
public byte getbyte (int index) { return double.valueof(arreglo[index]).bytevalue(); }
public double getdouble (int index) { return double.valueof(arreglo[index]).doublevalue(); }
public string getstring (int index) { return arreglo[index]; }
public char getchar (int index) { return (arreglo[index]).charat(0); }
public string[] getarreglo () { return arreglo; }
private string str (int d) { return string.valueof(d); }
private string str (double d) { return string.valueof(d); }
} //class
}//for
s1.cerrar();
}//main
}//void


SEGUNDA PARTE

_______________________________________________________________________________________________________
_______________________________________________________________________________________________________

//------------------------------------------------------------------------
//------------ EJEMPLOS DE: M.C. EDGAR - RANGEL - LUGO . ------------------
//------------------------------------------------------------------------
//........................................................................
//----------------------------------------------------------
//----------------------------------------------------------
//----------- ESTOS VIENEN DE APOYO , DESDE LA UNIDAD 1 ---
//----------------------------------------------------------
//----------------------------------------------------------
//----------------------------------------------------------
/// REUTILICE LA CLASE basicas_rangel.java
/// PARA COMPILAR Y EJECUTAR ESTE PROGRAMA : agenda.java
//----------------------------------------------------------
//----- Programa
//----- Para la GUARDAR DATOS DE UNA agenda empresarial ------
//----- Permite guardar datos en formatos tipo binario y tipo texto ------
//-----
import java.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class agenda {
public static void main(String args[]) {
basicas_rangel s1 = new basicas_rangel ();
String campos[] = {"Nombre del Cliente: ", "Domicilio : ",
"Telefono: ","Pais : ", "Edad: ", "Saldo: ", "Sexo:"};
//--- Guardando datos (Binarios) ---------
s1.Crear ("agenda_binario.dat");
for(int k=0;k<2;k++) {
s1.Capturar_Datos (campos, "Agenda Empresarial");
s1.guardar_binario ( s1.getInt(4) );
s1.guardar_binario ( s1.getDouble(5) );
s1.guardar_binario ( s1.getChar(6) );
s1.guardar_binario ( s1.getString(0) );
s1.guardar_binario ( s1.getString(1) );
s1.guardar_binario ( s1.getString(2) );
s1.guardar_binario ( s1.getString(3) );
}//for
s1.Cerrar();
s1.Abrir ("agenda_binario.dat"); //LEYENDO
System.out.println (" " + campos[4] + " " + s1.leer_entero () );
System.out.println (" " + campos[5] + " " + s1.leer_real () );
System.out.println (" " + campos[6] + " " + s1.leer_caracter () );
System.out.println (" " + campos[0] + " " + s1.leer_texto () );
System.out.println (" " + campos[1] + " " + s1.leer_texto () );
System.out.println (" " + campos[2] + " " + s1.leer_texto () );
System.out.println (" " + campos[3] + " " + s1.leer_texto () );
s1.Cerrar();
//--- Guardando datos (Texto) ---------
s1.Crear ("agenda_texto.txt");

for(int k=0;k<2;k++) {
s1.Capturar_Datos (campos, "Agenda Empresarial");
s1.guardar_texto ( s1.getString(0) );
s1.guardar_texto ( s1.getString(1) );
s1.guardar_texto ( s1.getString(2) );
s1.guardar_texto ( s1.getString(3) );
s1.guardar_texto ( s1.getInt(4) );
s1.guardar_texto ( s1.getDouble(5) );
s1.guardar_texto ( s1.getChar (6) );
}//for
s1.Cerrar();
s1.Abrir ("agenda_texto.txt"); //LEYENDO
System.out.println (" " + campos[0] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[1] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[2] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[3] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[4] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[5] + " " + s1.Leer_Texto () );
System.out.println (" " + campos[6] + " " + s1.Leer_Texto () );
s1.Cerrar();
//--------------------------------------------
}//main
}//void

Estoy de acuerdo con mi compañero Everardo creo que a todos mis compañeros incluyéndome yo, nos falto mencionar algunos tipos de archivos espero que para la otra podamos superar nuestro trabajo.