Fecha y hora actual: Jueves 17 Ene 2019 04:55
Índice del Foro

Foros de programación informática, diseño gráfico y Web

En esta comunidad intentaremos dar soporte de programación a todos los niveles, desde principiantes a profesionales de la informática, desarrollo de programas, programación web y mucho más.

Curso VB .NET - Tema 1.32 - Colecciones, Java

Responder al Tema

Índice del Foro > Visual Basic .NET > Curso VB .NET - Tema 1.32 - Colecciones, Java

Autor Mensaje
Tesis
Administrador


Registrado: 04 Mar 2007
Mensajes: 3200
Ubicación: Valencia - España

Mensaje Publicado: Viernes 09 Oct 2009 04:13

Título del mensaje: Curso VB .NET - Tema 1.32 - Colecciones, Java

Responder citando

Curso de programación en .NET - Tema 1.32 - Colecciones, Java


1. Colecciones, Java.

1.1 Objetivos del tema.

Explicar las características de las colecciones en Java.

1.2 Introducción.
Podríamos definirlas como una enumeración, a la que se le pueden añadir o quitar elementos. Podríamos definirlas como un array que en lugar de ser estático en el número de elementos, permite la adición y la eliminación de elementos, o sea que es dinámico. Desde el momento en que podemos declarar un array del tipo de un objeto determinado, un array es muy similar a una colección. También podríamos ver las colecciones como una forma de utilizar una lista, al fin y al cabo, se puede conseguir casi los mismos resultados, independientemente de los tiempos de respuesta entre una y otra estructura. Java proporciona varios tipos de colección en función de las restricciones que permite en cada uno de ellos.

  • Set Conjunto
  • Queue Cola
  • Map Mapa.
  • List Lista

Estos tipos de estructuras de datos derivan de dos clases principales, List y Map.
Y estas derivan de la clase principal Collections en el paquete java.util.

Los métodos para una colección son los necesarios para la gestión de la misma, y dado que no disponemos de un índice propiamente dicho, la gestión se basa en su recorrido, adición y eliminación. No todas los tipos de colecciones en Java, permiten que se pueda acceder a través de un índice.

1.3 Set.
Como la misma palabra indica es un conjunto de datos.
A diferencia de List, en un Set no pueden haber duplicados, el método Contains, existe, contiene, es muy eficiente.

Su utilización está claro que viene marcado por aquellas situaciones donde no se permita o no necesitemos que tengamos duplicados. No se respeta el orden de entrada, debido a la no duplicidad de objetos, el resultado del ejemplo al visualizar su contenido es de 2,3, 5, mientras que el orden de introducción es 5,3,2,3,5. El tamaño del conjunto, se adapta a medida que se van insertando nuevos elementos. Los métodos disponibles son:
  • add => addall Añade elementos
  • clear => Limpia la colección
  • contains => containsAll Contiene un elemento
  • equals => Indica si es igual un elemento, compara.
  • hashCode => Devuelve el código hash del elemento
  • isEmpty => Indica si está vacía.
  • remove, removeAll => Borra uno o todos los elementos.
  • retainAll => Hace una intersección de colecciones.
  • size => Indica el número de elementos de la colección.
  • toArray => Devuelve un array con el contenido de la colección.

Veamos un pequeño ejemplo:
Código:
package colecciones;
import java.util.HashSet;
import java.util.Set;
public class Main
{
   static void Conjunto()
   {
      Set <Integer> conjunto = new HashSet <Integer>();
      conjunto.add(5);
      conjunto.add(3);
      conjunto.add(2);
      conjunto.add(3);
      conjunto.add(5);
      // A pesar de que se añaden 5 elementos
      // solo habrán tres en el Conjunto, el resto se repiten.
      System.out.println("Número de elementos : " + conjunto.size());
      for (int n: conjunto)
      {
         System.out.print(n + " ");
      }
      System.out.println();
   }
   public static void main(String[] args)
   {
      Conjunto();
   }
}

De la misma forma que se añaden números enteros, podría crearse con objetos.

1.4 Stack.
Stack es una implementación de una pila, (LIFO), es decir último en entrar primero en salir.
Admite elementos duplicados.
Los métodos disponibles son:
  • empty => Devuelve si está o no vacía.
  • peek => Obtiene el primer elemento de la pila, pero no lo borra.
  • pop => Obtiene el primer elemento de la pila, pero sí lo borra.
  • push => Añade un elemento en la pila, al principio.
  • search => Devuelve la posición del elemento buscado.


Veamos un pequeño ejemplo:
Código:
package colecciones;
import java.util.Stack;
import java.util.EmptyStackException;
public class Main
{
   static void InsertarPila( Stack pila,int num )
   {
      pila.push( new Integer( num ) );
      System.out.println( "Insertado : " +num );
      System.out.println( "Contenido : " +pila );
   }
   static void ExtraerPila( Stack pila )
   {
      System.out.print( "Extracción : " );
      Integer a = (Integer)pila.pop();
      System.out.println( a );
      System.out.println( "Contenido : " + pila );
   }
   static void pila( )
   {
      Stack pila = new Stack();
      System.out.println( "Pila : " + pila );
      InsertarPila( pila , 3 );
      InsertarPila( pila , 26 );
      InsertarPila( pila , 35 );
      ExtraerPila( pila );
      ExtraerPila( pila );
      ExtraerPila( pila );
   
      try
      {
         ExtraerPila( pila );
      }
         catch( EmptyStackException e )
      {
      System.out.println( "La pila está vacía." );
      }
   }
   public static void main(String[] args)
   {
      pila();
   }
}


