Java - Ayuda en java

   
Vista:

Ayuda en java

Publicado por Silent (1 intervención) el 11/05/2015 07:16:06
A ver, tengo una duda con un programa que tengo que hacer en java, y no consigo solucionarlo por más que le de vueltas, mi duda es que tengo que cargar un archivo de texto externo, en el cual hay diferentes palabras y valores, en plan así:

Aliados:2
Enemigos:3
A;Pedro;12;1;3
E;Pepe;14;13;Sevilla;1
A;Pablo;18;11;3
E;Lolo;28;35;Madrid;1
E;Fernando;24;6;Barcelona;0


El archivo lo he cargado así:

1
2
3
4
5
6
7
8
9
10
11
12
13
try {
	BufferedReader lector = new BufferedReader(new FileReader("archivo1.txt"));
 
	String linea = lector.readLine();
	while (linea != null) {
		System.out.println(linea);
		linea = reader.readLine();
	}
 
	reader.close();
} catch (Exception e) {
	System.out.println("Error al leer");
}

Así cargo el archivo y lo leo línea por línea, hasta ahí bien. Ahora lo que quiero conseguir es que los datos se vayan almacenando en diferentes variables, pero por ejemplo, la primera parte en la que pone "Aliados: 2", "Enemigos: 3", quiero que solo se almacene el número y se salte las palabras Aliados: y Enemigos:. Los siguientes datos que aparecen quiero almacenarlo en diferentes variables, por ejemplo:

E;Pepe;14;13;Sevilla;1

La E indicaría que el objeto es un enemigo, Pepe sería la string del nombre, 14 sería un atributo de dicho objeto, 13 otro, Sevilla la string de la ciudad y 1 otro atributo...

Lo he intentado con StringTokenizer, pero no lo consigo entender correctamente. Sería de mucha ayuda si alguien me pudiese explicar cómo he de hacerlo. Muchas gracias.
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

Ayuda en java

Publicado por Andrés andres.mella.romero@gmail.com (231 intervenciones) el 12/05/2015 06:58:57
Revisión


//Usar un arreglo para aliados y uno para enemigos o uno para los dos?

Aliados:2 // Indica cuantos aliados son esta es la linea 1 token separado por :
Enemigos:3 //Indica cuantos enemigos son esta es la linea 2

// Esto ocurre despues de la linea 2!, es decir, estamos en la linea 3
A;Pedro;12;1;3
E;Pepe;14;13;Sevilla;1 //esta es una de las lineas más completas token separado por ; hay 6 tokens!
A;Pablo;18;11;3 //esta linea esta rara dado que no esta la "localiad"
E;Lolo;28;35;Madrid;1
E;Fernando;24;6;Barcelona;0


Implelmentación

Definitivamente necesitas una clase que modele o un aliado o un enemigo

Ahora necesitaras imprimir aliados y enemigos por separado ó da igual?


Aproximación 1: crear una clase combatiente y dos subclases, aliado y enemigo con esta solución procesas para imprimir por un lado los aliados y por otro los enemigos, pero la solucipon sólo seria una jerarquia de clases
Aproximación 2: crear una sola clase combatiente y crear un campo boolean que indique si es aliado o enemigo, aqui para imprimir por separado, habra que recorrer dos veces el arreglo

Tomando la linea mas completa E;Pepe;14;13;Sevilla;1 y separando por ; hay 6 tokens

token 1: en este caso E indicará que se trata de un enemigo o un aliado, caracter A ó E
token 2: indica el nombre del aliado
token 3: indica el atributo 1
token 4: indica el atributo 2
token 5: indica la localidad
token 6: indica el atributo 3

ok, hasta aquí todo es miel sobre hojuelas pero...... existe la linea A;Pablo;18;11;3 hay 5 tokens

token 1: en este caso A indicará que se trata de un enemigo o un aliado, caracter A ó E
token 2: indica el nombre del aliado
token 3: indica el atributo 1
token 4: indica el atributo 2
token 5: indica el atributo 3

Aja y ahora como lo implemento?

Solución: Jerarquía de clases

class Combatiente {

public final static String SEPARATOR_CHAR = ";";
public final static String ENEMIGO_CHAR = "E";
public final static String ALIADO_CHAR = "A";

private String nombre;
private Integer atributo01;
private Integer atributo02;
private Integer atributo03;
private String localidad;

public String toString() {

StringBuilder sb = new StringBuilder();

sb.append(this.nombre).append(SEPARATOR_CHAR);
sb.append(this.atributo01).append(SEPARATOR_CHAR);
sb.append(this.atributo02).append(SEPARATOR_CHAR);
if(null != this.localidad) {
sb.append(this.localidad).append(SEPARATOR_CHAR);
}

sb.append(this.atributo03).append(SEPARATOR_CHAR);

return sb.toString();

}

}

