Curso de java básico (scjp)

Properties, i/o, collection api

Objetivos generales Propiedades del Sistema La clase Properties Streams Consola I/O Entrada y Salida Archivos: File Colecciones Iteradores Maps

Propiedades del Sistema Las propiedades del sistema es una característica que reemplaza el concepto de variables de entorno (que son específicos de la plataforma) El método System.getProperties retorna el objeto Properties. El método getProperty retorna un String que representa el valor de la propiedad con dicho nombre Usar la opción -D para incluir una nueva propiedad Ejemplos: import java.util.*; public class TestProps { public static void main(String[] args) { Properties p = System.getProperties();//obtengo todas las properties p.setProperty("myProp", "myValue");//agrego una property p.list(System.out);//imprimo la property System.out.println(System.getProperty("java.vm.version"));//obtengo la property }} Salida: -- listing properties -- java.runtime.name=Java(TM) SE Runtime Environment sun.boot.library.path=C:\Program Files\Java\jre6\bin myProp=myValue El comando –D, es utilizado para setear properties del sistema. Se utiliza de la formaa: -Dproperty=value Ejemplo> javac hello.java java -Dhello=world hello

La clase Properties La clase Properties implementa un mapeo de nombre a valor. El método propertyNames retorna un Enumeration de todos los nombres de las propiedades. Se puede leer o escribir una colección de properties a un archivo utilizando load y store. Ejemplo: for (Enumeration en = p.propertyNames(); en.hasMoreElements();) {//obtengo los nombres de las properties. String key = (String) en.nextElement(); String location = p.getProperty(key); //obtengo la property System.out.println(key.toString()); System.out.println(location.toString()); }

Streams La mayoría de los programas trabajan con datos externos almacenados en archivos locales o provenientes de otras máquinas de la red Java trabaja con el concepto de streams de datos Abstraen el concepto de intercambio de información entre varios dispositivos y provee una interfaz consistente para interactuar con las diferentes fuentes de E/S. La idea básica de un stream es que los datos entran por un extremo en una secuencia en particular y salen por el otro extremo en la misma secuencia (FIFO)

Streams Luego de que los datos físicos se mapean a un stream, un programa Java puede leer los datos de ese stream de forma serial (de a byte, de a char, etc.) Algunos tipos de streams son los streams de bytes (InputStream, OutputStream) y de caracteres (Reader and Writer). El mismo archivo físico puede ser leído utilizando distintos tipos de streams, por ejemplo FileInputStream, or FileReader. Un stream es un flujo de datos desde una fuente a un destino. Este puede ser un archivo en el disco duro, en la nube; de cualquier tipo, ya sea un objeto, imágenes, un video, etc. En Java, se trabaja con streams para enviar o recibir información. No importa de donde venga o donde vaya la información y tampoco el tipo de los datos que están siendo leídos o escritos, los algoritmos para leer o escribir son casi siempre los mismos. La libreria java.io, contiene una colección de clases stream que permiten leer o escribir en dichos streams.

Streams Al trabajar con un stream, se debería: Abrir el stream que apunte a una fuente de datos específica: un archivo, un socket, URL, etc. Leer o escribir datos desde/a el stream Cerrar el stream Ejemplo: FileInputStream fis = null; // El buffer de lectura se debe hacer lo suficientemente grande // o esperar a saber el tamaño del fichero String s; try { fis = new FileInputStream( "c:\test.txt" ); fis.read(); fis.close(); } catch( FileNotFoundException e ) { System.out.println("El archivo no existe");} catch(IOException e) {System.out.println("Error de lectura");} En este ejemplo, abrimos el archivo test.tex, leemos el contenido y cerramos el stream.

Jerarquía Streams En esta imagen, vemos como está compuesto el paquete de java.io. Si bien todas las clases heredan de la clase Object, se define una jerarquía de clases de streams.

Consola I/O El System.out le permite escribir a la “salida estándar” Es un objeto de tipo PrintStream. El System.in le permite leer de la “entrada estándar” Es un objeto de tipo InputStream. El System.err le permite escribir a la “error estándar” Ejemplos: for (Enumeration en = p.propertyNames(); en.hasMoreElements();) { String key = (String) en.nextElement(); String location = p.getProperty(key); System.out.println(key.toString()); // salida estándar System.out.println(location.toString()); // salida estándar } StringBuffer str=new StringBuffer(); char c; try{ while ((c=(char)System.in.read())!='\n'){ str.append(c); System.out.println(str); System.err.println("error"); }catch(IOException ex){} Obtenemos: 123 error 123 //el mensaje error es mostrado en color rojo.

Ejemplo: lectura de entrada InputStreamReader isr = new InputStreamReader(System.in); BufferedReader br = new BufferedReader(isr); try { String linea = br.readLine(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } En este ejemplo, se abre un stream de lectura de tipo InputStreamReader, y el valor ingresado es asignado a la variable de tipo String línea. Este es un clásico ejemplo de lectura de datos por consola.

Ejemplo: escritura de salida El método println imprime el argumento y baja de línea(\n) El método print imprime el argumento sin la línea nueva (\n) Los métodos print y println son sobrecargados para los tipos primitivos (boolean, char, int, long,float, and double) y para char[], Object y String. Los métodos print(Object) y println(Object) llaman al método toString.

Archivos e I/O de Archivos Crear objetos File Manipular objetos File Leer y escribir de archivo Java.io, nos permite manipular archivos y objetos. Esta librería, nos permite crear objetos de tipo file, manipularlos: renombrarlos, moverlos, abrir un archivo, etc, asi como leerlo, y escribirlo.

Crear un objeto File try { File file = new File("filename"); // Crear el archivo si no existe boolean success = file.createNewFile(); if (success) { // El archivo no existía y fue creado } else { // El archivo ya existía } } catch (IOException e) { Los directorios son tratados como archivos en java File f = new File("myDir"); f.mkdir(); La clase File puede recuperar un array de archivos de un directorio

Clase File File names: String getName() String getPath() String getAbsolutePath() String getParent() boolean renameTo(File newName) File tests: boolean exists() boolean canWrite() boolean canRead() boolean isFile() boolean isDirectory() boolean isAbsolute(); File names: String getName() – obtiene el nombre del archivo String getPath() – obtiene la ubicación del archivo. Ej: test\..\.\file.txt String getAbsolutePath() – Ej: C:\projects\sandbox\trunk\test\..\.\file.txt String getParent() – Retorna el directorio padre del archivo boolean renameTo(File newName) – retorna true si el archivo puede ser renombrado. File tests: boolean exists() – retorna true si el archivo existe. boolean canWrite() – retorna true si el archivo puede ser escrito. boolean canRead() – retorna true si el archivo puede ser leído. boolean isFile() – retorna true si el archivo es un archivo valido. boolean isDirectory() – retorna true si el objeto File es un directorio. boolean isAbsolute() – retorna true si el path es absoluto.

File Stream I/O File input: Use la clase FileReader para leer caracteres Use la clase BufferedReader para utilizar el método readLine File output: Use la clase FileWriter para escribir caracteres Use la clase PrintWriter para utilizar los métodos print y println

File Stream I/O File input: FileReader fr = new FileReader("filename"); BufferedReader br = new BufferedReader(fr); String line = br.readLine(); fr.close(); File output: File file = new File("filename"); PrintStream print = new PrintStream(file); print.println("Hola Mundo"); print.close(); Para agregar contenido a un archivo existente se deberá utilizar la clase FileOutputStream. Esta clase cuenta con un constructor que recibe un boolean que especifica si se quiere agregar contenido. File file = new File("filename"); FileOutputStream fileStream = new FileOutputStream(file,true); PrintStream print = new PrintStream(fileStream);

Levantando un archivo de Properties Properties prop = new Properties(); InputStream is = null; try { is = new FileInputStream("d:\fichero.properties"); prop.load(is); } catch (IOException ioe) { } for (Enumeration e = prop.keys(); e.hasMoreElements() ; ) { // Obtenemos el objeto Object obj = e.nextElement(); System.out.println(obj + ": " + prop.getProperty(obj.toString())); En este ejemplo, se lee un archivo de properties, utilizando un input stream. Todas las properties contenidas en el archivo son cargadas en el objeto de tipo Properties: prop. Finalmente, se iteran las properties y se imprimen.

API De Collection Java provee un framework que permite trabajar con colecciones de objetos Una colección permite que varios objetos sean tratados como una unidad Los objetos pueden ser almacenados, recuperados y manipulados como elementos en una colección Este framework se encuentra en el paquete java.util Una colección — a veces llamada “contenedor” — es un objeto que agrupa múltiples elementos en una unidad simple. La librería java.util, nos proporciona interfaces y clases que nos permiten manejar dichos objetos de la misma forma.

API De Collection Hay ciertas operaciones básicas en las que vamos a usar colecciones: Agregar objetos a una colección Eliminar objetos de una colección Chequear si uno o un grupo de objetos pertenece a determinada colección Poder obtener objetos de una colección Recorrer una colección, obteniendo cada uno de los objetos almacenados

API De Collection Comprende las siguientes partes: Interfaces que permiten manipular colecciones independientemente de su implementación Un pequeño grupo de implementaciones Clases que proveen utilidades para operar sobre colecciones como ordenamiento, búsqueda, etc.

Principales Interfaces Collection Interfaz básica que define las operaciones normales que permiten mantener y manipular un grupo de objetos Set Extiende Collection para representar un conjunto de elementos únicos Sorted Set Extiende Set para agregar funcionalidades para mantener un conjunto de elementos de forma ordenada Collection Contenedor simple de objetos no ordenados. Los duplicados son permitidos. Set Colección desordenada de objetos. Los duplicados no son permitidos. SortedSet: Un set que está ordenado

Extiende Map para mantener los elementos en orden List Extiende Collection para mantener una secuencia de elementos que no tienen que ser únicos Map Interfaz básica que define operaciones para mantener mapeos entre claves y valores SortedMap Extiende Map para mantener los elementos en orden List Contenedor de elementos ordenados. Los duplicados son permitidos. Map Colección de pares: clave/valor. La clave es usada para indexar el elemento. Los duplicados no son permitidos. SortedMap esta ordenado por clave.

Principales Interfaces En este diagrama, vemos la jerarquia de las interfaces principales, donde Set, List y SortedList heredan de la interfaz Collection, mientras que SortedMap hereda de Map. En este caso, al implementar la interfaz SortedList, se deberán implementar los métodos definidos en las interfaces Set y Collection.

Principales Interfaces Como mencionamos anteriormente, la clase Collection define los metodos: add, remove, size, isEmpty, contains, iterator. Estos metodos son tambien implementados en las interfaces derivadas: List y Set.

Operaciones Básicas int size() boolean isEmpty() boolean contains(Object element) boolean add(Object element) boolean remove(Object element) int size() – retorna la cantidad de elementos de la lista. boolean isEmpty() - retorna true si la lista esta vacía. boolean contains(Object element) – retorna true si la lista contiene el objeto element. boolean add(Object element) – retorna true si se pudo agregar correctamente el elemento element. boolean remove(Object element) – retorna true si se pudo borrar de la lista correctamente el elemento element.

Operaciones sobre colecciones boolean containsAll(Collection c) boolean addAll(Collection c) boolean removeAll(Collection c) boolean retainAll(Collection c) void clear() boolean containsAll(Collection c) - retorna true si contiene toda la colección c. boolean addAll(Collection c) - retorna true si se puede agregar correctamente todos los elementos de la colección c. boolean removeAll(Collection c) ) - retorna true si se puede borrar correctamente todos los elementos de la colección c. boolean retainAll(Collection c) - Elimina todos los elementos de la colección excepto los que estén en c void clear() – se vacía la lista.

Iteradores Las colecciones proveen un iterador que permiten acceso secuencial a los elementos Se puede obtener un iterador invocando al siguiente método definido en la interfaz Collection: Iterator iterator() Retorna un objeto que implementa la interfaz Iterator Ejemplo: import java.util.*; class Dog { public String name; Dog(String n) { name = n; } } class ItTest { public static void main(String[] args) { List<Dog> d = new ArrayList<Dog>(); Dog dog = new Dog("aiko"); d.add(dog); d.add(new Dog("clover")); d.add(new Dog("magnolia")); Iterator<Dog> i3 = d.iterator(); // creamos un iterator para recorrer la lista while (i3.hasNext()) { Dog d2 = i3.next(); // cast not required System.out.println(d2.name);

Interfaz Iterator Métodos: boolean hasNext() Object next() Object remove() La interfaz Iterator, define los métodos hasNext, el cual retorna true si hay un próximo elemento para ser iterado; next, el cual retorna el próximo elemento y remove, el cual borra un elemento. ListIterator implementa la interfaz Iterator y define los metodos: hasPrevious, el cual retorna true si hay un objeto previo; previous análogo al método next, pero retorna el elemento anterior.

Uso del Iterador Un Iterator de un Set es desordenado Un ListIterator de un List puede recorrer la lista en ambos sentidos, utilizando next o previous: List list = new ArrayList(); // add some elements Iterator elements = list.iterator(); while ( elements.hasNext() ) { System.out.println(elements.next()); } En este ejemplo, vemos que se define una lista de tipo ArrayList, y se crea un Iterador, para recorrer los elementos de la lista, haciendo uso de un bucle. Se utiliza el método hasnext, para saber cuándo se llegó al último elemento de la estructura.

Implementaciones El paquete java.util provee implementaciones basadas en las interfaces principales Agrega clases abstractas que son las bases sobre las cuales se implementan las clases concretas

Implementación de Collection En este diagrama de clases, vemos las diferentes clases que forman parte de la API Collections. Cada clase, es identificada por su tipo: si es abstracta, una interfaz o una clase concreta. Como vemos, las interfaces pueden ser implementadas por cualquier clase, dado que estas proveen un conjunto de operaciones, las cuales deben ser definidas, por la clase que implementa dicha interfaz.

Sets No admiten duplicados Puede contener a lo sumo un valor null La interfaz Set no agrega operaciones HashSet implementa Set Utiliza una tabla de hash No garantiza orden de los elementos LinkedHashSet subclase de HashSet garantiza orden de inserción Ejemplo: Producto m = new Producto("Pan", 6); Producto n = new Producto("Leche", 2); // Definir un HashSet HashSet mandado = new HashSet(); mandado.add(m); // Doble inserción de Objeto/referencia q mandado.add(q); System.out.println(" - Lista de mandado con " + mandado.size() + " elementos"); // Definir Iterator para extraer/imprimir valores for( Iterator it = mandado.iterator(); it.hasNext();) { Producto x = (Producto)it.next(); System.out.println(x.nombre + " : " + x.cantidad); }

Lists Admiten duplicados y mantienen sus elementos en orden Cada elemento ocupa una posición en la lista cuya numeración comienza en cero Agrega operaciones para trabajar especificamente con listas Agregan un iterador particular para iterar sobre listas en ambas direcciones Se proveen 3 implementaciones de List: ArrayList, LinkedList y Vector Ejemplo: List myList = new ArrayList(); //creo una lista myList.add("Fred"); // agrego un elemento de tipo string myList.add(new Dog()); // agrego un elemento de tipo Dog myList.add(new Integer(42)); // agrego un elemento de tipo Integer En este caso, creamos una lista sin tipo, por lo que podemos agregar todo tipo de objetos: Dog, String, Integer, etc. List<Dog> myList = new ArrayList<Dog> (); //creo una lista de tipo Dog En este caso, solo puedo agregar objetos de tipo Dog.

Maps Definen mapeos clave valor Al par <clave, valor> se le llama entrada No admiten claves duplicadas Cada clave se mapea a un único valor Las claves y valores tienen que ser objetos, los tipos primitivos deben ser envueltos en sus clases wrapper El Map no es una colección (no extiende Collection)

Maps Operaciones básicas Implementaciones de Map: Object put(Object key) Object get(Object key) Object remove(Object key) boolean containsKey(Object key) boolean containsValue(Object value) int size() boolean isEmpty() Implementaciones de Map: HashMap, LinkedHashMap, HashTable Object put(Object key,Object value) - inserta la pareja clave, valor en el map. Object get(Object key) – se obtiene el objeto valor para la clave key Object remove(Object key) – se borra la pareja cuya clave es key boolean containsKey(Object key) – retorna true si el map contiene la clave key boolean containsValue(Object value) – retorna true si el map contiene el valor value. int size() – retorna la cantidad de claves que posee el Map boolean isEmpty() – retorna true si la estructura map esta vacia.

Sorted Sets y Sorted Maps Sets y Maps tienen interfaces especiales para implementaciones que ordenan sus elementos de acuerdo a un orden específico Los objetos pueden especificar su orden natural implementando la interfaz Comparable o de acuerdo a un orden total a través de un objeto comparador que implemente la interfaz Comparator Implementaciones: TreeSet y TreeMap

Comparator Comparator El control de la ordenación se puede lograr creando un objeto comparador que imponga el orden total de los elementos de una colección La interfaz tiene un único método: int compare(Object o1, Object o2) Ejemplo: import java.util.*; class GenreSort implements Comparator<DVDInfo> { public int compare(DVDInfo one, DVDInfo two) { return one.getGenre().compareTo(two.getGenre()); } En este ejemplo, vemos que la clase GenreSort implementa la interfaz Comparator para comparar objetos de tipo DVDInfo. Para ello, se define el metodo compare.

Comparable Comparable Una clase puede definir el orden natural de sus instancias implementando esta interfaz Muchas clases de la API de Java como los wrappers, String, Date, etc, implementan esta interfaz. Único método: int compareTo(Object o) Ejemplo: class DVDInfo implements Comparable<DVDInfo> { // #1 // existing code public int compareTo(DVDInfo d) { return title.compareTo(d.getTitle()); // #2 } En este caso, se debe definir el metodo compareTo, y la clase que queremos ordenar, debera implementar la interfaz Comparable.

Implementacion de Collection y Maps En esta tabla, vemos para cada clase de la API java.util, si es un Map, un Set, Link, si esta ordenada según algún criterio y si esta ordenada por un un índice o por su inserción en la lista.

Collection en JDK 1.1 Vector implements la interface List. Stack es una subclase de Vector y soporta los métodos push, pop y peek. Hashtable implements la interface Map. Enumeration es una variación de la interface Iterator: Un enumeration es retornado por el método elements de Vector, Stack y Hashtable Esas clases son thread-safe, y debido a eso, “pesadas.”

Resumen Propiedades del Sistema La clase Properties Streams Consola I/O Entrada y Salida Archivos: File Colecciones Iteradores Maps

Referencias Thinking in Java Bruce Eckel The Java Tutorial SCJP http://download.oracle.com/javase/tutorial/ SCJP Kathy Sierra – Cap. 7 – Generics and Collections