Clases de uso general en Java

Autor: Antonio J. Martn

NDICE

1. INTRODUCCIN.......................................................................................... 5 2. CLASES Y OBJETOS.................................................................................. 6 2.1. 2.2. 2.3. 2.4. DEFINICIN DE UNA CLASE JAVA .............................................................. 6 CREACIN DE OBJETOS ........................................................................... 8 MTODOS Y ATRIBUTOS ESTTICOS ......................................................... 9 CONSTRUCTORES ................................................................................. 11

2.4.1. Sobrecarga de constructores ......................................................... 13 2.4.2. Constructores por defecto .............................................................. 13 2.5. EMPAQUETADO E IMPORTACIN DE CLASES............................................ 14 EJERCICIO 1...................................................................................... 15 3. EL API JAVA SE........................................................................................ 17 3.1. 3.2. JAVADOC .............................................................................................. 17 CLASES PARA GESTIN DE CADENAS Y NMEROS. .................................. 18

3.2.1. Clase String.................................................................................... 18 3.2.1.1. Mtodos de la clase String....................................................... 19 EJERCICIO 2...................................................................................... 20 EJERCICIO 3...................................................................................... 20 3.2.2. La clase StringBuilder .................................................................... 22 3.2.2.1. Mtodos de la clase StringBuilder ........................................... 23 EJERCICIO 4...................................................................................... 23 3.2.3. La clase Math................................................................................. 24 3.2.3.1. Importaciones estticas ........................................................... 24 3.2.3.2. Principales mtodos de Math................................................... 25 EJERCICIO 5...................................................................................... 25 3.2.4. Clases de envoltorio....................................................................... 26 3.2.4.1. Creacin de un objeto de envoltorio ........................................ 26

3.2.4.2. Conversin de texto a nmero................................................. 27 3.3. CLASES DE ENTRADA/SALIDA ................................................................. 27

3.3.1. La clase PrintStream ...................................................................... 28 3.3.1.1. Obtencin de un objeto PrintStream........................................ 28 3.3.1.2. Envio de informacin a la salida .............................................. 28 3.3.1.3. Salida con formato ................................................................... 28 3.3.2. La clase Console............................................................................ 29 3.3.2.1. Obtencin de un objeto Console.............................................. 29 3.3.2.2. Mtodos de la clase Console................................................... 29 EJERCICIO 6...................................................................................... 30 3.3.3. La clase BufferedReader ............................................................... 30 3.3.3.1. Creacin de un objeto BufferedReader ................................... 30 3.3.3.2. Recuperacin de datos ............................................................ 31 EJERCICIO 7...................................................................................... 32 3.3.4. La clase Scanner ........................................................................... 32 3.3.4.1. Creacin de un objeto Scanner ............................................... 33 3.3.4.2. Mtodos de la clase Scanner................................................... 33 EJERCICIO 8...................................................................................... 33 3.4. CLASES DE COLECCIN ......................................................................... 34

3.4.1. Tipos de colecciones...................................................................... 34 3.4.2. Colecciones basadas en ndices.................................................... 34 3.4.2.1. Mtodos para la manipulacin de la coleccin ........................ 35 EJERCICIO 9...................................................................................... 36 3.4.3. Colecciones de tipo genrico ......................................................... 39 EJERCICIO 10.................................................................................... 40 3.4.4. Colecciones basadas en claves ..................................................... 42 3.4.4.1. Mtodos de la clase Hashtable................................................ 43 EJERCICIO 11.................................................................................... 45

3.4.5. Conjuntos ....................................................................................... 47 3.4.5.1. Mtodos de HashSet ............................................................... 47 3.4.6. Colas .............................................................................................. 48 3.4.6.1. Mtodos de PriorityQueue ....................................................... 48

1.

INTRODUCCIN

Adems de ser un potente lenguaje de programacin, la plataforma Java proporciona a los programadores un sinfn de clases que les ayudarn a resolver prcticamente cualquier problema que se le pueda plantear. Como ya indicamos en el tema anterior, todo este compendio de clases, conocido tambin como el API de Java, se encuentra organizado en tres grandes bloques: Java estndar (Java SE), Java Enterprise (Java EE) y Java micro (Java ME). A lo largo de este tema vamos a estudiar algunas de las clases de uso general del Java SE, clases que nos van a ayudar a resolver problemas habituales con los que nos vamos a encontrar en cualquier tipo de aplicacin. Antes de abordar este estudio, es necesario que aclaremos una serie de conceptos importantes sobre clases y objetos que, no slo nos facilitarn la comprensin de las clases del API Java, sino que nos permitirn tambin ir estructurando poco a poco nuestros programas de una forma ms adecuada. Posteriormente, en el tema 3, analizaremos en profundidad los conceptos de la programacin orientada a objetos y su aplicacin en el lenguaje Java.

2.

CLASES Y OBJETOS

Como ya sabemos por el tema anterior, todo programa Java se estructura en clases. Pero, qu es exactamente una clase? Desde un punto de vista conceptual, una clase define el comportamiento de un determinado tipo de elemento. Y se trata simplemente de eso, de un conjunto de especificaciones que determinan como se van a comportar cierto tipo de elementos. Estos elementos, creados a partir de las especificaciones de la clase, es lo que llamamos objetos. En el mundo real podemos encontrar numerosos ejemplos al respecto. Por ejemplo, cuando hablamos de un coche nos estamos refiriendo a un determinado tipo de elementos con una funcionalidad especfica, es decir, sirven para desplazarnos de un lugar a otro, se caracterizan por una serie de atributos como potencia, color, etc.; el concepto de coche sera pues una clase, caracterizada por una serie de atributos y funcionalidades. Pero en el momento que pensamos en un coche especfico existente con una determinada matrcula, entonces estaramos hablando ya de objeto. En resumen, la clase define el comportamiento y caractersticas de cierto tipo de elementos, mientras que los elementos fsicos, creados a partir de las especificaciones de la clase, seran los objetos. En programacin las clases contienen el cdigo que define el comportamiento de los tipos de objeto que representan. Este cdigo est dividido en dos partes: Atributos. Representan las caractersticas que tendrn los objetos de la clase, como el color, precio, potencia, etc.. Normalmente, los atributos son manejados a travs de variables internas de la clase. Mtodos. Se trata de funciones que implementan la funcionalidad de los objetos de la clase. En el caso de una hipottica clase coche, algunos de los mtodos que determinan el funcionamiento de los mismos seran acelerar o frenar.

2.1.

DEFINICIN DE UNA CLASE JAVA

