Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » Java » Lectura de dos archivos desde un txt y mostrarlos en consola.

Java - Lectura de dos archivos desde un txt y mostrarlos en consola.

Volver
Nuevo Tema
<<>>
 
Vista:
sin imagen de perfil
Val: 3
Ha aumentado su posición en 8 puestos en Java (en relación al último mes)
Gráfica de Java

Lectura de dos archivos desde un txt y mostrarlos en consola.

Publicado por José Luis (1 intervención) el 23/03/2021 04:57:23
Hola, he tenido un problema en java, lo que ocurre es que tengo dos archivos (matrizA.txt, matrizB.txt) de texto, ambos con la misma información:
2
2
2.3+3.4 3.4+2.9
2.0+3.0 3.4+2.3

Los dos primeros números pertenecen al numero de filas y columnas respectivamente, mientras la matriz se compone de flotantes donde el numero antes de "+" es real y el que va después es un numero imaginario.

-->Adjunto mi código a continuación:

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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
import java.util.*;
import java.util.Scanner;
import java.util.regex.Pattern;
//Para poder leer el archivo
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.File;
 
class COMPLEJO
{
	//Declaracion de atributos
	private float real;
	private float imaginario;
 
	//Metodo constructor
	COMPLEJO() //Constructor por default.
	{
		real = 0;
		imaginario = 0;
 
		System.out.println("Se ha ejecutado el contrsuctor por defecto");
	}
 
	//Constructor con parametros: Sirve para el metodo de comlejo multipliacion de un solo parametro.
	COMPLEJO(float r, float i)
	{
		real = r;
		imaginario = i;
	}
 
	//Para leer cada uno de los txt.
	public void CapturaComplejoA() throws Exception
	{
		String archivo = "MatricesA.txt";
		Scanner Lectura;
		Lectura = new Scanner(new File(archivo));
 
		System.out.println(" ");
		System.out.print("real = \t\t");
		real = Lectura.nextFloat();
		System.out.print("imaginario = \t");
		imaginario = Lectura.nextFloat();
	}
 
	public void CapturaComplejoB() throws Exception
	{
		String archivo = "MatricesB.txt";
		Scanner Lectura;
		Lectura = new Scanner(new File(archivo));
 
		System.out.println(" ");
		System.out.print("real = \t\t");
		real = Lectura.nextFloat();
		System.out.print("imaginario = \t");
		imaginario = Lectura.nextFloat();
	}
}
 
class MATRIZCOMPLEJA
{
	private COMPLEJO [][]Mx; //Variable de referencia.
	private int M;	//Filas
	private int N; //Columnas
	private int[][] ResultadoTXT = new int[M][N];
 
 
	MATRIZCOMPLEJA() //Metodo constructor.
	{
		M = 0;
		N = 0;
		Mx = null;
	}
 
	//Constructor con parametros
	MATRIZCOMPLEJA(int Filas, int Columnas)
	{
		int i, j;
		M = Filas;
		N = Columnas;
		Mx = new COMPLEJO[M][N];
 
		for(i=0; i<M; i++)
		{
			for(j=0; j<N; j++)
			{
				Mx[i][j] = new COMPLEJO();
			}
		}
	}
 
	//Para la lectura del primer txt
	public void LeerMatrizComplejaA() throws Exception//throws FileNotFoundExceptionthrows Exception
	{
		String archivo = "MatricesA.txt";
		Scanner Lectura;
		Lectura = new Scanner(new File(archivo));
		int M,N, i, j;
		FileReader fr = null;
        BufferedReader br;
 
		MATRIZCOMPLEJA MatrizA[][];
 
		System.out.println("Numero de filas: ");
		M = Lectura.nextInt();
		System.out.println(M);
		System.out.println("Numero de columnas: ");
		N = Lectura.nextInt();
		System.out.println(N);
 
		MatrizA = new MATRIZCOMPLEJA[M][N];
 
		try
		{
			if(Mx != null)
			{
				fr = new FileReader(archivo);
            	br = new BufferedReader(fr);
 
		 		String linea; //será utilizada para leer el contenido del archivo linea a linea
            	while((linea = br.readLine()) != null)
            	{
			 		for(i=0; i<M; i++)
					{
						for(j=0; j<N; j++)
						{
							Mx[i][j].CapturaComplejoA();
							System.out.println(MatrizA[i][j] + " \t");
						}
					}
				}
			}
			else
			{
				System.out.println("Hay un problema al leer el archivo.");
			}
		}
		catch (FileNotFoundException e)
		{
			System.out.println("No se encuentra archivo.");
			e.printStackTrace();
		}
		catch (NumberFormatException e)
		{
			System.out.println("No se pudo convertir a entero.");
			e.printStackTrace();
		}
		catch (IOException e)
		{
			System.out.println("Error accediendo al archivo.");
			e.printStackTrace();
		}
	}
 
