UNIVERSIDAD SANTO TOMAS

VICERECTORIA DE UNIVERSIDAD A DISTANCIA

FACULTAD DE CIENCIAS Y TECNOLOGIA
PROGRAMA INGENIERIA EN INFORMATICA

INGENIERIA WEB
TALLER

DOCENTE: MARIO DUSTANO CONTRERAS CASTRO

TIEMPO COMPLETO

BOGOTA, FEBRERO DE 2016

 PAQUETE UTIL
INTERFAZ ENUMERATION
La interfaz Enumeration define los métodos que permiten enumerar (obtener
cada vez) los elementos de un conjunto de objetos. Esta interfaz define los dos
métodos siguientes:
Bolean hasMoreElements()
Object nextElement()
Cuando se implementa, hasMoreElements() debe devolver true mientras haya
elementos para extraer y false cuando se hayan enumerado todos los
elementos. El método nextElement() devuelve el siguiente objeto de la
enumeración como una referencia genérica a objeto, es decir, cada llamada a
nextElement() obtiene el siguiente objeto de la enumeración. La rutina que
llama a este método tiene que convertir ese objeto al tipo de objeto de la
enumeración.
El siguiente ejemplo utiliza una clase llamada EString para implementar una
enumeración de objetos String, y una clase llamada EnumeracionDemo para
crear una instancia de EString, iterar sobre sus valores e imprimir cada uno de
ellos. Observe que EString devuelve la secuencia de String. Sin embargo, las
implementaciones de ambos métodos cumplen los requisitos especificados por
la interfaz Enumeration.
Proyecto en Netbeans

Primer Programa: EString

package enumeracionstring;
import java.util.*;
class EString implements Enumeration {
String A[ ]={"Bogota","Cali","Medellin","Barranquilla","Bucaramanga","Ibague"};
private int conteo = -1;
private boolean mas = true;
public boolean hasMoreElements() {
return mas;
}
public Object nextElement() {
conteo++;
if (conteo == A.length-1)
mas = false;
return (A[conteo].toString());
}
}
Segundo Programa: EString
package enumeracionstring;
import java.util.*;
import javax.swing.*;
public class EnumeracionString {
public static void main(String args[]) {
Enumeration estring= new EString();
StringBuffer B=new StringBuffer();
while (estring.hasMoreElements())
{
B.append("\n"); B.append(estring.nextElement());
}
JOptionPane.showMessageDialog(null," Lista de Ciudades: "+B.toString());
}
}

Ejecución o F5
CLASE STRINGTOKENIZER
Que es un Token. Conjunto de caracteres (números, letras) delimitado por un
espacio en blanco (por defecto) u otro carácter.
Clase StringTokenizer Permite descomponer una cadena en partes
lexicográficas (tokens) las cuales constituyen a ésta.
Los tokens se dividen entre sí mediante ciertos caracteres que, en este caso,
se les llama delimitadores.
Constructores:
StringTokenizer(String str) se crea un string divisible conteniendo str y con el
set de delimitadores por defecto " "
StringTokenizer(String str, String delim) se crea un string divisible y con el set
de delimitadores dad en delim
StringTokenizer(String str, String delim, boolean returnTokens) se crea un
string divisible y con el set de delimitadores dado en delim. Si returnTokens es
true los delimitadores son retornados como palabras de longitud uno, si false
los delimitadores dividen las palabras pero no se retornan
Métodos Descripción
boolean hasMoreTokens() true si existen mas palabras por retornar
String nextToken() retorna la siguiente palabra
String nextToken(String retorna la siguiente palabra utilizando un nuevo set
delim) de delimitadores
public int countTokens() retorna el numero de palabras que quedan
A Continuación se muestra la manera de trabajar la clase StringTokenizer, se
supone que se crea a partir de tres String(a, b, c) a medida que se utiliza el
método nextToken() el índice de siguiente token avanza hasta no mas tolens
T0.
A B C

nextToken
T1.

C
B

nextToken
T2.

nextToken
T3.
hasMoreTokens() Se hace igual a False.
Un ejemplo es el siguiente código :
import java.util.*;
public class CasoToken{
public static void main(String []args){
int i,j,k;
String Cuenta="33.55.28.12";
String Nombre="Pedro Contreras, Luis Cardenas, Ines Forero, Carlos Daza";
String Movimiento="2.5,4.2,1.3/4.3,2.8,2.5/2.5,3.6,1.8/4.6,3.8,4.2";
String S;
StringTokenizer T1=new StringTokenizer(Cuenta,".");
StringTokenizer T2=new StringTokenizer(Nombre,",");
StringTokenizer T3=new StringTokenizer(Movimiento,"/");
while(T1.hasMoreTokens() && T2.hasMoreTokens () &&
T3.hasMoreTokens())
{
System.out.println();
System.out.print(" Cuenta: "+T1.nextToken());
System.out.print(" Nombre: "+T2.nextToken());
System.out.print(" Movimiento Cuentas: "+T3.nextToken());
}
System.out.println();
}
}
COLECCIONES EN JAVA
 Permite almacenar y organizar objetos de manera útil para un acceso
eficiente.
 Núcleo de abstracciones de colecciones de utilidad (interfaces) e
implementaciones ampliamente útiles.
 Las interfaces proporcionan métodos para todas las operaciones
comunes y las implementaciones concretas especifican la decisión de
las operaciones no permitidas.
o (java.lang.UnsupportedOperationException)
 Sobre los elementos se puede iterar (Iterator)
Interfaz Collections
Collections es una clase que proporciona una serie de métodos estáticos para
manejar colecciones que pueden ser de mucha utilidad. Los métodos son los
siguientes:
 int binarySearch(List list, Object key): Busca un elemento en una lista
ordenada utilizando un algoritmo de búsqueda binaria. El método
devuelve un entero indicando la posición en la que se encuentra el
elemento, o bien un número negativo si no se encontró. Este número
negativo indica la posición la que se encontraría el elemento de haber
estado en la colección.
 int frequency(Collection c, Object o): Devuelve el número de veces que
