Menu

Programación en Java SE 6 desde cero: Parte 6

Una Collection es un contenedor de objetos, es decir, representa una referencia a un único objeto a través del cual seremos capaces de acceder a un grupo de objetos. Un ejemplo de Collection es un array de enteros, un vector de cadenas, o un mapa hash de objetos de tipo Cliente. En Java el Framework de Collections es un grupo de clases e interfaces pertenecientes al paquete java.util que permiten almacenar colecciones de objetos. De este gran grupo debemos conocer las listas, los mapas y los sets.

Programación en Java SE 6 desde cero: Parte 6

 

Collections y Generics en JAVA 

 

  1. Clases e Interfaces Collections

  2. hasCode y equals

  3. Generic Collections

  4. Clases y métodos Generics

  5. Package java.util

 

Objetivos

  • Descripción de las clases Java responsables del almacenamiento de colecciones de datos (Collection).

  • Identificar los usos de tipos genéricos (Generics) para definir estructuras de datos. 
  • Estudiar el paquete java.util del lenguaje de programación Java.

 

Clases e Interfaces Collections en JAVA

 

En el paquete java.util podemos encontrar un grupo de interfaces al que se conoce como interfaces collections y que representan varios tipos de colecciones. La principal interfaz de la cual extienden las demás es Collection, y a continuación vamos a enumerar las diferentes interfaces que descienden de Collection:

 

Interfaces que descienden de Collection en JAVA

 

  • Listas: una lista es una colección ordenada de elementos que permite dentro de su contenido elementos duplicados. Una lista debe implementar la interface List, y a los elementos de una lista se debe acceder a través de un indice.

  •  

    Sets: un set es una colección que no permite elementos duplicados. Un set debe implementar la interface Set.

  •  

    Colas: una cola es una colección de elementos ordenados de forma específica para poder procesarlos. Un ejemplo típico de cola es una para procesar sus elementos de forma FIFO (First-in First-out), el primero en llegar, el primero en salir. Aunque existe otro tipo de ordenaciones para las colas. Las colas implementan la interface Queue.

  •  

    Mapas: un mapa es una colección donde cada elemento contenido se identifica a partir de una llave. Esta colección no permite llaves duplicadas. Por lo tanto este tipo de colección es un conjunto de pares de tipo clave-valor. Los mapas deben implementar la interface Map, que es la única que no extiende de la interface Collection.

Los mapas son las únicas colecciones que no implementan la interface Collection en su cadena de herencia debido a que sus elementos contenidos son un par clave-valor, mientras que en el resto de colecciones los contenidos son elementos únicos.

 

Métodos Principales en JAVA

 

Los métodos principales de la interface Collection que debemos trabajar ya que son muy útiles para trabajar con listas, sets y colas son:

public boolean add(E e): que añade un nuevo elemento a la colección.

public boolean remove(Object objeto): Que borra una instancia del objeto indicado de la colección.

public boolean contains(Object objeto): Que devuelve true si localiza ese objeto por el que se pregunta dentro de la colección.

public Iterator <E> iterator(): Que devuelve un iterador que trabaja sobre todos los elementos contenidos en la colección.

 

Tipo de colección

 

A continuación vamos a ver cada tipo de colección y sus correspondientes clases e interfaces:

Las listas son una colección ordenada de elementos que permite entradas duplicadas. Los elementos que queremos almacenar en una lista se pueden insertar y sacar de la lista de una posición concreta. Los accesos a los elementos de una lista se realiza a través de un índice de forma similar a la que tratamos a los arrays.

Las listas en Java se utilizan mucho ya que conseguimos el mismo objetivo que trabajando con los arrays, sólo que de forma más cómoda. Su diferencia principal es que un array cuando lo definimos para trabajar con el es necesario conocer su tamaño y no es posible redimensionar un array, mientras que una lista podemos crearla sin conocer su tamaño y es posible que se redimensione.

En qué caso utilizaríamos una lista, por ejemplo para devolver por pantalla un listado de los principales clientes de nuestra compañía.