	//Para la lectura del segundo txt
	public void LeerMatrizComplejaB() throws Exception
	{
		String archivo = "MatricesB.txt";
		Scanner Lectura;
		Lectura = new Scanner(new File(archivo));
		int M,N, i, j;
		FileReader fr = null;
        BufferedReader br;
 
		MATRIZCOMPLEJA MatrizB[][];
 
		System.out.println("Numero de filas: ");
		M = Lectura.nextInt();
		System.out.println(M);
		System.out.println("Numero de columnas: ");
		N = Lectura.nextInt();
		System.out.println(N);
 
		MatrizB = new MATRIZCOMPLEJA[M][N];
 
		try
		{
			if(Mx != null)
			{
				fr = new FileReader(archivo);
            	br = new BufferedReader(fr);
 
		 		String linea; //será utilizada para leer el contenido del archivo linea a linea
            	while((linea = br.readLine()) != null)
            	{
			 		for(i=0; i<M; i++)
					{
						for(j=0; j<N; j++)
						{
							Mx[i][j].CapturaComplejoB();
							System.out.println(MatrizB[i][j] + " \t");
						}
					}
				}
			}
			else
			{
				System.out.println("Hay un problema al leer el archivo.");
			}
		}
		catch (FileNotFoundException e)
		{
			System.out.println("No se encuentra archivo.");
			e.printStackTrace();
		}
		catch (NumberFormatException e)
		{
			System.out.println("No se pudo convertir a entero.");
			e.printStackTrace();
		}
		catch (IOException e)
		{
			System.out.println("Error accediendo al archivo.");
			e.printStackTrace();
		}
	}
}
 
class practica4
{
	public static void main(String arg[]) throws Exception
	{
 
		//Se crea la matriz compleja
		MATRIZCOMPLEJA A; //Variable de referencia
		A = new MATRIZCOMPLEJA(); //Se asigna una nueva variable
		MATRIZCOMPLEJA B; //Variable de referencia
		B = new MATRIZCOMPLEJA();
		MATRIZCOMPLEJA C; //Variable de referencia
		C = new MATRIZCOMPLEJA();
		MATRIZCOMPLEJA P; //Variable de referencia
		P = new MATRIZCOMPLEJA();
 
		A.LeerMatrizComplejaA();
		B.LeerMatrizComplejaB();
	}
}


La consola si reconoce los valores de filas y columnas pero al llegar a la matriz, me manda el mensaje que no los reconoce, como puedo hacer que se muestre dichas matrices en consola?
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
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 de dos archivos desde un txt y mostrarlos en consola.

Publicado por Kabuto (1381 intervenciones) el 24/03/2021 02:06:03
Humm... hay cosas que no veo claras.