se repite el elemento especificado en la colección.
 Object max(Collection coll): Devuelve el mayor elemento de la colección.
 Object min(Collection coll): Devuelve el menor elemento de la colección.
 boolean replaceAll(List list, Object oldVal, Object newVal): Reemplaza
todas las ocurrencias en la lista de un cierto elemento por otro objeto.
 void reverse(List list): Invierte la lista.
 void shuffle(List list): Modifica la posición de distintos elementos de la
lista de forma aleatoria.
 void sort(List list): Ordena una lista utilizando un algoritmo merge sort.
Interfaz List
Una colección cuyos elementos permanecen en un orden particular a menos
que se modifique la lista (no significa lista enlazada aunque es una posible
implementación).
 boolean add(E o): Añade un nuevo elemento al final de la colección.
 boolean add(int index, E element): Añade un nuevo elemento en la
posición especificada.
 boolean addAll(Collection<? extends E> c): Añade todos los elementos
de la colección especificada a esta colección.
 void clear(): Elimina todos los elementos de la colección.
 boolean contains(Object o): Comprueba si el elemento especificado es
parte de la colección.
 get(int index): Recupera el elemento que se encuentra en la posición
espeficicada.
 int indexOf(Object o): Devuelve la primera posición en la que se
encuentra el elemento especificado en la colección, o -1 si no se
encuentra.
 int lastIndexOf(Object o): Devuelve la última posición en la que se
encuentra el elemento especificado en la colección, o -1 si no se
encuentra.
 remove(int index): Elimina el elemento de la posición indicada.
 boolean remove(Object o): Elimina la primera ocurrencia del elemento
indicado. Si se encontró y se borró el elemento, devuelve true, en caso
contrario, false.
 set(int index, E element): Reemplaza el elemento que se encuentra en la
posición indicada por el elemento pasado como parámetro. Devuelve el
elemento que se encontraba en dicha posición anteriormente.
 int size(): Devuelve el número de elementos que se encuentran
actualmente en la colección.
Interfaz Map
La interfaz Map<K,V> y las clases que la implementan vienen a reemplazar la
antigua clase Dictionary.
HashMap<K,V> es el tipo de mapeo más sencillo y probablemente el más
usado. Es la clase a utilizar si queremos asociar pares de claves y valores sin
orden, sin más. Internamente, como su nombre indica, utiliza un hash para
almacenar la clave. No permite claves duplicadas, pero si utilizar null como
clave.
Hashtable<K,V> es una vieja conocida del JDK 1.0, que, como Vector<E> pasó
a formar parte del framework de colecciones en Java 1.2. Esta clase es muy
similar a HashMap<K,V>, con la excepción de que es sincronizada y que no
acepta utilizar el valor null como clave. Como en el caso de Vector<E> contra
ArrayList<E>, nos interesará utilizar HashMap<K,V> siempre que no estemos
utilizando varios hilos de ejecución. En el caso de que necesitemos
sincronización, otra opción es utilizar el método Collections.synchronizedMap
sobre un HashMap, que funciona de forma similar a
Collections.synchronizedList.
LinkedHashMap<K,V> es una clase introducida con el J2SE 1.4 que extiende
HashMap<K,V> y utiliza una lista doblemente enlazada para poder recorrer los
elementos de la colección en el orden en el que se añadieron. Esta clase es
ligeramente más rápida que HashMap<K,V> a la hora de acceder a los
elementos, pero es algo más lenta al añadirlos.
Por último tenemos TreeMap<K,V>, en el que los pares clave-valor se
almacenan en un árbol ordenado según los valores de las claves. Como es de
esperar es la clase más lenta a la hora de añadir nuevos elementos, pero
también a la hora de accederlos.
De entre los métodos comunes a las cuatro clases los más utilizados son:
 void clear(): Elimina todos los elementos de la colección.
 boolean containsKey(Object key): Comprueba si la clave especificada se
encuentra en la colección.
 boolean containsValue(Object value): Comprueba si el valor
especificado se encuentra en la colección.
 get(Object key): Devuelve el valor asociado a la clave especificada o null
si no se encontró.
 boolean isEmpty(): Comprueba si la colección está vacía.
 keySet(): Devuelve un conjunto con las claves contenidas en la
colección.
 put(K key, V value): Añade un nuevo par clave-valor a la colección
 remove(Object key): Elimina el par clave-valor correspondiente a la
clave pasada como parámetro.
 int size(): Devuelve el número de pares clave-valor que contiene la
colección.
 Collection values(): Devuelve una colección con los valores que contiene
la colección.
Un ejemplo:
import java.util.*;
class Contador
{
private int i;
public Contador()
{
i=1;
}
public void incrementar()
{
++i;
}
public String toString()
{
return Integer.toString(i);
}
}
public class Estadistico {
public static void main( String args[] ) {
HashMap tabla = new HashMap();

for(int i=0; i < 10000; i++) {

// Generar un número entre 0 y 20
Integer num = new Integer((int)(Math.random()*20));

if(tabla.containsKey(num))
//Incrementamos el contador asociado al número
((Contador)tabla.get(num)).incrementar();
else
//Añadimos nuevo par: numero-contador
tabla.put(num, new Contador());
}
System.out.println(tabla);
}
}
Clase ArrayList
Declaración y creación
De forma general un ArrayList en Java se crea de la siguiente forma:
ArrayList Arreglo = new ArrayList();
Esta instrucción crea el ArrayList Arreglo vacío.
Un arrayList declarado así puede contener objetos de cualquier tipo.
Por ejemplo:
ArrayList a = new ArrayList();
Métodos de ArrayList
Algunos métodos que proporciona ArrayList son:
MÉTODO DESCRIPCIÓN
size() Devuelve el número de elementos (int)
add(X) Añade el objeto X al final. Devuelve true.
add(posición, X) Inserta el objeto X en la posición indicada.
get(posicion) Devuelve el elemento que está en la posición indicada.
remove(posicion) Elimina el elemento que se encuentra en la posición indicada.
Devuelve el elemento eliminado.
remove(X) Elimina la primera ocurrencia del objeto X. Devuelve true si el
elemento está en la lista.
clear() Elimina todos los elementos.
set(posición, X) Sustituye el elemento que se encuentra en la posición indicada
por el objeto X. Devuelve el elemento sustituido.
contains(X) Comprueba si la colección contiene al objeto X. Devuelve true
o false.
indexOf(X) Devuelve la posición del objeto X. Si no existe devuelve -1

