Introduccion a la programación y la informática, Universitat Politècnica de València.

1. Tema 6. Algunas clases predefinidas:
String, Math, clases envoltorio
Introducción a la Informática y la Programación (IIP)
Curso 2011/12
Departamento de Sistemas Informáticos y Computación

2. Contenidos
1. Introducción
2. La clase String
3. La clase Math
4. Clases envoltorio
26/10/2011 IIP ‐ Curs 2011/12 2

3. Introducción
Java contiene muchas clases predefinidas mediante las cuales se puede
trabajar con problemas muy variados, como son: de computación numérica,
representación gráfica, entrada y salida, ejecución paralela, conexiones
remotas, etc.
 Las clases String y Math permiten, respectivamente, operar con cadenas de
caracteres y realizar cálculos matemáticos avanzados.
 Las clases envoltorio ofrecen funcionalidades adicionales para operar con
valores elementales después de su transformación en objetos.
Todas estas clases forman parte del paquete java.lang, que se importa por
defecto, siendo accesibles sus elementos públicos desde cualquier clase que
los use.
26/10/2011 3IIP ‐ Curs 2011/12

4. La clase String
• La clase String es una clase predefinida (dentro del paquete java.lang)
mediante la cual se pueden manipular cadenas de caracteres.
Referencia: http://download.oracle.com/javase/6/docs/api/java/lang/String.html
• Sus objetos se pueden construir de diferentes formas, pero cualquier grupo
de caracteres entre comillas dobles es una referencia a un objeto de ese tipo.
Por ejemplo:
26/10/2011 4IIP ‐ Curs 2011/12
String st1 = “Esto es un ejemplo de String”;
String st2 = new String(“Esto es un ejemplo de String”);
String st3 = “”;
String st4 = new String();

5. La clase String
• Los String son inmutables, es decir, una vez inicializados no es posible alterar
su contenido (añadiendo, eliminando o cambiando caracteres).
• La concatenación (añadir una String después de otra, creando una nueva) es
la operación de uso más habitual para generar nuevas String a partir de
otras. El operador de concatenación es el "+", pudiéndose emplear el
operador "+= ".
26/10/2011 5IIP ‐ Curs 2011/12
String exp1 = “ejemplo1";
String exp2 = “Ejemplo2";
String exp3 = exp1 + exp2; // exp3 referencia a "ejemplo1Ejemplo2"
exp2 += exp1; // exp2 referencia a "Ejemplo2ejemplo1"
"ejemplo1"
"Ejemplo2"
"ejemplo1Ejemplo2"
"Ejemplo2ejemplo1"
Memoria
Montículo
exp1
exp2
exp3

6. La clase String. Comparaciones
• Los operadores "==" y "!=" comparan referencias, no los objetos String que
representan.
• Los operadores relacionales ">", ">=", "<", "<=" no están definidos y no se
pueden usar para comparar valores String.
• Para la comparación de igualdad se usa el método equals(Object), así:
• Para comparación de orden se usa el métode compareTo(String).
La comparación de cadenas se basa en el orden lexicográfico. Es decir, las
cadenas se comparan entre si como en un diccionario, pero teniendo en
cuenta su código.
26/10/2011 6IIP ‐ Curs 2011/12
boolean b = st1.equals(st2);
// b es true sii st1 i st2 tienen exactamente los mismos caracteres.
int i = st1.compareTo(st2); // dónde el entero i es:
// menor que 0 sii st1 es anterior a st2.
// major que 0 sii st1 es posterior a st2.
// igual a 0 sii st1 es igual carácter a carácter a st2.

7. La clase String. Comparaciones
Ejemplos:
26/10/2011 7IIP ‐ Curs 2011/12
String s1 = "Hola", s2 = "Hello", s3;
boolean iguales;
iguales = s1 == s2; // iguales == false
iguales = s1.equals(s2); // iguales == false
s3 = s1;
iguales = s3 == s1; // iguales == true
iguales = s3.equals(s1); // iguales == true
int comp1 = s3.compareTo(s1); // comp1 == 0
int comp2 = s3.compareTo(s2); // comp2 > 0
int comp3 = s2.compareTo(s3); // comp3 < 0

