Marzo 2007 Lenguajes Visuales Clase III.

Presentación del tema: "Marzo 2007 Lenguajes Visuales Clase III."— Transcripción de la presentación:

1 Marzo 2007 Lenguajes Visuales Clase III

2 Estructuras de datos Estructuras estáticas. Estructuras dinámicas.
Marzo 2007 Estructuras de datos Estructuras estáticas. Arreglos simples. Arreglos de arreglos. Estructuras dinámicas. Colecciones. Sin elementos duplicados. Con elementos duplicados. Listas ordenadas. Diccionarios. Arboles. Marzo 2007 Godio - López - Cancela

3 Estructuras estáticas
Marzo 2007 Estructuras estáticas Los arreglos son estructuras que permiten contener varios valores del mismo tipo. La longitud del arreglo (cantidad de valores) se establece en el momento de la declaración de la estructura. Una vez creada la estructura es de longitud fija. En los arreglos multidimensionales cada elemento de la dimensión es una referencia a otro arreglo con su propia dimensión. El concepto de matrices está representado por estructuras de arreglos de arreglos en los cuales cada elemento de la primera dimensión es una referencia a otro arreglo, todos de la misma longitud. Marzo 2007 Godio - López - Cancela

4 Declaración de arreglos.
Marzo 2007 Declaración de arreglos. Arreglos de una dimensión. int[ ] arr1; // declara a un arreglo de int. arr1 = new int[10]; // dimensiona un arreglo de 10 int. int[10] arr2 = new int[10]; // declara y dimensiona. int[ ] arr3 = { 7, 2, 14, 8 }; // declara, dimensiona e inicializa Arreglos de arreglos. int[ ][ ] mat1; mat1 = new int[4][3]; int[2][ ] mat2; mat2[0] = new int[4]; mat2[1] = new int[3]; int[ ][ ] mat3 = { { 3, 8 }, {12, 1, 7 }, { 19 } }; Marzo 2007 Godio - López - Cancela

5 Marzo 2007 Recorrido de Arreglos La propiedad length indica la cantidad de elementos que un arreglo posee en una determinada dimensión: arreglo.length ; Cada elemento se referencia subindicando la posición del arreglo: arreglo[ posición] ; Ejemplo del recorrido de todos los elementos de un arreglo: for (int i = 0 ; i < arreglo.length ; i++ ) { arreglo[ i ] … } Ejemplo del recorrido de todos los elementos de un arreglo de arreglos: for (int j = 0 ; j < arreglo[ i ].length ; j++ ) arreglo[ i ] [ j ] … Marzo 2007 Godio - López - Cancela

6 Marzo 2007 Arreglos de objetos Se declaran y dimensionan de la misma forma que los de tipos por valor. Cada elemento debe instanciarse. Object[ ] objetos = new Object[ 3 ]; objetos[0] = new String(“abc”) ; objetos[1] = new Integer( 10 ) ; objetos[2] = new Double( ); Se recorren de la misma forma. for (int i = 0 ; i < objetos.lenght ; i++) { Object o = objetos[ i ] ; } Marzo 2007 Godio - López - Cancela

7 Genéricos Son tipos parametrizados que permiten definir colecciones para cualquier el tipo de dato. Sin utilizar parámetros: List nombres = new ArrayList(); nombres.add(“Juan”); nombres.add(“Ana”); … Object o = nombres.get(0); String s = (String) o; El elemento debe ser convertido a String al ser todos Objects. Utilizando parámetros List<String> nombres = new ArrayList <String>(); Se define una lista de Strings nombres.add(“Juan”); nombre.add(“Ana”); … String s = nombres.get(0); No es necesario convertirlos al ser todos Strings. El tipo de dato del genérico se indica cuando se declara la estructura. Marzo 2007 Godio - López - Cancela