Se pueden consultar todos en:

http://docs.oracle.com/javase/7/docs/api/java/util/ArrayList.html
Recorrer un ArrayList
Con un ciclo for
for(int i = 0;i<array.size();i++){
System.out.println(array.get(i));
}
Con un bucle foreach:
Si suponemos el array de enteros llamado numeros:
for(Integer i: numeros){
System.out.println(i);
}
Si el array contiene objetos de tipos distintos o desconocemos el tipo:
for(Object o: nombreArray){
System.out.println(o);
}
INTERFAZ ITERATOR
Un Iterator o Iterador es un patrón de diseño que nos ofrece una interfaz
estándar para recorrer una estructura de datos sin que nos tengamos que
preocupar por la representación interna de los datos de dicha estructura.
Esta forma de recorrer estructuras de datos ofrece muchas ventajas entre las
que podemos destacar que nuestro código no depende de la estructura de
datos.
Por lo tanto la “estructura” puede ser un árbol binario o una lista doblemente
enlazada ya que el iterador nos abstrae del modo de realizar el recorrido. De
este modo podemos sustituir de manera sencilla estructuras de datos en
nuestro código sin que se nos presenten problemas desagradables.
Este patrón lo podemos sustituir por un bucle for, que haría básicamente lo
mismo, pero la velocidad en la búsqueda es superior en el patrón iterator con
respecto al bucle for.
En Java tenemos reflejado el patrón Iterator en la clase java.util.Iterator que es
ampliamente utilizada en las conocidas Collections.
interface Iterator{
boolean hasNext(); /* Devuelve true si la iteración tiene mas
elementos */
Object next(); /* Devuelve el siguiente elemento de la
iteración
Lanza excepción NoSuchElementException */
void remove(); /* Elimina el último elemento devuelto por la
iteración
Está capacitado para decir que no lo implementa
UnsupportedOperationException */
Por ejemplo, recorrer un array de empleados:
Proyecto en Netbeans

Clase Empleado
package listaempleado;
public class Empleado {
String nom;
int nit;
String cargo;
int sueldo;
}
Programa Principal: ListaEmpleado
package listaempleado;
import java.util.*;
public class ListaEmpleado {
public static void main(String[] args) {
{
Scanner leer = new Scanner(System.in);
int op;
Empleado nodo=new Empleado();
ArrayList lista = new ArrayList();
do{
System.out.println( "Ingrese el nombre del Empleado" );
do
{
nodo.nom = leer.nextLine();
}
while(nodo.nom.length()<2);
System.out.println( "Ingrese el nit:" );
nodo.nit = leer.nextInt();
System.out.println( "Ingrese el cargo:" );
do
{
nodo.cargo = leer.nextLine();
}
while(nodo.cargo.length()<2);
System.out.println(nodo.cargo);
System.out.println( "Ingrese sueldo:" );
nodo.sueldo= leer.nextInt();
 lista.add("Nombre del alumno:\n"+nodo.nom);
lista.add("nit:\n"+nodo.nit);
lista.add("cargo:\n"+nodo.cargo);
lista.add("sueldo:\n"+nodo.sueldo);
System.out.println( "¿Desea ingresar otro Empleado?" );
System.out.println( "1.-Si\t 2.-No" );
op = leer.nextInt();
}
while(op != 2);
List lista2 = new ArrayList(lista);
Iterator it = lista2.iterator();
while (it.hasNext()){
System.out.println(it.next()+"");
}
}
}
}

Ejecución o F5
Clase Scanner
Analizador léxico simple. Se construye sobre algún tipo de fuente de
caracteres:
Scanner (String source) Scanner (Readable source) Scanner (Reader source)
Scanner (InputStream source) Scanner (File source)
Sobre la fuente de caracteres, va seleccionando lexemas (tokens) separados
por espacio en blanco. Proporciona los resultados por medio de una interface
Iterator:
String s ="Martes, 13 de septiembre de 2005, actualizado a las 16:16 h.";
Scanner scanner = new Scanner(s);
for (Iterator it = scanner; it.hasNext(); ) {
String token = (String) it.next();
System.out.println(token);
}
Martes,
13
de
septiembre
de
2005,
actualizado
a
las
16:16
h.
Además, ofrece una serie de métodos que, habiendo leído un token, lo
intentan interpretar como algún tipo primitivo de java:
int nextInt() double nextDouble() boolean nextBoolean()
byte nextByte() float nextFloat() short nextShort() long nextLong()
Dichos métodos intentan interpretar el token que toca leer, lanzando una
excepción si no puede:
· InputMismatchException si el token no responde al tipo deseado
· NoSuchElementException si no quedan más tokens
Es muy frecuente usar un Scanner para analizar la entrada de datos desde
consola:
Scanner scanner = new Scanner(System.in);
System.out.print("Escriba dos números: ");
double x = scanner.nextDouble();
double y = scanner.nextDouble();
System.out.println("producto: " + (x + y));
Escriba dos números: 3,1416 2
producto: 5.1416
Por último cabe mencionar el método
String nextLine() que retorna lo que queda por leer de la línea actual; es decir,
desde donde estemos hasta el primer fin de línea. Llamadas consecutivas a
nextLine() van proporcionando líneas sucesivas de texto.
Clase Vector
Permite crear un arreglo de Objetos que puede cambiar de tamaño (Dinámico)
Constructores:
Vector() crea un arreglo vacío
Vector(int initialCapacity) crea un arreglo con la capacidad dada por
initialCapacity
Métodos
addElement(Object)
Int indexOf(Objeto)
Int indexOf(Objeto,int pos)
Int lastIndexOf(Objeto)
Int lastIndexOf(Objeto,int pos)
Object elementAt(int index)
void setElementAt(object obj,
int index)
void setSize(in newSize)
int capacity()
int size()
copyInto(Object anArray[])
Object firstElement();
Object lastElement();
insertElementAt(Object obj,
int index);
boolean isEmpty();
void removeAllElements();
boolean
removeElement(Object obj);
void removeElementAt(int
index);
String toString();
void trimToSize();
Descripción
Adiciona un objeto
Busca un objeto dentro del vector. Retorna la
primera ocurrencia o sino -1 por inexistencia
Int pos:: indica desde que posición de
búsqueda
Busca un objeto dentro del vector. Retorna la
uúltima ocurrencia o sino -1 por inexistencia
Int pos:: indica desde que posición de
búsqueda
retorna el componente con el índice dado por
index
el elemento dado por el índice index es
igualado a obj
modifica el tamaño actual del vector, si
disminuye de tamaño los elementos por
encima del newSize son eliminados
retorna la capacidad actual
retorna el numero de componentes del vector
Copia el contenido de un arreglo de objetos en
el Vector
Retorna el primer elemento
Retorna el último elemento
Inserta un objeto a partir de la posición index
Retorna True si el vector esta vacio
Elimina todos los objetos del vector
Retorna True si elimino el Objeto obj del
vector de objetos
Elimina el Objeto de la posición index
Retorna el contenido del vector de objetos en
forma de cadena
Ajusta la capacidad del vector al tamaño o
número de elementos
Clase Arrays
Clase que permite hacer algunas operaciones sobre arreglos. Estas
operaciones son las siguientes:
binarySearch
equals
fill
sort
BinarySearch.- Permite buscar un valor en un arreglo ordenado
ascendentemente utilizando para ello el algoritmo de búsqueda binaria. Se ha
resaltado que el arreglo a de estar previamente ordenado para que funcione
apropiadamente el método, caso contrario puede obtenerse resultados
inesperados. Como se indicó antes se trata de un método sobrecargado para
los diferentes tipos de datos primitivos y para Object. Por ejemplo veamos el
método específico de double (los otros son practicamente iguales):
public static int binarySearch(double[] a, double key)
el método recibe el arreglo y el valor que se quiere buscar; este valor
obviamente siempre es del mismo tipo. Devuelve un entero que corresponde al
índice del elemento que coincide con el valor buscado
Ejemplo:
double[] c = {10, 20, 30, 40, 50};
int i;
i = Arrays.binarySearch(c, 30);
//devuelve i = 2
i = Arrays.binarySearch(c, 10);
// i = 0, recordando que el índice siempre empieza en 0
¿Qué pasa si no encuentra el valor?
Devuelve el valor que representa el punto de inserción con el signo - . Punto
de inserción es el punto donde, de acuerdo al orden, se esperaría que
estuviera ese valor. Utilizando el mismo arreglo c que hemos creado, veamos
algunas búsquedas:
i = Arrays.binarySearch(c, 25); // i = -2
i = Arrays.binarySearch(c, 45); //i = -4
equals.- Su nombre lo dice todo, sirve para indicarnos si dos matrices son
iguales. Dos matrices son iguales si tienen los mismos elementos y en el
mismo orden. También se consideran iguales si sus refencias valen null.
Devuelve un boolean: true si son iguales y false si no lo son.
Ejemplo:
char[] uno = {'j', 'a', 'v', 'a', 'm', 'a', 'n', 'i', 'a'};
char[] dos = {'j', 'a', 'v', 'a', 'm', 'a', 'n', 'i', 'a'};
System.out.println(Arrays.equals(uno, dos));
//imprimirá true
fill.- Sirve para asignar valores a varios elementos de una matriz.
Ejemplo:
double[] cambiarValores = {4, 5, 6, 4, 3, 6, 8};
Arrays.fill(cambiarValores, 0);
//todos los elementos de la matriz asumen el valor 0
Hay una forma de indicarle un rango para que se efectue el cambio de manera
en el mismo.
Tomando la declaración anterior de cambiarValores, tendriamos:
Arrays.fill(cambiarValores, int desde, int hasta, 0);
//El primer int indica el índice desde (incluido) y el segundo el índice hasta (no
incluido), el tercero es el valor utilizado para reemplazar.
El resultado es un array con los siguientes valores:
Arrays.fill(cambiarValores, 2, 5, 0);
{4, 5, 0, 0, 0, 6, 8}
sort.- Ordena los elementos de forma ascendente. Para ello internamente
utiliza un algoritmo muy eficiente conocido como quicksort. Ejemplo:
double[] ordenarArreglo = {4, 0, 3, 9, 7, 43, 64, 32, 45, 23, 2, 6};
Arrays.sort(ordenarArreglo);
También permite el ordenamiento de un rango. Igualmente el primer int indica
el índice desde (incluido) y el segundo el índice hasta (no incluido).
Arrays.sort(ordenarArreglo, 3, 5);
//ordena los elementos 4 y 5(no olvidar que comienza de 0)
Preguntas:
1. ¿Cómo ordena la clase Arrays objetos de tipo String?
2. ¿Cómo ordena la clase Arrays objetos genéricos Object?
Respuestas Anteriores:
1. Todas son válidas. El problema se soluciona entendiendo 2 cosas. En primer
lugar, que se pueden repartir los corchetes (para cada arreglo anidado) entre el
tipo de dato y el nombre de la variable de tal manera que todas las siguientes
expresiones son equivalentes:
int myInt[][][] ...
int[] myInt[][] ...
int[][] myInt[] ...
int[][][] myInt ... //etc.
En segundo lugar, algo visto en el primer post sobre este tema que se puede
asignar directamente los valores encerrandolo entre llaves o bien utilizando el
operador new, el tipo, los corchetes vacíos y los valores entre llaves (remitirse
a la Cuarta y Quinta forma de crear arreglos, el mensaje Arreglos). En un
arreglo de arreglos, se pueden combinar indistintamente estas formas.
//***********
Finalmente solo indicar que los arrays son una forma muy eficiente de
manipular estructuras lineales de datos cuando el tamaño no varía (o por lo
menos se tiene un máximo posible razonablemente estable, por lo cual puede
crearse el array de este tamaño) y no hay (o hay muy pocas) modificación (nes)
en el orden de los elementos. El acceso a una posición determinada es muy
rápida comparativamente hablando, pues "se salta" a la posición de memoria
(del dato primitivo o la referenncia en caso de objetos). Debe preferirse esta
estructura a otras como ArrayList cuando las condiciones anteriores se
cumplan (lo cual implica ausencia de inserciones o borrados de elementos),
pues lo contario supondría un despedicio de recursos
Ejemplo:
import java.util.*;
public class Arreglo1
{
int []a;
Arreglo1 ()
{
a=new int [10];
}
void cargar()
{
for(int i=0;i<a.length;++i)
a[i]=(int)(Math.random()*100);
}
void mostrar()
{
String s= "Vector:";
for(int i=0;i<a.length;++i)
s+=" "+a[i];
System.out.println(s);
}
public static void main(String[]args)
{
Arreglo1 m=new Arreglo1();
//m.crear();
m.cargar();
m.mostrar();
Arrays.sort(m.a);
m.mostrar();
System.exit(0);
}//Cierro main
}// Cierro
Clase Stack
Permite crear un arreglo de Objetos (Pila) que puede cambiar de tamaño
(Dinámico) cuya administración es LIFO (Ultima en Entrar primera en salir)
Constructores:
Stack() crea una Pila de Objetos Vacía
Métodos Descripción
push(Object) Adiciona un objeto ( Apila)
int search(Objeto) Busca un objeto dentro del vector. Retorna la
posición del mismo o sino -1 por inexistencia
boolean empty(); Retorna True si el vector esta vacio
Object pop(); Retorna y saca el último Objeto ingresado
(Desempila)
Object peek(); Retorna el último objeto ingresado ( Tope)
push(A) push(B) push(C) pop() == C
pop()==B pop()==A empty()==True