1.5 Queue.
Es una colección diseñada para almacenar datos en el formato de primero en entrar primero en salir, FIFO. Por lo tanto puede tener elementos, objetos, duplicados o no, y su orden estará relacionado con el de entrada.

Los métodos disponibles son:
  • element, Recupera pero no borra el primer elemento.
  • offer, Inserta el elemento especificado en la cola, si es posible.
  • peek, Recupera pero no borra el primer elemento, devuelve nulo si está vacía.
  • poll, Recupera y borra el primer elemento en la cola.
  • remove, Recupera y borra el primer elemento, devuelve nulo si está vacía


Veamos un pequeño ejemplo:
Código:
package colecciones;
import java.util.Queue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.NoSuchElementException;
public class Main
{
   static void InsertarCola (Queue cola, int num)
   {
      cola.add(new Integer (num)) ;
      System.out.println( "Insertado : " + num );
      System.out.println( "Contenido : " + cola );
   }
   static void ExtraerCola ( Queue cola )
   {
      System.out.print( "Extracción : " );
      Integer a = (Integer)cola.remove() ;
      System.out.println( a );
      System.out.println( "Contenido : " + cola );
   }
   static void cola()
   {
      Queue <Integer> cola = new LinkedBlockingQueue <Integer>();
      System.out.println( "Cola : " + cola );
      InsertarCola( cola , 3 );
      InsertarCola( cola , 26 );
      InsertarCola( cola , 35 );
      ExtraerCola( cola );
      ExtraerCola( cola );
      ExtraerCola( cola );
      
    try
      {
         ExtraerCola( cola );
      }
      catch( NoSuchElementException e )
      {
         System.out.println( "La cola está vacia." );
      }
   }
   public static void main(String[] args)
   {
      cola();
   }
}


1.6 Map.
Es una colección similar a un diccionario, es decir dispone de la funcionalidad de asociar parejas de datos del tipo
    Clave => Valor

Cada clave debe tener un valor asociado.
Los métodos disponibles son:
  • clear, Limpia la colección
  • containsKey, containsValue, Si contiene una clave o un valor.
  • EntrySet, Devuelve una vista del contenido de valores de la colección.
  • equals, Indica si es igual un elemento, compara.
  • get, Devuelve un valor de la clave especificada.
  • hashCode, Devuelve el código hash del elemento
  • isEmpty, Indica si está vacía.
  • keySet, Devuelve el conjunto de claves de la colección.
  • put, Realiza una asociación entre una clave y un valor.
  • putAll, Copia la colección especificada en la de destino.
  • remove, Borra un elemento.
  • size, Indica el número de elementos de la colección.
  • values, Devuelve el contenido de la colección.


Código:
staticMap rellenar(Map m)
{
   m.put("Silla","Mueble");
   m.put("Naranja","Fruta");
   m.put("Clavo","Herramienta");
   // primero introduce valores y luego devuelve el mapa
   return m;
}


Otro ejemplo.
Código:
package colecciones;
  import java.util.LinkedHashMap;
  static void CargarColeccion(LinkedHashMap c)
  {
    System.out.println("Carga colección.");
    c.put(1,"Silla");
    c.put(25,"Mesa");
    c.put(3,"Puerta");
  }
  static void VerColeccion(LinkedHashMap c)
  {
    System.out.println("Ver colección.");
    int x;
    x = 0;
    System.out.println("El valor 0 no existe " + c.get(x));
    x = 1;
    System.out.println("El valor 1 sí existe " + c.get(x));
  }
  public static void main(String[] args)
  {
    LinkedHashMap Coleccion = new LinkedHashMap();
    CargarColeccion (Coleccion);
    VerColeccion(Coleccion);
  }
}


1.7 List.
De la colección List, podemos encontrar dos tipos.
    ArrayList.
    LinkedList.

ArrayList es el sistema más parecido a lo que es un array tradicional, pero con la diferencia de que es dinámico, no estático como es un array clásico, cuyo tamaño se define en la creación.

LinkedList es una estructura dinámica.
List es una colección ordenada en la secuencia de entrada.
Se puede acceder a los elementos por su posición, o mediante una búsqueda.
También se dispone de un método que permite iterar por el contenido de la colección.

Los métodos disponibles son:
  • add, addall, Añade un elemento a la colección, o varios elementos.
  • clear, Limpia la colección
  • contains, containsAll, Sí contiene un elemento.
  • equals, Indica si es igual un elemento, compara.
  • ge, Devuelve el elemento indicado en la posición.
  • hashCode, Devuelve el código hash del elemento.
  • IndexOf, Devuelve la posición que ocupa un determinado elemento.
  • isEmpty, Indica si está vacía.
  • iterator, Permite recorrer la lista en el orden de entrada.
  • lastIndexOf, Devuelve la última aparición del elemento.
  • remove, removeAll, Borra uno o todos los elementos.
  • retainAll, Hace una intersección de colecciones.
  • set, Hace que se reemplace el elemento especificado por el que se incorpora.
  • size, Indica el número de elementos de la colección.
  • toArray, Devuelve un array con el contenido de la colección.


