HTMLpointHTMLpoint HTMLpoint.com


 Il package java.util



Antes de empezar esta lección tengo que hacer una pequeña advertencia.
Hemos visto como hay que programar usando Java, pero me he dado cuenta de que los teclados italianos no tienen tienen llaves, en cambio en los teclados que uso yo sí que aparecen. Por lo tanto os tengo que decir cómo podéis hacer aparecer estas llaves en vuestras pantallas.
Para que aparezca { hay que pulsar el teclado ALT, y manteniéndolo pulsado hay que teclear en el pequeño teclado numérico que está a la derecha el número 123 (ALT+123).
Para que aparezca } hay que teclear en cambio ALT+125.
Para los otros símbolos útiles en Java:
ALT Gr + es el de [ y ALT Gr + + de ]. Las teclas están subrayadas para no confundirlas con el signo + que indica che indica "pulsar a la vez". ALT Gr es el ALT que se encuentra a la derecha de la tecla ESPACIO, mientras que ALT se encuentra a la izquierda (mirando al teclado).

Este paquete es muy útil porque pone a disposición 34 clases y 13 interfaces que implementan algunas de las estructuras de datos más comunes. Algunas operaciones sobre fechas y sobre el calendario, y otras cosas.
Además el paquete java.util incluye otros subpaquetes que son: java.util.mime, java.util.zip y java.util.jar que sirven respectivamente para tratar archivos de tipo MIME, de tipo ZIP y de tipo Java Archive (JAR), que veremos en seguida en este capítulo. Como estructura de datos, en informatica, se llama a la estructura lógica lista para contenerun cierto número de datos en la que es posible insertar un datos, quitarlos, buscarlos, como mucho ordenarlos. Una simple estructura de daots que ya hemos visto es la array. Esta contiene un número cero de datos que pueden ser cualquier cosa, desde byte a objetos complejos, y sobre la misma se pueden incluir otros datos, hacer búsquedas o borrar, incluso un array se puede ordenar.
Para ve si en un array grande N está presente un dato X, yo tengo que visitar todo el array y hacer comparaciones con cada elemento del array, por lo que esta es una operación bastante compleja. Existen estructuras de datos que esta búsqueda la hacen empleando un solo acceso a la estructura, estas son, por ejemplo las citadas tablas hash. La elección de las estructuras de datos para usar en un programa es bastante complicada, por ello se elige una estructura en lugar de otra dependiendo del uso que se vaya hacer en el programa. Por ejemplo es difícil que en un database muy grande en el que se hacen muchas búsquedas se use un array como estructura de datos, porque empleareamos mucho tiempo para cada búsqueda (el ordenador es rápido, pero tiene sus límites si pensamos que éste emplea tanto tiempo para visitar completamente un database de mil millones de elementos), en este caso lo mejor tal vez sea emplear una tabla hash de cierta grandeza.
Java, por tanto, pone a disposción del usuario toda una gama de estructuras de datos, las gestiona, y a nosotros no nos queda más que usarlas. Para la elección de las estructuras de datos más acorde con nuestras intenciones, usaremos nuestro buen hacer porque, para elegirla de forma rigurosa son necesarios conocimientos específicos, entre otros los detalles que se realizan en las estructuras, estudiadas en cursos universitarios, como los algoritmos y Estructuras de Datos, y Fundamentos de Complejidad.
Cuando describa las clases de Java que se ocupan de la implementación de estas estructuras, las indicaré y trataré los tiempos de inserción, las búsquedas, etcétera…, pero siempre informalmente.
Vamos a ver qué incluye el paquete java.util

Interfaces

Collection
Comparator
Enumeration
EventListener
Iterator
List
ListIterator
Map
Map.Entry
Observer
Set
SortedMap
SortedSet

Estas interfaces establecen algunas propiedades de nuestras estructuras de datos. Se implementan en algunas de las siguientes clases.

Clases