Aquí lees líneas, pero luego no haces nada con ellas:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
try
{
    if(Mx != null)
    {
        fr = new FileReader(archivo);
        br = new BufferedReader(fr);
 
        String linea; //será utilizada para leer el contenido del archivo linea a linea
        while((linea = br.readLine()) != null)
        {
            for(i=0; i<M; i++)
            {
                for(j=0; j<N; j++)
                {
                    Mx[j].CapturaComplejoB();
                    System.out.println(MatrizB[i][j] + " \t");
                }
            }
        }
    }

Lo que haces es llamar a estos métodos:
1
Mx[i][j].CapturaComplejoA();

Quienes a su vez también leeran el archivo, desde el principio, en busca de valores mediante clase Scanner que se puedan convertir a floats:

1
2
3
4
5
6
7
8
9
10
11
12
public void CapturaComplejoA() throws Exception
{
    String archivo = "MatricesA.txt";
    Scanner Lectura;
    Lectura = new Scanner(new File(archivo));
 
    System.out.println(" ");
    System.out.print("real = \t\t");
    real = Lectura.nextFloat();
    System.out.print("imaginario = \t");
    imaginario = Lectura.nextFloat();
}

Y esto, no solo es redundante hacer dos lecturas del mismo archivo por canales diferentes, si no que además las primeras líneas del archivo, los dos enteros que indican las filas y las columnas, a pesar de ser enteros son también aceptables como floats así seguramente el Scanner usará esos enteros para construir el número complejo, y no los floats.

Y aunque no los cogiera, como cada vez que se invoca ese método lee desde el principio, siempre cogería los primeros floats, no los siguientes. Así que la matriz se construiría toda con los mismos números complejos.

Y por otra parte, es muy posible que el Scanner ponga pegas al encontrarse el "meta carácter" '+', ya que este carácter se usa para construir patrones (Patterns) de expresiones regulares.
Y como Scanner internamente se vale de expresiones regulares para detectar los números que busca, no va a saber como debe interpretar ese '+' y probablemente lanzaría excepción.

Luego, no es óptimo tener métodos idénticos, pero uno específico para leer el archivo "matrizA" y otro específico para "matrizB".
Se puede escribir una sola vez y recibir como argumento un String con el archivo que ha de leer. Así ese único método sirve para CUALQUIER archivo.

Mira, te hago la siguiente propuesta.
Esta sería la clase Complejo.
Muy similar a la tuya.
La mayor diferencia es que no va a leer ningún archivo. En lugar de eso recibirá un String con un grupo de números tipo [i]"2.3+3.4" que se encargará de separar y parsearlos para construir los dos float que necesita.
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
private static class Complejo {
 
    private float real;
    private float imaginario;
 
    public Complejo() {
        real = 0f;
        imaginario = 0f;
    }
 
    public Complejo(float real, float imaginario) {
        this.real = real;
        this.imaginario = imaginario;
    }
 
    public void capturarNumeros(String grupo) {
        String[] numeros = grupo.split("\\+");
        try {
            real = Float.parseFloat(numeros[0]);
            imaginario = Float.parseFloat(numeros[1]);
        }
        catch(Exception ex) {
            System.out.println("Error capturando números en grupo: " + grupo);
        }
 
    }
 
    @Override
    public String toString() {
        return String.format("(%.1f , %.1f)", real, imaginario);
    }
}

A continuación MatrizComplejos.
También parecida a tu clase, aunque la he simplificado. No creo que se necesiten atributos para las filas y columnas.
Esta clase es quien leerá el archivo que se le indique mediante un String.
Con las dos primeras líneas del archivo reconstruye la matriz con las nuevas dimensiones.
Con las siguientes líneas obtiene los "grupos" de dos valores mediante los cuales cada elemento de clase Complejo es capaz de obtener los float.

El método para leer archivos contempla posibilidades como que el archivo no tenga suficientes líneas y/o suficientes "grupos" de valores para completar la matriz según las dimensiones indicadas.
Parece un método grande y complejo, pero no lo es tanto, si quitas las líneas de comentarios se queda en poca cosa.

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
private static class MatrizComplejos {
 
    private Complejo[][] mx;
 
    public MatrizComplejos() {
        mx = null;
    }
 
    public MatrizComplejos(int filas, int columnas) {
        mx = new Complejo[filas][columnas];
        for (int f = 0; f < filas; filas++)
            for (int c = 0; c < columnas; c++)
                mx[f][c] = new Complejo();
    }
 
    public void leerArchivoTXT(String archivoTXT) {
 
        try {
            BufferedReader br = new BufferedReader(new FileReader(archivoTXT));
            //Leemos primera linea, indica las filas
            String linea = br.readLine();
            int filas = Integer.parseInt(linea);
            //Segunda línea, las columnas
            linea = br.readLine();
            int columnas = Integer.parseInt(linea);
            //Creamos una nueva matriz con las filas y columnas capturadas
            mx = new Complejo[filas][columnas];
            for (int f = 0; f < filas; f++)
                for (int c = 0; c < columnas; c++)
                    mx[f][c] = new Complejo();
            /*
             * Tenemos matriz creada. Ahora hay que crear los números complejos.
             * Las siguientes líneas del archivo, cada una proporciona
             * los valores para crear una fila completa de números complejos
             */
 
            for (int f = 0; f < filas; f++) {
                linea = br.readLine();
                if (linea == null) {
                    System.out.println("Error. El archivo no contiene suficientes líneas"
                            + " para llenar la matriz con números complejos");
                    break;//La matriz queda incompleta
                }
                else {
                    //Cada linea se compone de grupos de dos floats
                    //Un espacio en blanco separa cada uno de estos grupos
                    //Separamos los grupos en un array
                    String[] grupos = linea.split(" ");
                    //Cada grupo sirve para construir un complejo en esta fila
                    //Si hubieran menos grupos que columnas, no se completará la matriz
                    if (grupos.length < columnas)
                        System.out.println("Esta línea no contiene suficientes valores."
                                + " La matriz quedará incompleta.");
                    /*
                     * Creamos complejos con los grupos obtenidos.
                     * Si hay menos grupos que columnas, el límite a recorrer
                     * lo pone la cantidad de grupos y quedarán columnas incompletas.
                     * En cambio si tuvieramos más grupos que columnas,
                     * el límite lo ponen las columnas existentes, todas quedarán completas
                     * aunque habrán grupos que serán ignorados por ser excedentes.
                     */
                    int limite = grupos.length<=columnas?grupos.length:columnas;
                    for (int c = 0; c < limite; c++)
                        mx[f][c].capturarNumeros(grupos[c]);
                }
            }
             br.close();
        }
        catch(NumberFormatException nfe) {
            System.out.println("Error parseando a entero un valor del archivo.");
            System.out.println(nfe.getLocalizedMessage());
        }
        catch(Exception ex) {
            System.out.println("Error leyendo archivo: " + archivoTXT);
            System.out.println(ex.getLocalizedMessage());
        }
 
    }
 
    @Override
    public String toString() {
        if (mx == null)
            return "Matriz nula";
        else {
            StringBuilder texto = new StringBuilder();
            for (int f = 0; f < mx.length; f++)
                texto.append(Arrays.toString(mx[f]) + "\n");
 
            return texto.toString();
        }
    }
}

En el siguiente método main pongo a prueba ambas clases.
He usado dos archivos distintos, que generan matrices de distintas dimensiones y valores.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public static void main(String[] args) {
		MatrizComplejos matrizA = new MatrizComplejos();
		MatrizComplejos matrizB = new MatrizComplejos();
 
		System.out.println("Valores actuales de Matriz A:");
		System.out.println(matrizA);
		System.out.println("\nValores actuales de Matriz B:");
		System.out.println(matrizB);
 
		System.out.println("\nCapturando valores de los archivos...\n");
		matrizA.leerArchivoTXT("matrizA.txt");
		matrizB.leerArchivoTXT("matrizB.txt");
 
		System.out.println("Valores actuales de Matriz A:");
		System.out.println(matrizA);
		System.out.println("\nValores actuales de Matriz B:");
		System.out.println(matrizB);
	}
 
}
Resultado en pantalla resulta exitoso:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Valores actuales de Matriz A:
Matriz nula
 
