Colecciones de Java
Anuncio
Colecciones de Java
LSUB
GSYC
30 de enero de 2013
(cc) 2013 Laboratorio de Sistemas,
Algunos derechos reservados. Este trabajo se entrega bajo la licencia Creative Commons Reconocimiento NoComercial - SinObraDerivada (by-nc-nd). Para obtener la licencia completa, véase
http://creativecommons.org/licenses/by-sa/2.1/es. También puede solicitarse a Creative Commons, 559 Nathan
Abbott Way, Stanford, California 94305, USA.
Colecciones
• Son estructuras genéricas que implementan estas interfaces:
Collection
Set
SortedSet
List
Queue
Map
BlockingQueue
SortedMap
Collection
p u b l i c i n t e r f a c e C o l l e c t i o n <E> e x t e n d s I t e r a b l e <E> {
int size ();
boolean isEmpty ( ) ;
b o o l e a n add ( E e l e m e n t ) ;
b o o l e a n remove ( O b j e c t e l e m e n t ) ;
boolean c o n t a i n s ( Object element ) ;
I t e r a t o r <E> i t e r a t o r ( ) ;
Object [ ] toArray ( ) ;
<T> T [ ] t o A r r a y (T [ ] a ) ;
}
Listas
• La interfaz para lista no implica que esté implementada con
una lista enlazada. Por ejemplo, estas dos clases implementan
la interfaz List:
• ArrayList: usa un array, bueno para acceso aleatorio pero lento
para insertar elementos.
• LinkedList: implementado como una lista enlazada, lento para
acceso aleatorio.
Listas
p u b l i c i n t e r f a c e L i s t <E> e x t e n d s C o l l e c t i o n <E> {
E get ( i n t index ) ;
E se t ( i n t index , E element ) ;
v o i d add ( i n t i n d e x , E e l e m e n t ) ;
E remove ( i n t i n d e x ) ;
i n t indexOf ( Object o ) ;
i n t l a s t I n d e x O f ( Object o ) ;
L i s t I t e r a t o r <E> l i s t I t e r a t o r ( ) ;
L i s t I t e r a t o r <E> l i s t I t e r a t o r ( i n t i n d e x ) ;
L i s t <E> s u b L i s t ( i n t from , i n t t o ) ;
}
Listas
L i s t <I n t e g e r > l i s t = new A r r a y L i s t <I n t e g e r > ( ) ;
f o r ( i n t i = 0 ; i < 1 0 ; i ++)
l i s t . add ( i ) ;
System . o u t . p r i n t l n ( ” t h e s e c o n d e l e m e n t i s : ” + l i s t . g e t ( 2 ) ) ;
// SALIDA :
// t h e s e c o n d e l e m e n t i s : 2
Listas
L i s t <I n t e g e r > l i s t = new A r r a y L i s t <I n t e g e r > ( ) ;
f o r ( i n t i = 0 ; i < 1 0 ; i ++)
l i s t . add ( i ) ;
l i s t . remove ( 3 ) ;
System . o u t . p r i n t l n ( l i s t ) ;
// SALIDA :
// [ 0 , 1 , 2 , 4 , 5 , 6 , 7 , 8 , 9 ]
Iteradores
p u b l i c i n t e r f a c e I t e r a t o r <E> {
boolean hasNext ( ) ;
E next ( ) ;
}
Iteradores
L i s t <I n t e g e r > l i s t = new A r r a y L i s t <I n t e g e r > ( ) ;
I t e r a t o r <I n t e g e r > i t ;
int total = 0;
f o r ( i n t i = 0 ; i < 1 0 ; i ++)
l i s t . add ( i ) ;
it = list . iterator ();
while ( i t . hasNext ( ) )
t o t a l += i t . n e x t ( ) ;
System . o u t . p r i n t l n ( ” t o t a l : ” + t o t a l ) ;
// SALIDA :
// t o t a l : 4 5
Iteradores (de lista)
Pueden ir para atrás:
L i s t <I n t e g e r > l i s t = new A r r a y L i s t <I n t e g e r > ( ) ;
L i s t I t e r a t o r <I n t e g e r > i t ;
int total = 0;
f o r ( i n t i = 0 ; i < 3 ; i ++)
l i s t . add ( i ) ;
it = list . listIterator ();
while ( i t . hasNext ( ) )
System . o u t . p r i n t ( i t . n e x t ( ) ) ;
while ( i t . hasPrevious ())
System . o u t . p r i n t ( i t . p r e v i o u s ( ) ) ;
//SALIDA :
// 012210
Set
• Conjunto sin duplicados (con equals()).
• El método add devuelve si pudo añadir o no.
Set
p u b l i c i n t e r f a c e Set<E> e x t e n d s C o l l e c t i o n <E> {
// B a s i c o p e r a t i o n s
int size ();
boolean isEmpty ( ) ;
boolean c o n t a i n s ( Object element ) ;
// o p t i o n a l
b o o l e a n add ( E e l e m e n t ) ;
// o p t i o n a l
b o o l e a n remove ( O b j e c t e l e m e n t ) ;
I t e r a t o r <E> i t e r a t o r ( ) ;
// B u l k o p e r a t i o n s
b o o l e a n c o n t a i n s A l l ( C o l l e c t i o n <?> c ) ;
// o p t i o n a l
b o o l e a n a d d A l l ( C o l l e c t i o n <? e x t e n d s E> c ) ;
// o p t i o n a l
b o o l e a n r e m o v e A l l ( C o l l e c t i o n <?> c ) ;
// o p t i o n a l
b o o l e a n r e t a i n A l l ( C o l l e c t i o n <?> c ) ;
// o p t i o n a l
void c l e a r ( ) ;
// A r r a y O p e r a t i o n s
Object [ ] toArray ( ) ;
<T> T [ ] t o A r r a y (T [ ] a ) ;
}
Queue
Además de la interfaz de una colección:
p u b l i c i n t e r f a c e Queue<E>
E element ( ) ;
boolean o f f e r (E e ) ;
E peek ( ) ;
E poll ();
E remove ( ) ;
}
e x t e n d s C o l l e c t i o n <E> {
// como add ( )
// como e l e m e n t ( )
// como remove ( )
Queue
• Algunas no son FIFO: LIFO queues, priority queues, etc.
• Algunos métodos elevan excepciones:
• add(e): inserta un elemento.
• remove(): elimina la cabeza y la devuelve.
• element(): devuelve la cabeza (no la elimina).
• Otros retornan valores especiales (null o false):
• offer(e): inserta un elemento.
• poll(): elimina la cabeza y la devuelve.
• peek(): devuelve la cabeza (no la elimina).
BlockingQueue
• Es una cola para comunicar procesos.
• Thread-safe.
• Amplı́a la interfaz con operaciones bloqueantes.
BlockingQueue
p u b l i c i n t e r f a c e B l o c k i n g Q u e u e <E> e x t e n d s Queue<E> { ;
boolean put (E e ) ;
// como add , p e r o b l o q u e a
E take ( ) ;
// como e l e m e n t ( ) , p e r o b l o q u e a
}
BlockingQueue
• Bloqueantes sin timeout:
• put(e): inserta un elemento.
• take(): elimina la cabeza y la devuelve.
• Bloqueantes con timeout:
• offer(e, time, unit): inserta un elemento.
• poll(time, unit): elimina la cabeza y la devuelve.
Map
• Una especie de diccionario: mapea claves a valores.
• No puede tener claves duplicadas.
• Cada clave se mapea a como mucho un único valor.
Map
p u b l i c i n t e r f a c e Map<K , V> {
V p u t (K key , V v a l u e ) ;
V get ( Object key ) ;
V remove ( O b j e c t k e y ) ;
boolean containsKey ( Object key ) ;
boolean containsValue ( Object value ) ;
int size ();
boolean isEmpty ( ) ;
p u b l i c Set<K> k e y S e t ( ) ;
p u b l i c C o l l e c t i o n <V> v a l u e s ( ) ;
}
SortedSet y SortedMap
• SortedSet: los elementos del conjunto están ordenados.
• SortedMap: las claves están ordenadas.
• Los elementos deben implementar la interfaz Comparable.
• Por lo demás son iguales que Set y Map.
Implementaciones
Las básicas son:
• Set: HashSet, TreeSet, LinkedHashSet.
• List: ArrayList, LinkedList.
• Map: HashMap, TreeMap, LinkedHashMap.
• SortedSet: TreeSet.
• SortedMap: TreeMap.
• Queue: LinkedList, PriorityQueue.
Thread-safeness
• Podemos crear una colección envuelta con una clase
decoradora para hacerla thread-safe.
• Para ello podemos usar los métodos de Collections
synchronizedSet o synchronizedMap
p u b l i c s t a t i c <T> Set<T> s y n c h r o n i z e d S e t ( Set<T> s ) ;
• Por ejemplo:
S e t s = C o l l e c t i o n s . s y n c h r o n i z e d S e t ( new H a s h S e t ( ) ) ;
Algoritmos
Los básicos:
• Collections.sort(list): ordena.
• Collections.suffle(list): permutación aleatoria de elementos.
• Collections.reverse(list): invierte la lista.
• Collections.binarySearch(list, key): búsqueda binaria.
• Collections.min(list): menor valor.
• Collections.max(list): mayor valor.
