Curso de java básico (scjp)

El Paquete java.lang

Objetivos generales Qué es java.lang? Clase Object Wrapper Classes Utilidades de Conversión de tipos Clase String Clase StringBuffer Clase Math

Overview de java.lang Se importa automáticamente en tiempo de compilación. Contiene a la clase Object y las Wrapper Provee objetos para interactuar con la JVM Contiene clases que proveen: los streams de entrada, salida y error (System), manejo de cadena de caracteres (String, StringBuffer) funciones matemáticas (Math) El paquete Java java.lang contiene clases fundamentales e interfaces del lenguaje como ser: system, string, math, stringbuffer entre otras.

Overview de java.lang En la imagen anterior, vemos la jerarquía de clases del paquete java.lang. La clase Object, es la superclase de la estructura, de la cual heredan todos los objetos, tanto los proporcionados por el lenguaje como los creados por el programador. La clase Object, define funcionalidades básicas que todos los objetos exhiben y que todas las clases heredan

Métodos de la Clase Object Descripción boolean equals(Object o) Define si dos objetos son equivalentes. void finalize() Llamado por el Garbage Collector, cuando el Garbage Collector detecta que un objeto no puede ser referenciado. int hashCode() Retorna un código para un objeto, para que el objeto pueda ser usado en una clase Collection que utilice un Hashtable, HashMap o HashSet. final void notify() Activa un hilo que esta esperando para obtener el bloqueo de un objeto. final void notifyAll() Activa todos los hilos que están esperando para obtener el bloqueo de un objeto. final void wait() Provoca que el hilo actual espere hasta que otro hilo ejecute el método notify o notifyAll. String toString() Retorna una “Representación de texto” del objeto. En la tabla anterior, vemos algunos de los métodos que exhibe la clase Object. Dichos métodos pueden ser utilizados por cualquier clase. Si estos no son definidos, se utilizan los establecidos por la clase padre.

Wrapper Classes Los tipos primitivos no son objetos Para poder manipularlos como objetos java.lang provee clases wrapper para cada tipo primitivo En algunos casos, el trabajar con datos primitivos como objetos, es de gran ayuda. Por ejemplo, los contenedores definidos por el API en el package java.util (Arrays dinámicos, listas enlazadas, colecciones, conjuntos, etc.) utilizan como unidad de almacenamiento la clase Object. Dado que Object es la raíz de toda la jerarquía de objetos en Java, estos contenedores pueden almacenar cualquier tipo de objetos y utilizar todos los métodos que dicha clase proporciona. Pero los datos primitivos no son objetos, con lo que quedan en principio excluidos de estas posibilidades. Para resolver esta situación, es que tenemos las wrapper classes, Para identificar los tipos primitivos de los tipos Wrapper, vemos que los nombres de los tipos primitivos comienzan en minúscula, mientras que sus respectivas clases wrapper en mayúscula. Por ejemplo podríamos definir una clase envoltorio para los enteros, de forma bastante sencilla, con: public class Entero {     private int valor;          Entero(int valor) {         this.valor = valor;     }      int intValue() {         return valor;     } }

Wrapper Classes Todas las clases Wrapper son inmutables (su estado no puede cambiar) Adicionalmente definen constantes útiles Las clases de tipo wrapper, son inmutables, es decir que una vez que un objeto contenedor tiene un valor asignado a la misma, ese valor no se puede cambiar.

Construyendo Wrapper Classes Todas las clases wrapper a excepción de Character tienen 2 constructores: Uno que recibe el tipo primitivo que se quiere construir Otro que recibe la representación en String del tipo que se quiere construir Integer i1 = new Integer(42); Integer i2 = new Integer("42"); o Float f1 = new Float(3.14f); Float f2 = new Float("3.14f"); Si se desea convertir un String a un numero que no puede convertirse, el constructor lanza una NumberFormatException. En este caso, se utilizan wrapper classes, de manera de utilizar los constructores de conversión de tipos.