Código:
package colecciones;
import java.util.LinkedList;
public class Main
{
   static LinkedList Cargar(LinkedList c)
   {
      System.out.println("Carga de colección");
      c.clear();
      c.add("Silla");
      c.add("Naranja");
      c.add("Clavo");
      // primero introduce los valores y luego devuelve la colección
      return c;
   }
   static LinkedList CargarB(LinkedList c)
   {
      System.out.println("Carga de colección");
      c.clear();
      c.add("Arboles");
      c.add("Plantas");
      c.add("Animales");
      c.add("Clavo");
      // primero introduce los valores y luego devuelve la colección
      return c;
   }
   public static void main(String[] args)
   {
      LinkedList A = new LinkedList();
      LinkedList B = new LinkedList();
      Cargar(A);
      CargarB(B);
      System.out.println("Las dos colecciones, A y B");
      System.out.println(A);
      System.out.println(B);
   }
}


1.8 Métodos.
1.8.1 Creación.

Para su utilización necesitamos importar la clase que las gestiona, la que corresponda del ejemplo que vemos.
Código:
import java.util.Collection;
import java.util.LinkedList;
import java.util.LinkedHashMap;
import java.util.Stack;
import java.util.Queue;

La definición de una colección es como sigue.
Código:
LinkedList Registro = new LinkedList();

La forma de añadir elementos
Código:
Registro.add("Codigo");

O bien de ésta otra forma:
Código:
static LinkedList Cargar(LinkedList c)
{
   System.out.println("Carga de colección.");
   c.add("Silla");
   c.add("Naranja");
   c.add("Clavo");
   // primero se introducen los valores y luego se devuelve la colección
   return c;
}

Para después desde el Main
Código:
Cargar(Coleccion);

y todo junto quedaría :
Código:
public class Main
{
   static Collection Cargar(Collection c)
   {
      c.add("Silla");
      c.add("Naranja");
      c.add("Clavo");
      // primero se introducen los valores y luego se devuelve la colección
      return c;
   }
   public static void main(String[] args)
   {
      LinkedList Coleccion = new LinkedList();
      Cargar(Coleccion);
      .. / ..
   }
}

Pero el uso de una colección no se limita al uso de algo tan sencillo como un string.
Podemos utilizar objetos en una colección.
Podemos hacer éste otro uso en una colección:

Creamos una clase de la que instanciar luego objetos.
Código:
package colecciones;
class Dato
{
   public String Nombre;
   public int Longitud;
   public Dato()
   {
   }
}

Para después realizar algo parecido a lo siguiente:
Código:
static LinkedList CargarObjetos(LinkedList c)
{
   System.out.println("Carga colección de objetos.");
   Dato Item = new Dato();
   Item.Longitud = 1;
   Item.Nombre="Uno";
   c.add(Item);
   Item = new Dato();
   Item.Longitud=2;
   Item.Nombre="Dos";
   c.add(Item);
   Item = new Dato();
   Item.Longitud=3;
   Item.Nombre="Tres";
   c.add(Item);
   return c;
}

El ejemplo anterior funciona correctamente tal como se describe, sin embargo como prueba de lo que a veces la lógica te puede llevar a hacer, conviene probarlo comentando la siguiente línea.
Código:
Item = new Dato();

El resultado es que al recorrer la colección, se muestra solo el último valor introducido en la misma.

1.8.2 Recorrido.
La forma de recorrerla es creando una estructura repetitiva, vemos una forma de hacerlo.
Código:
package colecciones;
import java.util.LinkedList;
public class Main
{
   public static void main(String[] args)
   {
      LinkedList Coleccion = new LinkedList();
      Coleccion.add("Silla");
      Coleccion.add("Naranja");
      Coleccion.add("Clavo");
      int x=0;
      while (x<Coleccion.size())
      {
         System.out.println(Coleccion.get(x).toString());
         ++x;
      }
   }
}

El resultado de la ejecución es el que sigue:
Código:
compile:
run:
Silla
Naranja
Clavo

Podemos utilizar otro sistema.
Código:
Iterator Iter = Coleccion.iterator();
String Item;
while (Iter.hasNext()) // mientras haya elementos
{
   Item = Iter.next().toString();
   // obtenemos el siguiente
   System.out.println(Item);
}

El resultado es el mismo que antes.
Código:
compile:
run:
Silla
Naranja
Clavo

Otro ejemplo, con un objeto, la clase se llama Clase, y el objeto que se deriva de ella, Obj.
Código:
static void VerContenido( Queue cola)
{
   System.out.println( "Contenido ");
   // Definición del iterador que nos permitirá recorrer la colección.
   Iterator Iter = cola.iterator();
   Clase Obj;
   while (Iter.hasNext()) // mientras haya elementos
   {
      Obj = (Clase) Iter.next(); // obtenemos el siguiente
      System.out.println( "Longitud : " + Obj.longitud );
      System.out.println( "Nombre : " + Obj.Nombre);
   }
}

La línea de código:
Código:
Obj = (Clase) Iter.next(); // obtenemos el siguiente

Obtiene el objeto de la colección, una cola, y lo convierte al tipo Clase.
Después ya solo se utiliza el objeto y se visualiza su contenido:
Código:
System.out.println( "Longitud : " + Obj.longitud );
System.out.println( "Nombre : " + Obj.Nombre);


Para poder utilizar el ejemplo es necesario importar la clase.
Código:
import java.util.Iterator;

El primer ejemplo es fácil de entender, hemos creado un bucle en el que progresamos desde x igual a cero hasta el número de elementos que tiene la colección.
El segundo funciona igual, pero en lugar de incremento hay un método que nos devuelve el siguiente elemento de la colección mientras que queden elementos en la misma.

