- Introducción
A medida que vayas programando en Java te darás cuenta de que existe una gran cantidad de clases que resuelven muchos de los problemas que se te pueden presentar.
Conocer la existencia de estas clases y su funcionalidad te ayudará a desarrollar rápidamente tus propias aplicaciones.
En este capítulo se presentan algunas clases útiles que rápidamente incorporarás en tus aplicaciones, en particular vamos a estudiar los tipos genéricos, introducidos en Java SE5.
- Envolturas
- Colecciones. Genéricos.
- Sin genéricos:
- Con genéricos:
- Strings
- StringBuffer
- StringBuilder
-
Funcionalidad muy parecida a StringBuffer pero no es Thread safe.
- Matemáticas
- Métodos de la clase java.lang.Math
- Métodos de la clase java.util.Random
- Entrada desde teclado
- Resumen
- Envolturas.
- Colecciones y Genéricos.
- Cadenas de caracteres.
- Matemáticas..
En Java existen dos tipos de datos: los tipos primitivos y los tipos referencia.
La colecciones sólo pueden almacenar referencias.
Entonces, ¿Cómo podemos utilizar las colecciones con los tipos primitivos?
| Tipo base primitivo | Envoltura |
| void | java.lang.Void |
| boolean | java.lang.Boolean |
| char | java.lang.Character |
| byte | java.lang.Byte |
| short | java.lang.Short |
| int | java.lang.Integer |
| long | java.lang.Long |
| float | java.lang.Float |
| double | java.lang.Double |
Siempre es posible recuperar un tipo base a partir de su envoltura:
Integer envolturaEntero = new Integer(15);
Float envolturaReal = new Float(15.5f);
int entero = envolturaEntero.intValue();
float real = envolturaFloat.floatValue();
Por otro lado, se pueden conseguir tipos numéricos primitivos a partir de String:
String stringEntero = “505”;
String stringReal = “1.234”;
int entero = Integer.parseInt(stringEntero);
float real = Float.parseFloat(stringReal);
Muy útil al procesar los parámetros de entrada de la función main.
Las colecciones son contenedores de objetos, como por ejemplo vectores, tablas de dispersión, listas,...
| Interface | Implementación |
| Set | HashSet |
| SortedSet | TreeSet |
| List | ArrayList, LinkedList, Vector |
| Map | HashMap, HashTable |
| SortedMap | TreeMap |
Interface Collection
public boolean add(Object o)
public boolean remove(Object o)
public boolean contains(Object o)
public int size()
public boolean isEmpty()
public Iterator iterator()
public Object[] toArray()
public Object[] toArray(Object[] a)
public void add(int posicion, Object o)
public void remove(int posicion)
public Object get(int posicion)
public void set(int posicion, Object o)
public class A { //Aunque no es indique explícitamente, esta clase es hija de "Object"
protected int a = 0;
public A() {};
public A(int a) { this.a = a; }
public void getA() {
System.out.println("Clase A, valor: "+a);
}
}
class B extends A { //Y por lo tanto esta también
public B() { super(0); }
public B(int a) { super(a); }
public void getA() {
System.out.println("Clase B, valor:"+a);
}
}
public static void main(String args[]) { //¿Qué imprime?
public static void main(String args[]) {
ArrayList al = new ArrayList(); //Clase A, valor: 0
for(int i = 0; i < 10; i += 2) //Clase A, valor: 2
al.add(new A(i));//Objetos de tipo A //Clase A, valor: 4
for(int i = 1; i < 10; i += 2) //Clase A, valor: 6
al.add(new B(i));//Objetos de tipo B //Clase A, valor: 8
A a = null; //Clase B, valor: 1
Iterator it = al.iterator(); //Clase B, valor: 3
while(it.hasNext() == true) { //Clase B, valor: 5
a = (A)it.next(); //Objetos de tipo Object //Clase B, valor: 7
a.getA(); //Clase B, valor: 9
}
}
public class A {
private int a;
public A(int a) {this.a = a;}
public void print() {
System.out.println("Soy A y mi valor es: "+a);
}
}
public class B {
private int b;
public B(int b) {this.b = b;}
public void print() {
System.out.println("Soy B y mi
valor es: "+b);
}
}
public static void main(String args[]) {
ArrayList al = new ArrayList();
for(int i = 0; i < i =" 5;" it =" al.iterator();" obj =" it.next();">
public static void main(String args[]) { //Ahora Compila!!!
ArrayList al = new ArrayList(); //Soy A y mi valor es : 0
for(int i = 0; i < i =" 5;" it =" al.iterator();"> Error en tiempo
A a; //de ejecución en "a=(A)it.next()"
while(it.hasNext()) {
a = (A)it.next();
a.print();
}
}¿Cómo solucionarlo?
//Solucionado!!
public static void main(String args[]) {
ArrayList al = new ArrayList();
for(int i = 0; i < i =" 5;" it =" al.iterator();" ob =" it.next();" a =" (A)ob;" b =" (B)ob;">Solución utilizando Interfaces
public class A implements Imprime {
private int a;
public A(int a) {
this.a = a;
}
public void print() {
System.out.println("Soy A y mi valor es: "+a);
}
}
public interface Imprime {
public void print();
}
public class B implement Imprime {
private int b;
public B(int b) {
this.b = b;
}
public void print() {
System.out.println("Soy B y mi valor es: "+b);
}
}
public static void main(String args[]) {
ArrayList al = new ArrayList();
for(int i = 0; i < 5; i++)
al.add(new A(i));
for(int i = 5; i < 10; i++)
al.add(new B(i));
Iterator it = al.iterator();
Imprime imp;
while(it.hasNext()) {
imp = (Imprime) it.next();
imp.print();
}
}
//SOLUCIONADO!!Desde la versión del lenguaje SE%, se han introducido los tipos de datos genéricos, similares a los tipos de datos bastracto en C++
ArrayListal = new ArrayList ();
al.add(1); // Se crea un Integer con «1».
int i = al.get(0); // A partir de Integer se obtiene un intSe hace conversión entre tipos primitivos y envolturas:
int <--> Integer
float <--> Float
boolean <--> Boolean
...También se ha introducido una nueva estructura de control, el bucle for-each, con una sintaxis compacta.
ArrayList al = new ArrayList();
for(int i = 0; i < 10; i++)
al.add(new Integer(i));
for(int i = 0; i < 10; i++)
System.out.println(((Integer)al.get(i)).intValue);
ArrayList<Integer> al = new ArrayList<Integer>();
for(int i = 0; i < 10; i++)
al.add(i); // Conversión int --> Integer
for(Integer i: al) // Bucle for-each
System.out.println(i); // Conversión Integer --> int
Además los genéricos evitan errores que antes sólo se detectarían en tiempo de ejecución: Antes de JAVA SE5
ArrayList al = new ArrayList();
al.add(new Integer(1));
al.add(new Float(1.2));
Iterator it = al.iterator();
while(it.hasNext())
Integer i = (Integer)it.next(); // Error en ejecución,
//2º elemento Float
ArrayList<Integer> al = new ArrayList<Integer>();
al.add(new Integer(1));
al.add(new Float(1.2)); // Error en compilación.
Los Strings almacenan cadenas de caracteres que NO se pueden modificar.
String unaCadena = “Nombre “;
String otraCadena = “Apellidos”;
unaCadena = unaCadena + otraCadena; //El objeto String que contenía "Nombre" se pierde, y se crea
// otro con el contenido "Nombre Apellidos" que es referenciado por "unCadena"
Existe una gran cantidad de constructores para los Strings:
String cadena = "Esto es una cadena.";
char letras[]={"a", "b", "c"};
String otraCadena = new String(letras);
String pi = String.valueOf(3.141592);
Y muchos métodos de utilidad
public boolean equals(Object o)
public int length()
public String toLowerCase()
public String toUpperCase()
public String[] split(String s)
String cadena = “Esto es una cadena”;
String palabras[] = cadena.split(“ “);
palabras[] = {“Esto”, “es”, “una”, “cadena”};
Esta clase se comporta como un String pero se puede modificar. Es Thread safe
public static [double|float|etc] abs(double|float|etc)
public static double sin(double a)
public static double cos(double a)
public static double tan(double a)
public static double log(double a)
public static double sqrt(double a)
public static double pow(double a, double b)
public static double asin(double a)
public static double acos(double a)
public static double atan(double a)
//Como se puede apreciar todos son "static"
public boolean nextBoolean()
public float nextFloat()
public int nextInt()
public int nextInt(int n)
public long nextLong()
public double nextDouble()
public double nextGaussian()
La clase java.util.Scanner es una potente clase para leer datos desde streams de entrada, por ejemplo el teclado:
Scanner escaner = new Scanner(System.in);
escaner.useDelimiter(“\\n”);
String cadena = escaner.next();
int entero = escaner.nextInt();
A medida que vayas conociendo más clases Java disminuirás el tiempo de codificación.
En esta sesión se han presentado clases de uso inmediato en tus aplicaciones:
