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

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.

• 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.

• 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.

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


• 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 la participaciòn concreta de mi compañero abel me parece buena es una de las participaciones mas facil de entender, y con ello pudimos observar las grandes diferencias de cada uno de los archivos ademas de la participaciòn en el codigo muy buena la participaciòn...

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.


Son aquellos que pueden contener cualquier clase de datos y de tal manera que son “entendibles” por la gente.


1.- Al abrirlo con un editor de texto nos daremos cuenta de la información que contiene.

2.-Al momento de abrirlo se verán textos mezclados con código ASCII.


1.-Un usuario puede modificar, si sabe, las variables para personalizar el programa.

2.-Fácil de exportar.

3- Guardan los datos como caracteres, lo que los hace visibles con un editor de texto por parte del programador y usuarios.


1.-No hay forma para un programa de determinar de manera confiable que codificación se usó.



son archivos que contienen información de cualquier tipo codificada en binario para el propósito de almacenamiento y procesamiento en ordenadores.


1.- Brindaran a nuestras aplicaciones la posibilidad de trabajar con registros sin necesidad de un motor de base de datos.

2.- Incorporan valores en formato de bits y/o bytes.

3- Al abrirlo con un editor de texto, no podemos interpretar parte de la información.


1.-Evitaremos iniciar el motor de la base de datos, y dispondremos de mayor flexibilidad en el manejo de los registros, puesto que no se trata de muchos registros.

2.-fácil de entender donde empieza y dónde terminan los datos.

3.- Pueden contener información tipo texto.

4.-Evitan la pérdida de información y calidad.

5.- tienen la facilidad de manipular cualquier tipo de datos.


1- No cualquier persona puede interpretar la información.


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



REUTILICE LA CLASE basicas_rangel.java
/// PARA COMPILAR Y EJECUTAR ESTE PROGRAMA : easypad.java
//---------------------------------------------------------//--------//---
Programa
//--- Un Editor de Textos Sencillo – Usando Java
//--- Guarda datos en formato tipo TEXTO
//---
import java.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class easypad {
public static void main(String args[]) {
basicas_rangel s1 = new basicas_rangel ();
s1.Editor_Texto("Bienvenidos a EasyPad");
System.out.println("Texto del Area: " + s1.getTexto() );
//Guardarlo en un archivo
s1.Crear("temporal.txt");
s1.guardar_texto(s1.getTexto());
s1.Cerrar();
}//main
}//void


REYNALDO MUÑOZ RAFAEL

Mi retroalimentación es para mi compañero Bolivar Pérez Mendóza, como se puede observar es muy clara la informacion, que presenta en de cada tipo de archivo, pero a mi parecer pienso que los de acceso secuencial no se pueden incluir en este tipo de archivos,y con lo que respecta a los archivos de texto y binario, muestra en cada uno de los mismos, los formatos y/o extensiones, puesto que a muchos de nosotros nos falto mencionar.
bueno ese es mi punto de vista.
saludos


ATENTAMENTE
REYNALDO MUÑOZ RAFAEL

1)
Tipo de archivos
Archivo de texto
Características:
Formato de estencion es TXT.
Contiene texto fin formato
Guarda formatos separados por tabulaciones
VENTAJAS:

-Fácil de leer
-Se aprecia muy bien la información
-Rápido de leer
-permite visualizar la información
- Permite guardar tipos definidos por el usuario.
- Todos los registros tienen el mismo tamaño.
DESVENTAJAS
-Información expuesta
-muy vulnerable
-puede ser plagiado
Carece de información tipo letra

Archivos binarios
Características:
-Puede ser tipo de acceso
-Los registros tiene el mismo tamaño
-tipo binario y texto

VENTAJAS:
-lenguaje maquina
-contenido protegido
-Puede contener cualquier tipo de información
-puede ser importado a programas de bases de datos
-ocupa menos espacio
-es simple para guardar y escribir datos
-Permite utilizar el paradigma orientado a objetos

DESVENTAJAS:
-no se puede leer fácilmente
-Debe conocerse con precisión como se describen los datos en el archivo

Archivos secuenciales

Características:
-Puede haber archivo tipos binario y de texto
-Pueden ser archivos de acceso directo
-Es posible un registro sin leer los anteriores

VENTAJAS:
- Guarda tipos definidos por el usuario.
-Los lenguajes de programación los graban de manera secuencial.
-provee mecanismos para realizar su recorido
-es la forma de organización de un registro
-su uso es de manera mas rapida.
- Son muy sencillos de usar y aplicar.
DESVENTAJAS:
-Es muy pobre el acceso a un registro
-es poco practico el acceso aleatorio
-La dirección de registro esta implícita
- En la mayoría de los casos, es de tipo binario, y aveces de tipo texto.
- Eran casi siempre de acceso directo.

4) Implementar las operaciones para archivos secuenciales.
el formato de las instrucciones que nos permite el manejo de los datos contenidos en una organización de un fichero secuencial depende del lenguaje de pragramacion.
Las instrucciones empleadas están el los ficheros que les doy a conocer:

Abrir (OPEN) Abrir un fichero para poder trabajar con sus registros. Se puede abrir de tres formas:
(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.
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

ALEJANDRO PEREZ ROSALES

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

//------------------------------------------------------------------------
//------------ 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 más 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 cuál 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.

LUIS ANGEL ZAPATA PEREZ

Replica dirigida a: María Guadalupe Vigueras

Estoy de acuerdo en las respuestas aportadas por mi compañera, hizo énfasis en tres tipos de archivos que son: archivos de texto, archivos binarios y archivos secuenciales, pero yo le recomendaría que hiciera una investigación más profunda del tema abarcara más contenido en sus respuestas y así poder entender mejor el tema.

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
1. ARCHIVOS DE TEXTO 
VENTAJAS
permite visualizar el contenido del archivo claramente y puede ser importado a programas de bases de datos.
DESVENTAJAS
 su contenido de este archivo puede ser fácilmente ya que este es un archivo de texto
2. ARCHIVOS BINARIO
VENTAJAS
 pueden ocupar menos espacio y son mucho más fácil de entender donde empiezan y donde terminan los datos.
DESVENTAJAS
 permite trabajar con registros sin necesidad de un motor de bases de datos.
 no se puede observar la información del archivo con facilidad ya que es un poco más complicado por ser binario.
3. ARCHIVO DE ACCESO SECUENCIAL
VENTAJAS
permite guardar tipos definidos por el usuario y su uso es mucho más rápido.
DESVENTAJAS
 tiene mecanismos para realizar su recorrido.
 el acceso a un registro es pobre y
no nos permite la localización de un registro, no se puede realizar individualmente.
son muy 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 código 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


//------------------------------------------------------------------------
//------------ 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 deacuerdo con mis compañeros creo que a todos nos faltaron algunos tipos de archivos y hay otros que no existen. saludos a todos que tengan un buen dia.

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.

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.

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.

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.

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.

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

_______________________________________________________________________________________________________
_______________________________________________________________________________________________________

//------------------------------------------------------------------------

//------------------------------------------------------------------------
//........................................................................
//----------------------------------------------------------
//----------------------------------------------------------

//----------------------------------------------------------
//----------------------------------------------------------
//----------------------------------------------------------

//----------------------------------------------------------
//----- 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

ATT: RANFERI GUADALUPE RIOS

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
1. ARCHIVOS DE TEXTO
VENTAJAS
permite visualizar el contenido del archivo claramente y puede ser importado a programas de bases de datos.
DESVENTAJAS
su contenido de este archivo puede ser fácilmente ya que este es un archivo de texto
2. ARCHIVOS BINARIO
VENTAJAS
pueden ocupar menos espacio y son mucho más fácil de entender donde empiezan y donde terminan los datos.
DESVENTAJAS
permite trabajar con registros sin necesidad de un motor de bases de datos.
no se puede observar la información del archivo con facilidad ya que es un poco más complicado por ser binario.
3. ARCHIVO DE ACCESO SECUENCIAL
VENTAJAS
permite guardar tipos definidos por el usuario y su uso es mucho más rápido.
DESVENTAJAS
tiene mecanismos para realizar su recorrido.
el acceso a un registro es pobre y
no nos permite la localización de un registro, no se puede realizar individualmente.
son muy 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 código 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


//------------------------------------------------------------------------
//------------ 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


Atentamente: Ricardo Suazo Buenas

Estoy de acuerdo con los comentarios de mis compañeros en los conceptos de archivo y su clasificación y características.

Pues es muy interesante este tema. coincido con mis compañeros y me sirvio de mucho aprendizaje para realizar actividades relacionadas a los archivos y sus componentes.
Atentamente: Ricardo Suazo Buenas

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.








4) Implementar las operaciones para archivos secuenciales.

Introducción

Archivos secuenciales
Para leer un archivo secuencial, el sistema siempre comienza al principio del archivo y lee un registro a la vez hasta llegar al registro deseado. Por ejemplo si ocurre que el registro particular es el décimo en un archivo, el sistema comienza en el primer registro y lee hacia delante un registro a la vez hasta llegar al décimo.
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.
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.



ESBEYDE YAEL PEREZ RIOS

Felicidades !!!



Nuevamente, muchas felicidades !!!

Atte: M.C. Edgar Rangel Lugo.

1)  diferencia existente entre los diferentes tipos de archivos, así como las ventajas y desventajas.

r= Existen muchos tipos de archivos de imágenes disponibles, pero lo más posible es que te hayas conseguido con algunos que suelen ser los más comunes: el JPG (también conocido como JPEG), el PNG y el GIF. Todos tienen sus ventajas y desventajas, así que hay conocerlos mejor nos permitirá decidir cuál es el que necesitamos usar en diferentes escenarios.

La mayoría de los navegadores en Internet tienen la capacidad de mostrar estos tres tipos de imágenes sin ningún problema, algunos formatos funcionan mejor para ciertas ocasiones. Por ejemplo, los JPG se utilizan con frecuencia para imágenes que son realistas y que se ven bien aunque el tamaño del archivo sea muy bajo; los GIF, que tanto se usan hoy en día, muestran imágenes animadas; los PNG, por su parte, tienen la habilidad de mantener la calidad al máximo siempre y soportan transparencias.
GIF: perfecta para usar en archivos pequeños con colores limitados (escala de grises, por ejemplo). Evitar su uso para fotografías.
PNG: utilizar en gráficos, ilustraciones, y archivos pequeños en la web que necesiten transparencias. Evitar en fotografías con muchos detalles que necesiten ser subidas a la web porque serán demasiado pesadas.
JPG: ideal para mostrar fotografías en la web sin ocupar mucho espacio en un servidor. Terrible para edición de imágenes.


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

