Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » Java » Ayuda con ficheros Java - no se escribir el fichero con el formato que he dicho

Java - Ayuda con ficheros Java - no se escribir el fichero con el formato que he dicho

Volver
Nuevo Tema
<<>>
 
Vista:

Ayuda con ficheros Java - no se escribir el fichero con el formato que he dicho

Publicado por Antonio (1 intervención) el 18/02/2020 18:42:27
Veréis estoy haciendo un ejercicio en el que tengo dos ficheros uno:
Marquez,cat1
Pedrosa,cat1
Lorenzo,cat1
Y el otro:
Marquez,25
Pedrosa,20
Lorenzo,10
Marquez,20
Pedrosa,23
Lorenzo,12

Y ahora necesito hacer un tercer fichero con el nombre, la categoría y los puntos sumados de cada uno y ordenarlos de mayor a menor puntuación. Ya los tengo separado en dos arraylist de objetos:

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
File corredores = new File("C:\\AD\\ejercicio1\\corredores.txt");
ArrayList<String> lineasCorredores = new ArrayList<String>();
ArrayList<Corredor> listaCorredores = new ArrayList<Corredor>();
lineasCorredores = ejercicio1.leeFichero(corredores);
 
for(int i=0; i<lineasCorredores.size();i++ ) {
String[] corredor = lineasCorredores.get(i).split(",");
 
listaCorredores.add(new Corredor(corredor[0], corredor[1]));
 
System.out.println(corredor[0] +" "+ corredor[1]);
}
 
File puntos = new File("C:\\AD\\ejercicio1\\puntos.txt");
ArrayList<String> lineasPuntos = new ArrayList<String>();
ArrayList<Puntos> listaPuntos = new ArrayList<Puntos>();
lineasPuntos = ejercicio1.leeFichero(puntos);
 
for(int i=0; i<lineasPuntos.size();i++ ) {
String[] corredor = lineasPuntos.get(i).split(",");
 
listaPuntos.add(new Puntos(corredor[0], corredor[1]));
 
System.out.println(corredor[0] +" "+ corredor[1]);
}

Pero no se escribir el fichero con el formato que he dicho antes. Ayuda pls!!
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

Ayuda con ficheros Java - no se escribir el fichero con el formato que he dicho

Publicado por Kabuto (1381 intervenciones) el 18/02/2020 20:43:19
Hola.
Se me ocurre darle un enfoque un poco distinto aprovechando mejor las características de la POO.

Se podría crear una clase Corredor, que tenga los tres atributos: nombre, categoría y puntuación.

Podría implementar la interfaz Comparator para "enseñarle" como ha de compararse con otros objetos Corredor y así facilitar las cosas cuando haya que ordenar el listado de corredores.

Tras implementar esta interfaz, podemos "enseñarle" a compararse sobrescribiendo el método compareTo(). En dicho método le diremos que ha de comparar los atributos de puntuaciones para discernir quién es "mayor" y quien es "menor".

Además, podemos sobrescribir el método toString() para "enseñarle" como mostrar sus atributos en una línea de texto. Esto será útil para cuando tengamos que crear el fichero final de datos.

Esta podría ser la clase Corredor:

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
public class Corredor implements Comparable<Corredor>{
 
	private String nombre;
	private String categoria;
	private int puntuacion;
 
	public Corredor(String nombre, String categoria) {
		this.nombre = nombre;
		this.categoria = categoria;
		puntuacion = 0;
	}
 
	public String getNombre( ) {
		return nombre;
	}
 
	public void sumaPuntos(int puntos) {
		puntuacion += puntos;
	}
 