8 Genéricos Identificación y tipos de parámetros:
E : parámetro que identifica al elemento de la colección. K : parámetro que identifica al elemento clave de la colección. V : parámetro que identifica al valor que apunta la clave. T : parámetro que identifica un conjunto de valores. . . . Son utilizados en la definición de una clase que permita instanciarse con tipos genéricos. Marzo 2007 Godio - López - Cancela

9 Genéricos Definición de clases genéricas
Indicar en la declaración de la clase el tipo de genérico que reconoce: class Lista<E> class Diccionario<K,V> Indicar el tipo de dato genérico a los miembros de la clase. private E item; public E getItem() { return item; } public void setItem(E item) { this.item = item; } private K clave; private V valor; public K getClave() { return clave; } public V getValor() { return valor; } Marzo 2007 Godio - López - Cancela

10 Marzo 2007 Colecciones El manejo que realiza la VM de las colecciones se representa mediante la siguiente arquitectura: Interfaces. Son los tipos abstractos que representan la colección. Implementaciones. Son las implementaciones concretas de la interfaz de la colección. Definen estructuras reusables. Algoritmos. Métodos depurados para ejecutar eficientemente un proceso, como los algoritmos de búsqueda y ordenamiento. Estos son polimórficos, para poder ser adoptados por distintas colecciones. Marzo 2007 Godio - López - Cancela

11 Colecciones - Interfaces
Jerarquía de las Interfaces Marzo 2007 Godio - López - Cancela

12 interface Collection Es la ruta de todas las colecciones.
Marzo 2007 interface Collection Es la ruta de todas las colecciones. Representa un grupo de objetos conocidos como elementos. Define el siguiente comportamiento (código parcial): public interface Collection<E> extends Iterable<E> { int size(); boolean isEmpty(); boolean contains(Object element); boolean add(E element); boolean remove(Object element); Iterator iterator(); void clear(); . . . } Marzo 2007 Godio - López - Cancela