r=

public class CreateFileOrFolder
{
   static void Main()
   {
       // Specify a name for your top-level folder.
       string folderName = @"c:\Top-Level Folder";

       // To create a string that specifies the path to a subfolder under your
       // top-level folder, add a name for the subfolder to folderName.
       string pathString = System.IO.Path.Combine(folderName, "SubFolder");

       // You can write out the path name directly instead of using the Combine
       // method. Combine just makes the process easier.
       string pathString2 = @"c:\Top-Level Folder\SubFolder2";

       // You can extend the depth of your path if you want to.
       //pathString = System.IO.Path.Combine(pathString, "SubSubFolder");

       // Create the subfolder. You can verify in File Explorer that you have this
       // structure in the C: drive.
       //    Local Disk (C:)
       //        Top-Level Folder
       //            SubFolder
       System.IO.Directory.CreateDirectory(pathString);

       // Create a file name for the file you want to create.
       string fileName = System.IO.Path.GetRandomFileName();

       // This example uses a random string for the name, but you also can specify
       // a particular name.
       //string fileName = "MyNewFile.txt";

       // Use Combine again to add the file name to the path.
       pathString = System.IO.Path.Combine(pathString, fileName);

       // Verify the path that you have constructed.
       Console.WriteLine("Path to my file: {0}\n", pathString);

       // Check that the file doesn't already exist. If it doesn't exist, create
       // the file and write integers 0 - 99 to it.
       // DANGER: System.IO.File.Create will overwrite the file if it already exists.
       // This could happen even with random file names, although it is unlikely.
       if (!System.IO.File.Exists(pathString))
       {
           using (System.IO.FileStream fs = System.IO.File.Create(pathString))
           {
               for (byte i = 0; i < 100; i++)
               {
                   fs.WriteByte(i);
               }
           }
       }
       else
       {
           Console.WriteLine("File \"{0}\" already exists.", fileName);
           return;
       }

       // Read and display the data from your file.
       try
       {
           byte[] readBuffer = System.IO.File.ReadAllBytes(pathString);
           foreach (byte b in readBuffer)
           {
               Console.Write(b + " ");
           }
           Console.WriteLine();
       }
       catch (System.IO.IOException e)
       {
           Console.WriteLine(e.Message);
       }

       // Keep the console window open in debug mode.
       System.Console.WriteLine("Press any key to exit.");
       System.Console.ReadKey();
   }
   // Sample output:

   // Path to my file: c:\Top-Level Folder\SubFolder\ttxvauxe.vv0

   //0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
   //30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56
   // 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 8
   //3 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
}



realizaron
gerardo de jesus moreno morales
gustavo mondragon juarez
abel gutierrez

1) Investigar la diferencia existente entre los diferentes tipos de archivos, así como las ventajas y desventajas.

R= Las imágenes son uno de los contenidos que mas compartimos en Internet, pero como cualquier otro archivo, tienes que saber es que existen una muy extensa variedad de tipos de formato de imagen, y cada uno presenta diferentes características, con sus diversas ventajas y desventajas.
Esto quiere decir que no existe realmente un formato de imagen general que sea superior a los demás, sino que cada uno depende del contexto en que sea utilizado.
Siempre es importante que sepamos identificar los tipos de formato de imagen que vayamos a usar, ya que cada formato te dará importantes diferencias de rendimiento y tamaño, además de que en algunos casos solo es viable usar algún formato de imagen específico, como puede ser el GIF para las animaciones.

JPG: Entre todos los tipos de formato de imagen, este es el formato mas utilizado para compartir imágenes en Internet y el mas común en general, aunque eso no quiere decir que sea apropiado para hacer cualquier cosa, de hecho, hay muchos ámbitos donde es muy poco recomendable usarlo.

PNG: Otro de los formatos mas populares. El formato PNG es un formato de compresión sin perdida, además soporta perfectamente las transparencias, lo que lo hace un formato ideal para imágenes sin fondo, logotipos e imágenes que contengan texto. Además, al no reducir la calidad de las imágenes, los dibujos lineales tienen una apariencia en PNG mucho mejor de lo que jamás podrán tener en JPG.

GIF: El formato Gif es un formato con compresión sin perdida… más o menos, ya que tiene una gran limitación: sólo soporta 256 colores, a diferencia de los millones del JPG o PNG. Es el único formato de esta lista que soporta animaciones y es ampliamente usado en Internet por esto último.

WebP: Aunque este formato no es muy usado por los usuarios alrededor del mundo, si que lo es por empresas como Facebook. Este formato, que tiene el importante respaldo de haber sido desarrollado por Google, pretende unificar las ventajas de los formatos JPG, PNG y GIF, ya que permite guardar imágenes mediante compresión con perdida (como JPG), con menor tamaño que el formato JPG y una calidad comparable, a la vez que permite la compresión sin perdida, con un archivo final de menor tamaño que el PNG.



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.

R= /*Clase que permite escribir en un archivo de texto*/

//Importamos clases que se usaran
import java.io.File;
import java.io.FileWriter;

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

//Un texto cualquiera guardado en una variable
String saludo="Hola";