La posibilidad de recorrer la colección de esta forma, viene dada por la clase Iterator.
Cuando hemos cargado un objeto para recorrer la colección utilizaremos el mismo sistema.
Código:
// recorrido
x=0;
while (x<Coleccion.size())
{
   Item = (Dato) Coleccion.get(x);
   System.out.println(Item.Longitud);
   System.out.println(Item.Nombre);
   ++x;
}

Y el mismo bucle con iterator.
Código:
Iter = Coleccion.iterator();
while (Iter.hasNext())
{
   Item = (Dato) Iter.next();
   System.out.println(Item.Longitud);
   System.out.println(Item.Nombre);
}

Con lo que el ejemplo completo quedaría
Código:
package colecciones;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
public class Main
{
   // falta incluir la carga de las colecciones.
   public static void main(String[] args)
   {
      LinkedList Coleccion = new LinkedList();
      Dato Item = new Dato();
      CargarObjetos(Coleccion);
      int x=0;
      // recorrido
      while (x<Coleccion.size())
      {
         Item = (Dato) Coleccion.get(x);
         System.out.println(Item.Longitud);
         System.out.println(Item.Nombre);
         ++x;
      }
      Iterator Iter = Coleccion.iterator();
      while (Iter.hasNext())
      {
         Item = (Dato) Iter.next();
         System.out.println(Item.Longitud);
         System.out.println(Item.Nombre);
      }
   }
}

Utilizar Iterator viene obligado cuando no es posible recorrer una colección por el índice de sus elementos, ejemplo cola, pila.

1.9 Operaciones con una colección.
Una vez que disponemos de una colección, además de la acción de añadir elementos y recuperar elementos de la colección, podemos quitar elementos, comparar elementos.

1.9.1 Métodos sobre toda la colección, all.
Hay cuatro métodos que trabajan sobre toda la colección.
  • addAll
  • containsAll
  • removeAll
  • retainAll

Estos métodos los vemos en el apartado que le corresponde a cada uno.

1.9.2 Adición, add.
Hemos visto como se usa el método add,
Código:
Coleccion.add("Silla");

pero disponemos también de
Código:
Coleccion.addFirst(Item); // añade al principio de la colección
Coleccion.addLast(Item); // añade al final de la colección

y de los métodos, offerFirst y offerLast,

Estos métodos insertan el elemento especificado en la parte delantera de la colección a menos que se violen las restricciones de capacidad.
Cuando se utiliza una capacidad restringida, este método es preferible, en general, a addFirst, addLast, que pueden dejar de insertar un elemento.

El método addAll añade todos los elementos de una colección a otra.
Podemos probarlo con éste ejemplo
Código:
package colecciones;
import java.util.Iterator;
import java.util.LinkedList;
public static void main(String[] args)
{ // falta incluir la carga de las colecciones.
   LinkedList A = new LinkedList();
   LinkedList B = new LinkedList();
   Cargar(A);
   System.out.println(A);
   System.out.println(B);
   B.addAll(A);
   System.out.println(B);
}

Cuya ejecución produce el siguiente resultado.
Código:
[Silla, Naranja, Clavo]
[]
[Silla, Naranja, Clavo]

El ejemplo precisa del procedimiento Cargar, sito al principio del tema.

1.9.3 Borrado, clear, remove.
Para borrar disponemos de los métodos remove.
Código:
Coleccion.removeFirst(); // borra el primer elemento de la colección.
Coleccion.removeLast(); // borra el último elemento de la colección.
Coleccion.remove(1); // borra el elemento indicado de la colección.

También podemos borrar todo el contenido de la colección utilizando el método clear, o removeAll.
Código:
Colección.clear();
Colección.removeAll(Colección);


Pero estos métodos tienen un matiz, clear borra todo el contenido de la colección y removeAll incorpora un argumento que es la colección que deseamos borrar de la colección actual, en el ejemplo se puede comprobar.
Código:
package colecciones;
import java.util.Iterator;
import java.util.LinkedList;
public static void main(String[] args)
{ // falta incluir la carga de las colecciones.
   LinkedList A = new LinkedList();
   LinkedList B = new LinkedList();
   Cargar(A);
   System.out.println("Las dos colecciones, A y B");
   System.out.println(A);
   System.out.println(B);
   System.out.println("A B se le añade A");
   B.addAll(A);
   System.out.println(B);
   System.out.println("borramos el 1 de A, y quitamos A de B con removeAll, y
   visualizamos B");
   A.remove(1);
   B.removeAll(A);
   System.out.println(B);
   System.out.println("Se añade A a B y se borra con clear B");
   B.addAll(A);
   System.out.println(B);
   B.clear();
   System.out.println(B);
}

El resultado es el que vemos.
Código:
Las dos colecciones, A y B
[Silla, Naranja, Clavo]
[]
A B se le añade A
[Silla, Naranja, Clavo]
borramos el 1 de A, y quitamos A de B con removeAll, y visualizamos B
[Naranja]
Se añade A a B y se borra con clear B
[Naranja, Silla, Clavo]
[]


El ejemplo precisa del procedimiento Cargar, sito al principio del tema.
Además disponemos de los métodos removeFirst, removeFirstOccurrence, y removeLast, removeLastOccurrence,

1.9.4 Lectura, get.
Hemos visto como se usa el método get,
Código:
Item = (Dato) Coleccion.get(x);

pero disponemos también de
Código:
Item = (Dato) Coleccion.getLast(); // devuelve el primer elemento
Item = (Dato) Coleccion.getFirst(); // devuelve el último elemento

Resaltar que en la línea de lectura (Dato) lo que permite es la conversión del objeto leído al tipo que le corresponde.
Código:
Item = (Dato) Coleccion.get(x); // (Dato) indica el tipo a convertir.


1.9.5 Posición de un elemento, indexOf.
Si deseamos saber la posición de un elemento, o solo si existe o no en la colección, podemos utilizar el método indexOf.
Este método nos devuelve la posición del elemento en a colección, o el valor -1 si no lo encuentra.

La sintaxis es
Código:
System.out.println(A.indexOf("Silla"));
posicion = A.indexOf("Puerta");
Un ejemplo :
// indexOf
System.out.println("indexOf");
System.out.println(A.indexOf("Silla"));
int valor = A.indexOf("Puerta");
switch (valor)
{
   case -1:System.out.println("No existe");
   break;
   default : System.out.println("Encontrado en la posición " + valor);
}

La salida del ejemplo es
Código:
indexOf
0
No existe


1.9.6 Copiado de la colección, clone.
El método clone, nos permite obtener una replica, copia o duplicado de la colección.
La sintaxis es
Código:
LinkedList Col = (LinkedList) Coleccion.clone();

O bien
Código:
LinkedList Col = new LinkedList();
Col = (LinkedList) Coleccion.clone();


El ejemplo:
Código:
// Duplicar colección
System.out.println("Duplicado");
LinkedList Col = (LinkedList) Coleccion.clone();
x=0;
while (x<Col.size())
{
   System.out.println(Col.get(x));
   ++x;
}


1.9.7 Conversión en array, toArray.
El método a utilizar es toArray.

Y la sintaxis del mismo es
Código:
Arr = (String[]) Coleccion.toArray(new String[0]);

Aunque también se puede usar
Código:
String[] Arr = (String[]) Coleccion.toArray(new String[0]);

Y un ejemplo para probar, al que hay que añadir la carga de la colección.
Código:
String[] Arr;
Arr = (String[]) Coleccion.toArray(new String[0]);
System.out.println("Conversión en array");
int x=0;
while (x < Arr.length)
{
   System.out.println(Arr[x]);
   ++x;
}


1.9.8 Comparar, contain.
Podemos comprobar si determinada información existe o no en una colección.
El método que lo realiza es contains.

La sintaxis del mismo es
Código:
Coleccion.contains("Silla");

Donde “Silla” es el dato que deseamos comprobar.
En el ejemplo vemos un ejemplo de su utilización.
En el primer ejemplo comprobamos si existe el elemento Silla, y en el segundo comprobamos si existe el elemento x de una colección, en ambos casos el resultado será true o false.
Código:
System.out.println(Col.contains("Silla"));
System.out.println(Col.contains(Coleccion.get(x)));


El método containsAll devolverá true si el contenido de la colección argumento está completa en la colección origen.
Código:
A.containsAll(B);


Su utilización por ejemplo :
Código:
System.out.println(A.containsAll(B));


El ejemplo podría ser así.
Código:
package colecciones;
import java.util.Iterator;
import java.util.LinkedList;
public static void main(String[] args)
{ // falta incluir la carga de las colecciones.
   LinkedList A = new LinkedList();
   LinkedList B = new LinkedList();
   System.out.println("Comprobamos si A está contenida en B");
   System.out.println("Contenido de A");
   System.out.println(A);
   System.out.println("Contenido de B");
   System.out.println(B);
   System.out.println(B.containsAll(A));
   System.out.println("Al contrario");
   System.out.println(A.containsAll(B));
   System.out.println("Añadimos A a B, y comprobamos");
   B.addAll(A);
   System.out.println("Contenido de A");
   System.out.println(A);
   System.out.println("Contenido de B");
   System.out.println(B);
   System.out.println(B.containsAll(A));
}

El resultado de la ejecución sería:
Código:
Comprobamos si A está contenida en B
Contenido de A
[Silla, Clavo]
Contenido de B
[Naranja]
false
Al contrario
false
Añadimos A a B, y comprobamos
Contenido de A
[Silla, Clavo]
Contenido de B
[Naranja, Silla, Clavo]
true


1.9.9 Reemplazo, set.
El método encargado de ello es set. La sintaxis
Código:
Col.set(x, (int) x + 49);


Donde x es el elemento a sustituir en la colección, y (int) x + 49) el nuevo contenido, en el que indicamos que le asignamos un entero.
En el ejemplo que sigue duplicamos en la colección Col el contenido de Colección, que no tiene nada que ver con el contenido que luego asignamos en el bucle.
Código:
package colecciones;
import java.util.Iterator;
import java.util.LinkedList;
public static void main(String[] args)
{ // falta incluir la carga de las colecciones.
   LinkedList A = new LinkedList();
   LinkedList B = new LinkedList();
   // Reemplazo de elementos
   System.out.println("Reemplazo");
   Col = (LinkedList) Coleccion.clone(); // Duplicado previo
   x=0;
   while (x<Col.size())
   {
      Col.set(x, (int) x + 49);
      System.out.println(Col.get(x));
      ++x;
   }
}