class Aliado extends Combatiente {


public String toString() {

StringBuilder sb = new StringBuilder();

sb.append(Combatiente.ALIADO_CHAR).append(SEPARATOR_CHAR);
sb.append(super.toString());

return sb.toString();
}


}
class Enemigo extends Combatiente {
public String toString() {
StringBuilder sb = new StringBuilder();

sb.append(Combatiente.ENEMIGO_CHAR).append(SEPARATOR_CHAR);
sb.append(super.toString());

return sb.toString();
}
}


public class War {

public static void main(String[] args) {

try {
final String COMBATIENTES_CHAR = ":";
int numeroLinea = 1;
Combatiente[] enemigos = null;
Combatiente[] aliados = null;
Combatiente actual = null;

int untimoEmemigo =0;
int untimoAliado =0;
StringTokenizer st = null;

String typoCombatiente = null;

BufferedReader lector = new BufferedReader(new FileReader("archivo1.txt"));


String linea = lector.readLine();

while (linea != null) {



if(numeroLinea < 3) {

st= new StringTokenizer(linea, COMBATIENTES_CHAR);
typoCombatiente = st.nextToken();
Integer cantidad = Integer.valueOf(st.nextToken());

if(Combatiente.ENEMIGO_CHAR.equals(typoCombatiente)) {

enemigos = new Enemigo[cantidad];
}else if(Combatiente.ALIADO_CHAR.equals(typoCombatiente)) {

aliados = new Aliado[cantidad];
}

}else {


st= new StringTokenizer(linea, Combatiente.SEPARATOR_CHAR);



typoCombatiente = st.nextToken();

if(Combatiente.ENEMIGO_CHAR.equals(typoCombatiente)) {

enemigos[untimoEmemigo] = new Ememigo();
enemigos[untimoEmemigo].setNombre(st.nextToken());
enemigos[untimoEmemigo].setAtributo01(Integer.valueOf(st.nextToken()));
enemigos[untimoEmemigo].setAtributo02(Integer.valueOf(st.nextToken()));
if(6 == st.countTokens()) {
enemigos[untimoEmemigo].setLocalidad(st.nextToken());
}
enemigos[untimoEmemigo].setAtributo03(Integer.valueOf(st.nextToken()));

untimoEmemigo++

}else if(Combatiente.ALIADO_CHAR.equals(typoCombatiente)) {

aliados[untimoAliado] = new Aliado();
aliados[untimoAliado] = new Ememigo();
aliados[untimoAliado].setNombre(st.nextToken());
aliados[untimoAliado].setAtributo01(Integer.valueOf(st.nextToken()));
aliados[untimoAliado].setAtributo02(Integer.valueOf(st.nextToken()));
if(6 == st.countTokens()) {
aliados[untimoAliado].setLocalidad(st.nextToken());
}
aliados[untimoAliado].setAtributo03(Integer.valueOf(st.nextToken()));

untimoAliado++
}



}



linea = reader.readLine();

numeroLinea++;

}



reader.close();

} catch (Exception e) {

System.out.println("Error al leer");

}

}

}

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
package war;
/**
 *
 * @author Andrés Mella Romero
 */
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.StringTokenizer;
 
class Combatiente {
 
    public final static String SEPARATOR_CHAR = ";";
    public final static String ENEMIGO_CHAR = "E";
    public final static String ALIADO_CHAR = "A";
 
    private String nombre;
    private Integer atributo01;
    private Integer atributo02;
    private Integer atributo03;
    private String localidad;
 
    public String getNombre() {
        return nombre;
    }
 
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }
 
    public Integer getAtributo01() {
        return atributo01;
    }
 
    public void setAtributo01(Integer atributo01) {
        this.atributo01 = atributo01;
    }
 
    public Integer getAtributo02() {
        return atributo02;
    }
 
    public void setAtributo02(Integer atributo02) {
        this.atributo02 = atributo02;
    }
 
    public Integer getAtributo03() {
        return atributo03;
    }
 
    public void setAtributo03(Integer atributo03) {
        this.atributo03 = atributo03;
    }
 
    public String getLocalidad() {
        return localidad;
    }
 
    public void setLocalidad(String localidad) {
        this.localidad = localidad;
    }
 
    @Override
    public String toString() {
 
        StringBuilder sb = new StringBuilder();
 
        sb.append(this.nombre).append(SEPARATOR_CHAR);
        sb.append(this.atributo01).append(SEPARATOR_CHAR);
        sb.append(this.atributo02).append(SEPARATOR_CHAR);
        if (null != this.localidad) {
            sb.append(this.localidad).append(SEPARATOR_CHAR);
        }
 
        sb.append(this.atributo03);
 
        return sb.toString();
 
    }
 
}
 