En Java, como ya sabemos, las clases se implementan mediante la palabra reservada class, incluyendo en su interior un bloque de sentencias con los atributos y mtodos que la definen. La estructura tpica de una clase se indica en el siguiente listado: class Nombre_clase{ private tipo atributo1; private tipo atributo2; : public tipo metodo1(tipo parmetro,...){

} public tipo metodo2(tipo parmetro,...){

} : } Los atributos de una clase Java se definen a travs de variables de mbito privado, es decir, variables que nicamente pueden ser utilizadas desde el interior de la clase. Por su parte, los mtodos estarn implementados mediante funciones, las cuales podrn devolver o no un valor, en funcin de la naturaleza del mtodo, y podrn recibir parmetros. El formato de un mtodo o funcin Java es el que se indica a continuacin: tipo_devolucion nombre_metodo (tipo parametro1, tipo parametro2){ //cuerpo del mtodo } Donde tipo_devolucion es el tipo de dato del valor devuelto por el mtodo, debindose indicar la palabra void si el mtodo no va a devolver ningn resultado. Por su parte, nombre_metodo representa el nombre asignado al mtodo y que deber seguir las mismas reglas que los nombres de clases. Entre los parntesis que se indican a continuacin del nombre del mtodo se declaran los parmetros que sern recibidos durante la llamada al mtodo; en caso de no recibir ningn parmetro se indicarn los parntesis vacos. A fin de que, una vez creado el objeto de la clase, los mtodos del mismo puedan ser utilizados desde cualquier parte del cdigo, se debe utilizar el modificador de acceso public en la declaracin de los mismos. En la figura 1 tenemos una sencilla definicin de la clase Coche en versin Java.

Definicin de la clase

Atributos

class Coche{ private int potencia; private String color; public void acelerar(){ //cdigo del mtodo acelerar } public void frenar(){ //cdigo del mtodo frenar } }

Mtodos

Figura. 1.

Como vemos en el listado anterior, los atributos de una clase deben ser declarados siempre como private, a fin de que el acceso a los mismos solo pueda realizarse desde el interior de la clase (este concepto, conocido como encapsulacin, ser tratado en profundidad durante el tema siguiente). Si queremos proporcionar acceso a los atributos desde el exterior de la clase, habr que hacerlo a travs de mtodos pblicos que proporcionen un acceso controlado a los mismos. Por cada uno de los atributos habr que proporcionar una pareja de mtodos, conocidos como mtodos set/get, que nos permitan realizar las operaciones de escritura y lectura, respectivamente, sobre los atributos. Por ejemplo, para que se pudiera tener acceso al atributo potencia desde el exterior de la clase Coche habra que incluir en la misma la siguiente pareja de mtodos: public } public void setPotencia(int p){ if(p>0){ //asigna al atributo el valor recibido como parmetro potencia=p; } } Como se puede apreciar, el mtodo setPotencia() ofrece un acceso controlado al atributo, evitando que se pueda asignar un valor negativo al mismo. El ejemplo de la figura 1 nos muestra un caso de clase Java que representa un tipo de objeto del mundo real, aunque no todas las clases utilizadas en programacin son tan intuitivas como esta. Determinar a partir de las especificaciones de un programa las clases en las que ste se debe estructurar y los mtodos y atributos de cada una de ellas no es tarea fcil, dado que no existen reglas fijas que establezcan como debe hacerse esta divisin int getPotencia(){

return potencia;

2.2.

CREACIN DE OBJETOS

Una vez implementada la clase, ya est lista para poder ser utilizada por los programas. Con la inclusin de atributos y mtodos dentro de una clase conseguimos que toda esta funcionalidad, definida en un nico lugar, pueda reutilizarse tantas veces como sea necesario en cualquier parte del programa. La utilizacin de la funcionalidad de una clase requiere la creacin de un objeto o instancia de la misma. Este objeto ser referenciado a travs de una variable con la que podremos llamar a los mtodos definidos dentro de la clase. La creacin de un objeto a partir de la clase se realiza utilizando el operador new : Tipo variable = new Tipo(); En este contexto, Tipo representa el nombre de la clase a partir de la que queremos crear el objeto. Por ejemplo, para crear un objeto de la clase Coche sera: Coche c = new Coche();

La instruccin anterior creara un objeto de la clase Coche y almacenara una referencia al mismo en la variable c, con la que podramos llamar a los distintos mtodos definidos en la misma utilizando el operador punto (.) : c.setPotencia(130); c.acelerar(); Las instancias u objetos creados son almacenados en memoria. Este espacio de memoria incluye adems de los mtodos una copia de cada uno de los atributos de la clase para ese objeto. Es importante indicar que, a diferencia de lo que sucede con los tipos primitivos Java donde la asignacin de un valor en una variable implica almacenar en esta el dato en s, cuando se asigna un objeto a una variable lo que se almacena en esta no es el objeto sino una referencia al mismo (figura 2).

int varnum = 10;

varnum

10

Coche ob = new Coche();

Instancia de Coche

ob

Figura. 2.

Este hecho tiene implicaciones cuando se asigna una variable objeto a otra, por ejemplo, cuando se hace la llamada a un mtodo que recibe como parmetro un tipo objeto. En estos casos, la variable destino no recibira una copia del objeto sino de la referencia al mismo, lo que implica que tendramos dos variables apuntando al mismo objeto.

2.3.

MTODOS Y ATRIBUTOS ESTTICOS

Segn se acaba de explicar, se necesita crear un objeto de una clase para invocar a los mtodos de esta. Esto es as porque al hacer la llamada a los mtodos las instrucciones se ejecutan sobre este, por ejemplo, cuando invocamos al mtodo setPotencia() para asignar un valor de potencia al objeto, este dato se graba en la copia del atributo potencia reservada para ese objeto. Pero no todos los mtodos definidos en una clase dependen de los atributos de la clase; es posible definir ciertos mtodos cuyo funcionamiento no est vinculado a un objeto

particular de la clase, produciendo para todos ellos el mismo resultado. A este tipo de mtodos se les conoce como mtodos estticos y son definidos con la palabra static. En el siguiente listado tenemos un sencillo ejemplo de mtodo esttico: class Calculadora{ public static int suma(int a, int b){ return a+b; } } Como vemos, el mtodo suma no hace uso de ningn atributo de la clase para realizar su funcin, tan solo depende de los parmetros recibidos. La ventaja de los mtodos estticos es que no se necesita crear ningn objeto de la clase para poderlo llamar (con el consiguiente ahorro de memoria), basta con indicar el nombre de la clase delante del nombre del mtodo: Calculadora.suma(3, 6); Al ser independientes de los objetos, los mtodos estticos no pueden hacer uso de los atributos de la clase ni tampoco de otros mtodos no estticos de la misma ya que stos son especficos de cada objeto de la clase. Por ejemplo, el siguiente cdigo no compilara: class Calculadora{ private int x; public void imprime(){ //mtodo no esttico } public static int suma(int a, int b){ imprime(); //error no puede hacer uso de imprime return a+b+x; //error, no puede hacer uso de x } } De esta forma, si tuviramos la necesidad de compartir informacin entre dos mtodos estticos existentes en la misma clase deberamos recurrir a atributos estticos. Un atributo esttico (conocido tambin como variable de clase) es un atributo cuyo valor no est vinculado a un objeto particular de la clase, debindose declarar tambin con el modificador static: class Calculadora{ private static int x; public static void factor(int p) x=p; } public static int suma(int a, int b){ return a+b+x; }

} En muchas ocasiones, ciertos atributos estticos suelen estar adems declarados como public a fin de que se pueda tener acceso a los mismos desde el exterior de la clase: class Operaciones{ public static int op; : } Operaciones.op = 20; //acceso a un atributo esttico pblico. En el tema anterior ya vimos algunos ejemplo de atributos y mtodos pblicos estticos en clases de Java estndar. Uno de estos casos es el atributo out de la clase System, el cual contiene una referencia al stream de salida estndar (consola).

2.4.

CONSTRUCTORES

Normalmente, los objetos de una clase requieren que parte de sus atributos sean inicializados con una valor antes de poder llamar a los mtodos del mismo. Por ejemplo, supongamos que tenemos la siguiente versin de la clase Calculadora con un mtodo que nos permite calcular potencias de un nmero elevado a otro dado: public class Calculadora { private int exponente; public void setExponente(int exp){ exponente=exp; } public double potencia(int base){ double resultado=1; for(int i=1;i<=exponente;i++){ resultado*=base; } return resultado; } } Dado que el exponente est definido como un atributo de la clase, ser necesario establecer un valor en el mismo antes de llamar al mtodo potencia() encargado de realizar el clculo. Por ejemplo: Calculadora c=new Calculadora(); c.setExponente(5); System.out.println("3 elevado a 5 es "+c.potencia(3)); La incomodidad que supone llamar explcitamente a los mtodos de inicializacin de atributos puede ser eliminada gracias a la utilizacin de los constructores.

Un constructor es un bloque de instrucciones definidas en una clase que son ejecutadas cada vez que se crear un objeto de la misma. Las reglas que se deben de tener en cuenta a la hora de definir un constructor son las siguientes: Un constructor debe ser definido con un nombre que debe ser igual al nombre de la clase. Un constructor puede recibir parmetros. Un constructor no devuelve ningn resultado. Un constructor puede ser declarado con cualquier modificador de acceso, aunque solo si se define como public ser posible crear objetos de la clase desde el exterior de la misma.

As pues, el formato de un constructor tendr el aspecto indicado: public nombre_clase (tipo param1, tipo param2..){ //instrucciones } Dado que sus instrucciones se ejecutan en el momento de crear el objeto, los constructores son el lugar ideal para la inclusin de instrucciones de inicializacin de atributos. Por ejemplo, podramos aadir un constructor a la clase Calculadora anterior segn se indica en el siguiente listado: public class Calculadora { private int exponente; public Calculadora(int exp){ exponente=exp; } public void setExponente(int exp){ exponente=exp; } public double potencia(int base){ double resultado=1; for(int i=1;i<=exponente;i++){ resultado*=base; } return resultado; } } En la misma instruccin de creacin del objeto, se debe especificar entre parntesis el valor del argumento o argumentos de llamada al constructor: Calculadora c=new Calculadora(5); System.out.println("3 elevado a 5 es "+c.potencia(3));

2.4.1. Sobrecarga de constructores Gracias a una caracterstica de los lenguajes orientados a objetos, conocida como sobrecarga, y que ser estudiada en profundidad en el siguiente tema, es posible definir ms de un constructor dentro de una clase. Dado que todos los constructores tienen el mismo nombre, para que el compilador pueda detectar que constructor se emplea en cada momento ser requisito imprescindible que cada constructor se diferencie de los restantes en el tipo y/o nmero de parmetros. Por ejemplo, dentro de la clase Calculadora podran convivir los siguientes constructores: public Calculadora(){ exponente=1; } public Calculadora(int exp){ exponente=exp; } public Calculadora(int exp1, int exp2){ exponente=exp1+exp2; } Cada un proporciona una forma diferente de inicializar los atributos de la clase; es en el momento de crear el objeto cuando se decide que constructor utilizar en funcin de los parmetros utilizados: Calculadora c = new Calcualdora(); //utiliza el primer //constructor Calculadora c1 = new Calcualdora(3); //utiliza el segundo //constructor Calculadora c2 = new Calcualdora(4, 6); //utiliza el tercer //constructor 2.4.2. Constructores por defecto Toda clase definida en Java debe de tener al menos un constructor. En caso de que el programador no proporcione ninguno de manera explcita, el compilador crear el llamado constructor por defecto que no es ms que un constructor sin parmetros y sin cdigo: public Nombre_clase(){ } El objeto de incluir este constructor no es otro que permitir la creacin de objetos de la clase. Es importante tener en cuenta que este constructor solo es aadido por el compilador en caso de que la clase no cuente con ninguno definido de forma explcita, como ocurra por ejemplo en la primera versin que hicimos de la clase Calculadora. Sin embargo, en la siguiente versin que presentamos donde incluamos un constructor con un parmetro para la inicializacin del exponente, el constructor por defecto no se crea, por lo que una operacin como esta:

Calculadora c = new Calculadora(); provocara un error de compilacin al no disponer la clase de constructores sin parmetros.

2.5.

EMPAQUETADO E IMPORTACIN DE CLASES

Segn vimos en el tema 1, las clases Java se organizan en paquetes. Para incluir una clase dentro de un determinado paquete debemos utilizar la sentencia package durante la definicin de la clase: package nombre_paquete; class Nombre_clase{ : } Por otro lado, cuando desde el cdigo fuente de una clase se quiere hacer uso de otra clase que se encuentra en una paquete diferente, podemos seguir dos caminos: Utilizar el nombre cualificado de la clase. El nombre cualificado de una clase est formado por el nombre de sta precedido por los nombres de los paquetes y subpaquetes en donde se encuentra. Por ejemplo, si la clase Operaciones estuviera definida de la siguiente manera: package : } y quisiramos declarar una variable de tipo Operaciones en otra clase situada en un paquete diferente a sta, deberamos utilizar: nivel1.nivel2.Operaciones op; Importar la clase. En muchos casos la utilizacin de nombres cualificados para hacer referencia a una clase puede resultar muy incomodo. Como alternativa, se puede importar la clase al principio del archivo de cdigo fuente de la clase destino utilizando la sentencia import. De esta forma, para poder referirse a la clase ser suficiente con utilizar el nombre simple de la misma. Por ejemplo, si quisiramos declarar una variable de la clase Operaciones desde otra clase llamada Principal situada en otro paquete diferente, utilizando la importacin de clases, sera: import nivel1.nivel2.Operaciones; class Principal{ Operaciones op; //utilizacin de la clase sin nombre //cualificado : } Si queremos hacer uso de varias clases situadas en el mismo paquete se puede realizar la importacin del paquete completo: nivel1.nivel2;

public class Operaciones{

import nivel1.nivel2.*; De los ejemplos anteriores se desprende algo que es muy importante tener en cuenta cuando se va a trabajar con clases de distintos paquetes y es que, independientemente del camino seguido a la hora de utilizar una clase que se encuentra en un paquete diferente, dicha clase deber estar declarada como publica en el interior de su paquete. Este es el caso de la clase Operaciones que hemos declarado antes con el modificador public. Si no llevara dicho modificador, la clase no sera accesible fuera del paquete nivel2 en el que se ha declarado, es decir, solo podra ser utilizada por clases de su mismo paquete.

EJERCICIO 1
Como primer ejercicio del tema y para afianzar los conceptos sobre creacin de clases y objetos, vamos a desarrollar un programa que nos permita realizar clculos geomtricos (rea y permetro) sobre crculos. El programa recibir como argumento de la lnea de comandos el radio de un crculo y nos mostrar en pantalla el rea y permetro de la figura. Para ello, vamos a dividir el programa en dos clases; por un lado tendremos la clase Circulo que definir las operaciones sobre un crculo y por otro lado tendremos una clase a la que llamaremos Cliente que se encargar de recuperar el radio, crear el objeto Circulo y llamar a los mtodos del mismo, as como presentar los resultados en pantalla. El poder aislar las operaciones sobre el crculo en una clase independiente nos permite reutilizar esta clase en otros programas donde se requiera realizar este tipo de clculos, independientemente de cmo se obtenga el radio y donde se vayan a presentar los resultados. Por otro lado, la clase Circulo ser definida dentro de un paquete llamado figuras (figura 3) mientras que la clase Cliente estar en el paquete pruebas.

Figura. 3.

El cdigo de la clase Circulo se muestra en el siguiente listado: package figuras; public class Circulo { private int radio; public Circulo(){ radio=1; } public Circulo(int r){ radio=r; } public double area(){ return radio*radio*3.1416; } public double perimetro(){ return 2*3.1416*radio; } } Como vemos, se definen dos constructores en la clase: uno de ellos que inicializa el radio al valor 1 y el otro que permite especificar el valor del mismo durante la creacin de los objetos, independizando as la clase del mecanismo utilizado para la obtencin del radio. En cuanto a la clase Cliente, su cdigo ser el siguiente: package pruebas; import figuras.Circulo; public class Cliente { public static void main(String[] args) { int radio=Integer.parseInt(args[0]); Circulo c=new Circulo(radio); System.out.println("El rea vale: "+c.area()); System.out.println("El permetro vale: "+c.perimetro()); } } En este ejemplo se emplea el mtodo parseInt() de clase Integer para la conversin del radio obtenido desde la lnea de comandos en un valor numrico. Este mtodo ser presentado en el siguiente apartado dedicado al estudio de las clases del API Java.

3. EL API JAVA SE
La plataforma Java Estndar Edition incluye cientos de clases con las que el programador puede resolver problemas comunes de programacin, como el acceso a datos, la gestin de entrada/salida o la construccin de interfaces grficas. Entre esta clases se encuentran algunas cuyo conocimiento resulta imprescindible para resolver problemas bsicos de programacin que podemos encontrar en la mayora de aplicaciones. Dedicaremos lo que resta de tema al estudio de estas clases, para ello estableceremos la siguiente divisin en grupos: Gestin de cadenas y nmeros. Entrada / salida Colecciones

3.1.

JAVADOC

Antes de entrar a analizar las distintas clases que componen los grupos indicados, vamos a presentar uno de los instrumentos ms importantes con que cuenta un programador para obtener informacin sobre las clases que tiene que utilizar: los javadoc. Javadoc son los documentos donde se muestra la ayuda de las clases de Java. En el sitio Web de Sun Microsystem podemos encontrar los documentos javadoc de las clases oficiales de Java (estndar, enterprise y microedition), informacin sta que resulta imprescindible para el da a da de un programador. Concretamente, en la direccin http://java.sun.com/javase/6/docs/api/ encontramos los javadoc de las clases que forman parte del Java estndar. El aspecto de las pginas de ayuda del javadoc se muestra en la figura 4.

paquetes

miembros de la clase

clases
Figura. 4.

La pgina de ayuda est dividida en tres zonas: Paquetes. Representa la zona superior izquierda de la pgina. En ella se muestra la lista de todos los paquetes definidos, en el caso de Java SE, se trata de todos los paquetes de clases incluidos en esta edicin. Clases. Al seleccionar un paquete de la lista anterior, en esta zona se muestran todas las clases incluidas dentro de dicho paquete. Miembros de la clase. Se trata del rea principal de la ayuda. En esta zona se muestra, adems de una breve explicacin de la clase seleccionada en el rea de clases, la lista de todos los miembros incluidos en la misma agrupados por categoras (atributos pblicos -campos-, constructores y mtodos). Si se selecciona un miembro en concreto, se mostrar en esta misma zona una breve explicacin sobre el mismo.

3.2.

CLASES PARA GESTIN DE CADENAS Y NMEROS.

Ahora s, pasaremos a analizar las distintas clases del Java SE; empezaremos con las clases para el tratamiento de cadenas y nmeros en un programa. Se trata de clases bsicas, pero muy tiles, con las que podemos realizar manipulaciones de cadenas de caracteres, operaciones numricas y conversiones entre texto y nmeros. Todas estas clases se encuentra en el paquete java.lang del Java SE, paquete que es importado automticamente por el compilador de Java, por lo que no ser necesario incluir las sentencias import para poder hacer uso de estas clases en un programa. A continuacin vamos a presentar algunas de las clases ms importantes de este paquete y a analizar sus principales mtodos y aplicaciones.

3.2.1. Clase String En Java no existe ningn tipo primitivo que represente una cadena de caracteres, estas son tratadas como objetos de la clase String. Sin embargo, dado que se trata de un objeto de uso muy comn en las aplicaciones, la creacin y almacenamiento de cadenas en variables se realiza como si fuera un tipo normal de Java: String s = Ejemplo de cadena; Aunque tambin se puede utilizar la forma estndar de creacin de objetos a partir de una clase: String s = new String(Ejemplo de cadena); En cualquier caso, hay que tener en cuenta que una cadena de caracteres es un objeto, por lo que la variable no contiene la cadena de caracteres sino una referencia a la misma. Una operacin comn con cadenas de caracteres es la concatenacin de textos, operacin que puede realizarse con el operador +: String s1 = esto es una cadena; s1+ = esto es otra cadena; System.out.println(s1);

Lo anterior mostrara en pantalla: esto es una cadena esto es otra cadena Sin embargo, a la hora de realizar operaciones de concatenacin hay que tener en cuenta una caracterstica de los objetos String y es que se trata de objetos inmutables, es decir, que no se pueden modificar. Esto significa que en el ejemplo anterior, la cadena apuntada por s1 no ha sido modificada al realizar la concatenacin, sino que se ha creado una nueva cadena resultante de la unin entre las dos (figura 5).

esto es una cadena

esto es otra cadena

Antes de la concatenacin

s1

esto es una cadena

esto es otra cadena

Despus de la concatenacin

s1
esto es una cadena esto es otra cadena

Figura. 5. Lo anterior debe ser tenido en cuenta a la hora de realizar un tarea repetitiva que implique la concatenacin de cadenas de caracteres; esta operacin puede resultar costosa en trminos de eficiencia puesto que se podran generar un elevado nmero de objetos en memoria.

3.2.1.1. Mtodos de la clase String Seguidamente vamos a comentar algunos de los mtodos ms importantes de la clase String, ilustrando con algunos ejemplos y prcticas la utilidad de los mismos: length(). Este mtodo devuelve el nmero de caracteres que forman la cadena sobre la que se aplica: String s = dos palabras; System.out.println(s.length()); //muestra el valor 12

EJERCICIO 2
En este ejercicio vamos a crear un programa que de todas las cadenas de caracteres suministradas desde la lnea de comandos al iniciar la ejecucin del programa (recordemos que cada cadena se separa de la siguiente por un espacio), nos muestre la cadena de mayor longitud. He aqu el cdigo fuente del ejercicio: public class MuestraCadenas { public static void main(String[] args) { String resultado=""; //almacenar la cadena ms larga int mayor=0; //lleva la cuenta de la longitud mayor //encontrada hasta el momento for(String s:args){ if(s.length()>mayor){ mayor=s.length(); resultado=s; } } System.out.println("La cadena ms larga es "+resultado); } } charAt(int pos). Este mtodo recibe como parmetro un nmero entero y nos devuelve el carcter que ocupa la posicin indicada por dicho nmero, teniendo en cuenta que el primer carcter de la cadena se encuentra en la posicin. El dato devuelto por el mtodo es de tipo char.

EJERCICIO 3
El siguiente ejercicio consiste en realiza un programa que nos muestre el nmero de vocales existentes en una cadena de caracteres dada. En este ejercicio utilizaremos los dos mtodos de la clase String vistos anteriormente para extraer cada uno de los caracteres de la cadena, realizndose la comparacin a travs de una estructura tipo switch: public class CuentaVocales { public static void main(String[] args) { String cad = "cadena de caracteres de ejemplo"; int contador=0; for(int i=0;i<cad.length();i++){ switch(cad.charAt(i)){ case 'a':

case 'e': case 'i': case 'o': case 'u': contador++; } } System.out.println("El nmero de vocales es "+contador); } }

equals(Object cad). Compara la cadena con otra que se le pasa como parmetro, devolviendo true si ambas son iguales. En la comparacin se hace distincin entre maysculas y minsculas. Hay que tener en cuenta que las cadenas de caracteres son objetos y no tipos primitivos, por lo que habr que utilizar este mtodo, y no el operador de igualdad (==), cuando queramos comprobar si dos cadenas son iguales.

equalsIgnoreCase(Object cad). Realiza la misma funcin que el mtodo anterior, solo que en este caso no se hace distincin entre maysculas y minsculas. indexOf(String cad). Nos devuelve la posicin que ocupa dentro de la cadena el texto suministrado como parmetro. En caso de que dicho texto no se encuentre en el interior de la cadena el mtodo devolver -1. El siguiente cdigo de ejemplo mostrara el valor 4 en la pantalla: String p = cadena principal; System.out.println(p.indexOf(na));

indexOf(string cad, int inicio). Se trata de una variante de la anterior, donde el segundo parmetro representa la posicin a partir de la cual comienza la bsqueda. lastIndexOf(String cad). Realiza la misma funcin que indexOf(), solo que en este caso la bsqueda del texto comienza desde el final de la cadena hacia el principio. lastIndexOf(String cad, int pos). Igual que el anterior, indicando mediante el segundo parmetro la posicin de comienzo de la bsqueda. substring(int pos1, int pos2). Devuelve un trozo de la cadena comprendido entre las posiciones indicadas en pos1 y pos2. El ultimo carcter devuelto ser el que ocupe la posicin pos2-1. El siguiente ejemplo muestra en pantalla el texto caracteres: String cad = "cadena de caracteres de ejemplo"; System.out.println(cad.substring(10,20));

split(String separador). Este mtodo devuelve un array formado por las subcadenas que componen la cadena. Como parmetro se debe indicar el separador de subcadena. El siguiente bloque de cdigo nos muestra un listado con todas las palabras contenidas en una determinada cadena de caracteres: String cad = "cadena de caracteres de ejemplo"; String [] palabras=cad.split(" "); for(String s:palabras){ System.out.println(s); }

replace(char anterior, char nuevo). Este mtodo devuelve una cadena resultante de reemplazar en la cadena original todas las ocurrencias del carcter indicado en el primer parmetro por el segundo. El siguiente cdigo de ejemplo nos mostrar en pantalla el texto: cadina di caractiris di ijimplo: String cad = "cadena de caracteres de ejemplo"; System.out.println(cad.replace('e', 'i')); Es importante resaltar que el mtodo replace() no realiza ningn tipo de operacin sobre la cadena original (como ya indicamos, los objetos String son inmutables), sino que devuelve una segunda cadena de caracteres resultante de realizar la operacin de sustitucin.

valueOf(tipo dato_primitivo). Se trata de un conjunto de mtodos estticos cuya funcin es la conversin de un tipo primitivo en un String. Existe una versin del mtodo valueOf() para cada uno de los tipos primitivos Java a excepcin de byte y short. El siguiente ejemplo nos indicara el nmero de cifras existentes en un determinado nmero entero, para ello, aplica el mtodo length() explicado anteriormente sobre el texto resultante de convertir el nmero a cadena a travs de valueOf(): int num = 3473; System.out.println(String.valueOf(num).length()); //muestra el valor 4

trim(). Este mtodo elimina los espacios en blanco que pudiera haber a la izquierda y derecha de la cadena, devolviendo la cadena sin dichos espacios.

3.2.2. La clase StringBuilder Hay determinadas operaciones de manipulacin de cadenas de caracteres que requieren la manipulacin de la propia cadena en vez de generar nuevos objetos. En estos casos se debe trabajar con cadenas que puedan ser modificables, como es el caso de StringBuilder. A diferencia de String, que permite crear un objeto asignando directamente la cadena a la variable, StringBuilder requiere la utilizacin del operador new: StringBuilder stb = new StringBuilder(Cadena modificable);

3.2.2.1. Mtodos de la clase StringBuilder Los principales mtodos de esta clase son: append(String s). Aade al final de la cadena el texto suministrado como parmetro. Adems de este mtodo, existe una versin del mismo para cada tipo primitivo Java que permite aadir un dato cualquiera a la cadena. El siguiente ejemplo aade a una frase el contenido de una determinada variable numrica: StringBuilder texto = new StringBuilder(El contenido del nmero es ); int num = 120; texto.append(num); toString(). Se trata de un mtodo que tienen todos los tipos de objetos Java, pero que en StringBuilder cobra especial importancia puesto que nos permite recuperar el texto como un objeto String para, entre otras cosas, poder enviar este al Stream de salida. La siguiente instruccin nos muestra en pantalla el texto anterior: System.out.println(texto.toString()); delete(int pos1, int pos2). Elimina el trozo de cadena comprendida entre las posiciones pos1 (incluida) y pos2 (no incluida). insert(int pos, String texto). Inserta en la cadena, en la posicin indicada en pos, el texto suministrado como segundo parmetro. replace(int pos1, int pos2, String nueva_cadena). Reemplaza los caracteres comprendidos entre las posiciones pos1 (incluida) y pos2 (no incluida) por la cadena que se suministra como tercer parmetro. length(). Al igual que en String, devuelve el nmero de caracteres contenidos en la cadena. indexOf(String texto). Como en el caso de String, devuelve la posicin del texto dentro de la cadena. indexOf(String texto, int pos). Igual que el anterior pero comenzando la bsqueda a partir de la posicin indicada en pos.

EJERCICIO 4
Vamos a realizar un ejercicio en el que, dada una determinada cadena de caracteres, se inserte un espacio en blanco adicional entre palabras. Mediante el mtodo indexOf() se irn buscando las posiciones donde se encuentran los espacios para insertar el espacio adicional, operacin esta que ser realizada a travs del mtodo insert(). A continuacin se muestra el cdigo del ejercicio: public class InsercionTexto { public static void main(String[] args) { StringBuilder texto = new StringBuilder("Texto donde se

insertarn espacios"); int inicio=0; int posinsercion; while(inicio<texto.length()){ //posicin donde se debe insertar el //espacio adicional posinsercion=texto.indexOf(" ", inicio); if(posinsercion!=-1){ texto.insert(posinsercion," " ); //busca nuevas posiciones de insercin //a partir de la actual inicio=posinsercion+1; } else{ break; } } System.out.println(texto.toString()); } } 3.2.3. La clase Math La clase Math dispone de una amplia variedad de mtodos estticos (nunca necesitaremos crear objetos Math) que nos permiten realizar operaciones matemticas diversas.

3.2.3.1. Importaciones estticas Dado que todos los mtodos de que dispone Math son estticos, el uso de los mismos desde cualquier clase Java se realizar utilizando la expresin: Math.nombre_metodo(); Pero para evitar el uso de la coletilla Math. a la hora de invocar a los mtodos, es posible hacer uso de las llamadas importaciones estticas. Las importaciones estticas permiten hacer uso de los miembros estticos de una clase sin necesidad de indicar explcitamente el nombre de la clase. Para realizar una importacin esttica debemos utilizar la siguiente expresin en la cabecera del cdigo fuente del programa: import static paquete.clase.*; Por ejemplo, para importar los miembros estticos de la clase Math utilizaremos la expresin: import static java.lang.Math.*;

Las importaciones estticas son independientes de las importaciones estndares de clases, es decir, importar una clase no implica que se importen los miembros estticos y viceversa.

3.2.3.2. Principales mtodos de Math Ahora s, los principales mtodos de la clase Math son: abs (double n). Devuelve el valor absoluto (sin signo) del nmero decimal que se le proporciona como parmetro. ceil (double n). Devuelve el entero mayor ms cercano al nmero suministrado: System.out.println(Math.ceil(3.2)); //muestra el nmero 4 Si en el ejemplo anterior se hubiera utilizado la importacin esttica de la clase Math quedara: System.out.println(ceil(3.2)); //muestra el nmero 4 floor (double d). Devuelve el entero menor ms cercano al nmero suministrado. round(double d). Devuelve el entero ms cercano a nmero suministrado. max (int a, int b). Devuelve el mayor de los dos nmero suministrados. Existe otras tres versiones de este mtodo para parmetros de tipo long, float y double, respectivamente. min (int a, int b). Devuelve el menor de los dos nmero suministrados. Existe otras tres versiones de este mtodo para parmetros de tipo long, float y double, respectivamente. random(). Devuelve un nmero aleatorio comprendido entre 0 (incluido) y 1 (no incluido).

EJERCICIO 5
En este ejercicio vamos a realizar un programa que nos muestre la suma de todos los nmeros enteros comprendidos entre dos nmeros aleatorios generados por el propio programa. Los nmeros aleatorios sern mayores de 0 y menores de 100. import static java.lang.Math.*; public class MuestraSuma { public static void main(String[] args) { int n1=(int)floor(random()*100); int n2=(int)floor(random()*100); int suma=0; for(int i=min(n1,n2);i<max(n1,n2);i++){ suma+=i; }

System.out.println("La suma de los nmeros vale "+suma); } } 3.2.4. Clases de envoltorio Por clases de envoltorio nos referimos a un conjunto de clases que representan a los tipos primitivos del lenguaje Java. Estas clases las utilizaremos en aquellos contextos en que necesitemos envolver un tipo primitivo dentro de un objeto, como por ejemplo, cuando tenemos que almacenar datos numricos en una coleccin. En la tabla de la figura 6 se muestra para cada tipo primitivo su clase de envoltorio equivalente.

Tipo primitivo
byte short int long char float double boolean

Clase de envoltorio
Byte S hort Integer Long Character Float Double Boolean
Figura. 6.

3.2.4.1. Creacin de un objeto de envoltorio Todas las clases de envoltorio disponen de un constructor que permite crear un objeto de la misma a partir del tipo primitivo envuelto por el objeto. Por ejemplo, la siguiente instruccin creara un objeto Integer que envuelve al nmero 100: Integer in = new Integer(100); Una vez creado el objeto Integer, podra utilizarse la variable in en aquellos contextos en los que se requiera tratar al nmero como un objeto, por ejemplo, para ser almacenado en una coleccin (ms adelante veremos con detalle este tipo de clases). Si queremos recuperar el dato primitivo envuelto por el objeto debemos recurrir al mtodo xxxValue() proporcionado por la clase de envoltorio correspondiente, donde xxx representa el tipo de dato que se quiere recuperar. Por ejemplo, para obtener el nmero envuelto por la variable in utilizaramos la expresin: int n = in.intValue(); A partir de la versin 1.5 del lenguaje se ha incorporado una caracterstica, conocida como autoboxing, que permite crear implcitamente el objeto de envoltorio asignando directamente el tipo primitivo a la variable objeto: Integer k = 200; //autoboxing De la misma forma, el autounboxing nos permite recuperar el valor primitivo a partir del objeto utilizando simplemente el operador de igualdad:

int t = k; //autounboxing A travs de la caracterstica de autoboxing/autounboxing es posible trabajar indistintamente con tipos primitivos y objetos en un programa Java. Por ejemplo, la siguiente instruccin es perfectamente vlida: Integer num =20; num++; En la primera de las instrucciones se realiza un autoboxing que crea un objeto Integer a partir del nmero 20, mientras que en la segunda instruccin tiene lugar primero un autounboxing que recupera el nmero envuelto por el objeto para, una vez realizado el incremento, volver a realizar un autoboxing que construye un nuevo objeto con el resultado de la operacin.

3.2.4.2. Conversin de texto a nmero Una de las principales utilidades de las clases de envoltorio es la conversin de cadenas de caracteres numricas a nmero; esto es as porque, como veremos ms adelante, los datos obtenidos desde el un dispositivo de entrada (fichero, teclado, peticin http, etc.) son recuperados en forma de texto. Para realizar estas conversiones, las clases de tipo numrico disponen de un mtodo esttico con el siguiente formato: static xxx parseXxx(String texto_numerico) donde xxx representa el nombre del tipo primitivo al que ser convertida la cadena. Por ejemplo, en el caso de la clase Integer el mtodo de conversin ser parseInt() y devolver el resultado de la conversin como un tipo int. El siguiente cdigo de ejemplo realiza una conversin a entero de un texto almacenado en una variable String para poder realizar una operacin matemtica con el mismo: String num = 30; int n = Integer.parseInt(num); n++; En caso de que se intente convertir a nmero un texto en el que alguno de sus caracteres sea no numrico, se producir una excepcin de tipo NumberFormatException.

3.3.

CLASES DE ENTRADA/SALIDA

Una de las operaciones habituales en todo programa informtico es el intercambio de datos con el exterior, concretamente, la recuperacin de datos desde un dispositivo externo (entrada) como el teclado o una conexin a Internet, o el envo de los mismos (salida) a un dispositivo de visualizacin o de procesamiento externo. La mayor parte de las clases Java para la realizacin de operaciones de entrada salida se encuentran en el paquete java.io. Primeramente analizaremos las clases para salida de datos, siguiendo a continuacin con las de entrada.

3.3.1. La clase PrintStream Esta clase permite enviar informacin en modo texto a cualquier dispositivo de salida. Esta clase trabaja contra los llamados stream o flujos de salida, de modo que la informacin es enviada de manera uniforme al stream, independientemente del tipo de dispositivo de que se trate, es decir, se podrn utilizar los mtodos de PrintStream para enviar informacin a cualquier dispositivo de salida siempre que se cuente con el stream de salida asociado al dispositivo.

3.3.1.1. Obtencin de un objeto PrintStream La clase PrintStream dispone de varios constructores para poder crear el objeto PrintStream, dependiendo del dispositivo al que se va a enviar la informacin. Entre estos constructores destacamos: PrintStream (OutputStream stream). Crea el objeto PrintStream a partir del stream asociado al dispositivo de salida. PrintStream (String nombre_fichero). Cuando la salida es un fichero, mediante este constructor se puede crear el objeto PrintStream a partir de la ruta de dicho fichero.

Pero si queremos obtener un objeto PrintStream asociado a la salida estndar (en aplicaciones de consola Java ser la consola), en el atributo esttico out de la clase System encontraremos una referencia al mismo, tal y como hemos podido comprobar en los ejemplos y ejercicios realizados hasta el momento.

3.3.1.2. Envo de informacin a la salida Una vez que se dispone del objeto PrintStream, a travs de los mtodos print() y println() podemos enviar informacin al dispositivo de salida en cuestin, tanto en formato texto como en cualquiera de los tipos primitivos del lenguaje. Aunque en temas posteriores se estudiar el tratamiento de ficheros en Java, el siguiente bloque de cdigo que se presenta como ejemplo de uso de PrintStream permite escribir una cadena de caracteres en un fichero desde un programa Java: PrintStream ps = new PrintStream (c:\\datos.txt); ps.println (Esto es una cadena); Una vez finalizadas las operaciones de escritura de datos se debera proceder al cierre del stream y la consiguiente liberacin de recursos llamado al mtodo close() del objeto PrintStream: ps.close();

3.3.1.3. Salida con formato Adems de los mtodos print() y println() para envo de datos a la salida, PrintStream dispone del siguiente mtodo para el envo de datos formateados a la salida: printf (String formato, Object ... datos). Enva a la salida la lista de datos indicada en el segundo parmetro, formateados segn la cadena indicada en el primer parmetro.

La expresin Object ...datos nos indica que se trata de un nmero variable de argumentos los que se pueden enviar a la salida, en este caso puede tratarse de cualquier nmero de objetos Java. En cuanto a la cadena de formato, puede estar formada por un texto fijo, que ser mostrado tal cual, ms una serie de especificadores de formato que determinan la forma en que sern formateados los datos. Por ejemplo, dado el siguiente bloque de instrucciones: int radio=5; double perimetro=2*Math.PI*radio; System.out.printf("El permetro del circulo de radio %1$d es %2$.2f",radio, perimetro); Tras la ejecucin del mismo se mostrara en pantalla lo siguiente: El permetro del circulo de radio 5 es 31,42 Para obtener ms informacin sobre la sintaxis de la cadena de formato y los caracteres utilizados en su configuracin, se puede consultar la ayuda de la clase Formatter (es la que define la estructura de los caracteres de formato) dentro del paquete java.util, concretamente la direccin del javadoc: http://java.sun.com/javase/6/docs/api/.

3.3.2. La clase Console Desde la versin JDK 1.6 tenemos una nueva clase para gestionar la interaccin con el usuario a travs de la consola, se trata de la clase Console, localizada en el paquete java.io. La utilizacin de esta clase para la lectura y presentacin de datos en consola resulta mucho ms simple que el empleo de las clases Scanner y BufferedReader estudiadas anteriormente.

3.3.2.1. Obtencin de un objeto Console Mediante los mtodos proporcionados por la clase Console se realizarn las operaciones de lectura y escritura en consola, para ello ser necesario primeramente obtener el objeto Console asociado a la Mquina Virtual en ejecucin. Este se obtiene a travs del mtodo esttico console() de la clase System: Console consola = System.console(); Este mtodo slo devolver el objeto consola si la mquina virtual se ha lanzado desde sta, es decir, si lo ejecutamos desde un IDE, como por ejemplo Netbeans, no tendremos ninguna consola asociada, por lo que el mtodo anterior devolver null.

3.3.2.2. Mtodos de la clase Console Una vez obtenido el objeto Console, podemos utilizar los siguientes mtodos de la clase para la realizacin de operaciones de entrada salida de datos: printf (String formato, Object ... datos). Su funcionamiento es exactamente el mismo que el de la clase PrintStream.

readLine(). Este mtodo permite recuperar los datos introducidos por teclado como un objeto String. Es, por tanto, un mtodo utilizado para operaciones de entrada de datos.

EJERCICIO 6
En este ejercicio crearemos un sencillo programa que solicite al usuario la introduccin de dos nmeros y muestre en la consola un mensaje indicando cual es el mayor y cual el menor de los nmeros suministrados. La interaccin con el usuario se realizar a travs de un objeto Console, cuyo mtodo readLine() ser utilizado para la recuperacin de los nmeros. Dado que dichos valores sern obtenidos como texto, se utilizar el mtodo parseInt() de la clase de envoltorio Integer para su conversin a nmero. Es importante indicar que este ejercicio debe ser ejecutado desde la consola de comandos y no desde un entorno de desarrollo. El cdigo es el siguiente: import java.io.*; import static java.lang.Math.*; public class MuestraNumeros { public static void main(String[] args) { Console consola=System.console(); consola.printf("Introduce un nmero"); int n1=Integer.parseInt(consola.readLine()); consola.printf("Introduce otro nmero"); int n2=Integer.parseInt(consola.readLine()); consola.printf("El mayor de los nmeros es %1d y el menor es %2d",max(n1,n2), min(n1,n2)); } } 3.3.3. La clase BufferedReader Como acabamos de ver, la clase Console dispone de un mtodo llamado readLine() que nos permite obtener la ltima lnea de caracteres introducida por el usuario a travs del teclado. Sin embargo, si lo que queremos es poder leer datos de cualquier stream de entrada la clase ms apropiada para realizar esta labor es BufferedReader. Un objeto BufferedReader utiliza un buffer para los caracteres de entrada, proporcionando as una mayor eficiencia en la lectura de los mismos. Esto significa, por ejemplo, que los datos introducidos por el usuario a travs del teclado sern almacenados en un buffer y sern recuperados por el programa cuando se produzca la pulsacin de la tecla enter.

3.3.3.1. Creacin de un objeto BufferedReader Para crear un objeto BufferedReader necesitamos disponer previamente de dos objetos intermediarios:

InputStream. Representa el stream asociado al dispositivo de entrada. En el caso de que los datos se introduzcan por teclado, el objeto InputStream asociado al mismo lo obtenemos a partir del atributo pblico in de la clase System: System.in. InputStreamReader. Un InputStreamReader representa un objeto puente que permite transformar los bytes recuperados por InputStream en caracteres, algo necesario antes de poder construir el BufferedReader. Un objeto InputStreamReader se construye pues a partir del InputStream correspondiente.

As pues, para crear un objeto BufferedReader debemos seguir los siguientes pasos: Obtener el objeto InputStream Crear, a partir del anterior, un objeto InputStreamReader Crear el objeto BufferedReader utilizando en su constructor el objeto InputStreamReader creado en el paso anterior.

El siguiente bloque de instrucciones representa un ejemplo de creacin de un objeto BufferedReader para recuperacin de datos introducidos por teclado: InputStream in = System.in; InputStreamReader isr = new InputStreamReader(in); BufferedReader br = new BufferedReader(isr); 3.3.3.2. Recuperacin de datos Los datos de entrada se recuperan a travs del mtodo readLine() de la clase BufferedReader, el cual devuelve la ltima lnea de caracteres existente en el buffer de entrada. Como ya sucediera cuando utilizbamos la clase Console, ser necesario convertir el dato String de entrada al tipo especfico. Por otro lado, segn podemos comprobar en el documento de ayuda sobre este mtodo (figura 7), la llamada a readLine() puede lanzar una excepcin de tipo IOException que habr que capturar. Ms adelante analizaremos el tema de las excepciones, de momento bastar con declarar la excepcin (throws IOException) en la cabecera del mtodo main() donde ser utilizado readLine().

declaracin de excepcin

Figura. 7.

EJERCICIO 7
En este ejercicio realizaremos el mismo programa desarrollado en el ejercicio 6, utilizando en este caso la clase BufferedReader para la recuperacin de los datos. El cdigo del programa se muestra en el siguiente listado: import java.io.*; import static java.lang.Math.*; public class MuestraNumeros { public static void main(String[] args) throws IOException{ BufferedReader br=new BufferedReader(new InputStreamReader(System.in)); System.out.println("Introduce un nmero"); int n1=Integer.parseInt(br.readLine()); System.out.println("Introduce otro nmero"); int n2=Integer.parseInt(br.readLine()); System.out.printf("El mayor de los nmeros es %1d y el menor es %2d",max(n1,n2),min(n1,n2)); } } 3.3.4. La clase Scanner La clase Scanner, introducida a partir de la versin 1.5 de Java SE, facilita la lectura de datos desde cualquier dispositivo de entrada al proporcionar mtodos que permiten recuperar dichos datos no solo en formato texto, sino tambin en cualquiera de los tipos primitivos del lenguaje. A diferencia de las clases anteriores que estn en el ava.io, la clase Scanner se encuentra en el paquete java.util.

Un objeto Scanner divide los datos de entrada en trozos o tokens utilizando un patrn de delimitacin de token, que por defecto es el espacio en blanco. Utilizando los mtodos de la clase Scanner, cada uno de esos tokens es recuperado en el tipo de dato apropiado.

3.3.4.1. Creacin de un objeto Scanner Para crear un objeto Scanner se utilizar el siguiente constructor: Scanner (InputStream is) Como se puede apreciar, es necesario proporcionar el stream de entrada por el que se van a recuperar los datos. Por ejemplo, para realizar la lectura de datos por teclado sera: Scanner sc = new Scanner (System.in); Tambin es posible utilizar un objeto Scanner para recuperar tokens existentes en una cadena de caracteres, en cuyo caso utilizaramos el constructor: Scanner (String cadena) 3.3.4.2. Mtodos de la clase Scanner Una vez creado el objeto los datos de entrada son troceados y estn listos para ser recuperados a travs de los siguientes mtodos: next(). Se desplaza al siguiente token y devuelve el contenido del mismo como un String. El siguiente cdigo de ejemplo permitira solicitar un dato por teclado y almacenarlo en una variable: Scanner sc = new Scanner (System.in); System.out.println(Introduzca el dato); String dato = sc.next(); hasNext(). Indica si existe o no un siguiente token para leer. nextXxx(). Representa un conjunto de mtodos que devuelve el siguiente token como un tipo bsico, siendo Xxx el nombre de este tipo bsico. Por ejemplo, nextInt() para lectura de un entero o nextFloat() para la lectura de un float. hasNextXxx (). Grupo de mtodos que indican si existe o no un siguiente token del tipo especificado, siendo Xxx el nombre del tipo. nextLine(). Devuelve la ltima lnea de texto completa del stream de entrada. useDelimiter(String d). Utilizando este mtodo se establece un nuevo delimitador de token.

EJERCICIO 8

Vamos a realizar un programa que, dado una lista de nmeros existentes en una cadena de caracteres separados por una coma (,), realice la suma de todos los nmeros contenidos en la misma y muestre el resultado en pantalla. El cdigo del programa ser el siguiente: import java.util.*; public class SumatorioNumeros { public static void main(String[] args) { String lista="5,20,11,4"; Scanner sc=new Scanner(lista); sc.useDelimiter(","); int suma=0; while(sc.hasNext()){ suma+=sc.nextInt(); } System.out.println("La suma es "+suma); } } 3.4. CLASES DE COLECCIN

Las clases de coleccin son sin duda alguna uno de los tipos de clases ms importantes que ofrece la edicin Java SE. A travs de las colecciones podemos manejar conjuntos de objetos en un programa de forma dinmica, a diferencia de los arrays que slo nos permiten trabajar con un nmero de elementos fijos. Utilizando los mtodos que nos ofrecen las clases de coleccin podemos aadir nuevos objetos a la coleccin, eliminar objetos existentes, buscar y recuperar objetos, etc. El paquete java.util proporciona un gran nmero de clases e interfaces para el manejo de colecciones, en funcin del tipo de conjunto de objetos que queramos manejar.

3.4.1. Tipos de colecciones En funcin de cmo se manejen los objetos, distinguimos cuatro tipos de colecciones: Colecciones basadas en ndices Colecciones basadas en claves Conjuntos Colas

3.4.2. Colecciones basadas en ndices Se les llama as porque, al igual que los arrays, cada elemento de la coleccin tiene asociado un ndice basado en la posicin que ocupa en la misma, siendo 0 el ndice del primer elemento.

Las clases ms utilizadas dentro de este grupo son Vector y ArrayList. La nica diferencia entre ellas simplemente es que los mtodos de Vector son sincronizados, lo cual resulta adecuado para trabajar en entorno multitarea (mltiples procesos accediendo concurrentemente al mismo objeto). En entorno monotarea, es ms eficiente el uso de mtodos no sincronizados, resultando ms adecuado el empleo de la clase ArrayList. Para crear objetos de cualquiera de estas clases no hay ms que utilizar el constructor por defecto de las mismas: Vector v = new Vector(); ArrayList lista = new ArrayList(); Inicialmente, la coleccin se crea vaca y todas las operaciones sobre la misma se realizan a travs de los mtodos expuestos por la clase.

3.4.2.1. Mtodos para la manipulacin de la coleccin Seguidamente, vamos a analizar los principales mtodos expuestos por la clase ArrayList que nos permitirn trabajar con una coleccin de objetos. add(Object ob). Mediante este mtodo aadimos un nuevo objeto a la coleccin, situndolo al final de la misma. Como vemos, el mtodo admite cualquier tipo de objeto Java (todos los objetos Java, sean de la clase que sean, son tambin Object), lo que significa que podemos crear colecciones de nmeros, cadenas de caracteres, objetos de clases personalizadas, etc. El siguiente bloque de cdigo crear una coleccin de tres objetos numricos: ArrayList numeros = new ArrayList(); numeros.add(new Integer(25)); numeros.add(new Integer(10)); numeros.add(new Integer(89)); Obsrvese como hemos tenido que crear objetos Integer a partir de los valores enteros para poder almacenarlos en el ArrayList, pues las colecciones solo admiten elementos de tipo objeto. Sin embargo, desde la versin Java 1.5 lo anterior puede hacerse tambin de la siguiente manera: ArrayList numeros = new ArrayList(); numeros.add(25); numeros.add(10); numeros.add(89); A travs del autoboxing, el nmero es convertido implcitamente por el compilador a objeto Integer antes de almacenarlo en la coleccin. get (int posicin). Devuelve el elemento que ocupa la posicin indicada como parmetro, siendo 0 la posicin del primer elemento. El dato es devuelto como Object, siendo necesaria una conversin explcita o casting al tipo especfico. Por ejemplo, para recuperar el primer nmero de la coleccin anterior sera: Integer num = (Integer)numeros.get(0); int n = num.intValue();

aunque utilizando el autounboxing se podra simplificar: int n = (Integer)numeros.get(0); size(). Devuelve el tamao actual de la coleccin. La siguiente instruccin mostrara el valor 3 en pantalla: System.out.println(numeros.size()); indexOf (Object ob). Este mtodo nos devuelve la posicin dentro de la coleccin del objeto que se le pasa como parmetro, dando como resultado el valor -1 si dicho elemento no se encuentra en la coleccin. remove (int pos). Elimina el elemento que ocupa la posicin indicada. Tras la eliminacin, la coleccin se reordena, pasando a ocupar la posicin del elemento eliminado el siguiente objeto de la coleccin y as sucesivamente.

EJERCICIO 9
Como ejemplo de utilizacin de colecciones basadas en ndices vamos a desarrollar un programa que nos permita registrar una serie de precios de productos en una coleccin, ofrecindonos adems la posibilidad de obtener unos datos estadsticos sobre los mismos. Al iniciarse el programa se presentar al usuario un men como el que se indica a continuacin: 1. Nuevo precio 2. Precio medio 3. Precio mximo 4. Precio mnimo 5. Mostrar todos los precios 6. Salir Men que volver a ser mostrado al usuario despus de realizarse la opcin correspondiente; as hasta que elija salir. Con la opcin 1 se le pedir al usuario que introduzca el precio que quiere almacenar, mientras que las dems opciones mostrarn los datos solicitados. Como veremos a continuacin en el listado de cdigo, en vez de incluir todo el cdigo en el interior del mtodo main() se realizar la gestin de cada una de las opciones en mtodos independientes para facilitar la claridad del cdigo y hacerlo ms estructurado: import java.io.*; import java.util.*; public class GestionPrecios { public static void main(String[] args){ //ArrayList donde se almacenarn los precios ArrayList precios=new ArrayList();

String opcion; Scanner sc=new Scanner(System.in); do{ System.out.println("Elegir opcin:\n"); System.out.println("1. Nuevo precio"); System.out.println("2. Precio medio"); System.out.println("3. Precio mximo"); System.out.println("4. Precio mnimo"); System.out.println("5. Mostrar todos los precios"); System.out.println("6. Salir"); opcion=sc.next(); switch(Integer.parseInt(opcion)){ case 1: double pr; System.out.println("Introduce precio"); pr=sc.nextDouble(); grabaPrecio(pr,precios); break; case 2: muestraMedia(precios); break; case 3: muestraMaximo(precios); break; case 4: muestraMinimo(precios); break; case 5: muestraTodos(precios); break; } } while(!opcion.equals("6")); } static void grabaPrecio(double d,ArrayList precios){ precios.add(d); } static void muestraMedia(ArrayList precios){ double media=0.0; for(Object pr:precios){

media+=((Double)pr).doubleValue(); } media/=precios.size(); System.out.println("El precio medio es: "+media); } static void muestraMaximo(ArrayList precios){ double maximo; //inicializamos al precio inicial maximo=((Double)precios.get(0)).doubleValue(); for(Object pr:precios){ double aux; aux=((Double)pr).doubleValue(); if(aux>maximo){ maximo=aux; } } System.out.println("El precio mximo es "+ maximo); } static void muestraMinimo(ArrayList precios){ double minimo; //inicializamos al precio inicial minimo=((Double)precios.get(0)).doubleValue(); for(Object pr:precios){ double aux; aux=((Double)pr).doubleValue(); if(aux<minimo){ minimo=aux; } } System.out.println("El precio mnimo es "+ minimo); } static void muestraTodos(ArrayList precios){ for(int i =0;i<precios.size();i++){ System.out.print(((Double)precios.get(i)). toString()+"|"); } } }

3.4.3. Colecciones de tipo genrico Un problema que hemos observado al tratar con colecciones de tipo ArrayList es el hecho de que todos los tipos de objetos son tratados como Object, lo que obliga por ejemplo, a realizar un casting o conversin al tipo especfico cada vez que se quiera recuperar un elemento. Por otro lado, al admitir un tipo Object el mtodo add(), es posible aadir cualquier tipo de objeto a la coleccin y mezclar incluso objetos de diferentes tipos, algo que no suele ser normal hacerlo salvo por error. El problema es que ese error no ser detectado al compilar el programa, sino durante la ejecucin del mismo cuando se intente convertir el objeto recuperado a un tipo que no le corresponde. Para solucionar estos problemas, a partir de la versin 1.5 de Java SE se incorporaron las llamadas colecciones de tipo genrico. Estas colecciones estn definidas de manera que puedan ser utilizadas con cualquier tipo de objeto Java, siendo en el momento de la creacin del objeto de coleccin cuando se debe indicar el tipo especfico de objeto con el que van a trabajar. A partir de ese momento, la coleccin solamente admitir objetos del tipo especificado. Es decir, a diferencia de las colecciones estndares que al admitir Object pueden almacenar cualquier tipo de objeto, las colecciones genricas requieren que se especifique el tipo concreto con el que se va a trabajar. Si nos fijamos en el javadoc en la definicin de la clase ArrayList, vemos algo similar a esto: class ArrayList<E> donde la expresin <E> indica que se trata de una coleccin de tipo genrico, siendo E la letra que se utiliza por convenio para referirse a un tipo genrico, es decir, un tipo que puede ser cualquier tipo de objeto Java y que deber ser especificado durante la creacin del objeto coleccin. Para crear un objeto ArrayList que admita, por ejemplo, nicamente cadenas de caracteres sera: ArrayList<String> lista = new ArrayList<String>(); Como vemos, se debe indicar entre los smbolos < y > el tipo especfico que se va a almacenar en la coleccin, tanto en la declaracin de la variable de coleccin como en la creacin del objeto de sta. A partir de ese momento, la coleccin solamente admitir datos del tipo especificado: lista.add(hola); lista.add(cadena); lista.add(nueva); Si se intenta aadir a la coleccin un objeto de un tipo diferente al especificado se producir un error de compilacin: lista.add(new Integer(10)); //error de compilacin De esta forma, se evitan la mezcla accidental de objetos de distinto tipo dentro de una misma coleccin. Por otro lado, la utilizacin de colecciones de tipo genrico evita tener que realizar conversiones a la hora de recuperar los objetos:

String s = lista.get(0); Al estar especificado el tipo de la coleccin, no ser necesario indicar a que tipo hay que convertir. Si nos fijamos en la ayuda del javadoc para el paquete java.util, observaremos que no solo ArrayList, sino todas las clases e interfaces de coleccin del paquete, estn definidas como colecciones de tipo genrico. Realmente, por compatibilidad con versiones anteriores, una coleccin de tipo genrico puede utilizarse como una coleccin estndar, es decir, si creamos un objeto de coleccin de la siguiente manera: ArrayList l = new ArrayList(); que es como lo hemos estado haciendo al principio, lo que el compilador est haciendo realmente es: ArrayList<Object> l = new ArrayList<Object>(); Se recomienda utilizar siempre la versin genrica de las colecciones, indicando el tipo especfico con el que se va a trabajar.

EJERCICIO 10
Se trata de realizar el mismo programa del ejercicio anterior utilizando la versin genrica de la coleccin ArrayList. El cdigo quedara como se indica a continuacin, donde, como se puede ver, se ha utilizado adems la tcnica del autoboxing/autounboxing para simplificar el almacenamiento/recuperacin de objetos: import java.util.*; public class GestionPrecios { public static void main(String[] args){ //ArrayList donde se almacenarn los precios ArrayList<Double> precios=new ArrayList<Double>(); String opcion; Scanner sc=new Scanner(System.in); do{ System.out.println("Elegir opcin:\n"); System.out.println("1. Nuevo precio"); System.out.println("2. Precio medio"); System.out.println("3. Precio mximo"); System.out.println("4. Precio mnimo"); System.out.println("5. Mostrar todos los precios"); System.out.println("6. Salir"); opcion=sc.next(); switch(Integer.parseInt(opcion)){ case 1: double pr; System.out.println("Introduce precio");

pr=sc.nextDouble(); grabaPrecio(pr,precios); break; case 2: muestraMedia(precios); break; case 3: muestraMaximo(precios); break; case 4: muestraMinimo(precios); break; case 5: muestraTodos(precios); break; } } while(!opcion.equals("6")); } static void grabaPrecio(double d,ArrayList<Double> precios){ precios.add(d); } static void muestraMedia(ArrayList<Double> precios){ double media=0.0; for(Double pr:precios){ media+=pr; } media/=precios.size(); System.out.println("El precio medio es: "+media); } static void muestraMaximo(ArrayList<Double> precios){ double maximo; //inicializamos al precio inicial maximo=precios.get(0); for(Double pr:precios){ if(pr>maximo){ maximo=pr; } }

System.out.println("El precio mximo es "+ maximo); } static void muestraMinimo(ArrayList<Double> precios){ double minimo; //inicializamos al precio inicial minimo=precios.get(0); for(Double pr:precios){ if(pr<minimo){ minimo=pr; } } System.out.println("El precio mnimo es "+ minimo); } static void muestraTodos(ArrayList<Double> precios){ for(int i =0;i<precios.size();i++){ System.out.print(precios.get(i)+"|"); } } }

3.4.4. Colecciones basadas en claves A diferencia de las anteriores, en las colecciones basadas en claves los elementos no tienen asignado ningn tipo de ndice basado en la posicin de los mismos. Lo que si tiene asociado cada elemento de la coleccin (llamado tambin valor) es una clave que lo identifica de forma nica dentro de la misma (figura 8), de modo que no puede haber en la coleccin dos objetos con la misma clave asociada. Tanto las claves como los valores pueden corresponder a cualquier tipo de objeto vlido en Java.

clave1 clave2

valor1 valor2

Figura. 8. Este tipo de colecciones son apropiadas para gestionar conjuntos de objetos donde los elementos almacenados disponen de algn dato que los identifica, como por ejemplo para gestionar una agenda de contactos donde cada contacto (valor) tendra asociado como dato identificativo (clave) su telfono. La utilizacin de este tipo de colecciones permite realizar ciertas operaciones tpicas como la bsqueda de objetos a partir de su clave. La clase de coleccin ms importante dentro de este grupo es Hashtable, cuya definicin en el javadoc es la siguiente: class Hashtable<k,v> Como vemos se trata de una definicin en versin genrica de la coleccin, donde k es el nombre utilizado para el tipo genrico que representa a la clave y v para el que representa al valor. Por ejemplo, si quisiramos crear una coleccin para almacenar objetos de tipo String, a los que asociaramos una clave de tipo numrico, deberamos utilizar la instruccin: Hashtable<Integer, String> lista = new Hashtable<Integer, String>(); Al igual que sucede con ArrayList, la coleccin Hashtable se encuentra vaca en el momento de su creacin.

3.4.4.1. Mtodos de la clase Hashtable Seguidamente vamos a analizar algunos de los mtodos ms importantes de que dispone la clase Hashtable para la manipulacin de colecciones basadas en claves: put (k clave, v valor). Mediante este mtodo se aade un nuevo objeto a la coleccin, especificando como primer parmetro la clave asociada al objeto y como segundo el objeto en s. Si queremos aadir un nombre a la lista de ejemplo creada anteriormente con un cdigo numrico asociado sera: lista.put(783, Manuel Lpez);

Si ya existiera en la coleccin un objeto con la clave indicada, el nuevo objeto pasara a sustituir al antiguo. En este caso, la llamada al mtodo put() devolvera el objeto sustituido, resultando null en cualquier otro caso. get (k clave). Devuelve el valor (objeto) asociado a la clave indicada. Si no existe ningn objeto con esa clave el mtodo devolver null. containsKey(k clave). Indica si existe(true) o no(false) algn objeto en la coleccin con la clave que se indica. contains(v valor). Indica si el objeto indicado como parmetro existe(true) o no(false) en la coleccin. remove(k clave). Elimina el elemento cuya clave se indica como parmetro, devolviendo el elemento eliminado. Si no existiera ningn elemento con dicha clave asociada, el mtodo no realizar ninguna accin y devolver como resultado null. size(). Devuelve el nmero de valores almacenados hasta el momento en la coleccin. keys(). Devuelve un objeto de tipo Enumeration con todas las claves de la coleccin. Dado que no existe un ndice asociado a cada elemento, el recorrido de una coleccin basada en claves debe realizarse a travs de un objeto auxiliar de tipo Enumeration. Aunque Enumeration es una interfaz y las interfaces sern estudiadas en el prximo tema, de momento es suficiente con indicar que las interfaces declaran una serie de mtodos que deben ser implementados por algn tipo de objeto. En el caso concreto de keys(), la llamada a este mtodo devuelve un objeto que implementa la interfaz Enumeration, lo que significa que podemos aplicar sobre este objeto los mtodos definidos en dicha interfaz. Los mtodos de la interfaz Enumeration se utilizan para realizar el recorrido de algn conjunto de objetos; en el caso de keys() servirn para recorrer la lista de claves del Hashtable. Estos mtodos son: o hasMoreElements(). Este mtodo devuelve un valor de tipo boolean que nos indica si existe algn elemento ms que recorrer. Consultando este mtodo se puede determinar si se ha llegado o no al final del conjunto que se est recorriendo. nextElement(). Devuelve el siguiente elemento del conjunto. Inicialmente, al crearse el objeto Enumeration, este se encuentra apuntando a la posicin anterior al primer elemento del conjunto, por lo que la primera llamada a nextElement() devolvera el primer objeto.

Utilizando un bucle de tipo while podemos realizar fcilmente el recorrido de cualquier conjunto Enumeration empleado los mtodos anteriores. Por ejemplo, si quisiramos mostrar la todos los nombres registrados en la lista de ejemplo creada anteriormente procederamos de la siguiente manera: Enumeration claves = lista.keys(); while(claves.hasMoreElements()){ //recupera cada clave Integer k=claves.nextElement(); //a partir de la clave obtiene el valor

System.out.println(claves.get(k)); } elements(). Devuelve un objeto Enumeration con los valores de la coleccin. El ejemplo anterior se podra realizar de forma ms simple: Enumeration nombres = lista.elements(); while(nombres.hasMoreElements()){ System.out.println(nombres.nextElement()); }

EJERCICIO 11
Como ejemplo prctico de uso de colecciones basadas en claves, vamos a realizar un programa que permita realizar la gestin de una lista de contactos. Cada contacto est caracterizado por un nombre de persona (valor) con un DNI (clave) que lo identifica y que ser de tipo numrico, pudindose localizar los contactos a partir de ese campo clave. Al iniciar el programa se mostrar el siguiente men de opciones: 1. Aadir contacto 2. Eliminar contacto 3. Mostrar contactos 4. Salir Men que volver a ser mostrado al usuario despus de realizarse la opcin correspondiente; as hasta que elija salir. El cdigo del programa se muestra en el siguiente listado: import java.util.*; public class Contactos { public static void main(String[] args) { Hashtable<Integer,String> lista= new Hashtable<Integer,String>(); int opcion; Scanner sc=new Scanner(System.in); sc.useDelimiter("\n"); do{ System.out.println("1. Aadir contacto"); System.out.println("2. Eliminar contacto"); System.out.println("3. Mostrar contactos"); System.out.println("4. Salir"); opcion=sc.nextInt(); String nombre;

Integer dni; switch(opcion){ case 1: System.out.println("Introduce Nombre: "); nombre=sc.next(); System.out.println("DNI: "); dni=sc.nextInt(); guardarContacto(nombre,dni,lista); break; case 2: System.out.println("Introduzca el dni: "); dni=sc.nextInt(); eliminarContacto(dni,lista); break; case 3: mostrarContactos(lista); break; } } while(opcion!=4); } static void guardarContacto(String valor,Integer clave, Hashtable<Integer,String> lista){ if(!lista.containsKey(clave)){ lista.put(clave,valor); } } static void eliminarContacto(Integer clave, Hashtable<Integer,String> lista){ if(lista.containsKey(clave)){ lista.remove(clave); } } static void mostrarContactos(Hashtable<Integer,String> lista){ System.out.println("Los contactos son: "); Enumeration<Integer> claves=lista.keys(); while(claves.hasMoreElements()){ Integer k=claves.nextElement(); System.out.println(k.toString()+" - "+lista.get(k));

} } } 3.4.5. Conjuntos Los conjuntos representan un tipo de coleccin donde los elementos no tienen asociado ni ndices ni claves. Cada elemento almacenado en el conjunto es nico, de manera que pueden existir en un mismo conjunto dos elementos considerados iguales. La clase ms representativa de este tipo de coleccin es HashSet, cuya definicin en el javadoc de Java SE es la siguiente: class HashSet<E> Esta clase resulta muy apropiada para trabajar con agrupaciones de objetos en aquellos casos donde el orden de colocacin de los mismos no es relevante y se necesita disponer de ningn identificador asociado a cada objeto. Para crear un objeto HashSet utilizando la versin genrica simplemente habr que especificar el tipo de objeto que va a ser almacenado en la coleccin: HashSet<String> conjunto = new HashSet<String>();

3.4.5.1. Mtodos de HashSet Los principales mtodos de esta clase son: add(E objeto). Aade el objeto especificado al conjunto. Si dicho elemento ya existe en el conjunto no se llevar a cabo ninguna accin. remove(Object ob). Elimina del conjunto el objeto especificado. Si dicho elemento no existe en el conjunto no se llevar a cabo ninguna accin. contains(Object ob). Indica si el objeto existe (true) o no (false) dentro del conjunto size(). Indica el nmero de elementos del conjunto. iterator(). Este mtodo permite recorrer el conjunto, para lo cual devuelve un objeto Iterator que permite llevar a cabo dicha accin. Iterator es una interfaz similar a Enumeration que proporciona los siguientes mtodos para realizar el recorrido del conjunto: o o hasNext(). Mtodo que devuelve un valor boolean que indica si existen o no ms elementos en el conjunto. next(). Se desplaza al siguiente elemento del conjunto y nos devuelve su valor.

El siguiente bloque de instrucciones mostrara en pantalla todas las cadenas de caracteres almacenadas en el HashSet referenciado por la variable conjunto: while(conjunto.hasNext()){ System.out.println(conjunto.next());

} 3.4.6. Colas Una cola es un tipo de coleccin en la que los elementos se colocan siguiendo el orden natural del tipo de objeto que se trate. Por ejemplo, en una cola de cadenas de caracteres el orden natural se correspondera con la ordenacin alfabtica de los elementos, mientras que en una cola de nmeros la ordenacin se realizara de menor a mayor. A la hora de extraer elementos de la cola, dicha extraccin se realizara por el principio de la misma, es decir, el primer elemento de la coleccin ser el primero en salir. Las colas se manejan a travs de la clase PriorityQueue. Por ejemplo, para crear una cola de nmeros enteros deberamos indicar la instruccin: PriorityQueue<Integer> pq = new PriorityQueue<Integer>();

3.4.6.1. Mtodos de PriorityQueue En cuanto a los principales mtodos de esta clase tenemos: add(E objeto). Aade el objeto a la cola, situndolo en la posicin que le corresponde segn el orden natural del tipo de objeto manejado. poll(). Extrae el elemento de situado al principio de la cola, devolviendo dicho elemento. El siguiente bloque de instrucciones de ejemplo mostrara en pantalla los nmeros 10, 20, 30 y 40 en ese orden: PriorityQueue<Integer> pq=new PriorityQueue<Integer>(); pq.add(30); pq.add(20); pq.add(40); pq.add(10); int t=pq.size(); for(int i=0;i<t;i++){ System.out.println(pq.poll()); } peek(). Devuelve el elemento situado al principio de la cola pero sin eliminarlo. size(). Devuelve el nmero de elementos existentes en la cola. iterator(). Devuelve un objeto Iterator que permite recorrer todos los elementos almacenados en la cola.

AUTOEVALUACIN
1. Cul de los siguientes mtodos se utiliza para convertir una cadena de texto numrica en un nmero entero?: A. intValue() B. valueOf() C. parseInt() D. setInt()

2. Indica cul de las siguientes instrucciones de creacin de objetos es incorrecta: A. String s = new String (cadena); B. Scanner sc = new Scanner (System.in); C. Math m = new Math(); D. String cad = otra cadena;

3. Si tenemos que crear una coleccin de objetos donde el nico requerimiento es que los objetos no puedan repetirse, la clase ms adecuada para la implementacin de la coleccin sera: A. ArrayList B. Hashtable C. Vector D. HashSet

4. Tenemos una clase llamada Operaciones en la que queremos incluir un constructor que permita crear objetos de dicha clase desde cualquier parte. Adems, el constructor recibir como parmetro un valor entero que permita inicializar un atributo de la clase. La sintaxis correcta para la creacin del constructor sera A. public Operaciones (int dato) B. public void Operaciones (int dato) C. Operaciones (int dato) D. public new (int dato)

5. Al ejecutar el siguiente cdigo StringBuilder sb1 = new StringBuilder(hola); StringBuilder sb2 = sb1; sb2.append(adios); System.out.println(sb1.toString()); Qu resultado se mostrar en pantalla? A. holaadios B. hola C. Se producir una excepcin en la tercera instruccin D. Se mostrar una cadena vaca

6. Para importar los miembros estticos de una clase llamada Clase1 existente en un paquete llamado paquete1 deberamos utilizar: A. static import paquete1.*; B. import paquete1.static.Clase1; C. import static paquete1.Clase1; D. import static paquete1.Clase1.*;

7. Al ejecutar el siguiente cdigo ArrayList<String> l1 = new ArrayList<String>(); l1.add(hola); l1.add(200); Integer t = l1.get(1); System.out.println(t.toString()); Qu resultado se mostrar en pantalla? A. 200 B. Se producir un error de compilacin en la lnea 3 C. Se producir una excepcin en la lnea 4 D. Se producir una excepcin en la lnea 5

8. Queremos almacenar en una coleccin basada en claves una serie de objetos pertenecientes a una clase llamada Libro a los que queremos asociar como dato clave si ISBN que es un tipo de dato String: Cul de las siguientes instrucciones sera la ms apropiada para crear la instancia de la coleccin?: A. Hashtable tabla=new Hashtable(); B. Hashtable<String, Libro> tabla=new Hashtable<String, Libro>(); C. Hashtable<String, String> tabla=new Hashtable<String, String>(); D. Hashtable tabla=new Hashtable(String, Libro);

Ejercicios Propuestos

1. Desarrollar un programa que al ejecutarse genere y muestre en pantalla la combinacin de la lotera primitiva (seis nmeros aleatorios diferentes entre 1 y 49) 2. Desarrollar un programa que solicite una cadena de caracteres por teclado y nos muestre dicha cadena con los caracteres invertidos 3. Desarrollar un programa que solicite la introduccin de un texto y, a continuacin, la introduccin de una palabra. Seguidamente, el programa eliminar del primer texto todas las ocurrencias existentes de la palabra introducida en segundo lugar, mostrando en pantalla el texto resultante de realizar dicha extraccin. Por ejemplo, si el texto es Esta cadena de caracteres de prueba y la palabra es de, el resultado ser Esta cadena caracteres prueba. 4. Realizar un programa que permita solicite la introduccin de nmeros por teclado. Se pedir al usuario que introduzca un nmero y a continuacin que introduzca otro, as sucesivamente hasta que introduzca un nmero negativo (que ya no ser tenido en cuenta). Despus, el programa mostrar en pantalla todos los nmeros ordenados de menor a mayor. 5. Desarrollar un programa que permita gestionar una especie de base de datos de productos, donde cada producto tendr un precio y un cdigo asociado. El programa mostrar el siguiente men: 1- Introducir producto 2- Modificar precio 3- Mostrar precio medio 4- Eliminar producto 5- Salir La opcin 1 nos pedir el cdigo y el precio del producto que queremos guardar. Si ya existiera ese cdigo nos mostrar un mensaje de advertencia y no har nada, volviendo a mostrar de nuevo el men. La opcin 2 nos pedir el cdigo del producto a modificar y, caso de que exista, el nuevo precio del mismo. Si el producto no existe no se realizar la sustitucin y se mostrar un mensaje de advertencia. La opcin 3 mostrar la media de todos los precios existentes. La opcin 4 solicitar el cdigo del producto y lo eliminar, pero si no existiera nos mostrar un mensaje de advertencia. 6. Crear una clase para la gestin de pilas de cadenas de caracteres, donde el ltimo dato en entrar es el primero en salir. La clase tendr los siguientes miembros pblicos: Constructores: Dispondr de un constructor con un parmetro entero que determine el tamao mximo en nmero de caracteres de las cadenas de texto que sern aadidas a la pila. Tendr adems otro constructor sin parmetro que permita crear la pila sin definir ningn tamao mximo para las cadenas Mtodos: La clase incluir los siguientes mtodos:

 agregar(String cadena). Aade la cadena de texto a la pila. Si sta tiene definida un tamao mximo para las cadenas y el dato que se quiere aadir supera dicho tamao, se aadirn solo el nmero de caracteres de la cadena igual al tamao mximo. eliminar(). Elimina de la pila la ltima cadena aadida. total(). Devuelve el nmero de cadenas existentes en la pila. Por otro lado, se crear una segunda clase para la interaccin con el usuario que inicialmente solicite a este la introduccin de un tamao lmite para las cadenas (si introduce un valor negativo, las cadenas no tendrn tamao) y cree la pila a partir de este valor. Despus, mostrar al usuario un men con las siguientes opciones: 1- Introducir cadena 2- eliminar cadena 3- salir