try
{
//Crear un objeto File se encarga de crear o abrir acceso a un archivo que se especifica en su constructor
File archivo=new File("texto.txt");

//Crear objeto FileWriter que sera el que nos ayude a escribir sobre archivo
FileWriter escribir=new FileWriter(archivo,true);

//Escribimos en el archivo con el metodo write
escribir.write(saludo);

//Cerramos la conexion
escribir.close();
}

//Si existe un problema al escribir cae aqui
catch(Exception e)
{
System.out.println("Error al escribir");
}
}
}

      /*Clase que permite leer un archivo de texto*/

//Importamos clases a usar
import java.io.FileReader;
import java.io.BufferedReader;
public class Leer
{
public static void main(String arg[])
{
//Creamos un String que va a contener todo el texto del archivo
String texto="";

try
{
//Creamos un archivo FileReader que obtiene lo que tenga el archivo
FileReader lector=new FileReader("texto.txt");

//El contenido de lector se guarda en un BufferedReader
BufferedReader contenido=new BufferedReader(lector);

//Con el siguiente ciclo extraemos todo el contenido del objeto "contenido" y lo mostramos
while((texto=contenido.readLine())!=null)
{
System.out.println(texto);
}
}

//Si se causa un error al leer cae aqui
catch(Exception e)
{
System.out.println("Error al leer");
}
}
}

ATENTAMENTE :
GRUPO: 4A6   "LOS PAISAS"
* CITLALI ARROYO ROMERO
*CARLOS ALBERTO RUIZ GUTIERREZ
*NEFTALI CABRERA TORRES
*CRISTIAN ALONSO IGNACIO

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.

Los tipos de archivos reconocidos por el sistema son normal, directorio o especial. No obstante, el sistema operativo utiliza muchas variaciones de estos tipos básicos.

A continuación se indican los tipos básicos de archivos existentes:
Normal: Almacena datos (texto, binario y ejecutable).
Directorio: Contiene la información que se utiliza para acceder a otros archivos.
Especial: Define un archivo de conducto FIFO (primero en entrar, primero en salir) o un dispositivo físico.

Todos los tipos de archivos reconocidos por el sistema se enmarcan en una de estas categorías. No obstante, el sistema operativo utiliza muchas variaciones de estos tipos básicos.

Archivos normales
Los archivos normales son los archivos más comunes y se utilizan para contener datos. Los archivos normales están en formato de archivos de texto o de archivos binarios:

Archivos de texto:
Los archivos de texto son archivos normales que contienen información almacenada en formato ASCII y que el usuario puede leer. Puede visualizar e imprimir dichos archivos. Las líneas de un archivo de texto no deben contener caracteres NUL y ninguna puede exceder de {LINE_MAX} bytes de longitud, incluido el carácter de nueva línea.

El término archivo de texto no impide la inclusión de caracteres de control o de otros caracteres no imprimibles (diferentes de NUL). Por lo tanto, los programas de utilidad estándar que listan archivos de texto como entradas o como salidas o bien son capaces de procesar los caracteres especiales o bien son capaces de describir explícitamente sus limitaciones dentro de sus secciones individuales.

Archivos binarios:
Los archivos binarios son archivos normales que contienen información que el sistema puede leer. Los archivos binarios podrían ser archivos ejecutables que indicaran al sistema que ha de realizar un trabajo. Los mandatos y los programas se almacenan en archivos binarios ejecutables. Los programas de compilación especial convierten texto ASCII en código binario.

Los archivos de texto y binarios sólo se diferencian en que los archivos de texto tienen líneas de menos de {LINE_MAX} bytes, sin ningún carácter NUL, cada una de las cuales termina con un carácter de nueva línea.

Archivos de directorios:
Los archivos de directorio contienen la información que el sistema necesita para acceder a todos los tipos de archivos, pero los archivos de directorio no contienen los datos reales del archivo. En consecuencia, los directorios ocupan menos espacio que un archivo normal y proporcionan a la estructura de sistema de archivos flexibilidad y profundidad. Cada entrada de directorio representa un archivo o un subdirectorio. Cada entrada contiene el nombre del archivo y el número de referencia de nodo de índice (número de i-nodo) del archivo. El número de inodo apunta al nodo de índice exclusivo que se ha asignado al archivo. El número de inodo describe la ubicación de los datos que se asocian al archivo. Un grupo independiente de mandatos crea y controla los directorios.

Archivos especiales:
Los archivos especiales definen dispositivos para el sistema o son archivos temporales creados por procesos. Los tipos básicos de archivos especiales son FIFO (primero en entrar, primero en salir), de bloques y de caracteres. Los archivos FIFO también se denominan conductos. Los conductos se crean mediante un proceso para permitir temporalmente las comunicaciones con otro proceso. Estos archivos dejan de existir cuando termina el primer proceso. Los archivos de bloque y los archivos de caracteres definen dispositivos.

Cada archivo tiene un conjunto de permisos (denominado modalidades de acceso) que determina quién puede leer, modificar o ejecutar el archivo.

https://www.ibm.com/support/knowledgecenter/es/ssw_aix_71/com.ibm.aix.osdevice/filetypes.htm