8. La clase String. Métodes relevantes
26/10/2011 IIP ‐ Curs 2011/12 8
Método Significado
length() Devuelve la longitud (número de caracteres) de la cadena.
trim() Devuelve la cadena eliminando los espacios en blanco al principio y
al final.
charAt(n) Devuelve el carácter que está en la posición n.
substring(ini,fi)
substring(ini)
Devuelve la subcadena comprendida entre las posiciones ini i fi‐1.
Sin fi, devuelve hasta el final de la cadena.
toUpperCase() Devuelve la cadena con las minúsculas convertidas a mayúsculas.
toLowerCase() Devuelve la cadena con las mayúsculas convertidas a minúsculas.
indexOf(cad) Devuelve la posición de la primera aparición de cad en la cadena o ‐
1 si no existe.
lastIndexOf(cad) Devuelve la posición de la última aparición de cad en la cadena o ‐1
si no existe.
startsWith(prefijo) Devuelve true sii la cadena comienza por prefijo.
endsWith(sufijo) Devuelve true sii la cadena termina con sufijo.
NOTA: Los métodos que devuelven cadenas, devuelven cadenas nuevas, diferentes de las originales.

9. La clase String. Ejemplos de métodes
String st1 = “Ejemplo 1”;
String mayus = st1.toUpperCase(); // mayus es “EJEMPLO 1”
String minus = st1.toLowerCase(); // minus es “ejemplo 1”
int longitud = st1.length(); // longitud == 9
char caracter = st1.charAt(1); // caracter == ‘j’
String sub = st1.substring(3,5); // sub es “mp”
String st = st1.concat(“ y 2”); // st es “Ejemplo 1 y 2”
boolean b = st1.startsWith(“Eje”); // b == true
boolean c = st1.endsWith(“Eje”); // c == false
int inici = st1.indexOf(“mpl”); // inicio == 3
int desde = st1.indexOf(“mpl”,2); // desde == 3
String st2 = “ Ejemplo 2 ”;
String noBlanco = st2.trim(); // noBlanco es “Ejemplo 2”
int ultima = st2.lastIndexOf(“ ”); // ultima == 11
26/10/2011 IIP ‐ Curs 2011/12 9

10. La clase Math
Características:
• Es una clase de Utilidades con un conjunto de constantes y métodos estáticos
para realizar operaciones matemáticas avanzadas.
• Sus atributos y métodos públicos, al ser estáticos, han de usarse anteponiendo
el identificador de la clase seguido de un punto.
Referencia: http://download.oracle.com/javase/6/docs/api/java/lang/Math.html
Math define:
• Dos constantes: Math.PI y Math.E,
• Un grupo de operaciones (métodos estáticos) que se pueden clasificar como:
– Trigonométricas,
– Logarítmicas ‐ exponenciales,
– Para generación de valores aleatorios,
– Matemáticas de carácter básico.
26/10/2011 10IIP ‐ Curs 2011/12

11. La clase Math
26/10/2011 11IIP ‐ Curs 2011/12
Invocación Significado Definición ‐ Cabecera
Math.sin(x) seno(x) public static double sin (double x)
Math.cos(x) coseno(x) public static double cos (double x)
Math.tan(x) tangente(x) public static double tan (double x)
Math.asin(x) arcoseno(x) public static double asin (double x)
Math.acos(x) arcocoseno(x) public static double acos (double x)
Math.atan(x) arcotangente(x) public static double atan (double x)
Uso Significado Definición
Math.E e = 2.7182818284590452354 public static final double E
Math.PI π = 3.14159265358979323846 public static final double PI
Constantes:
Operaciones trigonométricas (el ángulo se expresa en radianes):