Apila Apila Apila Desempila Desempila

C
B B
A A A B A
A
Una aplicación de la clases: StringTokenizer, Vector y Stack
Se requiere crear una clase denominada HashVector donde:
Existe una cadena donde los nombres y códigos están separados por una
coma (,)
Se deben crear dos vectores: uno para códigos y otro para nombres
Dada una cadena de código buscar en el vector de códigos, si existe llevar el
código a una pila de hallados y sino a una pila de no hallados
Listar la pila de hallados y no hallados.
Proyecto en Netbeans
Programa: HashVector
package simulahash;
import java.util.*;
class HashVector {
String A="10,Juana,25,Diego,3,Danna,8,Sofia,20,Maria,13,Sandra,25,Maria";
StringTokenizer T=new StringTokenizer(A.toString(),",");
Stack Hallado=new Stack();
Stack NoHallado=new Stack();
Vector Codigo=new Vector();
Vector Nombre=new Vector();
public HashVector() {
boolean estado=true;
while(T.hasMoreTokens()) {
if(estado)
Codigo.addElement(T.nextElement());
else
Nombre.addElement(T.nextElement());
estado=!estado;
}
}
void buscar(String Cod)
{
if(Codigo.contains(Cod))
{
if(Hallado.search(Cod)==-1)
Hallado.push(Cod);
}
else
{
if(NoHallado.search(Cod)==-1)
NoHallado.push(Cod);
}
}
String listar()
{
StringBuffer B=new StringBuffer("Codigos Encontrados \n");
while(!Hallado.empty())
{
B.append(Hallado.pop());
B.append("\n");
}
B.append("Codigos No Encontrados \n");
while(!NoHallado.empty())
{
B.append(NoHallado.pop());
B.append("\n");
}
return B.toString();
}
}
Programa: SimulaHash
package simulahash;
import javax.swing.*;
public class SimulaHash
{
public static void main(String args[])
{
HashVector H=new HashVector();
String S;
int i,n;
for(i=1;i<=7;i++)
{
do
{
S=JOptionPane.showInputDialog(null," Digite Codigo (Solo Numero): ");
n=Integer.parseInt(S);
}
while(n==0);
H.buscar(S);
}
JOptionPane.showMessageDialog(null,H.listar().toString());
System.exit(0);
}
}

Ejecución o F5
La Clase Random
La clase Random es un generador de números pseudo-aleatorios ya que
genera secuencias distribuidas uniformemente.
Constructores:
Random() Random(long semilla)
El primer constructor crea un generador de números que utiliza la hora actual
como semilla inicial. El segundo, permite especificar el valor de la semilla.
Métodos
Método Descripción
double nextDouble() Devuelve el siguiente número aleatorio double.
float nextFloat() Devuelve el siguiente número aleatorio flota.
double nextGaussian() Devuelve el siguiente número aleatorio gaussiano.
int nextInt() Devuelve el siguiente número aleatorio int.
long nextLong() Devuelve el siguiente número aleatorio long.
Establece una semilla, es decir, el punto de inicio
void setSeed(long semilla)
del generador de números aleatorios.
El siguiente programa obtiene 100 valores aleatorios y calcula la media. El
programa también cuanta el número de valores comprendidos dentro de una
desviación estándar utilizando incrementos de 0,5 para cada categoría.
import java.util.*;
public class RandDemos {
public static void main(String args[]) {
Random r = new Random();
double val;
double sum = 0;
int campana[] = new int[10];
for (int i=0; i < 100; i++) {
val = r.nextGaussian();
sum += val;
double t = -2;
for (int x=0; x < 10; x++, t += 0.5)
if (val < t) {
campana[x]++;
break;
}
}
System.out.println("Media de los valores: " + (sum/100));
// Visualizar la campana de Gauss
for (int i=0; i < 10; i++) {
for (int x=campana[i]; x > 0; x--)
System.out.println("*");
System.out.println();
}
}
}
La Clase Hashtable
La Clase Hashtable implementa un mecanismo de almacenaje de tabla
Hashing para almacenar pares de clave y valor.
Las tablas Hashing están diseñadas para localizar y recuperar rápidamente
información almacenada, usando una clave.
Constructores:
Hashtable: Construye un HashTable Vacia
Hashtable(int): Construye un Hashtable con capacidad int
Métodos
Método Descripción
Borra todos los elementos de la
clear()
Hashtable
contains(Objeto)
True si el objeto está en la tabla