AbstractCollection
AbstractList
AbstractMap
AbstractSequentialList
AbstractSet
ArrayList
Arrays
BitSet
Calendar
Collections
Date
Dictionary
EventObject
GregorianCalendar
HashMap
HashSet
Hashtable
LinkedList
ListResourceBundle
Locale
Observable
Properties
PropertyPermission
PropertyResourceBundle
Random
ResourceBundle
SimpleTimeZone
Stack
StringTokenizer
Timer
TimerTask
TimeZone
TreeMap
TreeSet
Vector
WeakHashMap

Excepciones

ConcurrentModificationException
EmptyStackException
MissingResourceException
NoSuchElementException
TooManyListenersException

Empezamos viendo algunas estructuras: BitSet, o en español Conjunto de Bit.
Esta clase ofrece una forma para crear y gestionar conjuntos bit (1,0) o mejor dicho, valores verdadero, falso.
El conjunto es desde luego un vector de bit pero que crece dinámicamente. Al principio los bit tienen un valor falso, y el vector mide 2^32-1 ((dos elevado a la treinta y dos) menos uno).
La clase tiene dos constructores: BitSet(), para crear un BitSet de dimensiones estándar, y BitSet(int nbits), para crear un BitSet que contiene nbits bit.
Las operaciones que se pueden hacer son:

void and(BitSet set), devuelve el and entre el BitSet y el otro BitSet localizados por set.
void andNot(BitSet set), borra todos los bit de la BitSet que tienen el correspondiente bit ajustado en la BitSet set.
void or(BitSet set), devuelve el or exclusivo entre el BitSet y el otro BitSet localizados por set.
void xor(BitSet set) , devuelve el or exclusivo entre el BitSet y el otro BitSet localizados por set.
void clear(int bitIndex), ajusta el bit especificado en falso.
void set(int bitIndex), ajusta el bit especificado en verdadero.
Object clone(), BitSet se declara Cloneable. Este método crea una copia igual.
boolean equals(Object obj), compara el objeto con otro objeto.
boolean get(int bitIndex), da el valor del bit número bitIndex.
int hashCode(), da un código hash para éste bitset.
int length(), da la grandeza lógica del bitset, es decir el bit más alto ajustado en verdadero más uno.
int size(), da el número de bit en el momento de la bitset. Es el bit más alto que se puede asignar a uno sin ampliar el bit set.
String toString(), transforma el bitset en una cadena

Probamos el bit set con el siguiente programa CaracteresUtilizados, que hay que editar en un archivo llamado CaracteresUtilizados.java, que coge una cadena en entrada y lee los caracteres que han sido utilizados.

import java.util.BitSet;
public class CaracteresUtilizados
{

public static void main (String[] a)
{

String tmp;

try {tmp=a[0];}
catch (ArrayIndexOutOfBoundsException e)
{errore();}

elabora(a[0]);

}

public static void error()
{

System.out.println("ERROR, necesito una cadena:");
System.out.println("\tTeclear:");
System.out.println("\t\tjava CaracteresUtilizados CADENA.");
System.exit(0);

}

public static void elabora (String a)
{

String tmp = a;

BitSet utilizados= new BitSet();

for (ent e = 0; e < tmp.length() ; e++)
utilizados.set(tmp.charAt(i));

String out="[";

ent dim=utilizados.size();

for (ent e = 0; e < dim; e++)
{
if (utilizados.get(i))
out+=(char )i;
};

out+="]";

System.out.println(out);

System.out.println("Para redactar he utilizado un bit set de "+utilizados.size()+" bit");

System.out.println ("\t\t\tPietro ");

}

}

Analizamos otra clase di java.util, la clase Vector. Esta clase implementa unos array de Object. Lo interesante de los array del lenguaje, es que se puede modificar la largura del vector cuando se realiza la puesta en marcha.
En Vector, además de los constructores, tenemos tres tipos de métodos, los que sirven para modificar el vector, los que sirven para obtener los valores incluídos en el vector, y los que sirven para gestionar el crecimiento del vector.

Hay cuatro constructores:

Vector(), construye un vector de tamaño 10, y que tiene la posibilidad de aumento igual a cero.
Vector(Collection c), construye un vector que incluye los elementos de la colección especificada, en el mismo orden en el que aparecen en la colección.
Vector(int initialCapacity), construye un vector tan grande como initialCapacity, con posibilidad de aumento igual a cero.
Vector(int initialCapacity, int capacityIncrement), construye un vector grande initialCapacity, con la posibilida de aumento igual a capacityIncrement.