EquipoDinamita:
Alan Henry Alcantar Medrano.
Jose Ramon Ortiz Lopez.
Natolio Tapia Mondragon.
Agustin Vivas Pineda.
Daniel Macedonio Bedolla.
Jonathan Urieta Albarran.

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ÓDIGO PARA LEER DATOS:
import java.io.*;
import java.net.*;
public class archivo3 {
public static void main (String gelipin[]) {
http://System.out.println("" + gelipin[0]);
try { FileInputStream f;
f=new FileInputStream ("datos.txt");
BufferedReader d;
d=new BufferedReader (new InputStreamReader(f));
String cad1, cad2,cad3,cad4;
cad1=d.readLine(); cad2=d.readLine(); cad3=d.readLine();
int n=Double.valueOf(cad2).intValue(); n=n+1;
System.out.println("\n" + cad1 + "\n" + cad2 + "\n" + cad3 + "\n" + n + "\n");
f.close();
} catch(Exception exc) {
System.out.println("ERROR;"+exc);
}
}
}

CÓDIGO PARA ABRIR UN ARCHIVO Y MUESTRE EL TEXTO EN BINARIO:
import java.io.*;
import java.net.*;
public class binario1 {
public static void main(String chidoone[]) {
try { FileOutputStream f;
f=new FileOutputStream("datosbinario.txt");
DataOutputStream d;
d=new DataOutputStream(f);
int n=5; double num=12.43; char c='A';
d.writeInt(n);
d.writeDouble(num);
d.writeChar(c);
d.close();f.close();
}catch(Exception exc) {System.out.println("ERROR:"+ exc);}
}
}

CÓDIGO PARA ABRIR UN ARCHIVO BINARIO Y LO MUESTRE EN TEXTO:
import java.io.*;
import java.net.*;
public class binario2 {
public static void main(String abc[]){
try {FileInputStream f;
f=new FileInputStream("datosbinario.txt");
DataInputStream d;
d=new DataInputStream(f);
int n=d.readInt ();
double num=d.readDouble();
char c=d.readChar();
System.out.println("\n" + n + "\n" + num + "\n" + c + "\n");
d.close();f.close();
}catch(Exception exc) {System.out.println("ERROR"+exc);}
}
}

FUENTE: APUNTES DE CLASE.

EquipoDinamita:
Alan Henry Alcantar Medrano.
Jose Ramon Ortiz Lopez.
Natolio Tapia Mondragon.
Agustin Vivas Pineda.
Daniel Macedonio Bedolla.
Jonathan Urieta Albarran.

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:

package foro;

import java.awt.*;
import java.io.*;
import javax.swing.*;

public class Foro extends JFrame {

String nombre;

JFrame frame;
JTextArea txtArea;
JButton boton, boton2;
JScrollPane scroll;

public Foro() {
nombre = "";
frame = new JFrame();
txtArea = new JTextArea();
boton = new JButton("Terminar");
boton2 = new JButton("Salir");
scroll = new JScrollPane(txtArea, JScrollPane.VERTICAL_SCROLLBAR_ALWAYS, JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
}

public void iniciarApp() {
Foro f = new Foro();
String OPCION = JOptionPane.showInputDialog("Ingrese el valor de la operación que desea realizar:"
+ "\n1. Guardar en archivo"
+ "\n2. Leer archivo"
+ "\n3. Eliminar archivo"
+ "\n4. Modificar archivo"
+ "\n5. Salir");
int opcion = Integer.parseInt(OPCION);
f.eleccion(opcion);
}

public void iniciarFrame() {
frame.setBounds(300, 300, 300, 300);
frame.setLocationRelativeTo(null);
frame.setVisible(true);
frame.setDefaultCloseOperation(EXIT_ON_CLOSE);
frame.setLayout(new BorderLayout());
}

private void boton(java.awt.event.ActionEvent evento) {
frame.setVisible(false);
Guardar();
}

private void boton2(java.awt.event.ActionEvent evento) {
frame.setVisible(false);
iniciarApp();
}

public void Componentes() {
iniciarFrame();
txtArea.setEditable(true);
frame.add(scroll, BorderLayout.CENTER);
txtArea.setLineWrap(true);
txtArea.setWrapStyleWord(true);
boton.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
boton(evt);
}
});
boton2.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
boton2(evt);
}
});
}

public void Guardar() {
try {
nombre = JOptionPane.showInputDialog("Ingrese el nombre del archivo:");
FileOutputStream f = new FileOutputStream(nombre + ".txt");
DataOutputStream d = new DataOutputStream(f);

d.writeBytes(txtArea.getText());

JOptionPane.showMessageDialog(null, "El archivo se ha guardado en\nla misma ruta donde se encuentra\neste programa");
iniciarApp();

} catch (Exception ex) {
ex.printStackTrace();
}
}

public void Leer() {
try {
nombre = JOptionPane.showInputDialog("Ingrese el nombre del archivo:");
FileInputStream file = new FileInputStream(nombre + ".txt");
BufferedReader bf = new BufferedReader(new InputStreamReader(file));

while (true) {
String cadena = bf.readLine();
if (cadena == null) {
break;
} else {
iniciarFrame();
Componentes();
txtArea.setEditable(false);
txtArea.setText(cadena);
}
}
} catch (Exception ex) {
JOptionPane.showMessageDialog(null, "ERROR", "XXXXX", JOptionPane.ERROR_MESSAGE);
iniciarApp();
}
}