ArrayList: Es una lista redimensionable que está implementada de forma similar a un array. Cuando sus elementos van creciendo o disminuyendo, la lista se va redimensionando de forma automática, aunque proporciona métodos para poder controlar su tamaño orientados a mejorar el rendimiento de nuestros programas al trabajar con esta clase.

LinkedList: Es una lista que implementa una estructura de datos de tipo lista enlazada. Es única debido a que implementa las interfaces Queue y Deque.

Vector: Es en esencia exactamente igual que el ArrayList sólo que sus métodos están syncronizados. Como ya hemos estudiado es útil para trabajar en entorno multihilo, aunque su rendimiento es inferior al de la clase ArrayList.

Stack: Es una lista que implementa una pila de datos. Los elementos se metén por la cabeza de la pila y se sacan por el lugar de entrada. El comportamiento es LIFO (Last-in First-out) el último en entrar el primero en salir.

 

Métodos de las listas

 

Aparte de la operaciones que hemos estudiado que tienen todas las interfaces que heredan de Collection, todas las listas poseen métodos que proporcionan la capacidad de insertar un elemento en una posición específica, o añadir entera una colección de datos, o sustituir o borrar un elemento específico, o acceder a un elemento a partir de una posición indicada.

 

La interface Set

 

Un Set es una colección de elementos que no permiten entradas duplicadas. Modela conceptos matemáticos, por ejemplo la interface Set cuenta con los métodos andAll que realiza el concepto de unión entre sets y retainAll que realiza las operaciones de intersección entre sets.

Cuando se intenta insertar una entrada duplicada dentro de un set, ese elemento es ignorado.

Las diferencias entre las clases que implementan las interfaces Set es que cada una proporciona su propia funcionalidad:

HashSet: Es un set que almacena sus elementos en una tabla hash. No existe ordenación en su contenido y se utiliza el método hashCode de sus elementos para determinar su lugar dentro del set.

LinkedHashSet: Es un set que almacena sus elementos en una lista enlazada de tablas hash. Los elementos están basados en sus códigos hash y son ordenados según este criterio en una lista doblemente enlazada.

TreeSet: Es un set que almacena sus elementos en una estructura de árbol que también esta ordenada y es navegable.

 

Las cola en JAVA

 

Las operaciones básicas que proporciona un set, incluyen la posibilidad de añadir o borrar un elemento cualquiera de la colección, y realizar operaciones de unión o intersección.

Las colas son tipos de colecciones que añaden o borrar sus elementos en un orden específico. Típicamente se utilizan para almacenar elementos y procesarlos con algún tipo de prioridad. Las colas de forma normal procesan los elementos con el algoritmo FIFO, pero el algoritmo dependerá del tipo de cola que estemos utilizando.

Un deque, es una cola finalizada doblemente que permite que los elementos de la cola sean añadidos o borrados por ambos extremos de la cola. Deque es una subinterface de Queue.

 

Diferencias entre las clases Queue y Deque

 

Las diferencias entre las clases Queue y Deque es que cada una tiene sus propio comportamiento:

PriorityQueue: Es una cola donde los elementos se ordenan según establece el programador (al contrario que en FIFO).

LinkedList: Es la misma que estudiamos anteriormente, que implementa ambas interfaces (Queue y Deque), y se puede utilizar como ambas, ya que tiene la forma de una lista enlazada.

ArrayDeque: Es una Queue y una Deque, implementado como un array redimensionable y sin restricciones de tamaño.

Las operaciones básicas que soporta una cola son incluir un elemento, pedir el siguiente elemento disponible o preguntar a la cola si existe algún elemento más disponible. Las operaciones básicas de un queue son las mismas, solo que se puede operar con ella al comienzo y al final de la estructura de datos.

 

Mapas en JAVA

 

Un mapa, es una estructura de datos, que mapea una llave a un objeto, y genera un par unívocamente identificado. En esta estructura no se pueden meter llaves duplicadas. Utilizaremos un mapa, cuando necesitemos identificar a los objetos contenidos en la estructura de una forma diferente a un simple entero, como es el caso de los arrays o de las listas. Para hacernos una idea, podemos pensar en un caso típico, la agenda, donde a partir de un nombre identificamos un número de teléfono.

