Java - lectura archivos txt

 
Vista:

lectura archivos txt

Publicado por Alba (4 intervenciones) el 13/06/2021 11:55:49
Necesito saber como leer un archivo .txt en java y que me lo muestre en una interfaz
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder

lectura archivos txt

Publicado por Laura (4 intervenciones) el 14/06/2021 07:15:21
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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
public static int contarlineas(String ruta) {
 
 
    int lineas = 0;
 
 
    File fichero = new File(ruta);
    try {
        Scanner sc = new Scanner(fichero);
 
 
        while (sc.hasNextLine()) {
            sc.nextLine();
            lineas++;
        }
 
 
        sc.close();
 
    } catch (FileNotFoundException e) {
        // e.printStackTrace();
        System.out.println("ERROR: No se puede abrir el fichero.");
    }
 
    return lineas;
}
public static int contarcolumnas (String ruta) {
 
 
    int columnas = 0;
    String fila = "0";
 
 
    File Ficherolaberinto= new File(ruta);
    try {
        Scanner sc = new Scanner(Ficherolaberinto);
 
        // Bucle while para coger una linea
        while (sc.hasNextLine()) {
            fila = sc.nextLine();
 
        }
 
 
        sc.close();
 
    } catch (FileNotFoundException e) {
        // e.printStackTrace();
        System.out.println("ERROR: No se puede abrir el fichero.");
    }
 
 
    columnas = fila.split(";").length;
 
    return columnas;
}
 
 
 