public void Modificar() {
try {
nombre = JOptionPane.showInputDialog("Ingrese el nombre del archivo:");
FileInputStream file = new FileInputStream(nombre + ".txt");
BufferedReader bf = new BufferedReader(new InputStreamReader(file));

while (true) {
String cadena = bf.readLine();
if (cadena == null) {
break;
} else {
iniciarFrame();
Componentes();
txtArea.setEditable(true);
txtArea.setText(cadena);
}
}
} catch (Exception ex) {
JOptionPane.showMessageDialog(null, "ERROR", "XXXXX", JOptionPane.ERROR_MESSAGE);
iniciarApp();
}
}

public void Borrar() {
try {
nombre = JOptionPane.showInputDialog("Ingrese el nombre del archivo a borrar:");
File f = new File(nombre + ".txt");

if (f.delete()) {
JOptionPane.showMessageDialog(null, "El fichero ha sido borrado");
iniciarApp();
} else {
JOptionPane.showMessageDialog(null, "El fichero no ha sido borrado.\nAsegúrese de que el nombre esté\nescrito correctamente");
iniciarApp();
}
} catch (Exception ex) {
ex.printStackTrace();
}

}

public void eleccion(int op) {
switch (op) {
case 1:
iniciarFrame();
Componentes();
frame.add(boton, BorderLayout.SOUTH);
break;
case 2:
Leer();
frame.add(boton2, BorderLayout.SOUTH);
break;
case 3:
Borrar();
break;
case 4:
Modificar();
frame.add(boton, BorderLayout.SOUTH);
break;
case 5:
System.exit(0);
break;
default:
JOptionPane.showMessageDialog(null, "OPCIÓN INVÁLIDA", "ERROR", JOptionPane.ERROR_MESSAGE);
iniciarApp();
}
}

public static void main(String[] args) {
Foro f = new Foro();
f.iniciarApp();
}

}

A CONTINUACIÓN NUESTRO EQUIPO RESPONDERA LAS SIGUIENTES PREGUNTAS ESPERAMOS Y SEAN CORRECTAS  

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.

RESPUESTA 1) ARCHIVO 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. Por ejemplo los archivos informáticos que almacenan texto formateado o fotografías, así como los archivos ejecutables que contienen programas.
VENTAJAS: 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.

DESVENTAJAS : 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.


ARCHIVO DE TEXTO: Un archivo de texto simple, texto sencillo o texto sin formato (a veces usando calcos léxicos como texto llano o texto simple; es un archivo informático que contiene únicamente texto formado solo por caracteres que son legibles por humanos, careciendo de cualquier tipo de formato tipográfico.1 El término texto llano proviene de una traducción literal del término inglés «plain text», término que en lengua castellana significa texto simple o texto sencillo.
VENTAJAS: 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.

DESVENTAJAS: 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: En un archivo de acceso secuencial es posible leer o escribir un cierto número de datos comenzando siempre desde el principio del archivo. También es posible añadir datos a partir del final del archivo.

VENTAJAS: 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.

DESVENTAJAS: 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.

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

package archivo1;
import java.io.*;

public class Archivo1 {

 public static void main(String[] args) {
     try { FileOutputStream f;
     f=new FileOutputStream ("cartita.txt");
     DataOutputStream d;
     d= new DataOutputStream (f);
     
     d.writeBytes("Bienvenidos...\n");
     d.writeBytes("...a mi primer archivo...");
     
     d.close();
     f.close();
     
     }
     catch(Exception exc){ System.out.println("ERROR:"+exc);
     }
     try {
     FileInputStream f;
     f= new FileInputStream("datos.txt");
     BufferedReader d;
     d= new BufferedReader (new InputStreamReader(f));
    String cadena=d.readLine();
    String cadena2=d.readLine();
    int num= Double.valueOf(cadena2).intValue(); num++;
         System.out.println("nombre:" + cadena);
         System.out.println("edad:" + cadena2 + "\nprox edad" + num);
         //d.close ();
         f.close();
     } catch (Exception exc){System.out.println("error:" + exc);}

}
}


3) De acuerdo con el reactivo o práctica anterior, haciendo uso del lenguaje de programación recomendado por el facilitador (Java), debe implementar las diferentes operaciones que se pueden realizar para manipular información de un archivo, pero en este caso, debe distinguir los tipos de archivo de texto respecto a los binarios. Escriba código fuente y comparta en este foro.

package binario1;

import java.io.*;
import java.net.*;


public class Binario1 {

   
   public static void main(String chidoone[]) {
       //System.out.println ("" +chidoone[0]);
       
  try {  FileInputStream f;
  f= new FileInputStream ("datosbinarios.txt");
      DataInputStream d;
    d= new DataInputStream  (f);
    int n=d.readInt();
    double num= d.readDouble();
    char c= d.readChar();
    byte b= d.readByte();
     System.out.println("\n" + n + "\n" + num + "\n" + b +"\n");
                         
   
    d.close(); f.close();
  }
    catch(Exception exc) {System.out.println("error"+ exc);}
 
     
       
       
   }
   
}



LOS CREDITOS SON PARA EL M.C EDGAR RANGEL LUGO, POR LOS DICHOS CODIGOS FUERON ENSEÑADOS POR EL MISMO.


ATT: LAS COMADREJAS  

INTEGRANTES DEL EQUIPO LA COMADREJA: MARIO DE JESUS CARRANZA DIAZ
                                                         MARCO ANTONIO VALLE TOLEDO
                                                         DOMINGO ANTUNEZ SALGADO
DEL GRUPO "4A6"   DE LA CARRERA DE INGENIERIA EN INFORMATICA  