Construyendo Wrapper Classes La clase Character provee un solo constructor que recibe un char: Character c1 = new Character('c'); El constructor del objeto Boolean recibe un boolean o un string (case insensitive) con el valor “true” o “false” El objeto Boolean no puede ser usado en una condición: Boolean b = new Boolean(“true”); if (b) { …} // No compila, espera un boolean y no un Boolean La clase Character, representa los objetos que son caracteres de largo 1, ejemplo: ´a´ , ´@´, ´+´. Los objetos boolean, solo son utilizados como banderas, para establecer valores verdadero y falso. No pueden ser utilizados en condiciones. Sin embargo, el tipo primitivo si es utilizado en estructuras de control.

Método valueOf(…) Los métodos estáticos valueOf( ) presentes en la mayoría de las clases wrapper, proveen otra forma de construir estos objetos: valueOf(String arg0, int base) // convierte 101011 a 43 y // asigna el valor 43 a i2 Integer i2 = Integer.valueOf("101011", 2); valueOf(String arg0) // asigna 3.14 a f2 Float f2 = Float.valueOf("3.14f"); El método valueOf, permite crear números en distintas bases, según el tipo de objeto que se esté utilizando.

Utilidades de Conversión Una funcionalidad importante de los wrappers es convertir tipos de datos xxxValue() Cuando se quiera convertir un wrapper a un tipo primitivo se puede utilizar alguno de los métodos xxxValue() Integer i2 = new Integer(42); // crea un nuevo objeto wrapper byte b = i2.byteValue(); // convierte el valor de i2 a un byte short s = i2.shortValue(); // otro de los métodos xxxValue double d = i2.doubleValue();

Utilidades de Conversión En la tabla anterior, se especifica por cada clase si los métodos de conversión de tipos se encuentran o no disponibles para ser utilizados.

Utilidades de Conversión Constuctores de los objetos wrappers: Todas las clases wrapper menos Character proveen 2 constructores: Uno que toma la primitiva de la clase y otro que toma la representación en string del tipo construido. Ej.: Integer i1 = new Integer(11); Integer i2 = new Integer(“11″); Y Character solo tiene:  Character c1 = new Character(‘a’); Y Boolean puede tomar true, false, “true”, “false” El método valueOf(): Los métodos static valueOf() nos proveen otra forma de crear objetos Wrapper. Por ejemplo tenemos: valueOf(String value, int radix); valueOf(String value); Integer i2 = Integer.valueOf(“0101010″,2); -> nos convierte de binario a decimal y lo asigna Usando las utilidades de conversión de las clases Wrappers: xxxValue(): Cuando necesitamos convertir un valor wrapeado a una primitiva usamos uno de los tanto xxxValue(); Todos estos métodos no reciben argumentos: Integer i2 = new Integer(42); byte b = i2.byteValue();

parseXX y valueOf(): Ambos toman un string como argumento y lanzan un NumberFormatException si el string no esta correctamente formado. La diferencia entre los dos métodos es: - parseXXX() devuelve la primitiva en el nombre del método (XXX) - valueOf() devuelve una instancia nueva del objeto wrapper del tipo que invoco al método Ej.: double d = Double.parseDouble(“3.14″); Double d2 = Double.valueOf(“3.14″); toString(): La clase Objet tiene el método toString() y por lo tanto todas las demás en Java también. La idea del método es poder obtener una presentación del objeto en forma de String. Todas las clases Wrapper tiene este método que no recibe argumentos, no es static, y devuelve un String con el valor de la primitiva. Todas las clases numéricas poseen un método static sobrecargado con toString. Ej.: String d = Double.toString(“3.14″); Integer y Long poseen un tercer método static que recibe un segundo argumento llamado radix. toXXXString() (Binary, Hex, Octal): Las clases Integer y Long los poseen, y nos permite pasar de base 10 a otras bases. Ej.: String s3 = Integer.toHexString(254); // s3 = fe

