Index / Java / Proyectos / Leer y Escribir registros en archivo de texto

Leer y Escribir registros en archivo de texto

Autor jc mouse jueves, mayo 3, 2012

A veces se necesita utilizar archivos de texto plano como contenedor de registros como si de una base de datos se tratara, formas de hacer esto hay varias y depende de cada quien, aquí te traigo este proyecto que muestra una forma de resolver este problema.

Si los campos no son muchos, podemos agrupar los registros en lineas separando los campos por algún carácter, por ejemplo una coma «,», de esta forma podemos almacenar los registros así:

00001,Zutanito,z34@gmail.com
00002,Menganito,menzo@hotmail.com
00003, , any@yahoo.es

Como vemos tenemos 3 registros separados cada uno de ellos en una linea y cada registro tiene 3 campos (ID, Nombre, E-Mail), cuando agregamos un nuevo registro, este ocupara una linea nueva, si deseamos leer un registro, leemos una linea de texto y utilizamos el comando SPLIT de java para separar en un string cada campo.

Proyecto

IDE: Netbeans
Lenguaje: Java
Nivel: Intermedio
Tiempo: 15 minutos

Tutorial

1. Crea un nuevo proyecto en Netbeans de la siguiente forma. añade un Jframe (nombre: interfaz.java) y agrega los siguientes controles:

recuerda colocar los nombres a los objetos tal y cual está en la imagen

2. Crea una nueva clase, llamala «xFichero.java», añade el siguiente código:

