Resumen Interfaz List y clases implementadoras

En este diagrama os dejo las clases que deberéis conocer sobre la interfaz List, los métodos más usados y algunas anotaciones sobre ellas.

1. Ejemplo ArrayList

import java.util.*;
public class EjemArrayList{
    public static void main (String[] args){
        ArrayList nombres = new ArrayList();
        System.out.println("Elementos al inicio: " + nombres.size());
        nombres.add("Ana");
        nombres.add("Bea");
        nombres.add("Dalia");
        nombres.add("Pedro");
        nombres.add("Bea");  //comprobar que admite duplicados

        System.out.println("Contenido: " + nombres);
        System.out.println("Elementos: " + nombres.size());
        System.out.println(nombres.contains("Ana"));

        nombres.remove("Ana"); //eliminamos un elemento

        System.out.println("Contenido: " + nombres);
        System.out.println("Elementos: " + nombres.size());
        System.out.println(nombres.contains("Ana"));

        nombres.add(3, "Ana"); //Añadir en posicion x
        System.out.println("Contenido: " + nombres);

        System.out.println("SubLista(1,4):" + nombres.subList(1,4));
    }
}

Resultado de la ejecución:

2. Ejemplo LinkedList

import java.util.*;
public class EjemLinkedList {
    public static void main (String[] args){
        LinkedList nombres = new LinkedList();
        nombres.add("Ana");
        nombres.add("Maria");
        nombres.add("Pedro");
        nombres.addFirst("Elena"); //insertamos al ppio.
        nombres.addLast("Bea"); //insertamos al final.
        nombres.add(2, "Lola"); //insertamos en posicion x

        System.out.println("\nContenido: " + nombres);
        System.out.println("getFirst(): " + nombres.getFirst());
        System.out.println("getLast(): " + nombres.getLast());

        System.out.println("\nHacemos peek(): " + nombres.peek());
        System.out.println("Contenido: " + nombres);

        System.out.println("\nHacemos poll(): " + nombres.poll());
        System.out.println("Contenido: " + nombres);

        System.out.println("\nHacemos offer(): " + nombres.offer("Luis"));
        System.out.println("Contenido: " + nombres);

    }
}

Resultado de la ejecución:

Si queréis consultar algún método en concreto o verlos todos: ArrayList, LinkedList, List.

 

Resumen Interfaz Set y clases implementadoras

En este diagrama os dejo las clases que deberéis conocer sobre la interfaz Set, los métodos más usados y algunas anotaciones.

También algunos ejemplos para que comprobéis sus características.

1. Ejemplo HashSet

import java.util.*;
public class EjemploHashSet {

    public static void main (String[] args)
    {
        HashSet<String> s1 = new HashSet <String>();
        s1.add("Hola");
        s1.add("Hola amigo");
        s1.add("Encantado de conocerte");
        s1.add("Se me hace tarde");
        s1.add("Espero verte pronto");
        s1.add("Adios");

        s1.add("Adios"); //Intentamos añadir un duplicado.

        System.out.println("Numero de elementos: " + s1.size() + "\n");

        Iterator i = s1.iterator();
        while (i.hasNext()){
            System.out.println(i.next());
        }
    }
}

2. Ejemplo LinkedHashSet

import java.util.*;
public class EjemploLinkedHashSet {

    public static void main (String[] args)
    {
        LinkedHashSet<String> s2 = new LinkedHashSet <String>();
        s2.add("Hola");
        s2.add("Hola amigo");
        s2.add("Encantado de conocerte");
        s2.add("Se me hace tarde");
        s2.add("Espero verte pronto");
        s2.add("Adios");

        s2.add("Adios"); //Intentamos añadir un duplicado.

        System.out.println("Numero de elementos: " + s2.size() + "\n");

        Iterator i = s2.iterator();
        while (i.hasNext()){
            System.out.println(i.next());
        }
    }
}

3. Ejemplo TreeSet

import java.util.*;
public class EjemploTreeSet {

