Loading presentation...

Present Remotely

Send the link below via email or IM

Copy

Present to your audience

Start remote presentation

  • Invited audience members will follow you as you navigate and present
  • People invited to a presentation do not need a Prezi account
  • This link expires 10 minutes after you close the presentation
  • A maximum of 30 users can follow your presentation
  • Learn more about this feature in our knowledge base article

Do you really want to delete this prezi?

Neither you, nor the coeditors you shared it with will be able to recover it again.

DeleteCancel

Make your likes visible on Facebook?

Connect your Facebook account to Prezi and let your likes appear on your timeline.
You can change this under Settings & Account at any time.

No, thanks

Colecciones con JAVA

No description
by

Dario Vallejos

on 12 August 2015

Comments (0)

Please log in to add your comment.

Report abuse

Transcript of Colecciones con JAVA

Colecciones
Que son las colecciones?
JAVA Collection Framework(JCF)
Beneficios del uso de JCF
No se inventa la rueda, por lo tanto se reduce el tiempo de programación
Produce un incremento en la calidad del programa terminado
Se aplica el concepto DRY
Permite la extensión y especificación de algoritmos
Nos ayuda a abstraernos de la complejidades de búsqueda, inserción y eliminación de datos
Las colecciones no son mas que conjuntos de datos ordenados o no a los que quiero acceder por alguna razon.
Los programas las usan todo el tiempo
Lista de persona
Palabras de un diccionario
Una lista de elementos lista
Conjunto de documentos
etc ...
JCF: es básicamente una arquitectura unificada para el tratamiento de conjuntos de datos de manera flexible y robusta de esta forma JCF esta formado por
Interfaces
Implementaciones
Algoritmos reutilizables
Diagrama de clases
La interface Collection
Representa un grupo de objetos
El paquete y clase es java.util.Collection
Sirve para la generalización de interfaces
Esta en el tope de la jerarquía