	/*
	 * Como vamos a querer ordenar de MAYOR a MENOR,
	 * si este objeto es MAYOR (tiene más puntos) respecto del que se compara ha de devolver -1
	 * para que quede "por encima" del otro.
	 * Si quisieramos ordenar de MENOR a MAYOR, si este objeto tuviera más puntos tendría que
	 * devolver 1
	 */
	@Override
	public int compareTo(Corredor otroCorredor) {
		if (puntuacion > otroCorredor.puntuacion)
			return -1; //Este corredor tiene mas puntos (es "mayor")
		else if (puntuacion < otroCorredor.puntuacion)
			return 1; //Este corredor tiene menos puntos (es "menor")
		else
			return 0; //Ambos corredores tienen mismos puntos (son "iguales")
	}
 
	@Override
	public String toString() {
		return nombre + " -- " + categoria + " -- " + puntuacion;
	}
 
}

Ahora podríamos crear una segunda clase llamada GestionCorredores y sería quien hiciese prácticamente todo el trabajo.
A esta clase, en su constructor le podemos pasar dos String con las rutas donde ha de encontrar los ficheros de texto que ha de leer.

De este modo, lo primero que haría sería crear un único ArrayList con objetos de la clase Corredor.

Luego intentaría leer los datos de corredores.txt para obtener nombre y categoría de cada Corredor. Con estos datos ya puede comenzar a crear Corredores, quienes de momento tendrán puntuación 0 (por eso su constructor solo pide nombre y categoría) y añadirlos al ArrayList.

Si esta primera lectura ha tenido éxito, intentará el siguiente paso, leer el archivo puntos.txt.
Cada vez que obtenga una línea de este fichero, separará el nombre en un String y los puntos en un int. Y entonces buscará en el ArrayList que corredor coincide con ese nombre y le sumará los puntos que ha leído. Para esto, la clase Corredor ya tiene un método que suma puntos a su atributo puntuación.

Si esta segunda lectura también ha tenido éxito, ya podemos comenzar con el último paso, crear un fichero con los datos de los Corredores.
Antes de crear el fichero, hay que ordenar el ArrayList de mayor a menor. Para esto se pueden usar algoritmos como el "método de la burbuja", etc.... pero en realidad nosotros a nuestra clase Corredor ya le hemos enseñado como ha de compararse para ordenarse mayor a menor.
Así que nos basta con llamar al método sort() de nuestro ArrayList de corredores, sin necesidad de pasarle ningún parámetro adicional, y automáticamente ordenara los Corredores según les hemos enseñado en el método compareTo().

Y tras ordenar el listado, ya simplemente tenemos que crear un nuevo fichero, recorrer el listado de objetos Corredor y a cada uno de ellos invocar su método toString() para agregar una nueva línea de datos al nuevo fichero.

Esta podría ser la clase GestionCorredores. Su constructor hace automáticamente todos los pasos que hemos descrito llamando a los métodos necesarios.

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
public class GestionCorredores {
 
	private ArrayList<Corredor> corredores;
 
	public GestionCorredores(String rutaCorredores, String rutaPuntuaciones) {
		corredores = new ArrayList<Corredor>();
 
		if (leerCorredores(rutaCorredores) && leerPuntuaciones(rutaPuntuaciones)) {
			crearFicheroFinal();
		}
	}
 
	/**
	 * Busca un Corredor en el ArrayList y le suma puntos
	 * a su atributo puntuacion
	 * @param nombre Nombre del Corredor
	 * @param puntos Puntos que sumamos
	 */
	private void sumarPuntos(String nombre, int puntos) {
		for (Corredor c: corredores) {
			if (c.getNombre().equals(nombre))
				c.sumaPuntos(puntos);
		}
	}
 