    public static void main (String[] args)
    {
        TreeSet<String> s3 = new TreeSet<String>();
        s3.add("Hola");
        s3.add("Hola amigo");
        s3.add("Encantado de conocerte");
        s3.add("Se me hace tarde");
        s3.add("Espero verte pronto");
        s3.add("Adios");
        s3.add("Adios"); //Intentamos añadir un duplicado.

        System.out.println("Numero de elementos: " + s3.size() + "\n");

        Iterator i = s3.iterator();
        while (i.hasNext()){
            System.out.println(i.next());
        }

        System.out.println ("\nlower(\"Encantado de conocerte\"): "
        + s3.lower("Encantado de conocerte"));
        System.out.println("floor(\"Encantado de conocerte\"): "
        + s3.floor("Encantado de conocerte"));
        System.out.println("higher(\"Encantado de conocerte\"): "
        + s3.higher("Encantado de conocerte"));
        System.out.println("ceiling(\"Encantado de conocerte\"): "
        + s3.ceiling("Encantado de conocerte"));

        // Devolvemos el set en orden descendente
        NavigableSet<String> reverse =   s3.descendingSet();

        //Lo mostramos
        Iterator r1 = reverse.iterator();
        while (r1.hasNext()){
            System.out.println(r1.next());
        }

        //Hacemos un pollFirst y pollLast
        //Devuelve y elimina el primer elemento
        System.out.println("\nreverse.pollFirst: " + reverse.pollFirst());
        //Devuelve y elimina el ultimo elemento
        System.out.println("reverse.pollLast: " + reverse.pollLast() + "\n");

        //Vemos cómo queda el set
        Iterator r2 = reverse.iterator();
        while (r2.hasNext()){
            System.out.println(r2.next());
        }

    }
}

 

Las clases de cadena: String, StringBuffer y StringBuilder

Java proporciona tres clases diferentes para tratar con cadenas de caracteres:

• java.lang.String
• java.lang.StringBuffer
• java.lang.StringBuilder

Los objetos String son cadenas de caracteres estáticas, al crearse e inicializarse no pueden cambiar su valor. Es porque son inmutables que pueden ser compartidas por varias referencias.

Los objetos StringBuffer y StringBuilder, por el contrario, son cadenas de caracteres dinámicas, pueden cambiar su contenido y su capacidad.

La diferencia entre los objetos StringBuffer y StringBuilder es que los primeros pueden ser utilizados de forma segura por varios hilos, siendo sus métodos sincronizados mientras que los objetos StringBuilder no.

La clase StringBuilder se añadió en la versión J2SE 1.5.

 

30 preguntas sobre Assertions

He recopilado las siguientes 30 preguntas sobre Assertions de diferentes
fuentes, citadas al final del post.

Las primeras son más teóricas, preguntando sobre las características de las Assertions y su uso adecuado o no, mientras que las siguientes se concentran en que el aspirante conozca el resultado de la ejecución.

He creído mejor esta vez no colocar las respuestas, si alguna la encontráis difícil o dudosa, podemos hablar de ella en los comentarios.

1. Suponiendo que están habilitadas las assertions, ¿cúales de las siguientes sentencias lanzarán un error?

1. assert true : true;
2. assert true : false;
3. assert false : true;
4. assert false : false;

2. ¿Cuáles de las siguientes opciones son válidas?

1. -ae
2. -enableassertions
3. -source 1.4
4. -disablesystemassertions
5. -dea

3. ¿Cuál es el nombre de la excepción lanzada por una sentencia assertion?

1. Depends on the assertion statement.
2. FailedAssertion
3. AssertionException
4. RuntimeException
5. AssertionError
6. Error

4. ¿Qué puede provocar que una sentencia assert sea ignorada?

1. Nada.
2. Usando las opciones de compilación correctas.
3. Usando las opciones de tiempo ejecución correctas.
4. Usando las opciones de compilación y tiempo de ejecución correctas.

5. Suponiendo que las assertions están habilitadas, dado el siguiente método, ¿qué sentencias lanzarán una excepción?

static int inv(int value) {
assert value > -50 : value < 100;
return 100/value;
}

1. inv(-50)
2. inv(0)
3. inv(50)
4. inv(100)
5. inv(150)

 

Soluciones – Assertions

Solución Ejercicio 1:

Creamos la clase Assert_Identificador.java