La interface Iterator
La interfase Iterator es necesaria para recorrer colecciones y remover elementos en modo seguro
Creado por Collection.iterator()
Es la única forma de eliminar un elemento de la colección mientras se recorre
La interface Set
Colección que no puede contener elementos duplicados. Abstracción del concepto de matemático de conjunto.
Contiene los métodos heredados de Collection.
Sólo añade restricciones para prohibir elementos duplicados.
Los elementos no están ordenados.
La interface List
Una colección ordenada. Las listas pueden contener elementos duplicados. Generalmente se puede tener control sobre donde cada elemento es insertado y se puede acceder a cada elemento por su índice (posición).
La interface Map
Colección de pares clave/valor (tabla-diccionario)
No puede contener claves duplicadas
Una clave puede mapear a lo sumo un valor
Todo objeto puede ser utilizado como clave
Se utiliza int Object.hashCode()
Objetos iguales (equals) deben tener el mismo hascode
Metodos que permiten ver el mapa como collection
keySet() devuelve el set de claves
values() collection de values
public interface Iterator {//en java.util
boolean hasNext(); //retorna true si se puede invocar a next()
Object next();//retorna el próximo
elemento en la iteración
void remove(); // Opcional; elimina el elemento actual de la colección, sólo puede llamarse si antes invoco next()}
List list = new ArrayList();
Iterator it = list.iterator();
while(it.hasNext()){
//Object o = it.next();
//it.remove()
}
static void filter(Collection c) {
Iterator it = c.iterator();
while (it.hasNext())
if (!cond(it.next()))//Object
it.remove();}
/*Código genérico para cualquier
colección que admita la eliminación
e elementos */
public Set retornarDistintos(String[] args){
Set<String> s = new HashSet<String>();
for (String cadena : args){
if (!s.add(cadena))
System.out.println("Duplicados encontrados: " +cadena;
}
System.out.println(s.size() + " palabras diferentes: " + s);

return s;
}
}

Ejemplo
Operaciones adicionales.

Supóngase que s1 y s2 son Sets, y las operaciones sobre estos:

s1.containsAll(s2) - retorna true si s2 es una sub colección de s1, es decir si s1 contiene todos los elementos de s2.
s1.addAll(s2) - transforma a s1 en la unión de s1 y s2.
s1.retainAll(s2) - transforma a s1 en la intersección de s1 y s2. La diferencia entre s1 y s2.
Ejemplo con for-each
Permite atravesar la colección o arreglo usando un bucle for.

for(Object o: collection){
System.out.println(o);
}
Dos formas de recorrer una colección mediante for o con un Iterator
Pueden contener elementos duplicados
Nuevas operaciones:
Acceso posicional. “Arrays dinámicos” que utilizan para el acceso un índice a partir de 0
Búsqueda
Iteración. Con ListIterator se puede iterar hacia atrás o hacia adelante
Vista de rango
public interface List extends Collection {
// Acceso Posicional
Object get(int index);
Object set(int index, Object element); // Opt
void add(int index, Object element); // Opt.
Object remove(int index); // Opt.
abstract boolean addAll(int index, Collection c);// Opt
// Busqueda
int indexOf(Object o);
int lastIndexOf(Object o);
// Iteracion
ListIterator listIterator();
ListIterator listIterator(int index);
List subList(int from, int to); // Vista de rango
ejemplo:
public static void main(String[] args){
ArrayList list = new ArrayList()
list.add("primero");
list.add("segundo")
list.add(1,"tercero")
list.add(1,"cuarto");
System.out.println(list.indexOf("segundo"));
System.out.println(list.subList(0,2));

}

Map
// Operaciones básicas
put(Object, Object):Object;
get(Object):Object;
remove(Object):Object;
containsKey(Object):boolean;
containsValue(Object):boolean;
size():int;
isEmpty():boolean;
// Operaciones completas
void putAll(Map t):void;
void clear():void;
// Vistas como colecciones
keySet():Set;
values():Collection;
entrySet():Set;
public class Maps {

public static void main(String[] args)
{

//EJEMPLO1
Map<Object,String> mp=new HashMap<>();
//Map<Integer,String> mp=new HashMap<>();

// AÑADIR key & value pair AL MAP
mp.put(new Integer(2), "HOLA");
mp.put(new Integer(1), "ADIOS");
mp.put(new Integer(3), "MAÑANA");
mp.put(new Integer(4), "HOY");
mp.put(new Integer(2), "HOLA1");
//mp.put(2, "HOLA11");

//EJEMPLO2
Map<Object,String> mpr=new HashMap<>();
//Map<Double,String> mp=new HashMap<>();

// AÑADIR key & value pair AL MAP
mpr.put(new Double(2), "HOLAr");
mpr.put(new Double(1), "ADIOSr");
mpr.put(new Double(3), "MAÑANAr");
mpr.put(new Double(4), "HOYr");
mpr.put(new Double(2), "HOLA1r");

//PASAR Map A Set-interface PARA SACAR key & value
Set s=mp.entrySet();
//Set s=mpr.entrySet();

//MOVER CON ITERATOR A PROXIMO key & value DEL MAP
Iterator it=s.iterator();

while(it.hasNext())
{
// ENTRADA DEL MAP Map.Entry PATA OBTENER key & value
Map.Entry m =(Map.Entry)it.next();

// getKey PARA OBTENER key
int key=(Integer)m.getKey();
//double key=(double)m.getKey();

// getValue PARA OBTENER value
String value=(String)m.getValue();

System.out.println("Key :"+key+" Value :"+value);
}

//EJEMPLO MAS AVANZADO
System.out.println("\nManejo de Maps de frecuencias: ");
pruebaMaps();

}
impl. List
Vector
Impl.Set
HashSet
ArrayList
LinkedList
http://docs.oracle.com/javase/6/docs/api/java/util/Vector.html
http://docs.oracle.com/javase/6/docs/api/java/util/ArrayList.html
http://docs.oracle.com/javase/6/docs/api/java/util/LinkedList.html
TreeSet
LinkedHashSet
proposito general
proposito particular
ref:http://docs.oracle.com/javase/tutorial/collections/implementations/set.html
http://docs.oracle.com/javase/tutorial/collections/implementations/list.html
proposito general
La interface List
Full transcript