EL EQUIPO LOS DICHOSOS DARA UNA RESPONDERAN LA PREUNTA 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.
CUALQUIER DUDA O ACLARACION AL FINAL DE DICHO TRABAJO SE DEJARA EL SITIO WEB DEL AUTOR DONDE SE TOMO LA INFORMACION.
Archivo de
video: Son los que suelen obtener a partir de alguna cámara de video digital, o aún cuando esta se encuentre instalada en una PC o celular. El formato en el que se guardan estos datos puede ser avi, mpg o mov.






Archivos de animación: Son los que pueden realizarse desde una computadora y pueden ser reproducido con cualquiera de ellas, siempre y cuando se tenga instalado Flash o un navegador de Internet que permita la ejecución de los mismos. Algunos de los formatos que se utilizan para almacenar a los archivos de animación son el HTML, que se trata de una serie de etiquetas y códigos que pueden diseñar páginas dinámicas, a partir de la utilización del programador denominado Php. Flash es otro de los formatos utilizados, y se caracteriza por permitir la realización y reproducción de animaciones.






Archivo de imagen: Aquellos archivos que se obtienen a partir de la utilización de alguna cámara digital, incluso de aquellas que vienen incluidas en la computadora o en el celular. Aunque también, se puede obtener este archivo a partir de un scanner. Estos archivos se pueden almacenar en distintos formatos. Algunos de ellos son Gif, que es aquel archivo que puede ser comprimido y que usa hasta 256 colores. También, en formato Bitman, que se caracterizan por ser archivos de gran tamaño. Por otro lado, existe el formato Exif, que es aquel que se utiliza para almacenar fotografías de manera comprimida. Otro de los formatos más usados es el Jpeg, que puede usar hasta 16 millones de colores, pero que no puede almacenar ni animaciones ni transparencias. Además, este formato ocupa poco espacio, pero trae como consecuencia que la calidad de la imagen se vea reducida. Otro formato de sonido es el Bmp, que si bien almacena imágenes, no es adecuado para enviarlos por Internet.

Archivo de texto: Son los que se pueden obtener a partir de un scanner o desde el teclado de una computadora. Para poder acceder a ellos también es necesario contar con un programa que permita abrirlos, como por ejemplo Microsoft Office Word, Free Editor, Wondershare PDF Converter o Coolreader, entre otros. Algunos de los formatos más frecuentes son el Otd, que es abierto, por lo que puede ser abierto desde cualquier sistema operativo. Doc, en cambio, es un formato cerrado y que sólo puede accederse a él si se tiene Microsoft Office Word.

Archivo de sonido: Esta clase de archivo es la que almacena señales sonoras a partir de una serie de datos binarios. Esta información digital suele ser gravada a partir de un micrófono, grabador de voz, celular o PC, entre otros dispositivos. Algunos de los formatos en los que se puede almacenar esta clase de archivos son los siguientes: mp3, mp4 o m3u, y se caracterizan por ocupar poco espacio ya que se tratan de formatos reducidos que pueden mantener la calidad del sonido.


Derechos Reservados

Está permitido el uso de los contenidos, siempre y cuando se reconozca con un enlace a este artículo, como fuente de información.

Fuente: http://www.tipos.co/tipos-de-archivo/#ixzz4ZNnYFmjR

EL EQUIPO LOS DICHOSOS DARA UNA RESPONDERAN LA PREUNTA 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.
CUALQUIER DUDA O ACLARACION AL FINAL DE DICHO TRABAJO SE DEJARA EL SITIO WEB DEL AUTOR DONDE SE TOMO LA INFORMACION. Cool Cool affraid afro
Archivo de
video: Son los que suelen obtener a partir de alguna cámara de video digital, o aún cuando esta se encuentre instalada en una PC o celular. El formato en el que se guardan estos datos puede ser avi, mpg o mov.






Archivos de animación: Son los que pueden realizarse desde una computadora y pueden ser reproducido con cualquiera de ellas, siempre y cuando se tenga instalado Flash o un navegador de Internet que permita la ejecución de los mismos. Algunos de los formatos que se utilizan para almacenar a los archivos de animación son el HTML, que se trata de una serie de etiquetas y códigos que pueden diseñar páginas dinámicas, a partir de la utilización del programador denominado Php. Flash es otro de los formatos utilizados, y se caracteriza por permitir la realización y reproducción de animaciones.






Archivo de imagen: Aquellos archivos que se obtienen a partir de la utilización de alguna cámara digital, incluso de aquellas que vienen incluidas en la computadora o en el celular. Aunque también, se puede obtener este archivo a partir de un scanner. Estos archivos se pueden almacenar en distintos formatos. Algunos de ellos son Gif, que es aquel archivo que puede ser comprimido y que usa hasta 256 colores. También, en formato Bitman, que se caracterizan por ser archivos de gran tamaño. Por otro lado, existe el formato Exif, que es aquel que se utiliza para almacenar fotografías de manera comprimida. Otro de los formatos más usados es el Jpeg, que puede usar hasta 16 millones de colores, pero que no puede almacenar ni animaciones ni transparencias. Además, este formato ocupa poco espacio, pero trae como consecuencia que la calidad de la imagen se vea reducida. Otro formato de sonido es el Bmp, que si bien almacena imágenes, no es adecuado para enviarlos por Internet.