public class Assert_Identificador
{
        //Código Anterior a la J2SE 1.4
        //assert como identificador.
	public static void main(String[] args)
	{
		boolean assert;
		assert = Integer.parseInt(args[0]) % 5 == 0;
                if (assert) {
			System.out.println("Correcto");
		}
		else{
			System.out.println("No Correcto");
		}
	}
}

Compilamos normalmente y observamos el error:

Compilamos ahora indicando la versión 1.3 y observamos los warnings:

Ejecutamos:

Solución Ejercicio 2: 

Creamos la clase Assert_PalabraClave.java.

Definimos un constructor con la longitud del array de edades como parámetro.

Creamos un método público setEdad(int pos, int valor) para dar valores a las posiciones del array.
En este método público setEdad, validamos los argumentos lanzando excepciones si no son correctos. Quitaremos estas comprobaciones para provocar que salte la assertion posteriormente.

Creamos el método privado mediaEdades() que calcula la media e incluye la assertion que supone que la media siempre será >0.

public class Assert_PalabraClave{
    private int[] edades;

    public Assert_PalabraClave (int tam){
       edades = new int[tam];
    }

    public void setEdad(int i, int valor){
    /* En un método público no podemos usar assertions para comprobar los
       argumentos, se deben lanzar excepctions si no son válidos. Comentar
       los ifs y exceptions para dejar solo this.edades[i] = valor y
       poder poner en el main un valor negativo que haga saltar
       la assertion en mediaEdades. */

        if (iedades.length-1){
            throw new IllegalArgumentException("\nPosicion: " + i + " fuera de rango del array");
        }
        else if (valor < 0){
            throw new IllegalArgumentException("\nValor: " + valor + " menor de 0");
        }
        else{
    	    this.edades[i] = valor;
        }
    }

    private float mediaEdades(){
        int suma = 0;
        float media = 0;
        int i;
        for (i=0; i 0): "La media no es mayor que cero, es: " + media;
        return media;
    }

    public static void main (String[] args)
    {
          Assert_PalabraClave apc = new Assert_PalabraClave(5);
          apc.setEdad(0, 10);
          apc.setEdad(1, 3);
          apc.setEdad(2, 4);
          apc.setEdad(3, 7);
          apc.setEdad(4, 23);
          //apc.setEdad(4, -100); //para provocar excepción por valor menor de cero.
          //apc.setEdad(5, 39); //para provocar excepción por posición fuera de rango.

	  System.out.println("La media de edad es: " + apc.mediaEdades());

    }

Compilamos con -source 1.3 para observar el error:

Compilarmos normalmente y ejecutamos habilitando assertions:

Modificamos el código fuente para hacer saltar la assertion, compilamos y ejecutamos:

Solución Ejercicio 3:
En el constructor no se puede utilizar un assertion para comprobar los argumentos, ya que es público y esencial que al construirse el objeto se garantice que sus atributos tengan valores válidos. Modificar con excepciones.

Los asserts en los métodos públicos subir(int personas) y bajar(int personas) son correctos ya que no están comprobando los valores del argumento personas, sino el estado final de los atributos del objeto bus.

El assert que comprueba los argumentos pasados en la línea de comandos al programa también es un uso inapropiado. Modificar con excepciones.

Solución Ejercicio 4:

Escribimos un switch sencillo que según el entero nos imprima el día de la semana que le correspondería.

public class AssertSwitch{

  public static void mostrarDiaSemana(int dia)
  {
       switch(dia){
           case 1: System.out.println("Lunes");
           break;

           case 2: System.out.println("Martes");
           break;

           case 3: System.out.println("Miercoles");
           break;

	   case 4: System.out.println("Jueves");
           break;

	   case 5: System.out.println("Viernes");
           break;

           case 6: System.out.println("Sabado");
           break;

	   case 7: System.out.println("Domingo");
           break;

	   default:
		assert(false): "Int Dia pasado: " + dia;
        }
    }