clone() Crea un igual

Devuelve true si la tabla está vacía y false
Boolean isEmpty()
si contiene al menos una clave.
Devuelve una enumeración de la claves
Enumeration keys()
contenidas la tabla
True si la tabla contiene la clave indicada
containsKey(Objeto)

Almacena una clave y su valor en el

Object put(Object clave, Object
valor)
Object remove(Object clave)
get(Objeto)
diccionario. Devuelve null si la clave no
estaba ya en el diccionario, o el valor
anterior que tenía asociado si la clave ya
estaba en el diccionario.
Elimina la clave y su valor. Devuelve el
valor asociado a la clave. Si la clave no
está en la tabla, devuelve un objeto nulo.
Devuelve el objeto asociado con la clave
dada
El siguiente ejemplo utiliza la clase Hashtable, creando una lista de claves
(generando aleatoriamente) asociadas con nombres que se encuentran en un
vector tipo String. Además, se verifica que la clave sea única para poder
adicionar a la tabla mediante el método put. El public class crea un objeto Tabla
y se verifica la existencia de un código en la tabla.
Proyecto en Netbeans

Programa: Tabla
package demotablahash;
import java.util.*;
import javax.swing.*;
class Tabla
{
String lista="Juan Pedro Tomas Sebastian Juana Ines";
StringTokenizer cadena=new StringTokenizer(lista);
int numero=cadena.countTokens();
Hashtable ht=new Hashtable(numero*2);
Random r=new Random();
int n;
public Tabla()
{
while(cadena.hasMoreTokens())
{
do
{
n=Math.abs(r.nextInt()%20+1);
}
while(ht.containsKey(new String().valueOf(n).toString()));
ht.put(new String().valueOf(n).toString(),cadena.nextToken());
}
JOptionPane.showMessageDialog (null, "Las claves: "+ht.toString());
}
void buscar(String llave)
{
if(ht.containsKey(llave))
JOptionPane.showMessageDialog (null,llave+" = "+ht.get(llave));
else
JOptionPane.showMessageDialog (null, "No existe la clave");
}
}
Programa: DemoTablaHash
package demotablahash;
import javax.swing.*;
public class DemoTablaHash
{
public static void main(String Args[])
{
Tabla A=new Tabla();
String S;
S=JOptionPane.showInputDialog (null,"Digite la Llave: ");
A.buscar(S);
}
}

Ejecución o F5
 La Clase Dictionary
Dictionary es una clase abstracta que representa un depósito para almacenar
claves/valor. Una clave es un nombre que se utiliza posteriormente para
recuperar un valor. Dada una clave y un valor, se puede almacenar el valor en
un objeto Dictionary. Una vez almacenado el valor, se puede recuperar
utilizando su clave.
Métodos Clase Dictionary
Método Descripción
Devuelve una enumeración de los valores contenidos
Enumeration elements()
en el diccionario.
Devuelve el objeto que contiene el valor asociado con la
Object get(Object clave) clave. Si la clave no está en el diccionario, devuelve un
objeto nulo.
Devuelve true si el diccionario está vacío y false si
Boolean isEmpty()
contiene al menos una clave.
Devuelve una enumeración de las claves Contenidas en
Enumeration keys()
el diccionario.
Almacena una clave y su valor en el diccionario.
Object put(Object clave, Devuelve null si la clave no estaba ya en el diccionario,
Object valor) o el valor anterior que tenía asociado si la clave ya
estaba en el diccionario.
Elimina la clave y su valor. Devuelve el valor asociado a
Object remove(Object
la clave. Si la clave no está en el diccionario, devuelve
clave)
un objeto nulo.
Devuelve el número de parejas clave/valor de
int size()
diccionario.
Dictionary es una superclase de la clase Hashtable (tabla hash). Además, se
puede utilizar como superclase de cualquier clase que utilice una relación
clave/valor, pero será necesario implementar todos los métodos definidos por
Dictionary.
 La Clase Properties