12. La clase Math
26/10/2011 12IIP ‐ Curs 2011/12
Invocación Significado Definición ‐ cabecera
Math.pow(x,y) xy public static double pow (double x, double y)
Math.exp(x) ex public static double exp (double x)
Math.log(x) ln(x) public static double log (double x)
Math.log10(x) log(x) public static double log10 (double x)
Math.sqrt(x)
Raíz
cuadrada
public static double sqrt (double x)
Invocación Significado Definición‐ cabecera
Math.random()
Número aleatorio
en [0.0, 1.0[
public static double random ()
Operaciones logarítmicas – exponenciales:
Operación para obtener un valor aleatorio:

13. La clase Math
26/10/2011 13IIP ‐ Curs 2011/12
Invocación Significado Definición‐ cabecera
Math.abs(x) valor absoluto de x
public static double abs (double x)
public static float abs (float x)
public static int abs (int x)
public static long abs (long x)
Math.max(x,y) mayor de x e y
public static double max (double x,double y)
public static float max (float x, float y)
public static int max (int x, int y)
public static long max (long x, long y)
Math.min(x,y) menor de x e y Igual que max
Math.ceil(x) x public static double ceil (double x)
Math.floor(x) x public static double floor (double x)
Math.round(x)
Redondeo al
entero más
próximo
public static long round (double x)
public static int round (float x)
Operaciones matemáticas de carácter básico:

14. La clase Math. Ejemplos de métodos
double x = 2.0, y = 5.0;
// Exponenciales - logarítmicos:
pot = Math.pow(x, y); // pot == 32.0
raiz = Math.sqrt(x); // raiz == 1.4142135623730951
ln = Math.log(y); // ln == 1.6094379124341003
// Trigonométricas
sin = Math.sin(Math.PI/2); // sin es 1.0
alf = Math.arcsin(sin); // alf es 1.5707963267948966
tan = Math.tan(Math.PI/2); // tan es 1.633123935319537E16
// Matemáticas básicas:
abs = Math.abs(-x); // abs es 2.0
max = Math.max(x,y); // max es 5.0
ceil = Math.ceil(3.76); // ceil es 4.0
flr = Math.floor(3.76); // flr es 3.0
long round1 = Math.round(3.76); // round1 es 4L
long round2 = Math.round(3.45); // round2 es 3L
26/10/2011 IIP ‐ Curs 2011/12 14

15. La clase Math. Ejemplos
/**
* Redondea un valor a cierto número de decimales.
* @param numIni - valor a ser redondeado.
* @param numDec – número de decimales. Tiene que ser >= 0.
* @return número redondeado a numDec decimales.
*/
public static double redondearNumDec(double numIni, int numDec) {
double num = numIni*Math.pow(10,numDec);
num = Math.round(num);
num = num / Math.pow(10,numDec);
return num;
}
26/10/2011 IIP ‐ Curs 2011/12 15

16. La clase Math. Ejemplos
/**
* Devuelve un valor aleatorio en el intervalo entero [a,b].
* @param a - Un extremo del intervalo.
* @param b – El otro extremo del intervalo.
* @return Valor aleatorio en el interval entero [a,b].
*/
public static int aleaEnIntervalo (int a, int b) {
int aux1 = a; int aux2 = b;
a = Math.min(aux1,aux2);
b = Math.max(aux1,aux2);
double x0 = Math.random(); // x0 es un double en [0,1[
int valsEntreAiB = b – a + 1;
double x1 = x0 * valsEntreAiB; // x1 es un double en [0, valsEntreAiB[
double x2 = a + x1; // x2 es un double en [a,a+valsEntreAiB[ ==
// == en [a,a+(b-a+1)[ == en [a,b+1[
int valor = (int)x2; // valor es un int en [a,b+1[ == en [a,b]
return valor;
}
26/10/2011 IIP ‐ Curs 2011/12 16

17. Clases envoltorio
• En Java no hay referencias a valores elementales, por lo que la única forma
de tener una referencia a uno de ellos consiste en envolverlo en un objeto.
• Para eso, para cada uno de los tipos básicos hay una clase envoltorio que
permite tratar sus valores como objetos. Estas clases son:
Byte, Short, Integer, Long, Float, Double, Character y Boolean.
• Estas clases pertenecen al paquete java.lang por lo que pueden usarse,
sin tener que importarse explícitamente.
• Cada objeto de alguna de estas clases contiene un único atributo del tipo
básico pero, a diferencia del tipo original, está dotado de algunas
funcionalidades adicionales (proporcionadas en forma de constantes y
métodos).
• Todas las clases envoltorios son inmutables, lo que quiere decir que una vez
creado un objeto de la clase, no se puede modificar.
26/10/2011 17IIP ‐ Curs 2011/12

18. Clases envoltorio
Funcionalidades de las clases envoltorio (definición de constantes):
• Las constantes MAX_VALUE y MIN_VALUE están definidas en todas las clases
envoltorio de tipo numérico. Gracias a ellas se consigue en Java los valores
máximo y mínimo para cada tipo.
• Los tipos reales también disponen de las constantes POSITIVE_INFINITY
y NEGATIVE_INFINITY para representar los valores infinitos, así como de
la constante Double.NaN.
26/10/2011 18IIP ‐ Curs 2011/12
// Algunos ejemplos (valores enteros límite):
int maxI = Integer.MAX_VALUE; // maxI == 2147483647
int minI = Integer.MIN_VALUE; // minI == ‐2147483648
long maxl = Long.MAX_VALUE; // maxL == 9223372036854775807L
long maxl = Long.MAX_VALUE; // minL == ‐9223372036854775808L
// Uso de constantes en coma flotante:
double infPos = Double.POSITIVE_INFINITY;
double vNeg = infPos * -1; // vNeg es Double.NEGATIVE_INFINITY
double indet = (infPos/vNeg)*135.4; // indet es Double.NaN

19. Clases envoltorio
26/10/2011 19IIP ‐ Curs 2011/12
De String a tipos elementales De tipos elementales a String
byte by = Byte.parseByte(str); str = Byte.toString(b);
short s = Short.parseShort(str); str = Short.toString(s);
int i = Integer.parseInt(str); str = Integer.toString(i);
long l = Long.parseLong(str); str = Long.toString(l);
float f = Float.parseFloat(str); str = Float.toString(f);
double d = Double.parseDouble(str); str = Double.toString(d);
boolean bo = Double.parseBoolean(str); str = Double.toString(d);
Operaciones para convertir Strings en valores elementales y al contrario (str es una String):
Funcionalidades de las clases envoltorio (operaciones):
// Ejemplos:
int i = Integer.parseInt(“12345”); // i == 12345
double d = Double.parseDouble(“123.456”); // d == 123.456
Double d = Double.parseDouble(“123b.456”); // No correcto: EXCEPCIÓN

20. Clases envoltorio
26/10/2011 20IIP ‐ Curs 2011/12
Operación Significado
b = Character.isDigit(c) b es true sii c es un dígito.
b = Character.isLetter(c) b es true sii c es una letra.
b = Character.isSpaceChar(c) b es true sii c es un espacio blanco
Unicode.
b = Character.isLowerCase(c) b true sii c es una minúscula.
b = Character.isUpperCase(c) b true sii c es una mayúscula.
c2 = Character.toLowerCase(c) c2 es la minúscula de c.
c2 = Character.toUpperCase(c) c2 es la mayúscula de c.
Algunas operaciones con valores Character (c y c2 son char, b es boolean):
Funcionalidades de las clases envoltorio (operaciones):

21. Clases envoltorio
• Los tipos elementales y los tipos envoltorio son compatibles:
26/10/2011 21IIP ‐ Curs 2011/12
// Ejemplos:
// conversión implícita de double a Double:
Double d1 = 1.5;
// Creación de un Double y conversión a double:
double d2 = new Double(1.5);
// el método parseFloat convierte su argumento a float
// y después hace una conversión implícita de float a Float:
Float f1 = Float.parseFloat("12345677890.012345");
// conversión implícita de Float a float:
float f2 = f1;
// el métode parseInt convierte la String "12345" a int
// y después hace una conversión implícita de int a long:
long l = Integer.parseInt("12345");