class Aliado extends Combatiente {
 
    @Override
    public String toString() {
 
        StringBuilder sb = new StringBuilder();
 
        sb.append(Combatiente.ALIADO_CHAR).append(Combatiente.SEPARATOR_CHAR);
        sb.append(super.toString());
 
        return sb.toString();
    }
 
}
 
class Enemigo extends Combatiente {
 
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
 
        sb.append(Combatiente.ENEMIGO_CHAR).append(Combatiente.SEPARATOR_CHAR);
        sb.append(super.toString());
 
        return sb.toString();
    }
}
 
public class War {
 
    public static void main(String[] args) throws IOException {
        BufferedReader reader = null;
        try {
 
            final String COMBATIENTES_CHAR = ":";
            int numeroLinea = 1;
            Combatiente[] enemigos = null;
            Combatiente[] aliados = null;
 
            int ultimoEmemigo = 0;
            int ultimoAliado = 0;
            int tokens = 0;
            StringTokenizer st = null;
 
            String typoCombatiente = null;
 
            reader = new BufferedReader(new FileReader("archivo1.txt"));
 
            String linea = reader.readLine();
 
            while (linea != null) {
 
                if (numeroLinea < 3) {
 
                    st = new StringTokenizer(linea, COMBATIENTES_CHAR);
                    typoCombatiente = st.nextToken();
                    Integer cantidad = Integer.valueOf(st.nextToken());
 
                    if (Combatiente.ENEMIGO_CHAR.equals(typoCombatiente.substring(0, 1))) {
 
                        enemigos = new Enemigo[cantidad];
                    } else if (Combatiente.ALIADO_CHAR.equals(typoCombatiente.substring(0, 1))) {
 
                        aliados = new Aliado[cantidad];
                    }
 
                } else {
 
                    st = new StringTokenizer(linea, Combatiente.SEPARATOR_CHAR);
 
                    tokens = st.countTokens();
 
                    typoCombatiente = st.nextToken();
 
                    if (Combatiente.ENEMIGO_CHAR.equals(typoCombatiente)) {
 
                        enemigos[ultimoEmemigo] = new Enemigo();
 
                        enemigos[ultimoEmemigo].setNombre(st.nextToken());
                        enemigos[ultimoEmemigo].setAtributo01(Integer.valueOf(st.nextToken()));
                        enemigos[ultimoEmemigo].setAtributo02(Integer.valueOf(st.nextToken()));
 
                        if (6 == tokens) {
                            enemigos[ultimoEmemigo].setLocalidad(st.nextToken());
                            enemigos[ultimoEmemigo].setAtributo03(Integer.valueOf(st.nextToken()));
                        } else if (5 == tokens) {
                            enemigos[ultimoEmemigo].setAtributo03(Integer.valueOf(st.nextToken()));
                        }
 
                        ultimoEmemigo++;
 
                    } else if (Combatiente.ALIADO_CHAR.equals(typoCombatiente)) {
 
                        aliados[ultimoAliado] = new Aliado();
                        aliados[ultimoAliado].setNombre(st.nextToken());
                        aliados[ultimoAliado].setAtributo01(Integer.valueOf(st.nextToken()));
                        aliados[ultimoAliado].setAtributo02(Integer.valueOf(st.nextToken()));
                        if (6 == tokens) {
                            aliados[ultimoAliado].setLocalidad(st.nextToken());
                            aliados[ultimoAliado].setAtributo03(Integer.valueOf(st.nextToken()));
                        } else if (5 == tokens) {
                            aliados[ultimoAliado].setAtributo03(Integer.valueOf(st.nextToken()));
                        }
 
                        ultimoAliado++;
                    }
 
                }
 
                linea = reader.readLine();
 
                numeroLinea++;
 
            }
 
            //Imprimir los combatientes
            for (Combatiente c : enemigos) {
                System.out.println(c.toString());
            }
 
            for (Combatiente c : aliados) {
                System.out.println(c.toString());
            }
 
        } catch (Exception e) {
 
            System.out.println("Error al leer");
 
        } finally {
            if (null != reader) {
                reader.close();
            }
        }
 
    }
 
}

Untitled_war

Ahora trata de implementarlo con la sola clase Combatiente y un atributo booleano, saludos.
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