La clase Properties es una subclase de Hashtable que se utiliza para mantener
listas de valores en las que la clave es una cadena y el valor también es un
objeto String. La clase Properties es utilizada por otras clases de Java.
Constructores:
Properties()
Properties(Properties propDefecto)
El primer constructor crea un objeto Properties que no tiene valores por
defecto. El segundo crea un objeto que utiliza propDefecto para sus valores por
defecto. En ambos casos, la lista está vacía.
Métodos Clase Properties
Método Descripción
Devuelve el valor asociado a la clave. Devuelve
String getProperty(String clave) el objeto null si la clave no está en la lista ni en
la lista de propiedades por defecto.
Devuelve el valor asociado a la clave. Devuelve
String getProperty(String clave,
propDefecto si la clave no está en la lista ni en la
String propDefecto)
lista de propiedades por defecto.
Envía la lista de propiedades al flujo de salida
void list(PrintStream flujoSalida)
asociado a flujoSalida.
void load(InputStream Introduce una lista de propiedades del flujo de
flujoEntrada) throws IOException entrada asociado a flujoEntrada.
Devuelve la enumeración de las clasves. Aquí
Enumeration propertyNames() se incluyen las claves encontradas en la lista de
propiedades por defecto.
Después de escribir la cadena especificada por
void save(OutputStream
descripción, escribe la lista de propiedades en el
flujoSalida, String descripción)
flujo de salida asociado a flujoSalida.
El siguiente ejemplo utiliza la clase Properties, creando una lista de
propiedades en la que las claves son nombres de Departamentos Colombianos
y los valores son los nombres de sus capitales. Además, se especifica una lista
de propiedades por defecto cuando se construye un objeto
Properties(Departamento,Capital).
import java.util.*;
public class DemoPropiedad {
public static void main(String args[]) {
Properties defList = new Properties();
defList.put("Cundinamarca", "Bogota");
defList.put("Bogota", "Bogota");
Properties ciudades = new Properties(defList);
Enumeration comunidades;
String str;
ciudades.put("Valle","Cali");
ciudades.put("Antioquia","Medellin");
ciudades.put("Atlantico","Barranquilla");
ciudades.put("Bolivar","Cartagena");
comunidades = ciudades.keys();
while (comunidades.hasMoreElements()) {
str = (String) comunidades.nextElement();
System.out.println("Capital de " + str + " es " +
ciudades.getProperty(str));
}
System.out.println();
// Ahora encontrará Bogota en la lista por defecto.
str = ciudades.getProperty("Cundinamarca");
System.out.println("La ciudad de Cundinamarca: "+ str);
}
}
La Clase Date
La clase Date representa una fecha y hora.
Constructores:
Date()
Date(int año, int mes, int dia)
Date(int año, int mes, int dia, int horas, int minutos)
Date(int año, int mes, int dia, int horas, int minutos, int segundos)
Date(long milisegundos)
Date(String fecha)
Estos tres constructores establecen el día, mes y año. El parámetro año
especifica el número de años que han transcurrido desde 1900; mes establece
el mes del año, comenzado en 0 para Enero. El penúltimo constructor permite
construir un objeto Date especificando el número de milisegundos transcurridos
desde el 1 de Enero de 1970. El último, permite establecer la fecha utilizando
una cadena que contenga dicha fecha. Por ejemplo, new Date("Thu Feb 15
1999 22:24:24") construirá un objeto con la fecha y hora especificada.
La clase Date define los métodos que se muestran en la siguiente tabla. Hay
varios métodos que permiten establecer y obtener la fecha y la hora. No se
puede establecer el día de la semana, ya que depende del día del mes.
Métodos Clase Date
Método Descripción
Devuelve true si el objeto Date contiene
una fecha que es posterior a la fecha
boolean after(Date fecha)
especificada. En caso contrario, devuelve
false.
Devuelve true si el objeto Date contiene
una fecha que es anterior a la fecha
boolean before(Date fecha)
especificada. En caso contrario, devuelve
false.
Devuelve true si el objeto Date contiene
la misma fecha y hora que la fecha
boolean equals(Object fecha)
especificada. En caso contrario, devuelve
false.
Devuelve el día del mes, que será un
int getDate()
valor comprendido entre 1 y 31.
Devuelve el día de la semana en forma
de entero, correspondiendo el valor 0 al
int getDay()
Domingo, el 1 al Lunes y así
sucesivamente.
Devuelve la hora. Las horas se
int getHours() representan en función de un reloj de 24
horas.
Convierte una cadena que contiene una
fecha y hora en el número de
static long parse(String str) milisegundos que han transcurrido desde
el 1 de Enero de 1900. Devuelve el
número de milisegundos transcurridos.
 Método Descripción
Establece como el día del mes el valor
void setDate(int dia)
especificado por día.
Establece la hora con el valor
void setHours(int hoas) especificado. Para ello, se utiliza un reloj
de 24 horas.
Establece el año especificando el
número de milisegundos que han
void setYear(int año)
transcurrido desde el 1 de Enero de
1900.
Convierte el objeto Date en una cadena y
String toLocaleString() devuelve el resultado. La hora y la fecha
son locales.
Convierte el objeto Date en una cadena y
String toString()
devuelve el resultado.
Al igual que getDate(), getDay() y getHours() define los métodos: getMinutes(),
getMonth(), getSeconds() y getTime().
Comparación de fechas
Hay dos formas de comparar dos objetos Date. La primera es utilizar el método
getTime() en los dos objetos para obtener el número de milisegundos que han
transcurrido desde el 1 de enero de 1970 y comparar estos dos valores. Sin
embargo, hay una forma más sencilla que consiste en utilizar los métodos
before(), after() y equals().
Por ejemplo, como el día 12 del mes es anterior al 18, new
Date(99,2,12).before(new Date(99,2,18)) devuelve true.
Cadenas y zonas horarias
Los objetos Date se pueden convertir en cadenas de varias formas. El método
toString() convierte un objeto Date en una cadena como ésta: "Thu Feb 15
22:40:02 2001". El método toLocaleString() convierte un objeto Date en una
cadena más corta como ésta: "02/15/99 22:30:02".
Por último, el método toGMTString() convierte un objeto Date en un formato de
hora del meridiano de Greenwich como éste: "14 Feb 1976 20:00:30 GMT".
Para determinar la diferencia entre la zona horaria local y GMT se utiliza el
método getTimezoneOffset(), que devuelve la diferencia en minutos.
A continuación se muestra un breve programa que utiliza estos métodos:
import java.util.Date;
public class FormatoFechas {
public static void main(String args[]) {
Date curDate = new Date();
// Muestra la fecha y hora utilizando toString()
System.out.println("Formato por defecto: " + curDate);
System.out.println("Fecha y hora local: " + curDate.toLocaleString());
System.out.println("Fecha y hora GMT " + curDate.toGMTString());
System.out.println("Diferencia de la zona horaria:: " +
curDate.getTimezoneOffset());
}
}
La salida generada por este programa es similar a la siguiente:

APLICACIÓN DE INVENTARIO
El siguiente integra las clases StringBuffer, StringTokenizer, Hashtable.
Proyecto en Netbeans

Programa: InventarioUtil
package kardexutil;
import java.util.*;
import javax.swing.*;
class InventarioUtil {
int i,j,k;
final int n=10;
String Cod="33,55,28";
String Nom="Pino,Cedro,Guayacan";
String Cant="33,18,25";
Hashtable H1=new Hashtable();
Hashtable H2=new Hashtable();
int A[][]=new int[n][4];
Random R=new Random();
public InventarioUtil()
{
String S;
StringTokenizer T1=new StringTokenizer(Cod.toString (),",");
StringTokenizer T2=new StringTokenizer(Nom.toString(),",");
StringTokenizer T3=new StringTokenizer(Cant.toString(),",");
while(T1.hasMoreTokens() && T2.hasMoreTokens () && T3.hasMoreTokens())
{
S=T1.nextToken();
H1.put(S,T2.nextToken());
H2.put(S,T3.nextToken());
}
}
 boolean existe(int x)
{
return H1.containsKey(new String().valueOf(x));
}
void venta(int x,int cant)
{
int k=Integer.parseInt((String) H2.get(new String().valueOf(x)));
if(k>=cant)
{
H2.remove(new String().valueOf(x));
k=k-cant;
H2.put(new String().valueOf(x),new String().valueOf(k));
}
else
JOptionPane.showMessageDialog(null,"No se puede realizar la venta...no
hay existencia");
}
void compra(int x,int cant)
{
int k=Integer.parseInt((String) H2.get(new String().valueOf(x)));
H2.remove(new String().valueOf(x));
k=k+cant;
H2.put(new String().valueOf(x),new String().valueOf(k));
}
String impresion()
{
StringBuffer P=new StringBuffer(" CODIGO NOMBRE SALDO");
Enumeration claves=H1.keys();
String S;
while (claves.hasMoreElements())
{
S=(String) claves.nextElement ();
P.append("\n");
P.append(S);
P.append(" ");
P.append(H1.get(S));
P.append(" ");
P.append(H2.get(S));
}
return P.toString();
}
}
Programa: KardexUtil
package kardexutil;
import javax.swing.*;
public class KardexUtil{
public static void main(String[] args){
InventarioUtil X=new InventarioUtil();
Object[] Opcion={"1. Compra","2. Venta","3. Consulta","4.Cierre"};
int opc,cod=0;
String S;
do
{
S=(String) JOptionPane.showInputDialog(null,"Opciones: "," Almacen
Doris",JOptionPane.QUESTION_MESSAGE,null,Opcion,Opcion[2]);
opc=Character.digit (S.charAt(0),10);
switch(opc)
{
case 1:
cod=Integer.parseInt(JOptionPane.showInputDialog(null," Digite Codigo "));
if(!X.existe(cod))
JOptionPane.showMessageDialog (null,"No existe Codigo");
else
X.compra(cod,Integer.parseInt(JOptionPane.showInputDialog(null," Digite
Cantidad a Comprar ")));
break;
case 2:
cod= Integer.parseInt(JOptionPane.showInputDialog(null," Digite Codigo "));
if(!X.existe(cod))
JOptionPane.showMessageDialog(null,"No existe Codigo");
else
X.venta(cod,Integer.parseInt(JOptionPane.showInputDialog(null," Digite
Cantidad a Venta ")));
break;
case 3:
JOptionPane.showMessageDialog(null," Inventario
\n"+X.impresion().toString());
}
}while(opc!=4);
System.exit(0);
}
}

Ejecución o F5
APLICACIÓN DE PAISES
El siguiente integra las clases StringTokenizer, Hashtable E Interfaz
Enumeration:
Proyecto en Netbeans

Programa: Paises
package paises;
import java.util.*;
import javax.swing.*;
public class Paises
{
public static void main(String args[])
{
String Pais="Colombia,Peru,Chile,Venezuela,Bolivia";
String Ciudad="Bogota,Lima,Santiago,Caracas,La Paz";
String Poblacion="45000000,20000000,15000000,25000000,10000000";
Hashtable ciudades=new Hashtable();
Hashtable gente=new Hashtable();
StringTokenizer T1=new StringTokenizer(Pais.toString(),",");
StringTokenizer T2=new StringTokenizer(Ciudad.toString(),",");
StringTokenizer T3=new StringTokenizer(Poblacion.toString(),",");
Object Menu[]=new Object[T1.countTokens()];
String S;
while(T1.hasMoreTokens() && T2.hasMoreTokens() && T2.hasMoreTokens())
{
S=T1.nextToken().toUpperCase();
ciudades.put(S,T2.nextToken().toUpperCase());
gente.put(S,T3.nextToken().toUpperCase());
}
Enumeration comunidad=ciudades.keys();
int opc=-1;
while(comunidad.hasMoreElements())
{
opc++;
Menu[opc]=comunidad.nextElement();
}
Object[] Opcion={"1. Capital","2. Poblacion","3.Cierre"};
do
{
S=(String) JOptionPane.showInputDialog(null,"Opciones: "," Almacen
Doris",JOptionPane.QUESTION_MESSAGE,null,Opcion,Opcion[0]);
opc=Character.digit (S.charAt(0),10);
if(opc!=3)
{
S=(String) JOptionPane.showInputDialog(null,"Paises: "," O N
U",JOptionPane.QUESTION_MESSAGE,null,Menu,Menu[0]);
switch(opc)
{
case 1:
JOptionPane.showMessageDialog(null,"Pais: "+S.toString()+" Capital:
"+ciudades.get(S).toString());
break;
case 2:
JOptionPane.showMessageDialog(null,"Pais: "+S.toString()+"
Poblacion: "+gente.get(S).toString());
break;
}
}
}
while(opc!=3);
}
}

Ejecución o F5