RSS

Archivo de la etiqueta: ocpjp

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.

Anuncios
 
1 comentario

Publicado por en 22 junio, 2012 en Resumenes

 

Etiquetas: , , , , , ,

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());
        }

    }
}

 
4 comentarios

Publicado por en 9 junio, 2012 en Resumenes

 

Etiquetas: , , , , ,

Las clases de cadena: String, StringBuffer y StringBuilder

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

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.

Read the rest of this entry »

 
5 comentarios

Publicado por en 27 marzo, 2012 en Tema 6

 

Etiquetas: , , , , , , , , , ,

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)
 
2 comentarios

Publicado por en 24 marzo, 2012 en Preguntas

 

Etiquetas: , , , , , ,

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
    }
}


 
1 comentario

Publicado por en 23 marzo, 2012 en Deberes

 

Etiquetas: , , , , ,

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.

 
Deja un comentario

Publicado por en 22 marzo, 2012 en Deberes

 

Etiquetas: , , , , ,

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.

 
Deja un comentario

Publicado por en 20 marzo, 2012 en Tema 5

 

Etiquetas: , , , , ,

 
A %d blogueros les gusta esto: