Java - Leerá cada línea del poema usando un Buffer y contar vocales y consonantes

 
Vista:
sin imagen de perfil
Val: 5
Ha disminuido su posición en 99 puestos en Java (en relación al último mes)
Gráfica de Java

Leerá cada línea del poema usando un Buffer y contar vocales y consonantes

Publicado por arnau (3 intervenciones) el 31/05/2020 19:00:28
Tengo un ejercicio que se me resiste.
No hay manera de que me salga el ejercicio, es este:

(Dado un archivo plano “raíz://poema.txt” que contiene este poema de Antonio Machado:
(raíz debería ser , si se puede, preferentemente D:/ ó F/):
Caminante, son tus huellas
el camino y nada más;
Caminante, no hay camino,
se hace camino al andar.
Al andar se hace el camino,
y al volver la vista atrás
se ve la senda que nunca
se ha de volver a pisar.
Caminante no hay camino
sino estelas en la mar.
Leerá cada línea del poema usando un Buffer y indicará en dos ficheros (raíz://vocales.txt y raíz://consonantes.txt) cuantas hay de cada vocal y de cada consonante usando 5 líneas para vocales del primer fichero y 26 líneas de consonantes (¿incluyendo vocales?) del segundo fichero, aparecerán también aquellas vocales o consonantes que valgan CERO.)


Este es mi codigo:

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
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
 
 
 
 
public class lecturaficheroplano {
 
    public static void main(String[] args) {
 
 
        File archivo = new File ("F://poema.txt");
        File archivo_d = new File ("F://poema2.txt");
        FileReader fr = null;
 
        FileWriter fw = null;
        try {
            fw = new FileWriter(archivo_d);
        } catch (IOException ex) {
            System.out.println("error");
        }
        try {
            fr = new FileReader (archivo);
 
        } catch (FileNotFoundException ex) {
            System.out.println("Pringao!!!, no existe el archivo");
        }
        BufferedReader bk = new BufferedReader(fr);
        BufferedWriter bkw = new BufferedWriter(fw);
        String lk = "";
        int lml = 0; //Número de la línea más larga
        int tml = 0; //Tamaño de la línea más larga
        int lme = 0; //Línea en la que me encuentro (leyendo)
        int contablancos = 0;
        while (lk !=null)
        {
            try {
                lk = bk.readLine();
                lme++; //incrementamos el número de líneas leidas
                if (lk !=null)
                    {
                    lk = lk.replaceAll("[a|e|i|o|u]", "");
                    //Eliminar todas las vocales
                    //Negar el patrón y eliminar las consonantes.
                    for (int i=0; i < lk.length();i++)
                    {
                        if (lk.charAt(i)== ' ')
                            contablancos++;
                    }
                }
 
                {
                if (lk.length() > tml) //Si la línea leida es más larga
                {
                    tml = lk.length(); //Tomo nota de la nueva longitud
                    lml = lme; //En qué línea me encontré este tamaño
                }
                }
                if (lk != null)
                {
                    bkw.write(lk);
                    bkw.newLine();
                }
 
                //String a manipular, contenidos de la unidad formativa 1
                if (lk !=null) System.out.println(lk);
            } catch (IOException ex) {
                System.out.println("No puedo leer del fichero");
            }
 
        }
        System.out.println("La línea más larga es " + lml);
 
        try {
            bkw.flush();
            fw.close();
        } catch (IOException ex) {
            System.out.println("Error");
        }
    }
 
}
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

Leerá cada línea del poema usando un Buffer y contar vocales y consonantes

Publicado por Kabuto (1381 intervenciones) el 31/05/2020 20:17:31
Pues tu código no se corresponde con el enunciado, o yo lo estoy entendiendo de forma muy distinta.

A ver, se pide leer lineas, contar cuantas vocales y consonantes hay y mostrar resultado desglosado en dos archivos distintos, uno para vocales y otro para consonantes.

Si hay que desglosar resultados, pues hay que contar también por separado.
Así que por cada línea, iremos carácter por carácter, a ver que tenemos.
Si encontramos una 'a', aumentamos en 1 el contador de la vocal 'a'.
Si encontramos una 'b', aumentamos en 1 el contador de la consonante 'b'.
Etc..

Son 5 vocales y 22 consonantes (el enunciado dice 26 pero será una errata). No vamos a usar 27 variables contadoras porque no es práctico.
Si podemos usar dos arrays. Uno de 5 elementos para contar las vocales y otro de 22 para las consonantes.

Para evaluar que carácter hemos encontrado y decidir que contador vamos a incrementar, podemos usar un switch. Será un switch un poco largo, con 27 cases, pero bueno, no pasa nada. Si convendría hacer esto en un método separado, para no enmarañar el programa principal con un montón de líneas de código.
A dicho método se le pasa como parámetro el carácter en cuestión y el se encarga de contarlo donde proceda.

Una vez se han leído las líneas y hecho las cuentas, hay que crear dos ficheros de texto con los resultados desglosados.
Bastará con recorrer los arrays donde hemos contado y escribir cada resultado en una línea nueva en el fichero.
Las líneas de resultado pueden ser algo así:
a --> 24
e --> 12
i --> 17

Para facilitar la creación de estas líneas, podemos declarar previamente otros dos arrays de tipo char donde tengamos ya escritas vocales y consonantes.
Así con un único bucle, podemos crear una línea con el carácter necesario y el total contado.

Si te ha quedado más o menos claro el proceso que he propuesto, intenta escribirlo tú en un nuevo código.

Si no te sale o lo prefieres más fácil, aquí te dejo un código que haría lo que propongo.
El método para contar caracteres, no es perfecto, porque por ejemplo no está contando vocales acentuadas como la 'á'´.
Pero bueno, es facilísimo solucionarlo agregando más cases al switch.

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
public class LecturaFicheroPlano {
 
	//Archivo a leer
	private static File archivo = new File ("D://poema.txt");
	//Array de 5 elementos para contar vocales
	//La posicion[0] contará 'a', [1] contará 'e', [2] contará 'i', etc...
	private static int[] vocales = new int[5];
	//Array de 22 elementos para contar consonantes
	//La posicion[0] contará 'b', [1] contará 'c', [2] contará 'd', etc...
	private static int[] consonantes = new int[22];
 
	/*
	 * Los siguientes arrays son para tener ya escritas vocales y consonantes.
	 * Así podremos crear los ficheros de resultados de forma más sencilla
	 * con un bucle que recorra estos arrays al mismo tiempo que los arrays
	 * donde hemos contado
	 */
	private static final char[] VOCALES = {'a', 'e', 'i', 'o', 'u'};
	private static final char[] CONSONANTES = {'b', 'c', 'd', 'f', 'g', 'h', 'j', 'k', 'l',
			'm', 'n', 'ñ', 'p', 'q', 'r', 's', 't', 'v', 'w', 'x', 'y', 'z'};
 
	public static void main(String[] args) {
 
		//1er paso, leer lineas de fichero, extraer caracteres y contarlos
		try {
			BufferedReader br = new BufferedReader(new FileReader(archivo));
			String linea = br.readLine();
			while (linea != null) {
				//Leemos cada caracter de la línea y pasamos al método que los cuenta
				for (int i = 0; i < linea.length(); i++)
					contarChar(linea.toLowerCase().charAt(i));
				//Leemos siguiente linea
				linea = br.readLine();
			}
			br.close();
		} catch (FileNotFoundException e) {
			System.out.println("No se encuentra archivo: " + archivo.getAbsolutePath());
		} catch (IOException e) {
			System.out.println("Error al acceder al archivo: " + archivo.getAbsolutePath());
		}
 
		//2do paso, volcar los resultados en fichero de vocales y consonantes
		try {
			BufferedWriter bw = new BufferedWriter(new FileWriter("D://vocales.txt"));
			for (int i = 0; i < 5; i++) {
				bw.write(VOCALES[i] + " --> " + vocales[i]);
				bw.newLine();
			}
			bw.close();
			bw = new BufferedWriter(new FileWriter("D://consonantes.txt"));
			for (int i = 0; i < 22; i++) {
				bw.write(CONSONANTES[i] + " --> " + consonantes[i]);
				bw.newLine();
			}
			bw.close();
			System.out.println("Poema leído y resultados generados");
			System.out.println("\t\t--FIN DE PROGRAMA--");
		} catch (IOException e) {
			System.out.println("Error al intentar crear ficheros de resultados.");
		}
	}
 
	private static void contarChar(char caracter) {
		switch (caracter) {
		case 'a':
			vocales[0]++;
			break;
		case 'e':
			vocales[1]++;
			break;
		case 'i':
			vocales[2]++;
			break;
		case 'o':
			vocales[3]++;
			break;
		case 'u':
			vocales[4]++;
			break;
		case 'b':
			consonantes[0]++;
			break;
		case 'c':
			consonantes[1]++;
			break;
		case 'd':
			consonantes[2]++;
			break;
		case 'f':
			consonantes[3]++;
			break;
		case 'g':
			consonantes[4]++;
			break;
		case 'h':
			consonantes[5]++;
			break;
		case 'j':
			consonantes[6]++;
			break;
		case 'k':
			consonantes[7]++;
			break;
		case 'l':
			consonantes[8]++;
			break;
		case 'm':
			consonantes[9]++;
			break;
		case 'n':
			consonantes[10]++;
			break;
		case 'ñ':
			consonantes[11]++;
			break;
		case 'p':
			consonantes[12]++;
			break;
		case 'q':
			consonantes[13]++;
			break;
		case 'r':
			consonantes[14]++;
			break;
		case 's':
			consonantes[15]++;
			break;
		case 't':
			consonantes[16]++;
			break;
		case 'v':
			consonantes[17]++;
			break;
		case 'w':
			consonantes[18]++;
			break;
		case 'x':
			consonantes[19]++;
			break;
		case 'y':
			consonantes[20]++;
			break;
		case 'z':
			consonantes[21]++;
			break;
		}
	}
 
}

Y estos son los resultados que genera:
vocales.txt
1
2
3
4
5
a --> 37
e --> 21
i --> 11
o --> 11
u --> 4

consonantes.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
b --> 0
c --> 11
d --> 5
f --> 0
g --> 0
h --> 6
j --> 0
k --> 0
l --> 13
m --> 10
n --> 22
ñ --> 0
p --> 1
q --> 1
r --> 7
s --> 15
t --> 7
v --> 6
w --> 0
x --> 0
y --> 4
z --> 0


Pregunta cualquier cosa que no hayas entendido o te genere dudas.

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
2
Comentar
sin imagen de perfil
Val: 5
Ha disminuido su posición en 99 puestos en Java (en relación al último mes)
Gráfica de Java

Leerá cada línea del poema usando un Buffer y contar vocales y consonantes

Publicado por arnau (3 intervenciones) el 31/05/2020 20:42:00
Muchísimas gracias^^
Me ha servido de mucha ayuda.
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