HashMap: Es un mapa que almacena los elementos en una tabla hash. No existe ordenación de su contenido, y los elementos son guardados en la tabla hash basado en el método hashCode del elemento.

LinkedHashMap: Es un mapa que almacena los elementos en una tabla hash y en listas doblemente enlazadas. Las listas proporcionan ordenación a los elementos.

TreeMap: Es un mapa que almacena los elementos en una estructura de datos de árbol, con un orden natural o uno definido por el programador.

Estas estructuras de mapa, proporcionan diferentes métodos para acceder a su contenido, como un set de las llaves para acceder a los elementos, una lista de todos los valores guardados o un set del par llave valor.

Para saber utilizar correctamente las colecciones, debemos analizar la interface Comparable, que la podemos encontrar en el paquete java.util y genera una ordenación para los objetos a través del método compare que deben sobrescribir aquellos objetos que implementen esta interface. Por lo tanto Comparable solo posee un método:

  • Public int compareTo(T obj): El parámetro T indica que se debe pasar un tipo genérico. 
  • El valor retornado es un entero, que representará:
  • Cero: Los dos objetos son iguales.
  • Negativo: Este objeto es menor que el objeto que se pasó en el parámetro obj.
  • Positivo: Este objeto es mayor que el objeto que se pasó en el parámetro obj.

Métodos de los mapas

 

Hay clases del API que ya implementan esta interface, aunque también podemos conseguir ordenaciones en nuestros objetos implementando la interface Comparable. Por ejemplo la clase String implementa la interface Comparable y la ordenación que se hace en esta clase es por su léxico, que es prácticamente alfabética, excepto que las mayúsculas siempre aparecen antes que las minúsculas.

Vamos a observar el siguiente ejemplo:

public class PrincipalOrdenacion {

        public static void main(String args[]) {

               String a = "entrada";

               String b = "salida";

               String c = "Entrada";

               System.out.println(a.compareTo(b));

               System.out.println(c.compareTo(b));

               System.out.println(a.compareTo(c));

               System.out.println(a.compareTo(a));  

        }

}

Y sus resultados al ejecutarlo:

-14

-46

32

0

Podemos observar, entrada es menor que salida, que Entrada es aún menor que salida, entrada es mayor que Entrada y que entrada y entrada son exactamente iguales.

 

hashCode y equals en JAVA

 

Conviene en este punto en que se habla de las comparaciones, hablar también de las diferencias que existen entre el operador == y el método equals que se encuentra en todos los objetos.

El operador == compara los valores de tipos primitivos, pero cuando se trata de objetos, lo que compara es si dos variables hacen referencia al mismo objeto. En cambio el método equals se emplea para a través de la lógica de negocio ser capaces de determinar si un objeto es igual a otro (en cuanto a su estado, es decir sus atributos).

Por ejemplo:

public class PrincipalComparacion {

        public static void main(String args[]) {

               String x = "prueba";

               String y = new String("prueba");

               if(x == y) {

                       System.out.println("x == y");

               }

               if(x.equals(y)) {

                       System.out.println("x.equals(y)");

               }

        }

}

Cuyo resultado de ejecución es el siguiente:

x.equals(y)

 

Generic Collections en JAVA

 

Generic Collections, o colecciones genéricas, en su traducción hace referencia a unas nuevas características que se introdujeron en el lenguaje Java en la versión J2SE 5.0 y posteriores, que permiten parametizar los tipos de datos que vamos a introducir en una colección.

 

Java Collections Framework

 

Ya hemos visto que realmente el Java Collections Framework hace referencia a un conjunto de clases que nos sirven como contenedores de otros objetos, son agrupadores de otros objetos, y cada uno, lo utilizaremos con fines diferentes, pero en un vistazo abstracto vemos que son almacenes. Estas clases o almacenes permiten introducir en su contenido cualquier tipo de dato sin ninguna limitación, gracias a Generic se puede parametrizar en el código el tipo de datos que admitirá la colección con la que vamos a trabajar. 

Veamos un ejemplo:

import java.util.ArrayList;

public class PrincipalGenerics {

        public static void main(String args[]) {

               ArrayList listaPalabras = new ArrayList();

               listaPalabras.add("demostracion");

               listaPalabras.add("problema");

               listaPalabras.add("colecciones");

               listaPalabras.add(new java.util.Date());

               for(Object x : listaPalabras) {

                       String palabra = (String) x;

                       System.out.println(palabra.toUpperCase());

               }

        }

}

 

Clase Arraylist en JAVA

 

Como vemos, en la clase ArrayList, que es una de las que hemos estudiado, podemos incluir cualquier tipo de objeto sin ninguna limitación. En el ejemplo incluimos tres cadenas y una fecha. El resultado de la ejecución es el siguiente:

DEMOSTRACION

PROBLEMA

COLECCIONES

Exception in thread "main" java.lang.ClassCastException: java.util.Date

        at PrincipalPersona.main(PrincipalPersona.java:15)

 

Vemos que al iterar la lista, obtenemos cada tipo de objeto y puede generar, como es el caso problemas, al sacar los datos, ya que no somos capaces de controlar el tipo de datos que contiene la colección.

 

Tipos Generic

 

Este es el problema que pretende solucionar los tipos Generic, que permiten indicar cual es el tipo de dato que va a ir contenido en la colección que vamos a utilizar.

Si vemos la definición de la clase ArrayList, a partir de la version J2SE 5.0 aparece de la siguiente forma:

public class ArrayList <E>

Esta E que aparece entre los símbolos mayor y menor, que es posiblemente la primera vez que la vemos, hace referencia, a que la clase ArrayList permite parametrizar el tipo de dato que va a contener. Retrocedamos al ejemplo anterior, y pensemos que en la lista que hemos creado únicamente deseamos que se puedan incorporar objetos de tipo String, para ello recurriríamos a esta parametrización que se debe utilizar cuando denifimos la colección. En el siguiente ejemplo mostramos como se programa:

import java.util.ArrayList;

public class PrincipalGenerics {

        public static void main(String args[]) {

               ArrayList<String> listaPalabras = new ArrayList<String>();

               listaPalabras.add("demostracion");

               listaPalabras.add("problema");

               listaPalabras.add("colecciones");

               for(Object x : listaPalabras) {

                       String palabra = (String) x;

                       System.out.println(palabra.toUpperCase());

               }

        }

}

En este nuevo ejemplo, en que hemos utilizado las capacidades Generic de las colecciones, si intentáramos incluir la línea donde añadíamos a la lista clase de tipo java.util.Date el propio compilador Java no nos dejaría hacerlo.

 

Clases y métodos Generics

 

Es posible que queramos introducir tipos genéricos en nuestras propias clases. Y para ello el lenguaje, como ya hemos visto utiliza los símbolos mayor y menor, <>. En el siguiente ejemplo podemos observar una clase que admite tipos genéricos.

public class EjemploGenerics<T> {

        private T elemento;

        public EjemploGenerics(T elemento) {

               System.out.println("Elemento " + elemento.getClass());

               this.elemento = elemento;

        }

        public T getItem() {

               return this.elemento;

        }

}

La clase que acabamos de programar ahora admite que cualquier tipo de objeto en su interior, pero eso lo podríamos conseguir indicando que el tipo de objeto contenido es Object, con Generics, podemos indicar cuándo definamos la clase el tipo de objeto que admitirá. Vemos el ejemplo en relación con la clase que acabamos de programar:

public class PrincipalGenerics {

        public static void main(String args[]) {

               EjemploGenerics<String> eg1 = new EjemploGenerics<String>("ejemplo cadena");

               EjemploGenerics<Integer> eg2 = new EjemploGenerics

<Integer>(123);

               EjemploGenerics<Double> eg3 = new EjemploGenerics

<Double>(3.14159);

               String cadena = eg1.getItem();

               Integer entero = eg2.getItem();

               Double decimal = eg3.getItem();      

        }

}

Y la salida que obtenemos al ejecutar este programa:

Elemento class java.lang.String

Elemento class java.lang.Integer

