Es normal que nos encontremos en múltiples ocasiones con la necesidad de repetir diversas veces una misma sentencia. Por ejemplo: si buscamos un texto concreto dentro de otro texto. Tendremos que leer la primera palabra y si esta no es la que buscamos deberemos leer la segunda y así sucesivamente hasta localizar el texto que buscamos o hasta el final del fichero.

Tal y como dijimos si conocemos el número de veces que deberemos repetir la operación o podemos instanciar una repetición por medio de un contador utilizaremos una sentencia de repetición FOR. Si el bloque debe ejecutarse por lo menos una vez pero no sabemos cuantas más utilizaremos una sentencia DO WHILE y en caso de desconocerse el número de repeticiones y si la condición no se cumple no debe cumplirse el bloque ni una sola vez utilizaremos WHILE.

La mecánica de estos elementos de control de flujo se comprende de una forma más sencilla si lo vemos en ejecución. Planteémonos que debemos recoger un texto de un usuario, contar cuantas palabras tiene, descomponerlo en palabras y volverlo a montar.

En primer lugar podríamos crear un nuevo proyecto en el Eclipse llamado tercero. Le podríamos añadir una clase a la que llamamos FlujoFor. El código de esa clase seria más o menos el siguiente.

1. import java.util.*;
2. import java.util.regex.Pattern;
3. public class FlujoFor {
4. private String frase; //guardamos frase del constructor
5. //constructor sin parametros
6. FlujoFor()
7. {
8. Scanner sc = new Scanner(System.in);
9. System.out.println("Introduce una frase");
10. frase = sc.nextLine();
11. }
12. //constructor con parametros
13. FlujoFor(String Texto)
14. {
15. frase = Texto;
16. }
17. //metodo get para leer el atributo frase
18. public String getFrase() {
19. return frase;
20. }
21. void ManipularTexto(String Parrafo)
22. {
23. /*eliminamos los espacios del principio y
24. del final de la frase.*/
25. String FraseLimpia=Parrafo.trim();
26. /*creamos un delimitador para
27. partir el texto*/
28. Pattern deli=Pattern.compile(" ");
29. //partimos la frase y la pasamos a un array
30. String TrozoFrase [] = deli.split(FraseLimpia);
31. //cuantas palabras tiene
32. System.out.println("Tiene un total de " + TrozoFrase.length + " palabras");
33. //mostramos las partes de la frase
34. System.out.println("Se descone en: ");
35. for(int contador=0; contador
36. {
37. System.out.println(TrozoFrase[contador]);
38. }
39. //recomponemos la frase
40. System.out.println("Una vez compuesta queda: ");
41. String UnionFrase="";
42. for(int contador=0; contador
43. {
44. UnionFrase = UnionFrase + TrozoFrase[contador] + " ";
45. }
46. System.out.println(UnionFrase);
47. }
48. }

En este código aparecen algunos conceptos de los que no hemos hablado como la importación de java.util.regex.Pattern de esta clase de java hablaremos mas adelante. La función trim nos devuelve la frase una vez eliminados los espacios en blanco del principio y del final de la frase, por eso se la asignamos a una variable, donde la recogemos. La clase Pattern y su método compile (que pertenecen a la clase java.util.regex.Pattern) sirven para crear una expresión regular que en este caso utilizaremos como limitador, podríamos crear cualquiera e incluso varios a la vez, por ejemplo: Pattern deli=Pattern.compile("[ , . ¡]"); La función splits troceara una frase en base a un delimitador que tomara como limite y devolverá cada trozo de la frase formando un array en este caso será String TrozoFrase []. La longitud del array será en este caso igual al número de palabras, trozos, que componen la frase inicial. Los dos for que contiene el código ejecutan el mismo trabajo. En cada iteración toman una de las palabras, es decir el valor que esta guardado en el índice del array que se indica. TrozoFrase[contador] tiene el mismo valor que TrozoFrase[1], cuando contador valga uno claro esta. En el primer for en cada iteración se muestra el valor por consola. En el segundo for cada iteración añade el valor de TrozoFrase[contador] a la variable UnionFrase y después mostramos el valor de esta variable.

Para probar esta clase crearemos otra llamada TestFlujo y marcaremos la opcion public static void main(String[] args).

En caso que utilicemos el constructor sin parámetros nuestra clase quedaría mas o menos así.

1. public class TestFlujo {
2. public static void main(String[] args) {
3. FlujoFor MiFor= new FlujoFor();
4. MiFor.ManipularTexto(MiFor.getFrase());
5. }
6. }

En este código recogemos el valor del atributo frase con el método MiFor.getFrase() que devuelve precisamente ese valor. Un posible resultado seria el que se recoge en la imagen.

Si utilizásemos el constructor con parámetros nuestro código seria.

1. public class TestFlujo {
2. public static void main(String[] args) {
3. FlujoFor MiFor= new FlujoFor("Me esta gustado este blog");
4. MiFor.ManipularTexto(MiFor.getFrase());
5. }
6. }

Un posible resultado seria el que se recoge en la imagen.

En el siguiente post continuaremos con los bloques repetitivos.

Enlaces interesantes

• Eclipse
• Página oficial de Java en español