01 package jcficheros;
02 import java.io.BufferedReader;
03 import java.io.File;
04 import java.io.FileNotFoundException;
05 import java.io.FileReader;
06 import java.io.IOException;
07 import java.io.PrintWriter;
08 import java.util.ArrayList;
09 import java.util.Iterator;
10 import javax.swing.JFileChooser;
11 import javax.swing.JOptionPane;
12 import javax.swing.JTextField;
13 import javax.swing.filechooser.FileNameExtensionFilter;
14 /**
15  * @web https://www.jc-mouse.net
16  * @author Mouse
17  */
18 public class xFichero {
19 
20     private JFileChooser fileChooser;
21     private FileNameExtensionFilter filter = new FileNameExtensionFilter("Archivo de Texto","txt");
22     private File file = null;
23     private boolean isopen =false;//bandera de control para saber si se abrio un archivo
24     private ArrayList contenido = new ArrayList();//almacena los registros leidos de *.txt
25     private int index = 0; //lleva control del registro actualmente visible
26     //controles swing
27     private JTextField id;
28     private JTextField nombre;
29     private JTextField mail;
30 
31     //Constructor de clase
32     public xFichero(){}
33 
34     public xFichero(JTextField id , JTextField nombre , JTextField mail )
35     {
36         this.id = id;
37         this.nombre = nombre;
38         this.mail = mail;
39         System.out.println("Creado por jc-Mouse");
40     }
41 
42     //Retorna el nombre del archivo abierto
43     public String getFileName()
44     {
45         if( file != null)
46             return file.getName();
47         else
48             return "Sin Titulo";
49     }
50 
51     /* Abre la cja de dialogo Guardar como
52  Input: String de la forma "campo1,campo2,campo3"
53  */
54     public void GuardarComo(String texto)
55     {       
56        fileChooser = new JFileChooser();
57        fileChooser.setFileFilter(filter);
58        int result = fileChooser.showSaveDialog(null);
59        if ( result == JFileChooser.APPROVE_OPTION ){
60                 this.isopen = false;
61                 this.contenido.clear();
62                 this.index=1;
63                 if ( escribir( fileChooser.getSelectedFile(),  texto) )
64                 {
65                     JOptionPane.showMessageDialog(null, "Archivo '" + fileChooser.getSelectedFile().getName() + "' guardado ");
66                     this.isopen=true;
67                 }
68         }
69     }
70 
71     /* Actualiza nuevo registro al final de la lista
72  * input: String de la forma "campo1,campo2,campo3"
73  */
74     public void Actualizar(String texto)
75     {
76         //Si existe archivo abierto
77         if( this.file != null)
78         {
79             if ( escribir( this.file ,  texto) )
80             {
81                 JOptionPane.showMessageDialog(null, "Archivo '" + this.file.getName() + "' actualizado ");
82             }                        
83         }
84         else //sino crear nuevo archivo
85         {            
86             GuardarComo( texto );
87         }
88     }
89 
90     /* Muestra la ventana de dialogo Abrir archivo
91  */
92     public void Abrir()
93     {
94      fileChooser = new JFileChooser();
95        fileChooser.setFileFilter(filter);
96        //fileChooser.setCurrentDirectory(new java.io.File("e:/")); 
97        int result = fileChooser.showOpenDialog(null);
98        if ( result == JFileChooser.APPROVE_OPTION ){
99                 this.file = fileChooser.getSelectedFile();                
100                 leer( this.file );
101                 this.isopen=true;
102         }
103     }
104 
105     /* Función que escribe un registro en el archivo de texto
106  * Si el archivo ya contaba con registros re-escribe estos y al final
107  * escribe el nuevo registro
108  */
109     private boolean escribir(File fichero, String texto)
110     {
111         boolean res=false;        
112         PrintWriter writer = null;
113         try {
114             String f = fichero.toString();
115             //verifica que extension exista sino lo agrega
116             if(!f.substring( f.length()-4, f.length()).equals(".txt") )
117             {
118                 f = f + ".txt";
119                 fichero = new File(f);
120             }            
121             writer = new PrintWriter( fichero );
122             //si hay un archivo abierto
123             if( this.isopen )
124             {   //añade primero linea por linea conenido anterior
125                 Iterator It = contenido.iterator();
126                 while (It.hasNext())
127                 {
128                     writer.println( It.next() );
129                 }
130                 //se añade fila de texto al archivo
131                 writer.println( texto );
132                 this.contenido.add(texto);
133             }
134             else //esta guardando por primera vez
135             {
136                 this.contenido.add(texto);
137                 writer.println( texto );    
138             }            
139             this.file = fichero;
140             writer.close();            
141             res = true;
142         } catch (FileNotFoundException ex) {
143             System.out.println("Error:" + ex);
144         } finally {
145             writer.close();
146         }
147         return res;
148     }
149 
150     /* Lee linea por linea un archivo de texto y almacena los registros
151  * en un ArrayList segun orden de lectura
152  * input: File
153  */
154     public boolean leer( File fichero )
155     {
156         BufferedReader reader = null;
157         try {
158             reader = new BufferedReader(new FileReader(fichero));
159             this.contenido.clear();
160             String linea;
161             while ( (linea = reader.readLine() ) != null) {                
162                 this.contenido.add( linea );
163             }
164             //muestra el primer registro en la interfaz
165             Siguiente();
166             return true;
167         } catch (IOException ex) {
168             System.out.println("Error: " + ex);
169         }  finally {
170             try {
171                 reader.close();
172             } catch (IOException ex) {
173                 System.out.println("Error: " + ex);
174             }
175         }
176         return false;
177     }
178 
179     /* funcion qye avanza al siguiente registro del ArrayList y lo muestra en pantalla
180  */
181     public void Siguiente()
182     {
183         if( this.file != null )
184         {
185         //incrementa en 1 la variable "index", si se supera el tamaño de lineas, vuelve a valor 1
186         this.index = (index>=contenido.size())? 1 : index + 1;
187         int count =1;
188         Iterator It = contenido.iterator();
189         //comienza busqueda
190         while (It.hasNext())
191         {
192             String tmp = It.next().toString();
193             if( count == index)//si lo encuentra asiga valores
194             {   //separa el registro por campos. Separador = ","
195                 String[] datos = tmp.split(",");                                
196                 this.id.setText(datos[0]);
197                 this.nombre.setText(datos[1]);
198                 this.mail.setText(datos[2]);
199                 break;
200             }
201             count ++;
202         }
203         }
204     }
205 
206 }

