Reutilización del Software. Programación genérica

Transcripción

1 Reutilización del Software Programación genérica 1

2 Índice 1.-) Introducción 2.-) Contenedores (JGL containers) 3.-) Algoritmos (JGL algorithms) 4.-) Objetos función (JGL function objects) 5.-) Iteradores (JGL iterators) 6.-) Ejercicios con JGL 2

3 Genericidad Lista Pila Cola Queremos implementar los métodos: sort() greatest() printall() 3

4 Genericidad Lista Pila Cola sort() greatest() printall() sort() greatest() printall() sort() greatest() printall() Inconvenientes: El código el similar en todos las estructuras (replicación) Qué sucede si añadimos una nueva colección? (Set, Hash, Vector) 4

5 Genericidad Y mas cosas Algoritmos sort(colección c) greatest(colección c) printall(colección c) usa Colección (Interfaz) hasmoreelements() nextelement() implementa implementa implementa Lista Pila Cola 5

6 Genericidad class Algoritmos { public void printall (Colección c) { Object o; while (c.hasmoreelements()) { o=c.nextelement(); System.out.println(o); main() { Pila p=new Pila(); Algortimos.printAll(p); main() { Colección c=new Cola(); Algortimos.printAll(c); 6

7 Genericidad La programación genérica es una técnica que define algoritmos: 1. reusables 2. implementadados como entidades de primer nivel(clases) 3. independientes de los datos sobre los que opera Normalmente los algoritmos genéricos son utilizados sobre agregados de elementos (pilas, colas, listas, conjuntos. ) 7

8 JGL- Una librería genérica en Java 8

9 Qué es JGL? La Generic Collection Library for Java (JGL) es un conjunto de ESTRUCTURAS DE DATOS Y ALGORITMOS REUSABLES. JGL complementa a la librería que viene con el JDK (Java Development Kit), la cual contiene un soporte limitado para estructuras de datos y algoritmos. En JDK existen Vector, Enumeration, Dictionary,... 9

10 Componentes principales de la librería JGL Containers Adapters Algorithms Function Objects Iterators 10

11 Paquetes de la librería JGL package com.objectspace.jgl contiene interfaces, clases e iteradores package com.objectspace.jgl.adapters contiene los adaptadores a arrays nativos de Java package com.objectspace.jgl.algorithms contiene todos los algoritmos JGL package com.objectspace.jgl.functions contiene las funciones que pueden usarse para modificar algoritmos 11

12 Paquetes de la librería JGL(II) package com.objectspace.jgl.predicates contiene las clases con los predicados utilizados para especificar orden de elementos dentro de contenedores package com.objectspace.jgl.util contiene algunas clases con utilidades 12

13 JGL Containers La jerarquia Interfaces JDK

14 JGL Containers Características La versión JDK 1.5 y por lo tanto la JGL 5.0 permite definir clases e interfaces genéricas (generics) interface Stack<T> public interface Stack<T> extends Container<T> 14

15 JGL Containers Características Las clases al igual que las interfaces se definen de manera genérica public class ListStack<T> implements Stack<T> 15

16 JGL Containers Características Al crear una instancia se especifica la CLASE de elemento que contiene ListStack<String> pilastrings=new ListStack<String> o Stack<String> pilastrings=new ListStack<String> Ahora únicamente se pueden introducir elementos de tipo String, en caso contrario, el compilador detectará un error de tipos pilastrings.add( Esta inserción es correcta ); //OK pilastrings.add(new Integer(4)); //Error de compilación 16

17 JGL Containers Características No se pueden almacenar tipos primitivos (char, int, ) Para ello usar las clases Boolean, Character, Byte, Short, Integer, Long, Float y Double de java.lang pilaenteros.add(new Integer(4)); Cuando se extrae un elementos de la estructura NO hay que hacer el Casting Integer numero=pilaenteros.pop(); 17

18 JGL Containers Ejemplo Output array = Array(triangle, square, pentagon, hexagon) array.size() = 4 array.empty() = false after array is cleared... array.size() = 0 array.empty() = true public class Container1 { public static void main(string[] args) { Array<String> array = new Array<String>(); array.add( "triangle" ); array.add( "square" ); array.add( "pentagon" ); array.add( "hexagon" ); System.out.println( "array = " + array ); System.out.println( "array.size() = " + array.size() ); System.out.println( "array.empty() = " + array.isempty() ); array.clear(); System.out.println( "after array is cleared..." ); System.out.println( "array.size() = " + array.size() ); System.out.println( "array.empty() = " + array.isempty() ); 18

19 JGL Containers Ejemplo: Recorrido public class Container2 { public static void main( String[] args ) { Array<Integer> array = new Array<Integer>(); array.add( new Integer(1) ); array.add( new Integer(2)); array.add( new Integer(3)); Integer i; Enumeration<Integer> iterator = array.elements(); while ( iterator.hasmoreelements() ) { i= iterator.nextelement() System.out.println( i.tostring() ); Output

20 JGL Containers La interfaz Container<T> interface Container<T> public interface Container<T> extends java.lang.cloneable, java.io.serializable, java.util.collection<t> 20

21 JGL Containers 21

22 JGL Sequences La interfaz Sequence<T> Métodos pushfront/pushback popfront/popback front/back at/put remove replace public interface Sequence<T> extends Container<T>, java.util.list<t> Significado inserta un elemento al principio/final elimina y devuelve el elemento al principio/final devuelve el primer/último elemento devuelve/reemplaza el elemento en la posición especificada borra un valor concreto reemplaza un valor por otro count indexof cuenta el número de elementos coincidentes con uno devuelve la posición de un elemento concreto 22

23 JGL Containers => Sequences Ejemplo public class Sequences2 { public static void main( String[] args ) { Deque<String> deque =new Deque<String>(); deque.pushback( "APE" ); deque.pushback( "BAT" ); deque.pushfront( BAT"); deque.add( "cat" ); deque.add( "bat" ); deque.add( "bat" ); deque = Deque( BAT, APE, BAT, cat, bat, bat, cat ) deque.count( bat ) = 2 deque.indexof( bat ) = 4 After deque.remove( 4 ) = Deque( BAT, APE, BAT, cat, bat, cat ) After deque.replace( 0, 1, BAT, bat ) = Deque( bat, APE, BAT, cat, bat, cat ) deque.remove( cat ) = 2 After deque.remove( cat ) = Deque( bat, APE, BAT, bat ) deque.add( "cat" ); // add ES SINONIMO DE pushback System.out.println( "deque = " + deque ); System.out.println( "deque.count( bat ) = " + deque.count( "bat" ) ); int index = deque.indexof( "bat" ); System.out.println( "deque.indexof( bat ) = " + index ); deque.remove( index ); System.out.println( "After deque.remove( " + index + " ) = " + deque ); deque.replace( 0, 1, "BAT", "bat" ); System.out.println( "After deque.replace( 0, 1, BAT, bat ) = " + deque ); System.out.println( "deque.remove( cat ) = " + deque.remove( "cat" ) ); System.out.println( "After deque.remove( cat ) = " + deque ); 23

24 JGL Queues y Stacks CONTAINERS QUEUES & STACKS <<interface>> Container <<interface>> Queue <<interface>> PriorityQueue <<interface>> Stack ListQueue ListPriorityQueue ListStack Stack es una estructura de pila (LIFO). Por defecto, para su almacenamiento interno utiliza un Array, pero puede cambiarse. Queue es una estructura de cola (FIFO). Por defecto, para su almacenamiento interno utiliza una Slist, pero puede cambiarse. PriorityQueue es una estructura de cola con los elementos ordenados y que devuelve los elementos según dicho orden. Por defecto, para su almacenamiento interno utiliza un Array, pero puede cambiarse 24

25 JGL Queues y Stacks Aparte de los métodos de CONTAINER, Stack y Queue tienen los métodos push pop inserta un nuevo elemento en la Pila/Cola devuelve el último/primer elemento insertado en la Pila/Cola Los métodos para PriorityQueue son también push y pop. Al crear un nuevo objeto de dicho tipo se le puede dar un predicado por el cual se ordenen los elementos en la cola. Por ejemplo: GreaterString() 25

26 interface Stack<T> public interface Stack<T> extends Container<T> 26

27 interface Queue<T> public interface Queue<T>extends Container<T> 27

28 interface PriorityQueue<T> public interface PriorityQueue<T> extends Container<T> 28

29 JGL Queues y Stacks Ejemplo public class Stacks1 { public static void main( String[] args ) { Stack<String> stack = new Stack<String>(); stack.push( "bat" ); stack.push( "cat" ); stack.push( "dog" ); System.out.println( "stack = " + stack ); System.out.println(); bat System.out.println( "Non-destructively enumerate the Stack." ); Enumeration<String> e = stack.elements(); while ( e.hasmoreelements() ) System.out.println( e.nextelement() ); System.out.println(); System.out.println( "Pop and print each element." ); while (!stack.isempty() ) System.out.println( stack.pop() ); Output stack = Stack( Array( bat, cat, dog ) ) Non-destructively enumerate the Stack. bat cat dog Pop and print each element. dog cat 29

30 JGL Queues y Stacks Ejemplo public class Stacks5 { public static void main( String[] args ) { // Utiliza el predicado GreaterString para comparar elementos. PriorityQueue<String> queue = new PriorityQueue<String>( new GreaterString<String>() ); queue.push( "cat" ); queue.push( "dog" ); queue.push( "ape" ); queue.push( "bat" ); queue.push( "fox" ); queue.push( "emu" ); System.out.println( "Pop and print each element." ); while (!queue.isempty() ) System.out.print( queue.pop() + " "); Output Pop and print each element. ape bat cat dog emu fox 30

31 JGL Array adapters Los algoritmos genéricos de JGL se pueden aplicar a contenedores JGL, arrays nativos de Java y a estructuras de datos JDK. Para ello existen unas clases adaptadores que hacen que los arrays nativos 31 actúen como contenedores JGL (JGL Container)

32 Container add() clear() clone() JGL Array adapters implementa IntArray usa int[] class IntArray<T> implements Container<T> { int[] myarray; IntArray(int[] parray){ myarray=parray; public void add(object o) public void clear().. 32

33 JGL Array adapters Ejemplo: Recorrido arrays nativos public class Adapters1 { public static void main(string[] args) { int[] nativearray = new int[]{ 0, 3, 6, 0, 2, 3, 0, 7 ; List<Integer> intarray = new IntArray<Integer>(nativeArray); System.out.println( "Printing with JGL adapter: " + intarray ); // Now, treat the array like a list. ListIterator<Integer> iter = intarray.listiterator(); System.out.print( "Iterate forwards: " ); while ( iter.hasnext() ) System.out.print( iter.next() ); System.out.print( "\nand iterate backwards: " ); while ( iter.hasprevious() ) System.out.print( iter.previous() ); Output Printing with JGL adapter: (0, 3, 6, 0, 2, 3, 0, 7) Iterate fordwards :( ) 33 And iterate backwards = )

34 JGL Array adapters Ejemplo: Utilizando algoritmos public class Adapters2 { public static void main(string[] args) { int[] nativearray = new int[]{ 5, -1, 3, 6, 2, 3, 1, 7, -2 ; // Wrap the native array List<Integer> intarray = new IntArray<Integer>(nativeArray ); System.out.println( intarray ); // Count the values greater than 3 UnaryPredicate<Integer> greaterthan2 = new BindSecondPredicate<Integer>( new GreaterNumber<Integer>(), new Integer(2)); int count = Counting.countIf(intArray, greaterthan2); System.out.println( "Values greater than 2: " + count ); // Replace negative values with 0 Replacing.replaceIf(intArray, new NegativeNumber(), new Integer(0)); System.out.println( "Replace negative values with 0: " + intarray ); Counting.countIf y Replacing.replaceIf SON JGL ALGORITHMS (se trata más adelante) Output int[]( 5, -1, 3, 6, 2, 3, 1, 7, -2 ) Values greater than 2: 5 34 Replace negative values with 0: int[]( 5, 0, 3, 6, 2, 3, 1, 7, 0 )

35 Ejercicio Cómo definirías una Pila de enteros, utilizando como estructura interna de almacenamiento un array nativo de enteros? Modela el diagrama de clases Crea una instancia Pila y añade un elemento 35

36 JGL algorithms JGL proporciona más de 50 algoritmos reusables (desde un filtrado a un quicksort) que pueden ser aplicados a contenedores JGL, JDK y arrays nativos de Java (a través de adapters). Cada algoritmo se implementa como un método estático y público de una clase. Las clases son: Applying, Comparing, Copying, Counting, Filling, Filtering, Finding, Heap, MinMax, Permuting, Printing, Removing, Replacing, Reversing, Rotating, SetOperations, Shuffling, Sorting, Swapping, Transforming No pueden crearse instancias de estas clases 36 Se encuentran en com.objectspace.jgl.algorithms

37 JGL algorithms Ejemplo Counting public class Algorithms3 { public static void main( String[] args ) { Slist<Integer> list = new SList<Integer>(); list.add( new Integer( -1 ) ); list.add( new Integer( 1 ) ); list.add( new Integer( -2 ) ); list.add( new Integer( 1 ) ); list.add( new Integer( -3 ) ); System.out.println( "list = " + list ); Output list = SList( -1, 1, -2, 1, -3 ) Occurences of 1 = 2 Occurences of a negative = 3 NegativeNumber() ES JGL PREDICATE Object value = new Integer( 1 ); (se trata más adelante) int n1 = Counting.count( list, value ); System.out.println( "Occurences of " + value + " = " + n1 ); int n2 = Counting.countIf( list, new NegativeNumber<Integer>() ); System.out.println( "Occurences of a negative = " + n2 ); 37

38 JGL algorithms Ejemplo Finding Output public class Algorithms4 { public static void main( String[] args ) { int ints[] = { 3, 7, 8, 2, -5, 8, 9, -2 ; IntArray array = new IntArray( ints ); System.out.println( "array = " + array ); array = int[]( 3, 7, 8, 2, -5, 8, 9, -2 ) first negative = -5 some items are negative = true Integer negative = Finding.detect( array, new NegativeNumber<Integer>() ); System.out.println( "first negative = " + negative ); boolean some = Finding.some( array, new NegativeNumber<Integer>() ); System.out.println( "some items are negative = " + some ); 38

39 JGL Function Objects Muchos de los algoritmos y de los contenedores JGL requieren que se especifique un objeto función para poder ejecutar sus operaciones Hay dos tipos de objetos función: Predicados, devuelven valores booleanos y se usan para ordenar elementos o activar ejecuciones de acciones. Se encuentran en com.objectspace.jgl.predicates Funciones generales, ejecutan operaciones y devuelven objetos Se encuentran en com.objectspace.jgl.functions Se crean instancias de dichas clases de objetos 39 función

40 JGL Function Objects Predicates Los predicados se utilizan para ejecutar acciones u ordenar elementos. Devuelven siempre un valor booleano. El algoritmo countif() permite contar elementos que cumplen una determinada condición booleana (expresada mediante un predicado unario). El algoritmo sort() ordena según un criterio de ordenación (expresado mediante un predicado binario) JGL define interfaces para predicados unarios y binarios La interfaz UnaryPredicate tiene un método llamado execute() que toma un único parámetro un objeto La interfaz BinaryPredicate define un método 40 execute() que toma como parámetros dos objetos

41 La interfaz UnaryPredicate public interface UnaryPredicate<T> 41

42 JGL Function Objects Ejemplo: Unary Predicate. Mayores que 5 public class Functions { public static void main( String[] args ) { int array[] = { 5, 6, 7, 4, 3 ; IntArray ints = new IntArray( array ); UnaryPredicate<Integer> predicate = new GreaterThan5<Integer>(); int n = Counting.countIf( ints, predicate ); System.out.println( Greater than 5 in " + ints + " = " + n ); public final class GreaterThan5<T> implements UnaryPredicate<T> { public boolean execute(t number) { return ( number.intvalue()>5); 42

43 JGL Function Objects Ejemplo: Binary Predicate. Sort public class Functions { public static void main( String[] args ) { Deque deque=new Deque(); //insert data deque.add( cat );... BinaryPredicate comparator=new GreaterString<String>(); Sorting.sort(deque, comparator); public class GreaterString<T> implements BinaryPredicate<T,T> { public boolean execute(t first, T second) { return (first.tostring()).compareto(second.tostring() )> 0; 43

44 JGL Function Objects Predicates La librería de JGL nos ofrece un conjunto de predicados YA predefinidos En la documentación de JGL aparece: Todos los predicados unarios predefinidos Todos los predicados binarios predefinidos Todas los algoritmos JGL que aceptan un predicado 44

45 JGL Function Objects General Functions Las funciones generales se utilizan para aplicar operaciones matemáticas a todos los elementos de una colección. El algoritmo transform() puede ser usado para obtener una nueva secuencia a partir de otra donde a todos los elementos se les cambia de signo. JGL define interfaces para funciones unarias y binarias La interfaz UnaryFunction tiene un método llamado execute() que toma un objeto como parámetro y devuelve un objeto La interfaz BinaryFunction tiene un método execute() que toma como dos objetos como parámetros y devuelve un objeto 45

46 public class Functions5 { public static void main( String[] args ) { Deque<Integer> deque = new Deque<Integer>(); deque.add( new Integer( 4 ) ); deque.add( new Integer( -2 ) ); deque.add( new Integer( 3 ) ); UnaryFunction<Integer,Integer> function = Output before = Deque( 4, -2, 3 ) after = Deque( -4, 2, -3 ) new NegateNumber<Integer>(); System.out.println( "before = " + deque ); Transforming.transform( deque, deque.begin(), function ); System.out.println( "after = " + deque ); public class NegateNumber<T> implements UnaryFunction<T,T> { public T execute (T number) { return -1 *number ; JGL Function Objects General Functions 46

47 import com.objectspace.jgl.*; Output import com.objectspace.jgl.adapters.*; import com.objectspace.jgl.algorithms.*; import com.objectspace.jgl.functions.*; public class Algorithms9 { public static void main( String[] args ) { int ints1[] = { 1, 3, 5, 2 ; Array<Integer> array = new Array<Integer>(); IntArray<Integer> intarray1 = new IntArray<Integer>( ints1 ); UnaryFunction<Integer,Integer> function = new NegateNumber<Integer>(); Transforming.transform( intarray1, array, function ); System.out.println( "ints1 = " + intarray1 ); System.out.println( "array = " + array ); System.out.println(); int ints2[] = { 2, 4, 2, 3 ; int ints3[] = { 3, 6, 2, 1 ; SList<Integer> list = new Slist<Integer>(); IntArray<Integer> intarray2 = new IntArray<Integer>( ints2 ); IntArray<Integer> intarray3 = new IntArray<Integer>( ints3 ); BinaryFunction<Integer,Integer> function2 = new TimesNumber<Integer>(); Transforming.transform( intarray2, intarray3, list, function2 ); System.out.println( "ints2 = " + intarray2 ); System.out.println( "ints3 = " + intarray3 ); System.out.println( "list = " + list ); ints1 = int[]( 1, 3, 5, 2 ) array = Array( -1, -3, -5, -2 ) ints2 = int[]( 2, 4, 2, 3 ) ints3 = int[]( 3, 6, 2, 1 ) list = SList( 6, 24, 4, 3 ) 47

48 public class Algorithms1 { public static void main( String[] args ) { Array<String> array1 = new Array<String>(); array1.add( "cat" ); array1.add( "monkey" ); array1.add( "goat" ); Applying.forEach( array1, new Print<String>() ); SList<Integer> list = new SList<Integer>(); list.add( new Integer( 3 ) ); list.add( new Integer( 7 ) ); list.add( new Integer( 4 ) ); Output cat monkey PRINT goat list = SList( 3, 7, 4 ), total = 14 Integer total = Applying.inject( list, new Integer( 0 ), new PlusNumber<Integer>() ); System.out.println( "list = " + list + ", total = " + total ); class Print<T> implements UnaryFunction<T,T> { public T execute( T object ) { System.out.println(object.toString() ); return null; // Not used. 48

49 JGL Function Objects General Functions La librería de JGL nos ofrece un conjunto de funciones YA predefinidos En la documentación de JGL aparece: Todas las funciones unarias predefinidas Todas las funciones binarias predefinidas Todos los algoritmos JGL que aceptan una función 49

50 JGL Function Objects Binders Los objetos predicado BindFirstPredicate y BindSecondPredicate permiten fijar el primer o segundo argumento de un predicado binario public class Functions5 { public static void main( String[] args ) { DList<String> list = new DList<Integer>(); list.add( rojo ); list.add( amarillo ); list.add( verde ); list.add( azul ); UnaryPredicate<String> predicate= new BindSecondPredicate(new GreaterString<String>(), ambar ) int n =Counting.countIf(list,predicate); 50

51 JGL Function Objects Composers Los objetos función UnaryComposePredicate y BinaryComposePredicate permiten aplicar una función secundaria a cada operando antes de aplicar el predicado principal. Se pueden crear funciones objeto propias implementando el interfaz apropiado: UnaryPredicate BinaryPredicate,UnaryFunction,BinaryFunction y definiendo el método execute() 51

52 JGL Function Objects Composers Ejemplo: Ordenar un Array de Strings, en base al número de caracteres public class Functions7 { public static void main( String[] args ) { Array<String> array=new Array<String>(); list.add( rojo ); list.add( amarillo ); list.add( verde ); BinaryPredicate<String,String> comparator= new BinaryComposePredicate( new GreaterNumber<Integer,Integer>(), new LegthString<String, Integer>(), new LegthString<String,Integer>() ); Sorting.sort(array, comparator); 52