La misma acción podemos hacerla para una colección con objetos, y la sintaxis queda como sigue: Se parte de dos colecciones completamente distintas.
Código:
package colecciones;
import java.util.Iterator;
import java.util.LinkedList;
public static void main(String[] args)
{ // falta incluir la carga de las colecciones.
   LinkedList A = new LinkedList();
   LinkedList B = new LinkedList();
   // Reemplazo de elementos, objetos
   System.out.println("Reemplazo con un objeto");
   x=0;
   Dato Item = new Dato();
   while (x<Col.size())
   {
      Col.set(x, (Dato) Coleccion.get(x));
      Item = (Dato) Coleccion.get(x);
      System.out.println(Item.Longitud);
      System.out.println(Item.Nombre);
      ++x;
   }
}

Como se puede observar en el ejemplo, el cambio requiere de pasos posteriores para su utilización.

1.9.10 Intersección, retainAll.
RetainAll conserva de la colección origen solo aquellos elementos que estén en la colección del argumento. Dicho de otra forma se podría explicar como la intersección de dos conjuntos, y para el ejemplo que sigue :
Código:
B.retainAll(A);

si en la colección A no hay ningún elemento que esté en B, B quedaría como conjunto vacío, sin ningún elemento.

La colección del argumento, quedará siempre intacta, pues no forma parte del operativo.
Por lo tanto para las colecciones,
  • A = 1, 2, 3
  • B = 4, 5, 6

El resultado de A.retainAll(B) sería que A daría conjunto vacío, o se quedaría sin ningún elemento en la colección.
El resultado de B.retainAll(A) sería que B daría conjunto vacío, o se quedaría sin ningún elemento en la colección. Para el ejemplo siguiente
  • A = 1, 2, 3, 4
  • B = 4, 5, 6

El resultado de A.retainAll(B) sería que en A quedaría con el valor 4.
El resultado de B.retainAll(A) sería que en B quedaría con el valor 4.

1.9.11 Recuperar un elemento, poll.
Este método permite recuperar y borrar el primer elemento de la colección. Se dispone de dos versiones más del mismo, pollFirst y pollLast, que recuperan y borran el primer y ultimo elemento de la colección. Estos dos métodos, pollFirst y pollLast, devuelven nulo si no se dispone de datos en la colección.

La sintaxis es como sigue:
Código:
A.poll();
A.pollLast();
A.pollFirst();


Un ejemplo
Código:
package colecciones;
import java.util.Iterator;
import java.util.LinkedList;
public static void main(String[] args)
{ // falta incluir la carga de las colecciones.
   LinkedList A = new LinkedList();
   LinkedList B = new LinkedList();
   System.out.println("poll");
   Cargar(A);
   System.out.println(A);
   A.pollFirst();
   String Valor = A.pollFirst().toString();
   Valor = A.pollFirst().toString();
   if (Valor != null)
   {
      System.out.println(A);
   }   else {
      System.out.println("Vacío");
   }
}


1.9.12 Extraer de la lista, peek.
El funcionamiento es similar al de poll, pero sin borrar el elemento extraído de la lista. Dispone también de las opciones, peekFirst y peekLast.

La sintaxis del método es
Código:
Valor = A.peekFirst().toString();
Valor = A.peek().toString();


Un ejemplo de utilización:
Código:
package colecciones;
import java.util.Iterator;
import java.util.LinkedList;
public static void main(String[] args)
{ // falta incluir la carga de las colecciones.
   LinkedList A = new LinkedList();
   LinkedList B = new LinkedList();
   System.out.println("peek");
   Cargar(A);
   System.out.println(A);
   Valor = A.peekFirst().toString();
   Valor = A.peekFirst().toString();
   Valor = A.peekFirst().toString();
   Valor = A.peekFirst().toString();
   System.out.println(Valor);
}


Y el resultado del mismo:
Código:
peek
Carga de colección
[Silla, Naranja, Clavo]
Silla

Como se puede observar a pesar de haber ejecutado varias veces el método, el elemento devuelto es el primero.

1.9.13 Extrae un elemento en la colección, pop.
Este método recupera y borra el primer elemento de la colección. Es similar a removeFirst.

Su sintaxis es
Código:
A.pop();


Un ejemplo del mismo:
Código:
package colecciones;
import java.util.Iterator;
import java.util.LinkedList;
public static void main(String[] args)
{ // falta incluir la carga de las colecciones.
   LinkedList A = new LinkedList();
   LinkedList B = new LinkedList();
   // pop
   System.out.println("pop");
   A.pop();
   System.out.println(A);
   A.pop();
   A.pop();
   System.out.println(A);
}


El resultado de la ejecución es :
Código:
pop
[Naranja, Clavo]
[]

Como podemos observar se eliminan los elementos de la colección, a medida que se ejecutan las líneas.

1.9.14 Añade un elemento en la colección, push.
Añade un elemento en la colección, la adición se realiza por la parte inicial de la misma.

La sintaxis es:
Código:
A.push("Mesa");


Un ejemplo de la utilización:
Código:
package colecciones;
import java.util.Iterator;
import java.util.LinkedList;
public static void main(String[] args)
{ // falta incluir la carga de las colecciones.
   LinkedList A = new LinkedList();
   LinkedList B = new LinkedList();
   // push
   Cargar(A);
   System.out.println("push");
   System.out.println(A);
   A.push("Mesa");
   System.out.println(A);
}


El resultado de la misma:
Código:
push
[Silla, Naranja, Clavo]
[Mesa, Silla, Naranja, Clavo]