Valores actuales de Matriz B:
Matriz nula
 
Capturando valores de los archivos...
 
Valores actuales de Matriz A:
[(2,3 , 3,4), (3,4 , 2,9)]
[(2,0 , 3,0), (3,4 , 2,3)]
 
 
Valores actuales de Matriz B:
[(2,3 , 3,4), (3,4 , 2,9), (5,8 , 1,1)]
[(2,0 , 3,0), (3,4 , 2,3), (0,2 , 5,3)]
[(9,0 , 1,0), (2,6 , 1,1), (8,7 , 4,9)]


Pego a continuación todo el código completo, está escrito en una única clase.
Si algo no ha quedado claro o no se entiende, por favor, no dudes en preguntar.

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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
import java.io.BufferedReader;
import java.io.FileReader;
import java.util.Arrays;
 
public class LeerComplejos {
 
	//Modelo de un número complejo
	private static class Complejo {
 
		private float real;
		private float imaginario;
 
		public Complejo() {
			real = 0f;
			imaginario = 0f;
		}
 
		public Complejo(float real, float imaginario) {
			this.real = real;
			this.imaginario = imaginario;
		}
 
		public void capturarNumeros(String grupo) {
			String[] numeros = grupo.split("\\+");
			try {
				real = Float.parseFloat(numeros[0]);
				imaginario = Float.parseFloat(numeros[1]);
			}
			catch(Exception ex) {
				System.out.println("Error capturando números en grupo: " + grupo);
			}
 
		}
 