parseXxx() y valueOf() Ambos reciben un String como argumento Lanzan una NumberFormatException si el String no tiene la forma esperada Pueden convertir Strings en bases diferentes La diferencia es que: parseXxx() retorna un tipo primitivo valueOf retorna un objeto wrapper Como vemos, disponemos de varios mecanismos para la conversion de datos, tanto de wrapper classes a tipos primitivos, como de un tipo x a un tipo y. En este caso, los métodos parseXX y valueOfXX, deberían ser utilizados según corresponda, teniendo en cuenta las ventajas y desventajas de trabajar con tipos primitivos y wrapper classes. Los metodos static valueOf() nos proveen otra forma de crear objetos Wrapper. Por ejemplo tenemos: valueOf(String value, int radix); valueOf(String value); Integer i2 = Integer.valueOf(“0101010″,2); -> nos convierte de binario a decimal y lo asigna a i2 double d = Double.parseDouble(“3.14″); Double d2 = Double.valueOf(“3.14″); Donde: - parseXXX() devuelve la primitiva en el nombre del método (XXX) - valueOf() devuelve una instancia nueva del objeto wrapper del tipo que invoco al método

toString() La clase Object tiene el método toString(), heredado por todas las demás clases La idea del método es dar una representación del objeto que tenga cierto sentido Adicionalmente los wrappers agregan un toString estático que recibe el tipo primitivo correspondiente y retorna el String que lo representa La clase toString(), es un método definido en la clase Object. Este método, describe la representación de cada objeto, por lo que es utilizado para la impresión del mismo. Ejemplo: public class Empleado{ private String nombre; //gets and sets //constructores public String toString(){ return “Nombre: ”nombre; } Ej: Empleado e = new Empleado(“Jose”); System.out.println(e.toString()); Obtendríamos: Nombre: Jose

toXxxString() - Binario, decimal, hexadecimal Las clases Integer y Long permiten convertir números en base 10 a otras bases Estos métodos toXxxString toman un int o un long y retornan un String que lo representa: String s3 = Integer.toHexString(254); // convierte 254 a hexa System.out.println("254 in hex = " + s3); // el resultado es "254 in hex = fe" String s4 = Long.toOctalString(254); // convierte 254 a octal System.out.println("254 in octal = "+ s4); // el resultado es "254 in octal = 376"

Auto boxing/unboxing Problema (versiones previas a J2SE5.0) Pasar de un tipo primitivo a tipo wrapper y viceversa. La forma de hacerlo era: Integer j = new Integer(12); Int I = j.intValue(); Problemas: por ejemplo al manejar colecciones con tipos primitivos. Estas solo aceptan objetos. En versiones previas a J2SE 5,0, las colecciones (listas), solo manejan Objetos y no tipos primitivos, por lo que el manejo de wrapper classes y primitivos era engorroso. J2SE (Java Standard Edition) esta compuesto por: JRE (Java Runtime Environment) provee un conjunto de APIs, Java Virtual Machine (JVM), y otros componentes necesarios para ejecutar applets y aplicaciones escritas en el lenguaje Java JDK (Java Development Kit) contiene a la JRE y agrega diferentes herramientas como: compiladores, debuggers necesarios para desarrollar applets y aplicaciones.

Auto boxing/unboxing Solución – El compilador trabaja por nosotros: Byte byteObj = 22; // Autoboxing conversion int i = byteObj // Unboxing conversion ArrayList<Integer> al = new ArrayList<Integer>(); al.add(22); // Autoboxing conversion En versiones posteriores, se definió el auto boxing y unboxing, de manera que el trabajo de convertir de un tipo a otro, es realizado por el compilador.

Clase String Los Strings son objetos inmutables. Cada carácter en un String es un char Unicode de 16 bits. En Java los Strings son objetos String s = new String(); s = “abcdef” Variantes String s = new String(“abcdef”); String s = “abcdef” La clase String no puede ser extendida, ya que esta definida como final. Esta clase, no es un tipo primitivo, sino que los Strings son objetos. Hereda también de la clase Object. Como definir Strings: String s = “abc”; //crea un objeto String y //una variable de referencia “abc” va a ir al pool y s va a hacer referencia a ese lugar de memoria String s = new String(“abc”); //crea dos objetos String y una variable de referencia Como usamos new, se va a crear un nuevo objeto fuera del pool y s va a hacer referencia a ese objeto. Adicionalmente “abc” se coloca en el pool

Inmutabilidad de String El objeto no puede cambiar La referencia al objeto si puede cambiar A continuación veremos las referencias creadas a los objetos String. Una vez que se define un objeto String, este es incambiable, es inmutable. Strings y Memoria: La JVM aparta un espacio de la memoria para lo que llama pool de Strings constantes Cuando la JVM encuentra un literal String chequea el pool para ver si existe uno idéntico Si se encuentra uno, la referencia al nuevo literal es dirigida al literal que se encuentra en el pool (no se crea un nuevo objeto String) En el ejemplo, se crea una variable llamada s con el valor abc. Al crearla, se asigna una referencia a dicha variable

Inmutabilidad de String En la primer imagen, vemos que se crean dos variables s2 y s con la misma referencia. Ambas apuntan al String abc. En el segundo ejemplo, a la palabra s, se le concatena una nueva palabra, por lo que la referencia cambia, dado que la palabra cambia.

Inmutabilidad de String En el primer paso, vemos que la variable x, es asignada con la palabra Java, por lo que le corresponde una referncia a dicho String. En el segundo paso (step 2), a la variable x se le concatena la palabra Rules. Sin embargo, dado que dicha palabra con la concatenación no fue asignada a ninguna variable, esta se encuentra definida como objeto String, pero sin referencia.

Inmutabilidad de String En este ejemplo, vemos que en el paso 1, se crea un String con la palabra Java, siendo referenciada por la variable x, dado que esta es asignada a través del operador =. En el segundo paso, como la variable x, es reasignada, la referencia cambia de la palabra Java a la palabra Java Rules!

Métodos importantes de String public char charAt(int index) public String concat(String s) public boolean equalsIgnoreCase(String s) public int length() public String replace(char old, char new) public String substring(int begin) public String substring(int begin, int end) public String toLowerCase() public String toUpperCase() public String trim() public char charAt(int index): Obtiene el carácter ubicado en la posición idex public String concat(String s): concatena el String s. public boolean equalsIgnoreCase(String s): Compara dos Strings ignorando mayúsculas y minúsculas. public int length(): Obtiene el largo de un String. public String replace(char old, char new): Reemplaza el carácter old por el new. public String substring(int begin): Obtiene una sub palabra a partir de la posición begin. public String substring(int begin, int end): Idem anterior, determinando el final. public String toLowerCase(): Cambia la palabra a minúscula. public String toUpperCase(): Cambia la palabra a mayúscula. public String trim(): Elimina los espacios en blanco de una palabra.

Clase StringBuffer Utilizada cuando se deben realizar muchas modificaciones a una cadena de caracteres Si bien los Strings son inmutables, el StringBuffer puede ser modificado sin dejar una gran cantidad de Strings inutilizados en memoria El objetivo de esta clase, es manejar de forma óptima la memoria para definir Strings Ejemplos: String x = "abc"; x.concat("def"); System.out.println("x = " + x); // la salida es "x = abc“ Como no se realizó una asignación, el nuevo String se perdió inmediatamente x = x.concat("def"); System.out.println("x = " + x); // la salida es "x = abcdef“ El String “abc” queda en el pool ocupando memoria

Clase StringBuffer Utilizando StringBuffer: StringBuffer sb = new StringBuffer("abc"); sb.append("def"); System.out.println("sb = " + sb); // la salida es "sb = abcdef" En este ejemplo, vemos que se crea una palabra utilizando la clase String Buffer con el contenido ¨abc¨, para luego concatenarle la palabra ¨def¨ e imprimir su valor. En este caso, el utilizar la clase String Buffer en vez de la clase String nos premite manejar de mejor manera la cantidad de Strings inmutables que residen en memoria sin ser utilizados.

Métodos importantes de StringBuffer public synchronized StringBuffer append(String s) public synchronized StringBuffer insert(int offset, String public synchronized StringBuffer reverse() public synchronized StringBuffer append(String s): como el concat de la clase String. Concatena palabras. public synchronized StringBuffer insert(int offset, String): inserta una palabra. public synchronized StringBuffer reverse(): da vuelta una palabra.

Clase Math Utilizada para realizar operaciones matemáticas. Define aproximaciones para las constantes matemáticas pi y e public final static double Math.PI public final static double Math.E Todos los métodos definidos en Math son static. La clase Math, es utilizada para realizar operaciones matemáticas. Proporciona constantes y métodos estáticos para operaciones trigonométricas, logarítmicas y otras funciones matemáticas comunes. No se puede crear una instancia de Math ( su constructor es privado ) Math no puede extenderse, es final, al igual que la clase String.

Métodos de la Clase Math abs() – retorna el valor absoluto. ceil() – retorna el redondeo hacia arriba. floor() – retorna el redondeo hacia abajo. abs() public static int abs(int a) public static long abs(long a) public static float abs(float a) public static double abs(double a) Ejemplo: Math.abs(-1) //retorna 1 ceil() Math.ceil(9.0) // da como resultado 9.0 Math.ceil(8.8) // da como resultado 9.0 Math.ceil(8.02) // da como resultado 9.0 floor() Math.floor(9,4) //da como resultado 9,0

Métodos de la Clase Math max() – retorna el máximo min() – retorna el mínimo max() x = Math.max(1024, -5000); // x es 1024. public static int max(int a, int b) public static long max(long a, long b) public static float max(float a, float b) public static double max(double a, double b) min() x = Math.min(1024, -5000); // x es -5000.

Métodos de la Clase Math random() Retorna un double entre 0.0 y 1.0 round() Redondea al valor más cercano sin() representa un ángulo en radianes. Los grados pueden convertirse a radianes utilizando Math.toRadians(double g) random() – retorna un numero aleatorio – randomico. random() Retorna un double entre 0.0 y 1.0 round() Redondea al valor más cercano Math.round(-10.5); // el resultado es –10 public static int round(float a) public static long round(double a) sin() public static double sin(double a) a representa un ángulo en radianes. Los grados pueden convertirse a radianes utilizando Math.toRadians(double g) Ejemplos: System.out.println(Math.abs(-10)); System.out.println(Math.random()); System.out.println(Math.round(1.2)); System.out.println(Math.sin(90)); System.out.println(Math.tan(90)); System.out.println(Math.cos(90)); 10 0.7079061314120494 1 0.8939966636005579 -1.995200412208242 -0.4480736161291702

Métodos de la Clase Math cos() – función coseno tan() - función tangente sqrt() – función raíz cuadrada Retorna NaN (“Not a Number”) en lugar de un resultado complejo public static double sqrt(double a) toDegrees() Recibe un argumento representando un ángulo en radianes public static double toDegrees(double a) toRadians() Recibe un argumento representando un ángulo en grados public static double toRadians(double a) Las funciones: tan(), cos() y sin(), son las funciones trigonometricas: tangente, coseno y seno respectivamente. sqrt() – Retorna la raiz de un numero. Ejemplos: System.out.println(Math.tan(90)); System.out.println(Math.cos(90)); System.out.println(Math.sqrt(9)); System.out.println(Math.toDegrees(0.5)); System.out.println(Math.toRadians(90)); -1.995200412208242 -0.4480736161291702 3.0 28.64788975654116 1.5707963267948966

Métodos de la Clase Math

Métodos de la Clase Math

Resumen Qué es java.lang? Clase Object y sus características Wrapper Classes: qué son? Cómo se usan? Utilidades de Conversión de tipos Clase String: características Clase StringBuffer: características Clase Math: características

Bibliografía Thinking in Java Bruce Eckel The Java Tutorial http://download.oracle.com/javase/tutorial/