Podemos observar como el elemento añadido esta en el principio de la colección.

1.10 Ejercicios propuestos.
1.-Crear una colección que nos permita la gestión de los valores del tipo
  • Código
  • Denominación

2.-Introducir diez números y luego visualizarlos en orden inverso, al de entrada.
3.-Crear un programa que nos permita gestionar la cola de un dentista con el siguiente contenido
  • Número de orden
  • Nombre

4.-Tenemos que almacenar los nombres de las personas que van a asistir a un evento.
Estas personas se irán identificando a medida que se van incorporando al mismo. Necesitamos poder acceder posteriormente a sus datos, teniendo en cuenta que pueden ser:
  • Ponentes
  • Invitados
  • Organización


1.11 Solución a los ejercicios propuestos.
1.-Crear una colección que nos permita la gestión de los valores del tipo
  • Código
  • Denominación

Código:
package colecciones;
import java.util.LinkedHashMap;
public class Main
{
  static void CargarColeccion(LinkedHashMap c)
  {
    System.out.println("Carga colección.");
    c.put(1,"Silla");
    c.put(25,"Mesa");
    c.put(3,"Puerta");
  }
  static void VerColeccion(LinkedHashMap c)
  {
    System.out.println("Ver colección.");
    int x;
    x = 0;
    System.out.println("El valor 0 no existe " + c.get(x));
    x = 1;
    System.out.println("El valor 1 sí existe " + c.get(x));
  }
  public static void main(String[] args)
  {
    LinkedHashMap Coleccion = new LinkedHashMap();
    CargarColeccion (Coleccion);
    VerColeccion(Coleccion);
  }
}


2.-Introducir diez números y luego visualizarlos en orden inverso, al de entrada.
Código:
package colecciones;
import java.util.Stack;
import java.util.EmptyStackException;
public class Main
{
   static void InsertarPila( Stack pila,int num )
   {
      pila.push( new Integer( num ) );
      System.out.println( "Insertado : " +num );
      System.out.println( "Contenido : " +pila );
   }
   static void ExtraerPila( Stack pila )
   {
      Integer a = (Integer)pila.pop();
      System.out.println( "Extracción : " + a );
   }
   static void dos( )
   {
      Stack pila = new Stack();
      System.out.println( "Pila : " + pila );
      InsertarPila( pila , 3 );
      InsertarPila( pila , 26 );
      InsertarPila( pila , 35 );
      System.out.println( "Contenido actual : " + pila );
      System.out.println( "Número de elementos : " + pila.size() );
      
    try
      {
         while (pila != null)
         {
            ExtraerPila( pila );
         }
         System.out.println( "Contenido actual : " + pila );
      }
      catch( EmptyStackException e )
      {
         System.out.println( "La pila está vacía." );
      }
   }
   public static void main(String[] args)
   {
      dos();
   }
}

El bucle de visualización podría haberse hecho de cualquiera de estas dos formas:
Código:
while (pila.size() != 0)
while (pila != null)

Mientras el número de elementos sea distinto de cero, o mientras la pila sea distinto de nulo, no esté vacía.

3.-Crear un programa que nos permita gestionar la cola de un dentista con el siguiente contenido
  • Número de orden
  • Nombre

Código:
package colecciones;
import java.util.Queue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.NoSuchElementException;
public class Main
{
   static void InsertarCola (Queue cola, String nombre)
   {
      cola.add(new String (nombre)) ;
      System.out.println( "Insertado : " + nombre );
   }
   static void ExtraerCola ( Queue cola )
   {
      String a = (String) cola.remove() ;
      System.out.println( "Extracción : " + a);
   }
   static void tres()
   {
      Queue <Integer> cola = new LinkedBlockingQueue <Integer>();
      System.out.println( "Cola : " + cola );
      InsertarCola( cola , "Pedro" );
      InsertarCola( cola , "Luisa" );
      InsertarCola( cola , "Inma" );
      InsertarCola( cola , "Javier" );
      System.out.println( "Contenido : " + cola );
      
    try
      {
         while (cola != null) ExtraerCola( cola );
      {
            System.out.println( "Contenido : " + cola );
         }
    }
      catch( NoSuchElementException e )
      {
         System.out.println( "La cola está vacia." );
      }
   }
   public static void main(String[] args)
   {
      tres();
   }
}


Otra versión del ejercicio