13 Recorrido de una colección
Marzo 2007 Recorrido de una colección Una colección puede ser recorrida: Bloque for-each. Objeto Iterator. Bloque for-each es una particularidad del bloque for. Sintaxis: for ( elemento : colección) … for ( Object o : coleccion ) { o.toString( ) } Las colecciones permiten la implementación de un Iterador. La interface Iterator<E> define el siguiente comportamiento: public interface Iterator<E> { boolean hasNext( ); E next( ); void remove( ); } Implementación de un iterador: for ( Iterator i = c.iterator( ); i.hasNext( ); ) { System.out.println(i.next()); Marzo 2007 Godio - López - Cancela

14 interface Map Representa a los diccionarios.
Marzo 2007 interface Map Representa a los diccionarios. No permiten elementos duplicados. Define una clave que mapea al elemento. Define el siguiente comportamiento (código parcial): public interface Map { V put(K key, V value); V get(Object key); V remove(Object key); boolean containsKey(Object key); boolean containsValue(Object value); int size(); boolean isEmpty(); void clear(); . . . } Marzo 2007 Godio - López - Cancela

15 Colecciones - Implementaciones
Marzo 2007 Colecciones - Implementaciones Las interfaces de las colecciones se implementan en las siguientes clases: (lista parcial) interface Set class HashSet class TreeSet interface List class ArrayList class LinkedList interface Map class HashMap class TreeMap Marzo 2007 Godio - López - Cancela

16 Manejo de una List (implementando ArrayList)
Marzo 2007 Manejo de una List (implementando ArrayList) Declaración de una lista de elementos enteros. List<Integer> lista = new ArrayList<Integer>( ); Agregar un elemento al final de la lista. lista.add( 20 ); Insertar un elemento en determinada posición. lista.add( 0, 6 ); Buscar un elemento en la lista. If ( lista.contains( 20 ) ) // existe Eliminar un elemento en la lista. lista.remove( 20 ) ; Eliminar todos los elementos en la lista. lista.clear( ) ; Obtener un elemento en determinada posición. lista.get( posicion ) ; Marzo 2007 Godio - López - Cancela

17 Manejo de un Set (implementando HashSet)
Marzo 2007 Manejo de un Set (implementando HashSet) Declaración de un set de elementos enteros. Set<Integer> set = new HashSet<Integer>( ); Agregar un elemento al final del set. set.add( 20 ); Buscar un elemento en el set. If ( set.contains( 20 ) ) // existe Eliminar un elemento del set. set.remove( 20 ) ; Eliminar todos los elementos del set. If ( ! Set.isEmpty( ) ) set.clear( ) ; Asociar un Iterador a la colección set. Iterator i = set.iterator( ) ; Marzo 2007 Godio - López - Cancela

18 Manejo de un Map (implementando TreeMap)
Declaración de un TreeMap. SortedMap<String,String> map = new TreeMap<String,String>( ); Agregar un elemento. map.put( “lu”, “Lunes” ); Buscar un elemento por el valor. If ( map.containsValue( “Lunes” ) ) // existe Buscar un elemento por la clave. If ( map.containsKey( “lu” ) ) // existe Eliminar un elemento. map.remove( “lu” ); Eliminar todos los elementos. map.clear( ); Recorrer un TreeMap. Set keys = map.keySet( ); // obtiene el set de claves for ( Iterator i = keys.iterator( ); i.hasNext( ); ) { String key = i.next(); // obtiene la clave map.get( key ); // obtiene el valor } Marzo 2007 Godio - López - Cancela

19 Objetos auto referenciados
Son los elementos de las estructuras dinámicas Implementación de un OAR: Definir una clase parametrizada. Debe estar compuesta por: Un item de tipo genérico. Una o mas referencias a objetos de la misma clase. Definir constructores. Implementar encapsulamiento. < E > < E > < E > Marzo 2007 Godio - López - Cancela

20 Objetos auto referenciados
La clase Nodo<E> define un OAR Una colección de objetos Nodo<E> puede componer estructuras de datos simplemente enlazadas. El objeto parametrizado E item define la utilización de genéricos para las estructuras que tengan que implementarlo. La referencia siguiente de tipo Nodo<E> determina a otro objeto de la misma clase como miembro de ésta. Los restantes métodos conforman el encapsulamiento. public class Nodo<E> { private E item; private Nodo<E> sigiente; public Nodo(E item) { this.item = item; siguiente = null; } public Nodo(E item, Nodo<E> sig) { this.siguiente = sig; public E getItem() { return item; // métodos get y set Marzo 2007 Godio - López - Cancela

21 Estructuras auto referenciadas
Una estructura dinámica encadena sus valores con objetos auto referenciados. Estructuras básicas: Pila Cola Lista simple Estructuras complejas Lista doblemente enlazada Diccionario Arbol binario Estructuras avanzadas Arbol balanceado Cola de prioridades Arboles disjuntos Marzo 2007 Godio - López - Cancela

22 Estructuras auto referenciadas
Pila: Estado actual: Agregar: Eliminar Código: Declaración del Nodo<E> private Nodo<E> nodo; Agregar public void insertar(E item) { nodo = new Nodo<E> ( item, nodo ); } Eliminación public E eliminar() { … E item = nodo.getItem(); nodo = nodo.getSiguiente(); return item; nodo 8 12 nodo 44 8 12 nodo 44 8 12 Marzo 2007 Godio - López - Cancela

23 Estructuras auto referenciadas
La clase Nodo<E> define al OAR. La interface Ipila<E> define el TDA. La clase Pila resuelve la EAR. La clase EstructuraVaciaException define la excepción que debe lanzarse cuando no se pueda aplicar el método por encontrarse la estructura vacía. Pila<E> tope : Nodo<E> { IPila<E> Exception + vacia( ) : boolean + obtener( ) throws Ex : E + eliminar( ) throws Ex : E + insertar(E item) : void Nodo<E> EstructuraVaciaException item : E - sig : Nodo<E> Marzo 2007 Godio - López - Cancela