	/**
	 * Lee el archivo de corredores para crear y añadir
	 * objetos Corredor al ArrayList.
	 * @param ruta String con la ruta donde está el archivo de corredores.
	 * @return True si tuvo éxito la lectura, False si algo falló.
	 */
	private boolean leerCorredores(String ruta) {
		try {
			BufferedReader br = new BufferedReader(new FileReader(ruta));
			String linea = br.readLine();
			while (linea != null) {
				String[] datos = linea.split(",");
				corredores.add(new Corredor(datos[0], datos[1]));
				linea = br.readLine();
			}
			br.close();
			return true;
		} catch (FileNotFoundException e) {
			System.out.println("ERROR: No se encuentra fichero de corredores");
			e.printStackTrace();
			return false;
		} catch (IOException e) {
			System.out.println("ERROR: No se puede leer fichero de corredores");
			e.printStackTrace();
			return false;
		}
	}
 
	/**
	 * Lee el archivo de puntuaciones y las va sumando a los objetos Corredor
	 * que hay creados en el ArrayList.
	 * @param ruta String con la ruta donde está el archivo de puntuaciones.
	 * @return True si la lectura tuvo éxit, False si algo falló.
	 */
	private boolean leerPuntuaciones(String ruta) {
		try {
			BufferedReader br = new BufferedReader(new FileReader(ruta));
			String linea = br.readLine();
			while (linea != null) {
				String[] datos = linea.split(",");
				String nombre = datos[0];
				int puntos = Integer.parseInt(datos[1]);
				//Tenemos nombre y puntuacion, lo buscamos en listado y le sumamos puntos
				sumarPuntos(nombre, puntos);
 
				linea = br.readLine();
			}
			br.close();
			return true;
		} catch (FileNotFoundException e) {
			System.out.println("ERROR: No se encuentra fichero de puntuaciones");
			e.printStackTrace();
			return false;
		} catch (IOException e) {
			System.out.println("ERROR: No se puede leer fichero de puntuaciones");
			e.printStackTrace();
			return false;
		}
	}
 
	private void crearFicheroFinal() {
		/*
		 * Primero ordenamos el listado.
		 * Puesto que los objetos Corredor ya implementan la interfaz Comparable
		 * y hemos sobreescrito el método compareTo() para que sepan como ordenarse,
		 * el siguiente parámetro lo dejamos con valor null
		 */
		corredores.sort(null);
 
		//Creamos el fichero.
		try {
			File fichero = new File("listado.txt");
			BufferedWriter bw = new BufferedWriter(new FileWriter(fichero));
			//Recorremos los objetos Corredor y creamos una linea llamando a su método toString()
			for(Corredor c: corredores){
				bw.write(c.toString());
				bw.newLine();
			}
			bw.close();
			System.out.println("Fichero final creado.\nSe encuentra en: " + fichero.getAbsolutePath());
		} catch (IOException e) {
			System.out.println("ERROR: No se puede crear el fichero final de datos");
			e.printStackTrace();
		}
	}
 
}


Luego creamos un main, simplemente para invocar al constructor de GestionCorredores, indicándole el nombre/ruta de los archivos que ha de leer, y automáticamente se realizará todo el proceso.

1
2
3
4
5
6
7
8
9
public class Test {
 
	public static void main(String[] args) {
 
		new GestionCorredores("corredores.txt", "puntos.txt");
 
	}
 
}

Si algo falla informará por pantalla.
Si todo va bien, también informa por pantalla indicándo la ruta donde se puede encontrar el nuevo fichero creado:
1
2
Fichero final creado.
Se encuentra en: D:\Programación\Eclipse WorkSpace 2\WebProgramador\listado.txt

Y este es el texto que me encuentro en dicho archivo:
1
2
3
Marquez -- cat1 -- 45
Pedrosa -- cat1 -- 43
Lorenzo -- cat1 -- 22


En mi código he simplificado todo el proceso para que se lleve todo a cabo de forma automática sin que ningun usuario tenga que dar ordenes o introducir datos. Tu ya organízalo como quieras.

Lo interesante es ver cómo usando la interfaz Comparable y el método toString(), hacemos que el proceso de ordenar los datos del ArrayList y crear líneas para un fichero, sea algo super sencillo.

Pregunta cualquier duda que puedas tener.

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