Archivo de texto: Son los que se pueden obtener a partir de un scanner o desde el teclado de una computadora. Para poder acceder a ellos también es necesario contar con un programa que permita abrirlos, como por ejemplo Microsoft Office Word, Free Editor, Wondershare PDF Converter o Coolreader, entre otros. Algunos de los formatos más frecuentes son el Otd, que es abierto, por lo que puede ser abierto desde cualquier sistema operativo. Doc, en cambio, es un formato cerrado y que sólo puede accederse a él si se tiene Microsoft Office Word.

Archivo de sonido: Esta clase de archivo es la que almacena señales sonoras a partir de una serie de datos binarios. Esta información digital suele ser gravada a partir de un micrófono, grabador de voz, celular o PC, entre otros dispositivos. Algunos de los formatos en los que se puede almacenar esta clase de archivos son los siguientes: mp3, mp4 o m3u, y se caracterizan por ocupar poco espacio ya que se tratan de formatos reducidos que pueden mantener la calidad del sonido.


Derechos Reservados

Está permitido el uso de los contenidos, siempre y cuando se reconozca con un enlace a este artículo, como fuente de información.

Fuente: http://www.tipos.co/tipos-de-archivo/#ixzz4ZNnYFmjR
lol! lol!


EQUIPO LOS DICHOSOS

INTEGRANTES:
ERNESTO ECHEVERRIA.
ADIEL HERNANDEZ.
HERNAN SANTANA.
PABLO FORTUNATO.

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 BINARIO:
Es una archivo informático que contiene información de cualquier tipo, codificada en forma binaria para el propósito de almacenamiento y procesamiento de ordenadores.
CARACTERISTICAS:
Un archivo binario, es un archivo cuyo contenido usa exactamente la misma representación que utiliza el computador internamente para representar la información. El contenido de un archivo binario no está pensado para ser entendible por humanos. Si es abierto con el Bloc de Notas, generalmente se verá sólo símbolos ininteligibles. Internamente, muchos computadores representan los números enteros usando cuatro bytes. Cada byte está formado por ocho bits (unos o ceros). Las diferentes combinaciones de los treinta y dos bits permiten representar 232 números diferentes.
VENTAJAS:
*Ocupa menos espacio
*Fácil de entender dónde empieza y donde terminan los datos.
*Tiene la facilidad de manipular cualquier tipo de dato.
* Simpleza al guardar y escribir los datos.
DESVENTAJAS:
*Hacen falta editores o herramientas especiales (como las herramientas de localización de software) para editar estos archivos.

ARCHIVO DE TEXTO:
Los archivos de texto plano  son aquellos que están compuestos únicamente por texto sin formato, sólo caracteres. Estos caracteres se pueden codificar de distintos modos dependiendo de la lengua usada.
CARACTERISTICAS:
Cualquier archivo puede abrirse como texto plano desde un editor de texto. Obviamente si se abriera un archivo de música MP3, una persona no entendería su contenido. En cambio sí se abre un archivo HTML como texto plano, se vería el texto de la página web y todas las etiquetas que, procesadas, le darían un formato.
VENTAJAS:
*Tiene mayor facilidad para escribir
*Se puede borrar, mover o agregar, párrafos o  bloques de texto.
*Permite la corrección de errores ortográficos y gramaticales.
DESVENTAJAS:
*La única desventaja seria el aprender a utilizar estas herramientas.

ARCHIVOS DE ACCESO SECUENCIAL:
Es la forma básica de organizar un conjunto de registros, que forman un archivo, utilizando una organización secuencial.
CARACTERISTICAS:
En un archivo de acceso secuencial es posible leer o escribir un cierto número de datos comenzando siempre desde el principio del archivo. También es posible añadir datos a partir del final del archivo (habrá que recorrer todo el archivo => poca eficiencia).
VENTAJAS:
* 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.
*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.
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ódigo:


import java.io.*;
 
class LeeFichero {
   public static void main(String [] arg) {
      File archivo = null;
      FileReader fr = null;
      BufferedReader br = null;
 
      try {
         // Apertura del fichero y creacion de BufferedReader para poder
         // hacer una lectura comoda (disponer del metodo readLine()).
         archivo = new File ("C:\\archivo.txt");
         fr = new FileReader (archivo);
         br = new BufferedReader(fr);
 
         // Lectura del fichero
         String linea;
         while((linea=br.readLine())!=null)
            System.out.println(linea);
      }
      catch(Exception e){
         e.printStackTrace();
      }finally{
         // En el finally cerramos el fichero, para asegurarnos
         // que se cierra tanto si todo va bien como si salta  
         // una excepcion.
         try{                    
            if( null != fr ){    
               fr.close();      
            }                  
         }catch (Exception e2){  
            e2.printStackTrace();
         }
      }
   }
}
 
 

LA INFORMACION Y CODIGO AQUI PLASMADOS SON OBRA DEL M.C. EDGAR RANGEL LUGO, QUIENNOS PROPORCIONÓ LA INFORMACION NECESARIA PARA LA REALIZACION Y COMPRESION DE DICHO TRABAJO.


ATTE: the amazing
integrantes:
Ernesto Quintín García Pineda
Evelia Maldonado Miranda
Paola Rubí Benítez Bartolo

////////////////////////////////////////////////////////TABLA COMPARATIVA//////////////////////////////////////////////////////////////////////////////

Desventajas:

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