Elemento class java.lang.Double

Esta propiedad que acabamos de aprender, no es sólo aplicable, a los objetos, sino que podemos utilizarlo igualmente en las interfaces:

public interface Comestible<T> {

public void comer(T t);

}

Al implementar esta interface deberemos indicar que tipo de parámetro espera recibir el método sobrescrito:

public class ImplementacionComestible implements Comestible<String> {

        public void comer(String t) {

        }

}

Cuando sobrescribimos el método heredado de la interface, la tipificación del parámetro debe coincidir con la especificada en la definición de la clase.

Además de en clases e interfaces, los objetos genéricos se pueden utilizar en ámbitos inferiores como son los métodos. Permitiendo que el tipo de objeto que se declare como parámetro del método sea así. En el siguiente ejemplo, se utiliza esta técnica con el fin que acabamos de explicar.

 

Package java.util

 

En este último punto, vamos a estudiar como ordenar y buscar entre listas utilizando clases que se encuentran en el paquete java.util.

La clase Collections (cuidado no confundir con la interface Collection), contiene multitud de métodos estáticos de utilidad para trabajar y manipular colecciones. Dentro de los objetivos del examen se requiere específicamente conocer dos métodos para ordenar de esta clase:

public static <T extends Comparable<? Super T>> void sort(List<T> list): que ordena la lista que se pasa como parámetro acorde a su orden natural, que es aquella acorde a la implementación de los métodos compareTo de la interface Comparable. Por ello, los elementos de la lista deben implementar la interface Comparable y debe poder compararse mutuamente, que quiere decir que se tienen que poder comparar unos con otros sin lanzar excepciones de tipo ClassClastException.

public static <T extends Comparable<? Super T>> void sort(List<T> list, Comparator<? super T>): que ordena la lista que se pasa como parámetro acorde al Comparator que se pasa como segundo parámetro. Todos los elementos de la lista deben poder compararse mutuamente.

Debemos fijarnos que en el primer método sort el generic T es declarado como <T extends Comparable<? super T>>, que quiere decir que los elementos de la lista deben extender Comparable (lo que hace referencia a <T extends Comparable>) o que alguno de sus padres implemente Comparable (que hace referencia a <? super T>).

El segundo método de ordenación no tienen estas restricciones ya que la ordenación está basada en un Comparator, que es un objeto separado.

Veamos un ejemplo de uso del primer método de ordenación:

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

public class PrincipalOrdenacionCaracteres {

        public static void main(String [] args) {

               String prueba = "cadena ejemplo";

               char[] letras = prueba.toCharArray();

       List <Character> list = new ArrayList<Character> ();

               for(char c : letras) {

                       list.add(c);

               }

               Collections.sort(list);

               for(Character c : list) {

                       System.out.print(c + " ");

               }

        }

}

En el ejemplo podemos observar como a partir de una cadena que creamos, extraemos todos sus caracteres, los metemos en una lista y los ordenamos con esta utilidad que acabamos de aprender. La salida del programa es la siguente:

  a a c d e e e j l m n o p

Este tipo de uso, como ya hemos hablado, exige que todos los elementos contenidos en la lista deben poder compararse mutuamente, lo que exige en la mayoría de los casos que sean del mismo tipo, es decir no podremos comparar un carácter con un Integer, por ejemplo.

La otra versión del método sort en la clase Collections no requiere que los elementos de la lista implementen la interface Comparable. Ahora, en vez de eso, es necesario pasar como parámetro al método un objeto de tipo Comparator que determinará el orden de la lista.

Vamos a generar un ejemplo de Comparator, que ordene números enteros en el orden inverso al natural, es decir de mayor a menor. Para crear un comparador, es necesario generar una clase que implemente la interface Comparator y sobrescribir el método compare, como se puede ver en el siguiente ejemplo:

import java.util.Comparator;

public class ComparatorNumericoInverso implements Comparator<Integer> {

        public int compare(Integer primerNumero, Integer segundoNumero) {

               return segundoNumero - primerNumero;

        }

}

A continuación vamos a generar una clase con un método main donde podamos probar lo que acabamos de contruir.

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