Para la resolución del ejercicio es necesaria la siguiente clase:
Código:
package colecciones;
class Dato
{
   public String Nombre;
   public int codigo;
   public Dato()
   {
   }
}
package colecciones;
import java.util.Queue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.NoSuchElementException;
public class Main
{
   static void InsertarCola (Queue cola, Dato Pac)
   {
      cola.add(Pac) ;
      System.out.println( "Insertado : " + Pac.Nombre );
   }
   static void ExtraerCola ( Queue cola )
   {
      Dato Pac = (Dato) cola.remove() ;
      System.out.println( "Extracción : " + Pac.Nombre);
   }
   static void VerContenido( Queue cola)
   {
      System.out.println( "Contenido de la cola : ");
      // Definición del iterador que nos permitirá
      // recorrer la colección, cola
      Iterator Iter = cola.iterator();
      Dato Pac;
      while (Iter.hasNext()) // mientras haya elementos
      {
         Pac = (Dato) Iter.next(); // obtenemos el siguiente
         System.out.println( "Codigo : " + Pac.codigo );
         System.out.println( "Nombre : " + Pac.Nombre);
      }
   }
   static void tres()
   {
    Queue <Dato> cola = new LinkedBlockingQueue <Dato>();
    Dato Paciente;
    System.out.println( "Cola : " + cola );
    Paciente = new Dato();
    Paciente.codigo=1;
    Paciente.Nombre="Pedro";
    InsertarCola( cola , Paciente );
    Paciente = new Dato();
    Paciente.codigo=2;
    Paciente.Nombre="Luisa";
    InsertarCola( cola , Paciente );
    Paciente = new Dato();
    Paciente.codigo=3;
    Paciente.Nombre="Inma";
    InsertarCola( cola , Paciente );
    Paciente = new Dato();
    Paciente.codigo=4;
    Paciente.Nombre="Javier";
    InsertarCola( cola , Paciente );
    VerContenido(cola);
   
    try
    {
      while (cola != null) ExtraerCola( cola );
      {
        System.out.println( "Contenido : " + cola );
      }
    }
    catch( NoSuchElementException e )
    {
      System.out.println( "La cola está vacia." );
    }
  }
   public static void main(String[] args)
   {
      tres();
   }
}

4.-Tenemos que almacenar los nombres de las personas que van a asistir a un evento.
Estas personas se irán identificando a medida que se van incorporando al mismo. Necesitamos poder acceder posteriormente a sus datos, teniendo en cuenta que pueden ser
  • Ponentes
  • Invitados
  • Organización

Código:
package colecciones;
import java.util.Iterator;
import java.util.LinkedList;
public class Main
{
   static void Carga(LinkedList Evento)
   {
      Ejercicio Persona = new Ejercicio();
      Persona.Codigo =1;
      Persona.Nombre = "Pedro";
    Persona.Tipo ="P";
    Evento.add(Persona);
    Persona = new Ejercicio();
    Persona.Codigo =2;
    Persona.Nombre = "Luisa";
    Persona.Tipo ="P";
    Evento.add(Persona);
    Persona = new Ejercicio();
    Persona.Codigo =1;
    Persona.Nombre = "Inma";
    Persona.Tipo ="I";
    Evento.add(Persona);
    Persona = new Ejercicio();
    Persona.Codigo =2;
    Persona.Nombre = "Javier";
    Persona.Tipo ="I";
    Evento.add(Persona);
    Persona = new Ejercicio();
    Persona.Codigo =1;
    Persona.Nombre = "Carlos";
    Persona.Tipo ="O";
    Evento.add(Persona);
    Persona = new Ejercicio();
    Persona.Codigo =2;
    Persona.Nombre = "Cristina";
    Persona.Tipo ="O";
    Evento.add(Persona);
   }
   static void VerTipo(LinkedList Evento, String Texto, String Tipo)
   {
      System.out.println( "Relación de " + Texto);
      // Definición del iterador que nos permitirá
      // recorrer la colección, cola
      Iterator Iter = Evento.iterator();
      Ejercicio Persona = new Ejercicio();
      while (Iter.hasNext()) // mientras haya elementos
      {
         Persona = (Ejercicio) Iter.next(); // obtenemos el siguiente
         if (Persona.Tipo == Tipo)
         {
            System.out.println("Código : " + Persona.Codigo);
            System.out.println("Nombre : " + Persona.Nombre);
         }
      }
   }
   static void VerPersonas(LinkedList Evento)
   {
      int x = 0 ;
      Ejercicio Persona; // = new Ejercicio();
      while (x < Evento.size())
      {
         Persona = new Ejercicio();
         Persona = (Ejercicio) Evento.get(x);
         System.out.println("Código : " + Persona.Codigo);
         System.out.println("Nombre : " + Persona.Nombre);
         System.out.println("Tipo : " + Persona.Tipo);
         ++x;
      }
   }
   static void cuatro()
   {
      LinkedList Evento = new LinkedList();
      Carga(Evento);
      VerPersonas(Evento);
      VerTipo(Evento, "Invitados", "I");
   }
   public static void main(String[] args)
   {
      cuatro();
   }
}



Autor del curso: casiopea


Normas del foro
Aprende a postear correctamente usando las etiquetas
Volver arriba
Ver perfil del usuario Enviar mensaje privado
Responder al Tema
Mostrar mensajes anteriores:   
Ir a:  
Todas las horas están en GMT + 2 Horas

Temas relacionados

Tema Autor Foros Respuestas Publicado
El foro no contiene ningún mensaje nuevo

Ayuda con TestNG Parametrico en java netbeans

baltigo Java 0 Sábado 30 Jun 2018 01:37 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Publicar Aplicación web JAVA en tomcat

Irvin Java Web 1 Viernes 13 Oct 2017 17:54 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Imagen referencial De creación de jtable en apl...

Jensel S.G Java 6 Miércoles 13 Sep 2017 20:06 Ver último mensaje
El tema está bloqueado: no pueden editarse ni agregar mensajes.

EMPLEO ANALISTA PROGRAMADOR/A BACK-END JAVA EE

GRUPOARESTORA Bolsa de trabajo 0 Viernes 23 Jun 2017 14:33 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Curso de PHP-WordPress avanzado

wordpressadict PHP 1 Domingo 27 Nov 2016 19:59 Ver último mensaje
Panel de Control
No puede crear mensajes, No puede responder temas, No puede editar sus mensajes, No puede borrar sus mensajes, No puede votar en encuestas,