Sentencia while

La sentencia while permite la ejecución de un bloque de sentencias de forma repetitiva. El bloque de sentencias se ejecutará repetidamente mientras se cumpla una determinada condición, la cual será una expresión booleana. Si al evaluar la condición resulta true, el bloque se sentencias se ejecutará, y se repetirá su ejecución hasta que la condición resulte false.

Este tipo de sentencias, que permiten la repetición de un bloque de sentencias, reciben también el nombre de bucles.

Es importante tener controlada la salida del bucle, de forma que si entra en él, debe cumplirse en algún momento que la condición resulte false para que termine el bucle. Si no ocurriera esto, el bucle sería infinito y el programa dejaría de responder.

La sentencia while se caracteriza porque permite repetir un bloque de instrucciones de 0 a varias veces. La condición que se establece se evalúa antes de ejecutar el bloque de instrucciones que contiene la instrucción Mientras. Si el resultado de la expresión resulta Falso el bloque de instrucciones no se ejecutará ninguna vez.

Se debe utilizar el siguiente formato:

    while (condición)
    {
       BloqueDeSentencias;
    }

Como siempre, si el bloque de sentencias está formado por una única sentencia, se puede prescindir de las llaves.

El orden de ejecución de una sentencia while es la siguiente:

1. Evaluar la condición.
• Si el resultado es true, ejecutar el bloque de sentencias de la estructura while y volver al punto 1.
• Si el resultado es false ir al punto 2.
2. Continuar la ejecución del programa.

Las expresiones condicionales que se indican en los paréntesis del while suelen ser expresiones relacionales que resultan valores lógicos (true o false) o cualquier otra expresión que también resulte un valor booleano, por ejemplo:

• while (num > 0)
• while (letra == 'N' || letra == 'n')
• while (num >= 0 && num <=100)
• while (!cadena.equalsIgnoreCase("fin"))

Ejemplo: Generar la secuencia de números siguiente: 1 2 4 7 11 16 22 etc. En ella, se va incrementando cada vez una unidad más respecto a la anterior. La secuencia se debe generar hasta que se alcance el valor máximo que indique el usuario:

public class EjemploWhile extends javax.swing.JFrame
{

    public EjemploWhile()
    {
        initComponents();
    }

    /* Código generado automáticamente no mostrado */

    private void botónGenerarActionPerformed(java.awt.event.ActionEvent evt)
    {
        int numMax = Integer.valueOf(campoMáximo.getText());
        int numActual = 1;
        int incremento = 1;
        while (numActual <= numMax)
        {
            areaMensajes.append(String.valueOf(numActual) + " ");
            numActual+=incremento;
            incremento++;
        }
    }

    public static void main(String args[])
    {
        java.awt.EventQueue.invokeLater(new Runnable()
        {

            public void run()
            {
                new EjemploWhile().setVisible(true);
            }
        });
    }

    private javax.swing.JTextArea areaMensajes;
    private javax.swing.JTextField campoMáximo;
    private javax.swing.JButton botónGenerar;
    private javax.swing.JLabel jLabel1;
    private javax.swing.JScrollPane jScrollPane1;
}

En este ejemplo conviene observar que si el usuario introduce el valor 0 o cualquier valor negativo, el programa no entrará ninguna vez en el bloque de sentencias de la instrucción while.