    public static void main (String[] args){
        mostrarDiaSemana(3);
        mostrarDiaSemana(9); //Se supone que este valor nunca se daria
    }
}

 

Deberes – Assertions

Algunos ejercicios para practicar Assertions:

• Ejercicio 1: 

Crear una clase Assert_Identificador.java que utilice assert como identificador y que imprima «Correcto» si el argumento pasado en la línea de comandos es divisible por 5 y «No Correcto» en caso contrario.

Compilar normalmente para observar el fallo.
Compilar y ejecutar para que tome el código antiguo sin problemas.

• Ejercicio 2: 

Crear una clase Assert_PalabraClave.java que tenga como atributo un array de enteros llamado edades y crear un método privado mediaEdades que devuelva la medida de las edades en el array y se asegure con una assertion que la media será siempre > 0.

Compilar indicando -source 1.3 para observar el fallo.
Compilar normalmente y ejecutar habilitando assertions.
Introducir valores incorrectos para provocar un AssertionError

• Ejercicio 3:

Corregir la siguiente clase para que todos los assertions estén usados apropiadamente:

public class Bus {
    private int capacidad;
    private int asientosDisponibles;
    private int asientosOcupados;

    //Constructor para elegir capacidad y asientos iniciales ocupados.
    public Bus(int capacidad, int asientosOcupados){
       assert(capacidad>0);
       assert(asientosOcupados<capacidad);
       this.capacidad = capacidad;
       this.asientosDisponibles = this.capacidad - asientosOcupados;
       this.asientosOcupados = asientosOcupados;
    }

   public void subir(int personas)
    {
        try{comprobarPlazasDisponibles(personas);
        }catch(IllegalArgumentException e){
             System.out.println(e.getMessage());
             personas = this.asientosDisponibles;
        }
        this.asientosDisponibles = this.asientosDisponibles - personas;
        this.asientosOcupados = this.asientosOcupados + personas;
        assert(this.capacidad == this.asientosDisponibles + this.asientosOcupados);
    }

    private void comprobarPlazasDisponibles (int personas) throws IllegalArgumentException{
      if (personas > this.asientosDisponibles){
          throw new IllegalArgumentException("No hay asientos para " + personas + " personas");
      }
    }

    public void bajar(int personas)
    {
        try{ comprobarPlazasOcupadas(personas); //Llama a método privado.
        }catch(IllegalArgumentException e){
            System.out.println(e.getMessage());
            personas = this.asientosOcupados;
        }
    this.asientosDisponibles = this.asientosDisponibles + personas;
        this.asientosOcupados = this.asientosOcupados - personas;
        assert(this.capacidad == this.asientosDisponibles + this.asientosOcupados);
    }

    private void comprobarPlazasOcupadas (int personas) throws IllegalArgumentException{
      if(this.asientosOcupados < personas){
        throw new IllegalArgumentException("No hay " + personas + " personas ocupando asientos");
      }
    }

    public void mostrar()
    {    System.out.println("Capacidad: " + this.capacidad + ".\n" +
                "Ocupados: " + this.asientosOcupados + ".\n" +
	        "Disponibles: " + this.asientosDisponibles + ".\n");
    }

