¿Qué es un bucle?
Cuando nos referimos a bucles en lenguajes de programación, nos referimos a los bloques de codigo que facilitan la ejecución de un conjunto de instrucciones repetidamente. Estos bloques de codigo se ejecutan mientras alguna condición se evalúa como verdadera. En java hay tres formas de ejecutar bucles y que difieren en su sintaxis y tiempo de verificación de condición. Estos son los bucles for, while y do while.
El bucle for
El bucle for o for loop se utiliza para ejecutar un bloque de código un número determinado de veces usando una expresion inicial que se actualisa durante la ejecucion de el programa. La sintaxis del bucle for es:
for (expresión inicial; expresión de prueba; expresión de actualización) {
// cuerpo del bucle
}
En estos pasos:
- exprecion inicial declara variables y se ejecuta solo una vez.
- Se evalúa la condición. Si la condición es verdadera, se ejecuta el cuerpo del bucle for.
- La expression de prueba actualiza el valor de la expresion inicial.
- La condición se evalúa de nuevo. El proceso continúa hasta que la condición es falsa.
Ejempos usando el bucle for:
/* Sintaxis:
for(inicialización; condición de prueba;incremento/decremento)
{
declaraciones ejecutadas cada iteracion
}
*/
////////////////////////////////////////////////////////////
// Ejemplo #1:
// Programa para imprimir de el numero uno a cinco
public class Main {
public static void main(String[] args) {
int n = 5;
for (int i = 1; i <= n; ++i) {
System.out.println("El numero:"+i);
}
}
}
/*
salida:
El numero:1
El numero:2
El numero:3
El numero:4
El numero:5
*/
////////////////////////////////////////////////////////////
// Ejemplo #2:
// Un programa que suma un grupo de números y obtiene su promedio
public class Main {
public static void main(String[] args) {
int total = 0;
int promedio = 0;
int []numeros={3,44,77,89,6,2,66,70};
for (int i = 0; i < numeros.length; ++i) {
total += numeros[i];
}
promedio = total/numeros.length;
System.out.println("El promedio es:"+promedio);
}
}
/*
salida:
El promedio es: 44
*/
////////////////////////////////////////////////////////////
// Ejemplo #3:
// Un programa que recorre una matriz con letras. Utiliza un bucle for para comprobar si una letra es una vocal o una consonante.
public class vocalOconsonante {
public static void main(String[] args) {
char[] ch = {'i','z','t','a','e','c','t'};
int vocal=0;
int consonante=0;
for(int i =0; i<ch.length;i++)
if(ch[i] == 'a' || ch[i] == 'e' || ch[i] == 'i' || ch[i] == 'o' || ch[i] == 'u' )
vocal++;
else
consonante++;
System.out.println("El numero de vocales en el array es:"+vocal);
System.out.println("El numero de consonantes en el array es:"+consonante);
}
}
/*
Salida:
El numero de vocales en el array es:3
El numero de consonantes en el array es:4
*/
El bucle for each
El bucle for each se utiliza para iterar a traves de elementos de matrices y colecciones. El bucle for each es una manera mejorada de usar el bucle for.
for (tipo de dato elemento : matriz) {
// cuerpo del bucle
}
- El tipo de dato tiene que ser el mismo al de la matriz.
- En cada iteracion de el bucle el elemento cambia al siquiente valor de la matriz.
Ejempos usando el bucle for:
/* Sintaxis:
for(datatipo elemento: matriz)
{
declaraciones ejecutadas cada iteracion
}
*/
////////////////////////////////////////////////////////////
// Ejemplo #1:
// Programa para imprimir los numeros en un array
public class Main {
public static void main(String[] args) {
int numeros[] = {1,2,3,4,5};
for (int i : numeros) {
System.out.println("El numero:"+i);
}
}
}
/*
salida:
El numero:1
El numero:2
El numero:3
El numero:4
El numero:5
*/
////////////////////////////////////////////////////////////
// Ejemplo #2:
// Un programa que suma un grupo de números y obtiene su promedio
public class Main {
public static void main(String[] args) {
int total = 0;
int promedio = 0;
int []numeros={3,44,77,89,6,2,66,70};
for (int i : numeros) {
total += i;
}
promedio = total/numeros.length;
System.out.println("El promedio es:"+promedio);
}
}
/*
salida:
El promedio es: 44
*/
////////////////////////////////////////////////////////////
// Ejemplo #3:
// Un programa que recorre una matriz con letras. Utiliza un bucle for para comprobar si una letra es una vocal o una consonante.
public class vocalOconsonante {
public static void main(String[] args) {
char[] ch = {'i','z','t','a','e','c','t'};
int vocal=0;
int consonante=0;
for(char i : ch)
if(i == 'a' || i == 'e' || i == 'i' || i == 'o' || i == 'u' )
vocal++;
else
consonante++;
System.out.println("El numero de vocales en el array es:"+vocal);
System.out.println("El numero de consonantes en el array es:"+consonante);
}
}
/*
Salida:
El numero de vocales en el array es:3
El numero de consonantes en el array es:4
*/
El bucle while
El bucle while se ejecuta mientras una expresion es verdadera. Debe haber un valor que cambie durante la ejecución del bloque de código que eventualmente haga que la expresión sea falsa. De lo contrario, el aspecto se ejecutará infinitamente, dándote un error. Este error de bucle infinito describe una falla técnica que obliga a su computadora a repetir las mismas acciones una y otra vez. Un bucle infinito es un error de tiempo de ejecución. La sintaxis del bucle while es:
while (expresion){
cuerpo de el bucle
}
Aqui,
- el bucle evalúa la expresión entre paréntesis.
- Si es verdadero, ejecuta el bloque de código. Posteriormente la expresión será evaluada nuevamente.
- Si es falso, sale del bucle.
/* Sintaxis:
while(expresion)
{
declaraciones ejecutadas cada iteracion
}
*/
////////////////////////////////////////////////////////////
// Ejemplo #1:
// Programa para imprimir de el numero uno a cinco
public class Main {
public static void main(String[] args) {
int n = 5;
int i = 1;
while (i<=5) {
System.out.println("El numero:"+i);
i++;
}
}
}
/*
salida:
El numero:1
El numero:2
El numero:3
El numero:4
El numero:5
*/
////////////////////////////////////////////////////////////
// Ejemplo #2:
// Un programa que suma un grupo de números y obtiene su promedio
public class Main {
public static void main(String[] args) {
int total = 0;
int promedio = 0;
int cuenta = 0;
int []numeros={3,44,22,89,6,2,66,70};
while (cuenta<numeros.length) {
total += numeros[cuenta];
cuenta++;
}
promedio = total/numeros.length;
System.out.println("El promedio es:"+promedio);
}
}
/*
salida:
El promedio es: 37
*/
////////////////////////////////////////////////////////////
// Ejemplo #3:
// Un programa que recorre una matriz con letras. Utiliza un bucle for para comprobar si una letra es una vocal o una consonante. public public class vocalOconsonante {
public static void main(String[] args) {
char[] ch = {'z','z','t','a','c','o','t'};
int vocal=0;
int consonante=0;
int i = 0;
while(i<ch.length){
if(ch[i] == 'a' || ch[i] == 'e' || ch[i] == 'i' || ch[i] == 'o' || ch[i] == 'u' )
vocal++;
else
consonante++;
i++;
}
System.out.println("El numero de vocales en el array es:"+vocal);
System.out.println("El numero de consonantes en el array es:"+consonante);
}
}
/*
Salida:
El numero de vocales en el array es:2
El numero de consonantes en el array es:5
*/
El bucle do while
La logica detras de el bucle do while es igual a el bucle while la diferencia es que do while ejecuta el codigo dentro de el bucle una vez antes de comprobar la expresión de prueba. La sintaxis de el bucle do while es:
do{
do{
cuerpo de el bucle
}while{expresion};
- El bucle ejecuta el codigo en en cuerpo de el bucle.
- el bucle evalúa la expresión entre paréntesis.
- Si es falso, sale del bucle.
- Si es verdadero, continua ejecutando el bloque de código.
/* Sintaxis:
do
{
declaraciones ejecutadas cada iteracion
}while(expresion)
*/
////////////////////////////////////////////////////////////
// Ejemplo #1:
// Programa para imprimir de el numero uno a cinco
public class Main {
public static void main(String[] args) {
int n = 5;
int i = 1;
do {
System.out.println("El numero:"+i);
i++;
} while (i<=5)
}
}
/*
salida:
El numero:1
El numero:2
El numero:3
El numero:4
*/
Bucles anadidos
Un bucle anidado tiene un bucle dentro de otro bucle. Por lo general, se usan para trabajar con dos dimensiones usando array o otras estructuras de datos. Cómo funciona esto es que el primer paso del ciclo externo activa el ciclo interno, que se ejecuta hasta el final. Luego, el segundo paso del bucle exterior activa de nuevo el bucle interior. Esto se repite hasta que termine el bucle exterior. Cualquier tipo de bucle puede actuar como bucle interior o exterior.
/* Sintaxis:
Bucle(expresion)
{
Bucle(expresion){
declaraciones ejecutadas cada iteracion
}
}
*/
////////////////////////////////////////////////////////////
// Ejemplo #1:
// Programa para imprimir numeros uno a cien
public class Main {
public static void main(String[] args) {
int i = 0;
for(int j = 0;j<10;j++){
for(int k =0;k<10;k++){
i=j*10+k;
System.out.print(i+" ");
}
System.out.println(" ");
}
}
}
/*
salida:
0 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
*/
////////////////////////////////////////////////////////////
// Ejemplo #2:
// En este programa encontramos la nota media de cada alumno en una lista. Donde los nombres de la matriz contienen el nombre de los estudiantes y las calificaciones de la matriz bidimensional contienen sus calificaciones.
public class Main {
public static void main(String[] args) {
String n ="";
int alto = 0;
int [][]grados = {{66,52,99},{52,90,77},{89,99,87},{67,55,53},{43,66,87},{78,88,83},{82,93,84}};
String []nombres ={"luis","jose","anna","david","josefina","maria","rosy"
};
for(int j = 0;j<nombres.length;j++){
int t = 0;int promedio = 0;
for(int k =0;k<3;k++){
t+=grados[j][k];
}
promedio = t/3;
System.out.println(nombres[j]+" Tiene un promedio de clase de: "+promedio);
}
}
}
/* Salida:
luis Tiene un promedio de clase de: 72
jose Tiene un promedio de clase de: 73
anna Tiene un promedio de clase de: 91
david Tiene un promedio de clase de: 58
josefina Tiene un promedio de clase de: 65
maria Tiene un promedio de clase de: 83
rosy Tiene un promedio de clase de: 86
*/