public class PrincipalOrdenacionNumeros {

        public static void main(String [] args) {

               List <Integer> list = new ArrayList<Integer> ();

               list.add(-10);

               list.add(10);

               list.add(5);

               list.add(5);

               list.add(25);

               Collections.sort(list, new ComparatorNumericoInverso());

               for(Integer i : list) {

                       System.out.println(i);

               }

        }

}

Para ello creamos una lista y metemos diversos números en ella y aprovechamos nuestro comparador para ordenarla de forma inversa como nosotros esperamos. Como resultado de la ejecución obtenemos el resultado esperado:

25

10

5

5

-10

Las otras tareas importantes que debemos aprender de esta clase, aparte de la ordenación, es la de búsqueda de elementos, que será muy útil cuando estemos programando.

 

Para las búsquedas la clase Collections cuenta con dos métodos para buscar elementos en una lista:

public static <T> int binarySearch(List Extends Comparable<? super T>> list, T key): que busca el objeto específico dentro de la lista que se pasa como parámetro. La lista debe ser primero ordenada y los elementos de la lista deben implementar Comparable.

public static <T> int binarySearch(List<? Extends Comparable<? super T>> list, T key, Comparator<? super T>): que busca el objeto específico dentro de la lista que se pasa como parámetro. La lista debe ser primero ordenada y el Comparator que se pasa como parámetro debe ser el usado para ordenar la lista.

Ambos métodos necesitan previamente a ser utilizados que la lista facilitada esté ordenada. Si no lo está el resultado de la búsqueda no será útil. El resultado de la búsqueda nos devolverá un entero que indica la posición de la lista que ocupa el elemento que estamos buscando.

Vamos a ver un ejemplo:

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

public class PrincipalBusquedaBinaria {

        public static void main(String args[]) {

               List<Integer> listaNumeros = new ArrayList<Integer>();

               for(int i = 1; i <= 20; i++) {

                       int x = (int) (Math.random() * 10);

                       listaNumeros.add(x);

               }

               Collections.sort(listaNumeros);

               for(Integer i : listaNumeros) {

                       System.out.print(i + " ");

               }

               System.out.println();

               int index = Collections.binarySearch(listaNumeros, new Integer(5));

               if(index >= 0) {

                       System.out.println("El 5 lo hemos encontrado en el indice " + index);

               } else {

                       System.out.println("El 5 no lo hemos encontrado");

               }

        }

}

Donde creamos una lista de enteros, y metemos dentro 20 elementos, pero cada elemento es un número aleatorio entre cero y nueve, tras esto ordenamos la lista y luego procedemos a buscar el número cinco dentro de la lista, puede ser en función de los elementos de la lista que lo encontremos o no. Puedes ejecutar este código varias veces y apreciar su funcionamiento.

Debemos saber, que si en la lista se encuentra más de un elemento igual (en nuestro caso el número cinco), no hay seguridad de cual de ellos será.

En el siguiente caso vamos a apoyarnos en el comparador de números inverso que hemos generado en el caso de las ordenaciones para hacer lo mismo en las búsquedas, utilizaremos el mismo programa con ligeras modificaciones para adaptarnos a este nuevo orden:

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

public class PrincipalBusquedaBinaria {

        public static void main(String args[]) {

               List<Integer> listaNumeros = new ArrayList<Integer>();

               for(int i = 1; i <= 20; i++) {

                       int x = (int) (Math.random() * 10);

                       listaNumeros.add(x);

               }

               Collections.sort(listaNumeros, new ComparatorNumericoInverso());

               for(Integer i : listaNumeros) {

                       System.out.print(i + " ");

               }

               System.out.println();

               int index = Collections.binarySearch(listaNumeros, new Integer(5), new ComparatorNumericoInverso());

               if(index >= 0) {

                       System.out.println("El 5 lo hemos encontrado en el indice " + index);

               } else {

                       System.out.println("El 5 no lo hemos encontrado");

               }

        }

}

 

Package java.util II

 