    public static void main (String [] args)
    {
     assert(Integer.parseInt(args[0])>0 && Integer.parseInt(args[1])>0);
     Bus b = new Bus(Integer.parseInt(args[0]), Integer.parseInt(args[1]));     b.mostrar();

    System.out.println("Suben 6");  b.subir(6);  b.mostrar();
    System.out.println("Bajan 3");  b.bajar(3);  b.mostrar();
    System.out.println("Sube 1");   b.subir(1);  b.mostrar();
    System.out.println("Bajan 42"); b.bajar(42); b.mostrar();
    }
}

• Ejercicio4:

Escribir un bloque switch en el que usemos una assertion para comprobar un caso que no debe producirse.

Soluciones en la siguiente entrada para no alargar mucho el post.

 

Assertions: Habilitacion Selectiva, Usos Apropiados

Sobre versiones:

En el examen siempre estaremos usando la versión 6 del compilador (javac) y la versión 6 del lanzador (java). Si existen preguntas sobre código de versiones anteriores siempre serán en el contexto de compilar y ejecutar código antiguo con la versión 6 de Java.

A partir de la versión J2SE 1.4 assert es una palabra clave.
En versiones anteriores assert podía ser utilizada como identificador al no existir todavía las assertions.

Si quisiéramos compilar código antiguo en el que assert se utiliza como identificador hemos de indicar la versión al compilar con la opción -source:

javac -source 1.3 Assert_Identificador.java

Compilaría ok, aunque con warnings, indicando que assert se utiliza como identificador y ejecutaría ok.

Si ese código antiguo lo compiláramos con la versión 1.4 o con la versión por defecto, 1.6, nos daría error:

javac -source 1.4 Assert_Identificador.java
javac Assert_Identificador.java
javac -source 1.6 Assert_Identificador.java
javac -source 6 Assert_Identificador.java

De la misma forma, si un código que utiliza assert como palabra clave se compilara indicando la versión antigua en la que existía como identificador, también se produciría un error de compilación:

javac -source 1.3 Assert_PalabraClave.java

Habilitación e Inhabilitación selectiva:

En la entrada anterior vimos en un ejemplo cómo habilitabamos las assertions en tiempo de ejecución para un fichero .class en concreto:

java -ea Triangulo

Sin embargo, la habilitación o deshabilitación se puede hacer también:

• Para todas las clases:
  java -ea           //habilita assertions.
  java -da           //deshabilita assertions.
  java -ea -dsa    //habilita assertions en todas las clases menos las clases de sistema.

• Para todas las clases de un paquete y sus subpaquetes:
  java -ea: proyecto.utiles… //habilita clases del paquete proyecto.utiles y subpaquetes.
  java -da: proyecto.utiles… //deshabilita clases del paquete y subpaquetes.

• Usando combinaciones:
  java -ea -da: proyecto.utiles.Calendario //Habilita assertions menos la clase Calendario
  java -da -ea: proyecto.utiles… //Deshabilita assertions menos las clases del paquete y
  //subpaquetes

Usos Inapropiados: 

• Comprobar argumentos de método público.
  Al ser públicos y poder ser utilizados por terceros se debe garantizar con un control más estricto que las assertions, ya que si las assertions están deshabilitadas no se produce ninguna comprobación. Si los valores de los argumentos de un método público son incorrectos se debe lanzar una excepción.

• Comprobar argumentos de línea de comandos.
  De la misma forma si los valores pasados como argumentos a un programa se necesitan validar no deben ser comprobados con assertions sino con excepciones.

• Provocar efectos colaterales.
  Las assertions no deberían provocar cambios en el estado del programa. No deben modificarse datos dependiendo de si están habilitadas o no.

Usos Apropiados: 

• Comprobar argumentos de método privado.
  Los métodos privados serán llamados desde algún código público en el que ya se haya garantizado la correción de los argumentos pasados. Por lo tanto sí se pueden realizar suposiciones con assertions dentro del código privado.

• Comprobar casos que nunca se producirán (incluso en métodos públicos).
  En bloques if o switch para verificar que ciertas ramas o casos no se deben alcanzar nunca se coloca un assert(false) para que si estamos equivocados en nuestra suposición falle.

En el siguiente post veremos algunos ejercicios y preguntas sobre assertions.

 

Assertions: Introducción y Ejemplo

Una aserción es una expresión lógica que el programador supone que siempre será verdadera cuando se ejecute. Es una forma de confirmar que esta suposición es cierta durante el desarrollo y así evitar tener que programar código que compruebe o controle casos que no se producirán.

Tenemos dos formas de utilizar las assertions:

assert(expresion_logica);
assert(expresion_logica): expresion_valor;

La segunda sintaxis nos permite además establecer una expresión que nos dará más información sobre el error. Esta expresion_valor será cualquier expresión que pueda ser convertida a String, es decir puede ser un valor primitivo, una cadena, un objeto, una función que devuelva alguna de las anteriores, etcétera.

Características:

• Se incorporaron en la versión J2SE 1.4
• Siempre se afirma que algo será verdadero.
• Las assertions están deshabilitadas por defecto.
• Para habilitar las assertions añadir al comando java el parámetro -ea (ó -enable assertions).
• Para deshabilitar las assertions añadir al comando java el parámetro -da (ó -disableassertions).
• La clase java.lang.AssertionError desciende de java.lang.Error y ésta a su vez de java.lang.Throwable.

Ejemplo:
En este programa vamos a construir una clase Triangulo. Tendremos un constructor con los lados como parámetros. En la función esRectangulo que devuelve true si el triángulo es rectángulo y false en caso contrario, colocamos una aserción sobre los lados del triángulo.

import java.lang.Math;
public class Triangulo {