Algunos métodos de la clase son:

void add(int index, Object element), añade un elemento al vector en la posición indicada.
boolean add(Object o), añade un elemento al final del vector.
boolean addAll(Collection c), añade al final del vector los elementos de la colección especificada, en el mismo órden en el que aparecen en la colección.
boolean addAll(int index, Collection c), añade los elementos de la colección en el vector empezando por el código especificado.
Estos tres métodos se convierten en verdaderos si los elementos han sido añadididos.Se convierten en falsos si no tienen nada que ver.
void addElement(Object obj), añade el elemento al vector y aumenta la capacidad de uno. int capacity(), da la capacidad actual del vector.
void clear(), elimina todos los elementos que están en el vector.
Object clone(), método utilizado generalmente para clonar el objeto Vector, que es supuestamente cloneable.
boolean contains(Object elem), controla si el elemento especificado está en el vector.
boolean containsAll(Collection c), controla si toda la colección especificada está en el vector.
void copyInto(Object[] anArray), copia el contenido del objeto de tipo Vector en un array de objetos del lenguaje.
Object elementAt(int index), devuelve el elemento del vector que se encuentra en la misma posición especificada.
boolean equals(Object o), controla la identidad entre el vector y el objeto especificado.
Object firstElement(), da el primer elemento del vector en posición 0.
Object get(int index), da el elemento del vector que se encuentra en la posición especificada y lo borra del vector.
int hashCode(), da el código hash del vector.
int indexOf(Object elem), busca el primer dato elemento en el vector, y devuelve el índice. Con primer dato me refiero supuestamente al del índice más bajo.
int indexOf(Object elem, int index), busca el primer dato elemento en el vector empezando por el índice especificado y devuelve el índice.
void insertElementAt(Object obj, int index), incluye el objeto especificado en la posición que queramos del vector.
boolean isEmpty(), controla si el vector está vacío.
Object lastElement(), da el último componente del vector.
int lastIndexOf(Object elem), da el índice del último elemento del objeto especificado en el vector.
int lastIndexOf(Object elem, int index), como antes empezando por el índice especificado y moviéndose hacia detrás.
Object remove(int index), borra el elemento que se encuentra en la posición indicada en el vector.
boolean remove(Object o), borra el primer dato en el vector del objeto especificado.
boolean removeAll(Collection c), borra del vector todos los elementos incluidos en la colección especificada void removeAllElements(), borra todos los elementos del vector.
boolean removeElement(Object obj), borra el primer dato del objeto especificado en el vector.
void removeElementAt(int index), borra el elemento en la posición especificada.
boolean retainAll(Collection c), borra todos los elementos del vector que están incluidos en la colección especificada.
Object set(int index, Object element), sustituye los elementos en la posición especificada del vector con el elemento que se le da como parámetro (pone el element en la dirección index).
void setElementAt(Object obj, int index), pone el objeto especificado en la posición que queremos.
void setSize(int newSize), ajusta el nuevo tamaño del vector.
int size(), da el número de posiciones en el vector.
List subList(int fromIndex, int toIndex), crea un listado con los elementos del vector que se encuentran en la posición especificada come inicio o como final.
List es otra estructura de datos muy importante que Java lleva ya implementada.
Object[] toArray() e Object[] toArray(Object[] a), crean un array del lenguaje con los elementos incluidos en el vector.
toString(), da una representación bajo forma de cadena del vector que incluye las representaciones como cadena de todos los elementos incluidos en el vector. Prácticamente invoca el toString de todos los objetos.

Los que estén acostumbrados a programar con otros lenguajes de programación podrán apreciar la funcionalidad que a menudo el programador tiene que implementar él mismo de forma superficial. Lo que yo aprecio personalmente, como programador, es, además de la dinamicidad de la estructura de Vector, que siempre ha sido por definicón estática, la posibilidad de crear vectores con elementos heterogéneos. En realidad, éstos son vectores de objetos, y sabemos que los objetos de java pueden ser cualesquiera incluso programas. Por ejemplo, es posible crear un vector que incluya números enteros, valores booleanos y cadenas, lo que no se puede hacer con los demás array del lenguaje.
Para que quede más claro voy a poner un ejemplo.
Fijaos en este vector:

tribilín = { true , 10 , "Hola"};

¿De qué tipo será Tribilín? ent[]? boolean[]? O String[]? Ninguno de los tres. En Java es imposible crear un array hecho de esta forma, utilizando las famosas clases envoltorios, que, hasta ahora, nos habían parecido bastantes inútiles. Podemos crear un array y escribiremos.
Object[] tribilín={new Boolean(true),
new Integer(10),
new String("Hola")
};


Además, si utilizamos la clase Vector, tendremos muchos métodos para gestionar este vector de elementos heterogéneos.

Pongamos un pequeño ejemplo que usa los vectores. Definimos un espacio geométrico tridimensional de puntos, líneas y caras, que se definen así:

class punto
{
String nombre;
ent x,y,z;
public punto(String n, ent X,ent Y,ent Z)
{

x=X;

y=Y;

x=Z;

nombre=n;

}

public String toString()
{
return "\n"+nombre+"="+x+","+y+","+z+"\n";

}
}


class línea
{
String nombre;
punto inicio;
punto fin;
public línea(String n, punto i,punto f)
{

inicio=i;

fin=f;

nombre=n;

}

public String toString()
{
return "\n"+nombre+"=("+inicio.toString()+","+fin.toString()+")\n";

}

}


class cara
{
String nombre;
punto x1;
punto x2;
punto x3;
línea l1;
línea l2;
línea l3;
public cara(String n, punto X1,punto X2,punto X3)
{

x1=X1;
x2=X2;
x3=X3;
l1=new línea(n+"-línea1",x1,x2);
l2=new línea(n+"-línea2",x3,x2);
l3=new línea(n+"-línea3",x1,x3);
nome=n;

}

public String toString()
{

return "\n"+nombre+"={"
+l1.toString()+
","
+l2.toString()+
","
+l3.toString()+"}\n";

}
}

Las clases incluyen unos métodos toString(), que sobrescriben los métodos estándar para crear el outpu en el archivo del programa.
Las clases las pondremos en un archivo llamado Geometría.java, donde pondremos también los import necesarios al programa y las clases Geometría que incluye el main que definimos a continuación:
import java.util.*;
import java.io.*;

// Definicicón de la clase punto
// Definicicón de la clase línea
// Definicicón de la clase cara