Al igual que existe la clase Collections dentro del paquete java.util y nos da ciertas funcionalidades para trabajar con las colecciones, también existe una clase que se llama Arrays y tiene funcionalidades para buscar, ordenar y manipular arrays.

Esta clase contiene métodos para ordenar arrays de tipos primitivos y también de objetos. Existe un par de métodos para realizar estas ordenaciones por cada tipo de array (a excepción de los boolean). Por ejemplo para ordenar arrays de enteros tenemos el siguiente par de métodos:

  • public static void sort(int[] a)
  • public static void sort(int[] a, int indiceDesde, int indiceHasta)

Al igual que para el tipo primitivo int, tenemos los mismos métodos sobrecargados para el resto de tipos primitivos. Y también tenemos el mismo par sobrecargado para la ordenación de arrays de objetos:

  • public static void sort(Object[] a)
  • public static void sort(Object[] a, int indiceDesde, int indiceHasta)
La ordenación de un array de objetos, se hace siguiendo el orden natural y para ello los elementos contenidos en el array, deben implementar la interface Comparable.

De la misma forma que hemos visto para las colecciones, también dispone de las versiones de los métodos donde podemos pasar como último parámetro un Comparator:

  • public static<T> sort(T[] a, Comparator<? super T> c)
  • public static<T> sort(T[] a, int indiceDesde, int indiceHasta, Comparator<? super T> c)

Y también al igual que en el caso previo, este tipo de métodos es muy útil cuando los elementos del array no implementan la interface Comparable o cuando ordenamos de forma diferente al orden natural.

Otra de las utilidades que dispone la clase Arrays es la de convertir un array a una lista, para ello utilizaremos el método:

  • public static < T > List < T > asList(T... a)

Que está disponible en esta clase con ese fin. Podemos ver su uso en el siguiente ejemplo:

import java.util.Arrays;

import java.util.List;

public class PrincipalArray2List {

        public static void main(String args[]) {

               String[] misCadenas = {"una", "dos", "tres"};

               List <String>  lista = Arrays.asList(misCadenas);

               lista.set(1, "cuatro");

               for(String s : lista) {

                       System.out.println(s);

               }

        }

}

Donde a partir de un array de cadenas generamos una lista y posteriormente la modificamos.

Para realizar búsquedas dentro los arrays, dentro de la clase Arrays disponemos de métodos de búsqueda binaria. Existen un par de estos métodos por cada tipo primitivo (exceptuando el boolean), podemos observar a continuación el par que disponemos para el int:

  • public static int binarySearch(int[] a, int elementoBuscado)
  • public static int binarySearch (int[] a, int indiceDesde, int indiceHasta, int elementoBuscado)

Y existen un par por cada tipo primitivo, con la misma forma, donde únicamente varían los tipos de parámetro. Asimismo se dispone de métodos para la búsqueda en arrays de objetos:

  • public static int binarySearch(Object[] a, int elementoBuscado)
  • public static int binarySearch (Object[] a, int indiceDesde, int indiceHasta,  Object elementoBuscado)

Seguimos con el curso de Java en el siguiente enlace:

Programación en Java SE 6 desde cero: Parte 7

Las dudas que os puedan comentarlas justo aquí debajo e iremos respondiendo. 

¡Deja un comentario!

 

Modificado por última vez enJueves, 21 Abril 2016 10:09
Valora este artículo
(3 votos)

Deja tus comentarios

Enviar un comentario como invitado

0 / 300 Restricción de Carateres
El texto debe estar entre 10-300 caracteres
Your comments are subjected to administrator's moderation.
terminos y condiciones.

Gente en la conversación

  • Gipuzkoa, Spain

    Gracias a ti por comentar @Kevin, ya tenéis los 7 capítulos del curso de Java SE 6 publicados. Espero que sirva para aprender algo nuevo.

    Me gusta 0 URL corta:
  • Invitado - Kevin

    Yo ya he llegado al sexto capítulo del curso de JAVA SE 6, a ver cuando publican el séptimo :D . La verdad es que he aprendido muchísimo, está todo bien explicado y documentado. De los mejores cursos que he visto por la red, muchas gracias.

    Me gusta 0 URL corta:
volver arriba