Universidad de las Fuerzas Armadas – ESPE
PROGRAMACION ORIENTADA A OBJETOS
Jaime Cabezas, Samuel Flores, Pamela Tapia, Anthony Yánez
Fecha: 12 de marzo del 2024 NRC: 13929
Persistencia de datos (Manejo de archivos)
OBJETIVOS
1. Comprender los fundamentos de la persistencia de datos a través del manejo de
archivos
2. Explorar las técnicas de lectura y escritura de archivos en Java
3. Analizar los diferentes tipos de archivos utilizados en la persistencia de datos
MARCO TÉORICO
Un objeto se dice persistente cuando es almacenado en un archivo u otro medio permanente. A
diferencia de C++ que sólo soporta persistencia a través de bibliotecas propietarias por lo cual
su portabilidad y generalidad es limitada, Java se provee un mecanismo de serialización para
almacenar objetos en disco.
El manejo de archivos en la persistencia de datos es un aspecto fundamental en el desarrollo
de software, ya que permite almacenar y recuperar información de forma permanente. En este
marco teórico, se abordarán tres temas principales relacionados con el manejo de archivos:
lectura, escritura y tipos de archivos.
Lectura de archivos:
La lectura de archivos es el proceso de obtener datos almacenados en un archivo y cargarlos
en la memoria para su posterior procesamiento. En el contexto de la programación orientada a
objetos (POO), la lectura de archivos se realiza utilizando clases y métodos proporcionados por
el lenguaje de programación. Por ejemplo, en Java, se pueden utilizar clases como FileReader,
BufferedReader, Scanner, entre otras, para leer archivos de texto plano.
Durante el proceso de lectura de archivos, es importante manejar adecuadamente las
excepciones que pueden surgir, como archivos no encontrados o errores de lectura. Además,
es fundamental cerrar correctamente los flujos de lectura una vez que se ha completado la
operación para liberar recursos del sistema.
Escritura de archivos:
La escritura de archivos implica guardar datos en un archivo en el sistema de archivos del
sistema operativo. Al igual que la lectura, la escritura de archivos se puede realizar utilizando
clases y métodos proporcionados por el lenguaje de programación. En Java, por ejemplo, se
pueden utilizar clases como FileWriter, BufferedWriter, entre otras, para escribir datos en
archivos de texto plano.
Durante el proceso de escritura de archivos, es importante tener en cuenta la codificación de
caracteres adecuada para garantizar la compatibilidad entre diferentes sistemas y aplicaciones.
También es fundamental manejar excepciones relacionadas con la escritura de archivos, como
problemas de permisos de escritura o falta de espacio en disco.
Tipos de archivos:
Existen varios tipos de archivos utilizados en la persistencia de datos, cada uno con sus
propias características y aplicaciones. Los tipos de archivos más comunes incluyen:
Archivos de texto plano: Son archivos que contienen datos legibles por humanos en
forma de texto sin formato. Son ampliamente utilizados para almacenar datos simples y
son compatibles con una variedad de plataformas y aplicaciones.
Archivos binarios: Son archivos que contienen datos en forma de secuencias de bytes
que representan información de forma compacta y eficiente. Los archivos binarios son
adecuados para almacenar datos complejos, como imágenes, videos, archivos de
audio, bases de datos, entre otros.
Archivos estructurados: Son archivos que contienen datos organizados de acuerdo con
una estructura específica, como archivos JSON (JavaScript Object Notation) o XML
(eXtensible Markup Language). Estos archivos son utilizados para intercambiar datos
entre diferentes sistemas y aplicaciones de manera legible y estructurada.
En resumen, el manejo de archivos en la persistencia de datos es un aspecto crucial en el
desarrollo de software. Comprender los conceptos de lectura, escritura y los diferentes
tipos de archivos es fundamental para garantizar el almacenamiento y recuperación
eficientes de datos en las aplicaciones.
PROGRAMA
- Código del programa main:
package registro_de_usuario;
import [Link];
import [Link].*;
public class Registro_de_usuario {
public static void main(String[] args) throws IOException {
Scanner escaneo = new Scanner([Link]);
//Declaracion Writer Mejorado
BufferedWriter writer = new BufferedWriter(new FileWriter ("[Link]", true));//true sirve
para no sobre escribir datos
//Declaracion Reader Mejorado
BufferedReader reader = new BufferedReader(new FileReader("[Link]"));
//Encabezado
[Link]("\n\tREGISTRO DE USUARIO");
[Link]("\n\t===================");
[Link]();
//Registro de Usuario
Usuario U1 = new Usuario();
[Link]();
[Link]([Link]());
[Link]("\n");
[Link]([Link]());
[Link]("\n");
[Link]([Link]([Link]()));
[Link]("\n");
[Link]([Link]([Link]()));
[Link]("\n\n");
int op = 0;
do{
[Link]("\nDesea Registrar otro Usuario?:");
[Link]("\n1. Si");
[Link]("\n2. No\n");
op = [Link]();
switch(op){
case 1:
Usuario U2 = new Usuario();
[Link]();
[Link]([Link]());
[Link]("\n");
[Link]([Link]());
[Link]("\n");
[Link]([Link]([Link]()));
[Link]("\n");
[Link]([Link]([Link]()));
[Link]("\n\n");
break;
case 2:
[Link]("\nLos Usuarios se han guardado correctamente :D");
break;
default:
[Link]("\nRespuesta No Valida.");
}while(op != 2);
//Finalizar Writer
[Link]();
//Uso Reader
[Link]("\n\tUsuarios del Archivo");
[Link]("\n\t====================");
Usuario U3 = new Usuario();
int nomlinea = 1;
int apelinea = 2;
int edadlinea = 3;
int codlinea = 4;
String linea;
int contador = 1;
while ((linea = [Link]()) != null) {
if (contador == nomlinea) {
[Link](linea);
}else if(contador == apelinea){
[Link](linea);
}else if(contador == edadlinea){
[Link]([Link](linea));
}else if(contador == codlinea){
[Link]([Link](linea));
break;
contador++;
[Link]( "\[Link] Guardado en Objeto: " );
[Link]();
//Finalizar Reader
[Link]();
- Clase Usuario
package registro_de_usuario;
import [Link];
import [Link];
public class Usuario {
//Atributos
private String nombre;
private String apellido;
private int edad;
private int cod;
//Metodos
//Getters
public String getNombre() {
return nombre;
public String getApellido() {
return apellido;
public int getEdad() {
return edad;
public int getCod() {
return cod;
//Setters
public void setNombre(String nombre) {
[Link] = nombre;
public void setApellido(String Apellido) {
[Link] = Apellido;
public void setEdad(int edad) {
[Link] = edad;
public void setCod(int cod) {
[Link] = cod;
}
//Constructor
public Usuario(){
setNombre("");
setApellido("");
setEdad(0);
setCod(0);
//Lectura de Datos
public void LeerDatos(){
Scanner escaneo = new Scanner([Link]);
//Ingreso Nombre
[Link]("\n. Ingrese su Nombre: ");
nombre = [Link]();
//Ingreso Apellido
[Link]("\n. Ingrese su Apellido: ");
apellido = [Link]();
//Ingreso Edad con Validación
boolean ingvalido = false;
while (!ingvalido){
try {
[Link]("\n. Ingrese su Edad: ");
edad = [Link]();
if (edad <= 0){
throw new ArithmeticException();
ingvalido = true;
}catch(InputMismatchException e){
[Link]("\nERROR: Edad No Valida.\[Link] de Nuevo ");
[Link]();
}catch(ArithmeticException e){
[Link]("\nERROR: Edad No Valida.\[Link] de Nuevo ");
[Link]();
RamdomCode();
//Codigo de Usuario Random
public void RamdomCode(){
cod = (int)([Link]()*(100+150)+1);
//Imprimir Datos
public void ImprimirDatos(){
[Link]("\n. Nombre: " + getNombre());
[Link]("\n. Apellido: " + getApellido());
[Link]("\n. Edad: " + getEdad());
[Link]("\n. Codigo: " + getCod());
}
- Ejecución del Programa
CONCLUSIONES
1. La persistencia de datos es un aspecto fundamental en el desarrollo de
software, ya que permite que los programas almacenen y recuperen datos de
forma permanente. Mediante el manejo de archivos, los desarrolladores
pueden garantizar la integridad y durabilidad de la información generada y
manipulada por sus aplicaciones.
2. Existen diversas técnicas y herramientas disponibles para implementar la
persistencia de datos mediante el manejo de archivos. Desde el uso de flujos
de bytes y caracteres en Java, hasta la utilización de formatos de archivos
específicos como CSV, JSON o XML, se dispone de una amplia gama de
opciones para almacenar y recuperar datos de manera eficiente.
3. Al implementar la persistencia de datos mediante el manejo de archivos, es
importante tener en cuenta consideraciones de diseño y rendimiento. La
elección del tipo de archivo adecuado, así como la optimización de los
procesos de lectura y escritura, pueden tener un impacto significativo en el
rendimiento y la escalabilidad de una aplicación. Además, es fundamental
garantizar la seguridad y la integridad de los datos almacenados, así como
manejar adecuadamente los errores y excepciones que puedan surgir durante
el proceso de persistencia.
Bibliografías:
IBM documentation. (s. f.). [Link]
java-persistence-api-jpa
FileReader - referencia de la API Web | MDN. (2023, 20 febrero). MDN Web Docs.
[Link]
Hartman, J. (2023, 26 diciembre). Java BufferedReader: How to Read File in Java with
Example. Guru99. [Link]
utm_campaign=click&utm_medium=referral&utm_source=relatedarticles#:~:te
xt=Que%20es%20BufferedReader%20en%20Java,problemas%20caracteres
%2C%20matrices%20o%20l%C3%ADneas.