    private float ladoa;
    private float ladob;
    private float ladoc;

    public Triangulo(float ladoa, float ladob, float ladoc){
        this.ladoa = ladoa;
        this.ladob = ladob;
        this.ladoc = ladoc;
    }

    public boolean esRectangulo(){
        //Sabemos un lado de un triangulo debe ser menor que la suma
        //de los otros dos lados.
        assert(ladoa < ladob + ladoc): "\nladoa: " + ladoa
                                     + " no es < que:  "
                                     + ladob + " + " + ladoc;
        return(Math.pow(ladoc,2) == Math.pow(ladoa,2) + Math.pow(ladob,2));
    }

    public static void main (String[] args){
        //Triangulo con valores de lados correctos.
        Triangulo t1 = new Triangulo(6,8,10)
        If t1.esRectangulo(){
            System.out.println("El triangulo t1 es rectangulo");
        }
        //Creamos un triangulo cuyos lados harán saltar la assertion.
        Triangulo t2 = new Triangulo(10,3,2);
        if t2.esRectangulo(){
           System.out.println("El triangulo t2 es rectangulo");
        }
    }
}

Resultado:
Vemos en la captura que primero hemos compilado el fichero fuente.
En segundo lugar, hemos ejecutado el programa, pero al estar deshabilitadas las assertion por defecto no ocurre ningún error.
Por último ejecutamos el programa habilitando las assertions y vemos que la condición no se cumple al comprobar los lados del segundo triángulo.
Nos añade a la traza del error la cadena «ladoa: 10.0 no es < que: 3.0 + 2.0»

 

Control del Flujo: Bucles II (break, continue, etiquetas)

Una vez que hemos visto los bucles en Java vamos a ver cómo les afectan las siguientes sentencias: break y continue.

Escribimos un bucle anidado y vemos la diferencia entre break y continue:

public class BucleConBreak{
    public static void main(String[] args){
        for (int i = 0; i< 6; i++){
            for (int j=0; j<5; j++){
                if (j==3){
                    break;
                }
                else{
                    System.out.println("iteracion [i,j]: " + i + ", " + j);
                }
            }
        }
    }
}

El resultado es:

La sentencia break hace que se salga completamente del bucle más interno y proseguimos con la siguiente iteración del bucle externo.

El mismo código pero con continue:

public class BucleConContinue{
     public static void main(String[] args){
         for (int i = 0; i< 6; i++){
             for (int j=0; j<5; j++){
                 if (j==3){
                     continue;
                 }
                 else{
                      System.out.println("iteracion [i,j]: " + i + ", " + j);
                 }
             }
         }
      }
 }

Devuelve:

La sentencia continue hace que pasemos a la siguiente iteración del bucle más interno.

Etiquetas

Es común utilizar las etiquetas con bucles for o while y en conjunción con las sentencias break y continue.

Una etiqueta se coloca antes de la sentencia a etiquetar seguida de ‘:’
Son útiles cuando tenemos bucles anidados y queremos especificar en cuál de ellos queremos hacer un break o continue.

En el siguiente ejemplo tenemos un ejemplo de break etiquetado:
El funcionamiento normal del break sería salir del bucle más interno, el while en este caso.
Sin embargo, el break etiquetado hace que rompa el bucle etiquetado, es decir el for.

public class BucleBreakLabeled{
    public static void main (String[] args){
        boolean esVerdadero = true;
        externo: //etiqueta la siguiente sentencia, es decir el for.
        for (int i = 0; i<5; i++){
            while (esVerdadero){
                System.out.println("Hola!");
                break externo; //break con etiqueta, hace que rompa la sentencia de la etiqueta, el for.
            }
            System.out.println("Despues del while!");
        }
        System.out.println("Despues del for!");
    }
}

Devuelve:

Las sentencias break y continue con etiquetas deben estar dentro de un bucle con la misma etiqueta, si no dará error de compilación.

 

Control del Flujo: Bucles

Los bucles nos permiten alterar el flujo de ejecución de un programa ejecutando repetidamente una sentecia o grupo de sentencias.

En Java 6 tenemos tres opciones distintas a la hora de realizar iteraciones:

• while,
• do while,
• for (normal y mejorado)

Vamos a ver cada una de ellas en detalle.

While

Es el bucle indicado cuando no se sabe de antemano cuántas veces se va a ejecutar el bucle. Simplemente queremos que se repitan ciertas acciones mientras la condición del bucle sea cierta.

//inicialización de variables
while (condicion){   //La condicion debe evaluarse a boolean
    //codigo         //Puede no ejecutarse ninguna vez
}

Cómo funciona:

Al entrar en el while se comprueba la condicion por primera vez.
Si resulta falsa no llega a ejecutar el código y se prosigue la ejecución fuera del bucle.
Si es cierta se ejecuta el código y se vuelve a comprobar la condición.
Así sucesivamente hasta que la condición devuelva falso y salgamos del bucle.

Como veremos la última sentencia que se ejecutará en un bucle siempre será la comprobación de la condición.

Por ejemplo:
En este código la variable i vuelve a incrementarse en la última comprobación de la condición del bucle, cuando ésta ya es falsa.

public class EjemWhile1{
    public static void main (String[] args){
        int i = -1;
        boolean encontrado = false;
        int[] medidas = {10, 30, 40, 50, 70};
        while (++i < 5 && !encontrado){
            if(medidas[i] == 40){
             encontrado = true;
            }
        }
        System.out.println(i);
    }
}

En los bucles while estar atento a:

• Declaración de variables en la condición del while. No se puede, deben estar declaradas con anterioridad.
• Expresiones en la condición del while que no sean boolean.
  Por ejemplo: enteros en lugar de boolean o asignaciones en lugar de comparaciones, darán error de compilación.

Do While

En estos bucles primero se ejecuta el código y luego se comprueba la condición, por lo que tenemos asegurado que el código se ejecuta al menos una vez.

do{
    elem = pila.obtener();
    System.out.println("elem: " + elem);
} while (!pila.esVacia());

Cómo funciona:
En primer lugar se ejecuta el código del bucle.
A continuación se comprueba la condición. Si esta es falsa se prosigue la ejecución fuera del bucle. Si es verdadera se ejecuta el código y se vuelve a comprobar la condición.

Estar atento a las mismas consideraciones que en el while.

For

Es el bucle que solemos utilizar cuando sabemos cuántas veces queremos ejecutar cierto código.

En su sintaxis podemos destacar tres partes importantes:
– declaración e inicialización de variables
– condición
– incremento.

Aunque ninguna de ellas son obligatorias.

Ejemplo de bucle mínimo for:

for ( ; ; ){ //sin inicializacion, condición ni incremento. Sería un bucle infinito.
    //infinito
}

Ejemplo de un bucle for que equivaldría a un while:(sin inicialización ni incremento)

int i = 0;
for ( ; i<10 ; ){
    i++;
}

Ejemplo de un bucle for típico:

for (int i=0;i<10;i++){
    //declaración e inicializacion "int i=0"
    //condicion "i<10"
    //incremento "i++"
    System.out.println("i: " + i);
}

Cómo funciona:

La inicialización de la variable se ejecuta al principio una sola vez.
A continuación se comprueba la condición y si es falsa se prosigue la ejecución fuera del bucle.
Si resulta cierta se ejecuta el código, se incrementa la variable y se vuelve a comprobar la condición.

Consideraciones del For.

Declaración e inicialización:

• Se pueden declarar 0, 1 o más variables del mismo tipo. Si hay más de una se separan por comas.
• Las variables declaradas en el for pierden su ámbito al salir del bucle for.
• Esta parte sólo se ejecuta una vez, al principio de la ejecución del bucle.

Condición:

• Sólo se puede comprobar una condición no varias.

Incremento:

• Se ejecuta despúes de que se ejecute el código del for.

For «Mejorado»

Simplifica recorrer un array o una colección. Tiene dos partes, la declaración y el elemento a recorrer.

int[] array = {10,20,30,50};
for (int elem: array){
    System.out.println("elem: " + elem);
}

En la declaración: hay que declarar una variable compatible con el tipo de los elementos del array o de la colección.

En la expresión: será una variable array, colección o un método que las retorne.