public class Geometría
{

public static ent NÚMERO = 3000;

public static void main(String[] arg)
{
Vector espacio=new Vector(1,1);

System.out.println("Geometría en el espacio:");

ent pti = NÚMERO;

System.out.println();

System.out.println("Género "+pti+" objetos a caso por cada especie");

System.out.println("Cambiar la constante NÚMERO en Geometría para generar un número diferente.");

ent lin=NÚMERO;

ent car;

car=NÚMERO;


System.out.println();

ent d1=espscio.capacity();

System.out.println ("Capacidad del vector:"+espacio.capacity());

System.out.println("Redacto los puntos...");

ent e=0;

for ( e = 0 ; e {

float a=(float ) Math.random();

float b=(float ) Math.random();

float c=(float ) Math.random();

ent x=Math.round(a*1000);

ent y=Math.round(b*1000);

ent z=Math.round(c*1000);

String nome="Punto"+(e+1);

punto tmpP=new punto(nombre,x,y,z);

espacio.addElement(tmpP);

};

System.out.println ("Capacidad del vector:"+espacio.capacity());

ent d2=espacio.capacity();

System.out.println("Redacto las líneas...");

for ( e = 0 ; e {

float a=(float ) Math.random();

float b=(float ) Math.random();

float c=(float ) Math.random();

float d=(float ) Math.random();

float e=(float ) Math.random();

float f=(float ) Math.random();


ent x=Math.round(a*1000);

ent y=Math.round(b*1000);

ent z=Math.round(c*1000);

ent x1=Math.round(d*1000);

ent y1=Math.round(e*1000);

ent z1=Math.round(f*1000);

String nombre="Línea"+(i+1);

punto P1=new punto ("Punto 1 del "+nombre,x,y,z);

punto P2=new punto ("Punto 2 del "+nombre,x1,y1,z1);

linea tmpL=new linea(nombre,P1,P2);

espacio.addElement(tmpL);

};

System.out.println ("Capacidad del vector:"+espacio.capacity());

ent d3=espacio.capacity();

System.out.println("redacto las caras...");

for ( e = 0 ; e {

float a=(float ) Math.random();

float b=(float ) Math.random();

float c=(float ) Math.random();

float d=(float ) Math.random();

float e=(float ) Math.random();

float f=(float ) Math.random();

float g=(float ) Math.random();

float h=(float ) Math.random();

float j=(float ) Math.random();

ent x=Math.round(a*1000);

ent y=Math.round(b*1000);

ent z=Math.round(c*1000);

ent x1=Math.round(d*1000);

ent y1=Math.round(e*1000);

ent z1=Math.round(d*1000);

ent x2=Math.round(g*1000);

ent y2=Math.round(h*1000);

ent z2=Math.round(j*1000);

String nome="Cara"+(e+1);

punto P1=new punto ("Punto 1 del "+nombre,x,y,z);

punto P2=new punto ("Punto 2 del "+nombre,x1,y1,z1);

punto P3=new punto ("Punto 1 del "+nombre,x2,y2,z2);

cara tmpF=new cara(nombre,P1,P2,P3);

espacio.addElement(tmpF);

};

System.out.println ("Capacidad final del vector:"+espacio.capacity());

ent d4=espacio.capacity();

File FileOut=new File("Geometría.txt");

FileWriter Output;

try {Output=new FileWriter(FileOut);}
catch (IOException e) {Output=null;};

try {

Output.write("Geometría.txt\nnúmero objetos="+3*NÚMERO+"\n");

Output.write("Tamaño del Vector:\al principio:"+d1+"\n después de la inclusión de los números:"+d2);

Output.write("\ndespués de la inclusión de las líneas:"+d3+"\ndespués de la inclusión de las caras:"+d4);

Output.write("\n\nContenido:\n");

Output.write(espacio.toString());

Output.write("\n\n\n\t\tPietro Castellucci");

Output.flush();

} catch (IOException e) {};

System.out.println("\nLee el archivo Geometría.txt.\n");

};

}

Si ponemos en marcha el programa veremos que el Vector espacio aumenta dinámicamente con los objetos heterogéneos punto, línea y cara.
Finalmente tendremos un archivo llamado Geometría.txt que incluye la descripción del vector. El archivo con 5 elementos por cada especie es algo como:

Geometría.txt
número objetos=15

Tamaño del Vector:

al principio:1
después de la inclusión de los puntos:5
después de la inclusión de las líneas:10
después de la inclusión de las caras:15

Contenido:
[
Punto1=653,932,0
,
Punto2=100,273,0
,
Punto3=855,210,0
,
Punto4=351,702,0
,
Punto5=188,996,0
,
Línea1=(
Punto 1 de la Línea1=680,454,0
,
Punto 2 de la Línea1=69,16,0
)
,
Línea2=(
Punto 1 de la Línea2=116,651,0
,
Punto 2 de la Línea2=371,15,0
)
,
Linea3=(
Punto 1 de la Línea3=947,335,0
,
Punto 2 de la Línea3=477,214,0
)
,
Línea4=(
Punto 1 de la Línea4=391,671,0
,
Punto 2 de la Línea4=692,725,0
)
,
Línea5=(
Punto 1 de la Línea5=762,283,0
,
Punto 2 de la Línea5=582,192,0
)
,
Cara1={
Cara1-línea1=(
Punto 1 de la Cara1=826,235,0
,
Punto 2 de la Cara1=13,378,0
)
,
Cara1-línea2=(
Punto 1 de la Cara1=12,950,0
,
Punto 2 de la Cara1=13,378,0
)
,
Cara1-línea3=(
Punto 1 de la Cara1=826,235,0
,
Punto 1 de la Cara1=12,950,0
)
}
,
Cara2={
Cara2-línea1=(
Punto 1 de la Cara2=382,30,0
,
Punto 2 de la Cara2=224,597,0
)
,
Cara2-línea2=(
Punto 1 de la Cara2=277,361,0
,
Punto 2 de la Cara2=224,597,0
)
,
Cara2-línea3=(
Punto 1 de la Cara2=382,30,0
,
Punto 1 de la Cara2=277,361,0
)
}
,
Cara3={
Cara3-línea1=(
Punto 1 de la Cara3=139,802,0
,
Punto 2 de la Cara3=880,935,0
)
,
Cara3-línea2=(
Punto 1 de la Cara3=643,921,0
,
Punto 2 de la Cara3=880,935,0
)
,
Cara3-línea3=(
Punto 1 de la Cara3=139,802,0
,
Punto 1 de la Cara3=643,921,0
)
}
,
Cara4={
Cara4-linea1=(
Punto 1 de la Cara4=516,614,0
,
Punto 2 de la Cara4=429,210,0
)
,
Cara4-línea2=(
Punto 1 de la Cara4=979,860,0
,
Punto 2 de la Cara4=429,210,0
)
,
Cara4-línea3=(
Punto 1 de la Cara4=516,614,0
,
Punto 1 de la Cara4=979,860,0
)
}
,
Cara5={
Cara5-línea1=(
Punto 1 de la Cara5=152,663,0
,
Punto 2 de la Cara5=828,101,0
)
,
Cara5-linea2=(
Punto 1 de la Cara5=651,761,0
,
Punto 2 de la Cara5=828,101,0
)
,
Cara5-línea3=(
Punto 1 de la Cara5=152,663,0
,
Punto 1 de la Cara5=651,761,0
)
}
]


Pietro Castellucci

Intentad fijar la constante NÚMERO a 4000 y poned en marcha el programa.
Como habéis visto hay muchas estrucuturas de datos en java.util, y describirlas todas sería demasiado trabajo.
Lo que nos interesa es que todas tienen métodos para introducir, quitar, recuperar y métodos para gestionar la estructura misma.
Las estructuras de datos implementadas son tablas hash, listas, pile, code, árboles etc… Según vuestras exigencias podeís utilizar una u otra. Para tener más detalles, sin embargo, os aconsejo ojear la documentación del Java Development Kit, donde stán escritas todas estas clases.
Por ahora os sirve con saber que las tablas hash son muy rápidas buscando un objeto. Por lo general, basta con un solo acceso a las estructuras de datos para encontrar el objeto que buscáis.
Los listados son como los vectores. Los objetos están relaccionados entre sí, y desde un obbjeto es posible alcanzar el siguiente o el anterior o los dos, según la realización del listado .
Los Pile son listados particulares, en los que se introducen objetos siempre al comienzo de la estructura y, de aquí, se pueden tomar. Por lo tanto en pila el último objeto que ha entrado es el primero que sale. Pensad en los objetos como si fueran unos documentos que hay despachar desde una oficina. Se ponen en órden en la mesa del encargado según sus llegadas, uno encima del otro. El encargado de despachar los documentos empieza siempre por el que está encima de la pila. Ésta puede parecer una estructura de datos tonta, pero os aseguro que es la más mportante de todas. Las utilizan todos los lenguajes de programación para invocar las funciones y los procedimientos. (Incluso Java la usa para invocar los métodos), para transladar los parámetros y recuperar los resultados. Sin esta estructura sería imposible programar de forma recursiva, que es una forma de programar muy potente.
Las colas funcionan al revés. Se pueden comparar con las colas de los bancos. Los objetos son las personas que están en la cola delante de la ventanilla. Llegan y se ponen al final de la cola. Mientras tanto el empleado atiende a las personas que están delante. Tambiém esta estructura es muy importante porque algunas variantes (las colas de prioridad, en las que los objetos tienen prioridad, se atienden según esta característica, es decir, se cuelan). Se utilizan mucho en los sistemas operativos como Windows, Linux, Unix, etc. para gestionar las necesidades de imprenta de una sola impresora por parte de todos los usuarios del sistema.
Antes de pasar al siguiente paquete, quiero mostraros una pequeña comparación sobre la búsqueda de un objeto entre muchos que están incluidos en distintas estructuras. Particularmente, en las estructuras de tipo vector y de tipo tabla hash.
Veremos como los resultados de la búsqueda cambian de forma evidente aumentando el tamaño de las estructuras. Imaginemos unos objetos de este tipo:

class O
{
String nombre=new String();
ent valor;
public O(String a, ent v)
{
nombre=a;
valor=v;
}
}

Creamos un vector de 100000 de estos elementos. Buscamos uno y vemos el tiempo que tardamos:

import java.util.*;

class O
{

String nombre=new String();

ent valor;

public O(String a, ent v)
{
nombre=a;
valor=v;
}

}



public class Rvector
{

public static ent NÚMERO = 100000;

public static void main (String[] s)
{

Vector V = new Vector(NUMERO);

ent numnombre=128756;

O O_30000=null;

System.out.println("Redacto el vector, introduzco "+NÚMERO+" objetos de tipo O con valores que no tienen relación con el índice.");

System.out.print("Inicio: O_"+numnombre);

for (ent e=0; i< NÚMERO;i++)
{

O tmp = new O("O_"+numnombre,numnombre);

if (numnombre==30000) O_30000 = tmp;

numnombre--;

V.add(e,tmp);

};
System.out.println(" Fin: O_"+numnombre);

System.out.println("Inicio la búsqueda de O_30000");

long Inicio=System.currentTimeMillis();

ent index=V.indexOf(O_30000);

O tmp=(O ) V.get(index);

long Fine=System.currentTimeMillis();

System.out.println("Oggetto O_30000 trovato in "+(Fin-Inicio)+" millisec. al índice "+index);

System.out.println("Vale:\nNombre:"+tmp.nombre+"\nValor:"+tmp.valor+"\n");

}

}

El programa buscará el objeto O_30000. El output del programma es:
Redacto el vector, introduzco 100000 objetos de tipo O con valores independientes del índice.
Inicio: O_128756 Fin: O_28756
Empiezo la búsqueda de O_30000
Objeto O_30000 encontrado en 50 millisec. …..

Ahora hago lo mismo usando una estructura como la tabla hash:

import java.util.*;

class O
{

String nombre=new String();

ent valor;

public O(String a, ent v)
{
nombre=a;
valor=v;
}

}



public class Rhash
{

public static ent NÚMERO = 100000;

public static void main (String[] s)
{

Hashtable H = new Hashtable(NUMERO+1);

ent numnombre=128756;

O O_30000=null;

System.out.println("Redacto el cuadro, introduzco "+NÚMERO+" objetos de tipo O.");

System.out.print("Inicio: O_"+numnombre);

for (ent e=0; i< NÚMERO;e++)
{

O tmp = new O("O_"+numnombre,numnombre);

if (numnombre==30000) O_30000 = tmp;

numnombre--;

H.put(tmp,tmp);

};
System.out.println(" Fin O_"+numnombre);

System.out.println("Inicio la búsqueda de O_30000");

long Inizio=System.currentTimeMillis();

O tmp=(O ) H.get(O_30000);

long Fine=System.currentTimeMillis();

System.out.println("Obbjeto O_30000 encontrado en "+(Fin-Inicio)+" millisec. ");

System.out.println("Vale:\nNombre:"+tmp.nombre+"\nValor:"+tmp.valor+"\n");


}

}

Otra vez el programa buscará el objeto O_30000. El output del programma es:
Redacto el vector, introduzco 100000 objetos de tipo O.
Inicio: O_128756 Fin: O_28756
Empiezo la búsqueda de O_30000
Objeto O_30000 encontrado en 0 millisec. …..

El paquete java.util no incluye sólo estas utilísimas estructuras de datos, sino también clases que simplifican la gestión de fechas y horarios, para la internacionalización, y otras clases de utilidad como el string tokenizer. Coge de una cadena todas las palabras y unos generadores de números casuales.


  Volver al inicio de la página