public static String[][] importar_datos (String ruta) {
 
    // Inicializamos el array
    String[][] datos = {};
 
    // Pasamos las líneas del fichero al array
    File fichero = new File(ruta);
    try {
        Scanner sc = new Scanner(fichero);
 
        // Instanciamos el array
        datos = new String[contarlineas(ruta)][contarcolumnas(ruta)];
 
        // Inicialización
        int i = 0;
        String fila = "0";
        String[] array_fila = {};
 
 
        while (sc.hasNextLine()) {
 
            // Cogemos una fila y la insertamos en un array
            fila = sc.nextLine();
            array_fila = fila.split(";");
 
            // Pasamos la información del array de fila
            for (int j = 0; j < array_fila.length; j++) {
                datos[i][j] = array_fila[j];
            }
            i++;
 
        }
 
 
        sc.close();
 
    } catch (FileNotFoundException e) {
        // e.printStackTrace();
        System.out.println("ERROR: No se puede abrir el fichero.");
    }
 
    return datos;
}
public void crearLaberinto (int anchoLaberinto){
 
 
 
    this.anchoLaberinto = anchoLaberinto;
    maze = importar_datos("Laberinto");
 
 
 
public void mostrarLaberinto(){
 
    for (int f=0; f<maze.length; f++) {
        for (int c=0; c<maze[f].length; c++) {
            System.out.print(maze [f][c]);
        }
        System.out.println();
    }
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////// tengo esa parte de código pero me dan estos errores
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 9 out of bounds for length 9
at model.Laberinto.importar_datos(Laberinto.java:129)
at model.Laberinto.crearLaberinto(Laberinto.java:150)
at Control.Sistema.main(Sistema.java:21)
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Kabuto
Val: 3.428
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

lectura archivos txt

Publicado por Kabuto (977 intervenciones) el 15/06/2021 01:08:56
A ver, copiar código sin entender lo que hace, no te va a ayudar en nada.

Para hacer lo que pides tienes que aprender dos cosas:
- Leer archivos de texto
- Crear una interfaz.

Veamos primero lo fácil, leer un texto.

Un archivo de texto se puede leer con la clase Scanner o con la clase BufferedReader.
Ambas sirven, yo tengo por costumbre usar BufferedReader.

Entonces, podemos crear una clase con un método estático que se dedique explícitamente a leer un fichero de texto y retornar las líneas del texto en un ArrayList de Strings.
Es más cómodo hacerlo estático porque así no hay que instanciar un objeto de esta clase. Como no queremos representar una "entidad" (una Persona, un Coche, un Empleado...), si no que solo necesitamos que nos proporcione un servicio (leer un texto), pues será más cómodo hacer un método estático para llamarlo cuando necesitemos de sus servicios.

Como parámetro (entre los paréntesis) le haremos llegar un String que contendrá la ruta en disco del fichero que ha de ser leído.

El valor de retorno será un ArrayList porque su tamaño puede ser variable y nos interesa esto, ya que no sabemos cuantas líneas tendrá el archivo.
Se podría usar un array primitivo, pero a estos hay que darles un tamaño fijo que no puede variar, así que no nos interesa ya que nunca sabremos de antemano cuántas líneas se van a leer.

Esta podría ser la clase, con el método estático:
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
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
 
public class LectorTXT {
 
	public static ArrayList<String> leerTXT(String rutaFichero) {
 
		//Aquí guardaremos las lineas leidas en el archivo txt
		ArrayList<String> lineas = new ArrayList<String>();
 
		try {
			BufferedReader lector = new BufferedReader(new FileReader(rutaFichero));
			//Leemos primera linea
			String linea = lector.readLine();
			while (linea != null) { //Mientras hayan lineas para leer...
				lineas.add(linea); //Añadimos linea leida al ArrayList
				linea = lector.readLine(); //Leemos la siguiente línea
			}
			//Ya no quedan lineas por leer
			lector.close(); //Cerramos lector
			return lineas; //Retornamos el ArrayList leido
 
		} catch (FileNotFoundException e) {
			System.out.println("No se encuentra fichero:\n" + rutaFichero);
			return null;
 
		} catch (IOException e) {
			System.out.println("Error accediendo a:\n" + rutaFichero);
			return null;
		}
	}
}


Y ahora en otra clase con un método main(), podemos ponerlo a prueba.
Recogemos el ArrayList que nos devuelve la invocación del método anterior y lo mostramos en pantalla.
Cabe la posibilidad de que no pueda leerse el archivo, porque hemos dado una ruta equivocada, por permisos de acceso de usuario...
En este caso el método devuelve valor null, así que hay que tenerlo en cuenta.

En esta prueba le pido que me lea un txt donde tengo un poema de Machado:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import java.util.ArrayList;
 
public class PruebaLector {
 
	public static void main(String[] args) {
 
		//Pedimos a nuesta clase lectora que nos lea un texto.
		ArrayList<String> texto = LectorTXT.leerTXT("d:/machado.txt");
 
		//Mostramos en pantalla el texto leído
		if (texto == null)
			System.out.println("No pudo leer el archivo de texto");
		else {
			System.out.println("Texto leído:\n");
			for (String linea: texto)
				System.out.println("\t" + linea);
		}
 
	}
 
}

Y en pantalla puedo comprobar que la lectura ha tenido éxito:
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
Texto leído:
 
	Anoche cuando dormía
	soñé, ¡bendita ilusión!,
	que una fontana fluía
	dentro de mi corazón.
 
	Di, ¿por qué acequia escondida,
	agua, vienes hasta mí,
	manantial de nueva vida
	de donde nunca bebí?
 
	Anoche cuando dormía
	soñé, ¡bendita ilusión!,
	que una colmena tenía
	dentro de mi corazón;
 
	y las doradas abejas
	iban fabricando en él,
	con las amarguras viejas
	blanca cera y dulce miel.
 
	Anoche cuando dormía
	soñé, ¡bendita ilusión!,
	que un ardiente sol lucía
	dentro de mi corazón.
 
	Era ardiente porque daba
	calores de rojo hogar,
	y era sol porque alumbraba
	y porque hacía llorar.
 
	Anoche cuando dormía
	soñé, ¡bendita ilusión!,
	que era Dios lo que tenía
	dentro de mi corazón.


Bien, pues esto es todo lo que necesita para leer un archivo de texto.
Revisa el código, pruébalo, asegúrate de entender la lógica que sigue y el significado de cada línea de código.
Pregunta si no es así.


Luego veremos como hacerlo con una interfaz. Pero primero ha de quedarte claro este primer paso.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Kabuto
Val: 3.428
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

lectura archivos txt

Publicado por Kabuto (977 intervenciones) el 15/06/2021 02:12:49
Si ya hemos entendido como leer un fichero, podemos pasar a la siguiente parte.
Para crear una interfaz con Swing, podemos crear una ventana/marco dividida en dos partes.

En la parte superior un campo de texto para escribir una ruta directamente o bien escoger un archivo mediante un botón que abrirá un explorador de ficheros.
Con un segundo botón, daremos orden de leer el archivo a partir de la ruta indicada.

En la parte central, simplemente un área de texto para mostrar el texto obtenido del archivo txt.

La interfaz podría quedar así:

imagen_2021-06-15_014926


Bien, esa interfaz la podemos confeccionar con el siguiente código:
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
import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 
import javax.swing.*;
import javax.swing.border.BevelBorder;
 
public class LectorSwing extends JFrame{
 
	private JButton btElegir;
	private JButton btLeer;
	private JTextField jtRuta;
	private JTextArea areaTexto;
 
	//Constructor del JFrame
	public LectorSwing() {
 
		iniciarComponentes();
 
		//Panel superior con campo de texto y botones
		JPanel pnNorte = new JPanel();
		pnNorte.setLayout(new BoxLayout(pnNorte, BoxLayout.Y_AXIS));
		JPanel pnElegir = new JPanel();
		pnElegir.add(new JLabel("Indique ruta del fichero: "));
		pnElegir.add(jtRuta);
		pnElegir.add(btElegir);
		JPanel pnLeer = new JPanel();
		pnLeer.add(btLeer);
		pnNorte.add(pnElegir);
		pnNorte.add(new JSeparator(SwingConstants.HORIZONTAL));
		pnNorte.add(pnLeer);
		pnNorte.setBorder(BorderFactory.createCompoundBorder(
				BorderFactory.createEmptyBorder(15, 15, 15, 15),
				BorderFactory.createRaisedSoftBevelBorder()));
 
		//Panel central con el area de texto
		JPanel pnCentro = new JPanel();
		JScrollPane sp = new JScrollPane(areaTexto); //Proporciona al area de texto barras de scroll
		sp.setBorder(BorderFactory.createBevelBorder(BevelBorder.RAISED));
		pnCentro.add(sp);
 
		//Configuracion del JFrame
		setLayout(new BorderLayout());
		add(pnNorte, BorderLayout.NORTH);
		add(pnCentro, BorderLayout.CENTER);
 
		setTitle("Lector TXT");
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		pack();
		setLocationRelativeTo(null);
		setVisible(true);
	}
 
	private void iniciarComponentes() {
		btElegir = new JButton("Seleccionar");
		btLeer = new JButton("Leer TXT");
		jtRuta = new JTextField(15);
		jtRuta.setToolTipText("Ruta del archivo a leer");
		areaTexto = new JTextArea(15, 40);
		areaTexto.setEditable(false);
	}
 
	//Método main para poner en marcha el programa
	public static void main(String[] args) {
		SwingUtilities.invokeLater(new Runnable() {
			@Override
			public void run() {
				new LectorSwing();
			}
		});
	}
 
}

Con este código obtenemos la interfaz, pero aún no tiene funcionalidad, los botones de acción no hacen nada.
Ese será el siguiente paso, pero antes, insisto de nuevo en la importancia de revisar el código escrito hasta ahora y comprobar que se entiende.

Si es así, vamos al último paso.
Hay que proporcionar "acciones" a los botones.

Para ello añadiremos a la clase anterior, dos "subclases" internas para crear dos ActionListener, es decir, dos "acciones", una para cada botón.

El botón para elegir fichero lo que tiene que hacer es mostrar un "explorador" para que el usuario pueda buscar y elegir el fichero que quiere leer.
Para esto usamos la clase JFileChooser. Cuando el usuario haya elegido un archivo, mostraremos la ruta en el campo de texto.
Esta sería la clase ActionListener que hemos de añadir a la clase anterior:
1
2
3
4
5
6
7
8
9
10
private class AccionElegirFichero implements ActionListener {
		@Override
		public void actionPerformed(ActionEvent e) {
			//Abrimos ventana para seleccionar fichero
			JFileChooser selector = new JFileChooser();
			selector.showOpenDialog(null);
			String ruta = selector.getSelectedFile().getAbsolutePath();
			jtRuta.setText(ruta); //Mostramos la ruta del archivo escogido
		}
	}


La siguiente acción es para el botón que hace la lectura.
Para ella, primero recogemos la ruta escrita en el campo de texto.
Comprobamos que no esté vacío y entonces se la pasamos al método estático de la clase LectorTXT para que lea el archivo y nos de un ArrayList con el texto..

Comprobamos que NO haya devuelto un valor null, si todo ha ido bien, transferimos las líneas leídas al area de texto para mostrarlas en la interfaz.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
private class AccionLeerTXT implements ActionListener {
		@Override
		public void actionPerformed(ActionEvent e) {
 
 
			String ruta = jtRuta.getText(); //Recogemos ruta de fichero escogido
			//Comprobamos que no esté en blanco
			if (ruta.isBlank())
				JOptionPane.showMessageDialog(null, "Escoja una ruta", "Leer TXT",
						JOptionPane.WARNING_MESSAGE);
			else {
				//La clase LectorTXT nos proprocionará un ArrayList con el texto leido
				ArrayList<String> texto = LectorTXT.leerTXT(ruta);
				if (texto == null)
					JOptionPane.showMessageDialog(null, "No se pudo leer el fichero escogido", "Leer TXT",
							JOptionPane.ERROR_MESSAGE);
				else {
					//Transferimos las lineas leidas, al area de texto
					for (String linea: texto)
						areaTexto.append(linea + "\n");
				}
			}
		}
	}

Y ahora solo queda asignar estas acciones a los botones.
Esto lo hacemos desde el método iniciarComponentes(), justo después de inicializar los botones.

1
2
3
4
5
6
7
8
9
10
private void iniciarComponentes() {
		btElegir = new JButton("Seleccionar");
		btElegir.addActionListener(new AccionElegirFichero());
		btLeer = new JButton("Leer TXT");
		btLeer.addActionListener(new AccionLeerTXT());
		jtRuta = new JTextField(15);
		jtRuta.setToolTipText("Ruta del archivo a leer");
		areaTexto = new JTextArea(15, 40);
		areaTexto.setEditable(false);
	}

Y ya está, ya podemos escoger y leer el fichero que queramos.

imagen_2021-06-15_021119

Pregunta cualquier cosa que no entiendas.
Adjunto un zip en este mensaje con el código de las dos clases que hemos creado.

Un saludo.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

lectura archivos txt

Publicado por Tom (1707 intervenciones) el 16/06/2021 09:13:07
@Kabuto como ejercicio didáctico está muy bien (aunque la mayoría de los que hacen este tipo de preguntas no esperan aprender nada -requiere esfuerzo-, sólo copiar y pegar algo).
Pero no estaría mal recordar que se puede hacer:
1
2
3
jTextArea ta = ...
String fileName = ...
ta.read(new FileReader(fileName), fileName);
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
1
Comentar