Esta clase es la en cargada de gestionar la lectura y escritura de los registros.

3. En la clase interfaz.java debes añadir el siguiente código:

    //instancia de clase
    private xFichero file;

    /** Creates new form interfaz */
    public interfaz() {
        initComponents();
        this.setLocationRelativeTo(null);
        //crea la instancia pasando como parametros los controles JTextField
        file = new xFichero( this.txtID, this.txtNombre, this.txtCorreo );
        this.setTitle("" + file.getFileName() + " - NotePASes [https://www.jc-mouse.net/]");
    }

    private void mGuardarComoActionPerformed(java.awt.event.ActionEvent evt) {                                             
        String datos = this.txtID.getText() + "," + this.txtNombre.getText() + "," + this.txtCorreo.getText();
        file.GuardarComo(datos);
        this.setTitle("" + file.getFileName() + " - NotePASes [https://www.jc-mouse.net/]");
    }                                            

    private void mAbrirActionPerformed(java.awt.event.ActionEvent evt) {                                       
         file.Abrir();
         this.setTitle("" + file.getFileName() + " - NotePASes [https://www.jc-mouse.net/]");
    }                                      

    private void mSgteActionPerformed(java.awt.event.ActionEvent evt) {                                      
        file.Siguiente();
    }                                     

    private void mGuardarActionPerformed(java.awt.event.ActionEvent evt) {                                         
        String datos = this.txtID.getText() + "," + this.txtNombre.getText() + "," + this.txtCorreo.getText();
        file.Actualizar(datos);
        this.setTitle("" + file.getFileName() + " - NotePASes [https://www.jc-mouse.net/]");
    }

Importante: No copies y pegues, sino toma tu tiempo de estudiar el código y ver donde va cada pedazo de código.

Para terminar ejecuta el proyecto 🙂

Descargate el proyecto desde AQUI

También Te Podría Interesar

CUF: Código Único en Kotlin

En este post implementamos en lenguaje Kotlin (lenguaje de programación de tipado estático que corre sobre la máquina vi...

iFrame Injection – Ocultar código malicioso

En ocasiones los administradores de sitios web experimentan problemas de lentitud en su carga o en el peor de los casos...

Material Design: Paleta de Colores

«Material Design es una guía integral para el diseño visual, de movimientos y de interacción en distintas plataformas y...

Software Libre: Decompilador Java

El proyecto «Java Decompiler» tiene como objetivo desarrollar herramientas para descompilar y analizar byte code de jav...

Detectar un punto dentro de un polígono HTML5

En un ejemplo anterior [Seleccionar y mover shapes en html5] se utilizo un método sencillo para detectar si un punto se...

Animación con sprites y LibGDX

En este post veremos una pequeña introducción a lo que son las animaciones con LibGDX y el uso de sprites. ¿Que es la an...

2 comentarios en “Leer y Escribir registros en archivo de texto”

Andres Felipe dice:

4 marzo, 2013 a las 15:58

Muchas gracias por la información, respecto a esta tengo una consulta:

Tengo un formulario, el cual esta conformado por una variedad de: jTextField, jComboBox, jRadioButton y jCheckBox. Y lo que requiero es guardar toda esta informacion en un solo archivo con posibilidad de cargarlo para futuras modificaciones o ejecutar procesos de calculo. Si me puedes orientar y/o ayudar a como se debe realizar este codigo te lo agradezco. Que tenga un buen día.
1. Mouse dice:
  
  9 marzo, 2013 a las 1:54
  
  bien podrías utilizar un archivo de texto con un registro por linea, osea:
  
  1 | campo1 | campo2 | campo3 |
  2 | campo1 | campo2 | campo3 |
  
  cuando recuperes los datos los partes con split y ya puedes trabajar con ellos, lo malo es que a la hora de actualizar, te complicas o.O
  
  lo ideal es utilizar un archivo XML si es que no quieres utilizar una base de datos portable, java cuenta con buenas librerias para manipular XML tanto en lectura como escritura 🙂