		@Override
		public String toString() {
			return String.format("(%.1f , %.1f)", real, imaginario);
		}
	}
 
	//Modelo de una matriz de números complejos
	private static class MatrizComplejos {
 
		private Complejo[][] mx;
 
		public MatrizComplejos() {
			mx = null;
		}
 
		public MatrizComplejos(int filas, int columnas) {
			mx = new Complejo[filas][columnas];
			for (int f = 0; f < filas; filas++)
				for (int c = 0; c < columnas; c++)
					mx[f][c] = new Complejo();
		}
 
		public void leerArchivoTXT(String archivoTXT) {
 
			try {
				BufferedReader br = new BufferedReader(new FileReader(archivoTXT));
				//Leemos primera linea, indica las filas
				String linea = br.readLine();
				int filas = Integer.parseInt(linea);
				//Segunda línea, las columnas
				linea = br.readLine();
				int columnas = Integer.parseInt(linea);
				//Creamos una nueva matriz con las filas y columnas capturadas
				mx = new Complejo[filas][columnas];
				for (int f = 0; f < filas; f++)
					for (int c = 0; c < columnas; c++)
						mx[f][c] = new Complejo();
				/*
				 * Tenemos matriz creada. Ahora hay que crear los números complejos.
				 * Las siguientes líneas del archivo, cada una proporciona
				 * los valores para crear una fila completa de números complejos
				 */
 
				for (int f = 0; f < filas; f++) {
					linea = br.readLine();
					if (linea == null) {
						System.out.println("Error. El archivo no contiene suficientes líneas"
								+ " para llenar la matriz con números complejos");
						break;//La matriz queda incompleta
					}
					else {
						//Cada linea se compone de grupos de dos floats
						//Un espacio en blanco separa cada uno de estos grupos
						//Separamos los grupos en un array
						String[] grupos = linea.split(" ");
						//Cada grupo sirve para construir un complejo en esta fila
						//Si hubieran menos grupos que columnas, no se completará la matriz
						if (grupos.length < columnas)
							System.out.println("Esta línea no contiene suficientes valores."
									+ " La matriz quedará incompleta.");
						/*
						 * Creamos complejos con los grupos obtenidos.
						 * Si hay menos grupos que columnas, el límite a recorrer
						 * lo pone la cantidad de grupos y quedarán columnas incompletas.
						 * En cambio si tuvieramos más grupos que columnas,
						 * el límite lo ponen las columnas existentes, todas quedarán completas
						 * aunque habrán grupos que serán ignorados por ser excedentes.
						 */
						int limite = grupos.length<=columnas?grupos.length:columnas;
						for (int c = 0; c < limite; c++)
							mx[f][c].capturarNumeros(grupos[c]);
					}
				}
				 br.close();
			}
			catch(NumberFormatException nfe) {
				System.out.println("Error parseando a entero un valor del archivo.");
				System.out.println(nfe.getLocalizedMessage());
			}
			catch(Exception ex) {
				System.out.println("Error leyendo archivo: " + archivoTXT);
				System.out.println(ex.getLocalizedMessage());
			}
 
		}
 
		@Override
		public String toString() {
			if (mx == null)
				return "Matriz nula";
			else {
				StringBuilder texto = new StringBuilder();
				for (int f = 0; f < mx.length; f++)
					texto.append(Arrays.toString(mx[f]) + "\n");
 
				return texto.toString();
			}
		}
	}
 
	//Metodo main para probar
	public static void main(String[] args) {
		MatrizComplejos matrizA = new MatrizComplejos();
		MatrizComplejos matrizB = new MatrizComplejos();
 
		System.out.println("Valores actuales de Matriz A:");
		System.out.println(matrizA);
		System.out.println("\nValores actuales de Matriz B:");
		System.out.println(matrizB);
 
		System.out.println("\nCapturando valores de los archivos...\n");
		matrizA.leerArchivoTXT("matrizA.txt");
		matrizB.leerArchivoTXT("matrizB.txt");
 
		System.out.println("Valores actuales de Matriz A:");
		System.out.println(matrizA);
		System.out.println("\nValores actuales de Matriz B:");
		System.out.println(matrizB);
	}
 
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
2
Comentar