Poo 4 Cbasic

Tema 4. Clases Básicas Predefinidas.
Entrada/Salida
Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I. Informática.

Universidad de Málaga
Programación Orientada a Objetos
Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I.Tema

Informática.
4. ClasesUniversidad
Básicas Predefinidas.
de Málaga Entrada/Salida Programación Orientada a Objetos 1 / 57
Programación Orientada a Objetos
Tema 4. Clases básicas predefinidas. Entrada/Salida

Organización en paquetes
Clases básicas: java.lang
Clases básicas del paquete java.util
Entrada/Salida. java.io
Esta obra se encuentra bajo una licencia Reconocimiento-NoComercial-CompartirIgual 4.0 Internacional (CC BY-NC-SA 4.0) de Creative Commons.

Informática.
Organización en paquetes
Un paquete en Java es un mecanismo de organización que permite agrupar

clases e interfaces relacionadas desde un punto de vista lógico.
Define una jerarquía donde organizar las clases.
Proporciona protección de acceso.
Delimita un ámbito para el uso de nombres.
La plataforma Java incorpora unos paquetes predefinidos para facilitar
determinadas acciones.
Además, se pueden definir nuevos paquetes.
Para definir un paquete hay que encabezar cada fichero que forme parte del
paquete con la declaración:
package <nombre-del-paquete>;
Cuando no aparece esta declaración, se considera que las clases e interfaces de
los ficheros pertenecen a un paquete anónimo.
Los ficheros java que forman parte del paquete se deben situar adecuadamente
según la jerarquía especificada por el nombre del paquete.

Informática.
Uso de paquetes
Desde fuera de un paquete sólo se puede acceder a clases e interfaces

públicas.
Para acceder a una clase o interfaz desde otro paquete se puede:
Utilizar el nombre de la clase cualificado con el nombre del paquete.
java.util.Random rnd = new java.util.Random();
Importar la clase al comienzo del fichero y usar su nombre simple.
import java.util.Random;
//...
Random rnd = new Random();
Importar todas las clases del paquete completo al comienzo del fichero y usar
los nombres simples de todas las clases e interfaces del paquete.
import java.util.*;
//...
Random rnd = new Random();
El sistema de ejecución de Java importa automáticamente el paquete
anónimo, el paquete java.lang y el paquete actual.

Informática.
La Interfaz de Programación de Aplicaciones de Java
La API de Java (Java Application Programming Interface) es la especificación

de la biblioteca de paquetes que se suministra con la plataforma de
desarrollo de Java (JDK).
Estos paquetes contienen interfaces y clases diseñadas para facilitar la tarea de
programación.
En este tema veremos parte de los paquetes: java.lang, java.util y
java.io.

Informática.
El paquete java.lang
El paquete java.lang siempre está incluido en cualquier aplicación, no es
necesario importarlo explícitamente.
Contiene las clases básicas del sistema:
System: proporciona objetos para entrada/salida, y funcionalidades del sistema.
Math: proporciona funciones matemáticas usuales.
Object: la raíz de la jerarquía de clases. Define el comportamiento base de
todos los objetos.
String y StringBuilder: manejo de cadenas de caracteres.
Envoltorios de tipos primitivos (char, int, double, etc.)
Class: proporciona información sobre las clases.
Etc.
Contiene interfaces:
Cloneable: especifica que un objeto puede ser clonado.
Comparable: especifica el método de ordenación natural entre objetos
(compareTo()).
Runnable: especifica el método a ejecutar por el gestor de hebras (run()).
Etc.
Contiene también excepciones y errores.
Informática.
La clase java.lang.System
La clase System proporciona objetos para entrada/salida, y funcionalidades del

sistema.
Proporciona tres variables de clase (estáticas) públicas para realizar la entrada
y salida de datos:
PrintStream out, err: salida de datos.
InputStream in: entrada de datos.
Métodos de clase (estáticos) públicos:
void arraycopy(...): permite copiar elementos de un array a otro array.
long currentTimeMillis(): devuelve el valor del tiempo actual en
milisegundos.
void gc(): permite invocar al recolector de basura.
- Etc. (consultar la documentación para más información).

Informática.
La clase java.lang.Math
La clase Math proporciona constantes numéricas y funciones matemáticas.

Constantes (estáticas) públicas:
double E = 2.718281828459045: el valor del número e.
double PI = 3.141592653589793: el valor del número pi.
Métodos de clase (estáticos) públicos:
double sin(double), double cos(double), double tan(double), double
asin(double), double acos(double), double atan(double): funciones
trigonométricas.
x abs(x), x max(x,x), x min(x,x): valor absoluto, máximo y mínimo.
double exp(double), double pow(double, double), double
sqrt(double), int round(float): exponenciación, potencia, raíz cuadrada,
redondeo.
double random(): generación de números aleatorios (0 ≤ r < 1).
Etc. (consultar la documentación para más información).

Informática.
La clase java.lang.Object
Es la clase raíz de toda la jerarquía de clases de Java.
Define el comportamiento mínimo común de todos los objetos.
Si una clase no hereda de otra, entonces hereda automaticamente de Object.
Todas las clases heredan, directa o indirectamente, de Object.
No tiene mucho sentido crear instancias de Object, ya que la funcionalidad que
ofrece es limitada.
Métodos de instancia importantes de la clase Object:
String toString(): representación String del objeto actual.
boolean equals(Object o): indica si otro objeto es igual al objeto actual.
int hashCode(): devuelve el valor del código hash del objeto actual.
Object clone(): crea un nuevo objeto y devuelve una copia (bit a bit) del
objeto actual.
Class getClass(): devuelve información sobre la clase del objeto actual.
- Etc. (consultar la documentación para más información).
Usualmente NO es adecuada la implementación por defecto, y en caso de ser

necesario un determinado método, usualmente las subclases deben redefinir su
implementación.
Informática.
La clase java.lang.Object. El método equals()

Usualmente, las clases derivadas deben redefinir este método para que realice
la comparación adecuadamente (por defecto realiza una comparación por ==).
Todas las clases del sistema tienen redefinido este método (también enum).
La anotación @Override indica al compilador que un método pretende
redefinir a un método de la superclase (útil para detectar errores).
instanceof comprueba si un objeto es una instancia de una clase.
class Persona {
private String nombre;
private int edad;
public Persona(String n, int e) { nombre = n; edad = e; }
@Override
public boolean equals(Object o) {
boolean ok = false;
if (o instanceof Persona) {
Persona other = (Persona) o;
ok = (this.edad == other.edad) && this.nombre.equals(other.nombre);
} ▴
return ok; // compara DIFERENCIANDO mayúsculas y minúsculas.
}
}

Informática.
La clase java.lang.Object. El método equals()

Usualmente, las clases derivadas deben redefinir este método para que realice
la comparación adecuadamente (por defecto realiza una comparación por ==).
Todas las clases del sistema tienen redefinido este método (también enum).
La anotación @Override indica al compilador que un método pretende
redefinir a un método de la superclase (útil para detectar errores).
instanceof comprueba si un objeto es una instancia de una clase.
class Persona {
private int edad;
@Override
boolean ok = false;
ok = (this.edad == other.edad) && this.nombre.equalsIgnoreCase(other.nombre);
} ▴
return ok; // compara SIN DIFERENCIAR mayúsculas y minúsculas.
}
}

Informática.
La clase java.lang.Object. El método hashCode()
Si dos objetos son iguales (según el método equals()), entonces el método hashCode()
debe devolver el mismo valor del código hash para ambos objetos. Si a.equals(b) entonces
a.hashCode() == b.hashCode().
Es posible que dos objetos diferentes generen el mismo código hash. Se denomina colisión.
Si se redefine el método equals(), entonces también se debe redefinir el método
hashCode(), considerando los mismos componentes.
int hashCode(): devuelve el valor del código hash del objeto actual. La suma de los
hashCode() de los componentes involucrados en equals().
class Persona {
private int edad;
@Override
boolean ok = false;
ok = (this.edad == other.edad) && this.nombre.equals(other.nombre);
} ▴
return ok; // compara DIFERENCIANDO mayúsculas y minúsculas.
}
@Override
public int hashCode() { ▾
return Integer.hashCode(this.edad) + this.nombre.hashCode();
}
}
Informática.
La clase java.lang.Object. El método hashCode()
Si dos objetos son iguales (según el método equals()), entonces el método hashCode()
debe devolver el mismo valor del código hash para ambos objetos. Si a.equals(b) entonces
a.hashCode() == b.hashCode().
Es posible que dos objetos diferentes generen el mismo código hash. Se denomina colisión.
Si se redefine el método equals(), entonces también se debe redefinir el método
hashCode(), considerando los mismos componentes.
int hashCode(): devuelve el valor del código hash del objeto actual. La suma de los
hashCode() de los componentes involucrados en equals().
class Persona {
private int edad;
@Override
boolean ok = false;
ok = (this.edad == other.edad) && this.nombre.equalsIgnoreCase(other.nombre);
} ▴
return ok; // compara SIN DIFERENCIAR mayúsculas y minúsculas.
}
@Override
public int hashCode() { ▾
return Integer.hashCode(this.edad) + this.nombre.toLowerCase().hashCode();
}
}
Informática.
Cadenas de caracteres
Las cadenas de caracteres se representan en Java como secuencias de

caracteres Unicode encerradas entre comillas dobles.
"Ejemplo de cadena de caracteres"
Para manipular cadenas de caracteres, por razones de eficiencia, se utilizan dos

clases incluidas en java.lang y una de java.util:
java.lang.String: para cadenas inmutables
java.util.StringJoiner: para unir cadenas.
java.lang.StringBuilder: para cadenas modificables.

Informática.
La clase java.lang.String
Cada objeto de la clase String contiene una cadena de caracteres.

Los objetos de esta clase se pueden inicializar:
Forma normal:
String str = new String("¡Hola!");
Forma simplificada:
String str = "¡Hola!";
Los objetos de la clase String en Java son inmutables.

Sin embargo, a un objeto de la clase String se le pueden asignar cadenas
distintas durante su existencia.
Pero una cadena de caracteres almacenada en un objeto de la clase String
NO puede ser modificada (crecer, cambiar un carácter, etc.).

Informática.
Metodos de consulta
int length(): devuelve el número de caracteres de la cadena.
char charAt(int p): devuelve el carácter que se encuentra en la posición p
en la cadena (0 ≤ p < length()).
int indexOf(char/String c2): devuelve la primera posición de c2
(carácter o cadena).
int lastIndexOf(char/String c2): devuelve la última posición de c2
(carácter o cadena).
Si se intenta acceder a una posición no válida el sistema lanza una excepción:
IndexOutOfBoundsException.

Informática.
Metodos que producen nuevos objetos String
String substring(int desde, int hasta): devuelve un nuevo objeto
String con los caracteres a partir de la posición desde y hasta la posición
hasta (sin incluirla).
String substring(int desde): devuelve un nuevo objeto String con los
caracteres a partir de la posición desde y hasta el final.
String replace(String c2, String c3): devuelve un nuevo objeto
String con los caracteres del objeto actual, reemplazando todas las
ocurrencias de c2 por c3.
String replaceFirst(String regex, String c3): devuelve un nuevo
objeto String con los caracteres del objeto actual, reemplazando la primera
ocurrencia de regex por c3.
String concat(String c2): devuelve un nuevo objeto String con los
caracteres del objeto actual concatenados con los caracteres de c2 (equiv a +).
Si se intenta acceder a una posición no válida el sistema lanza una excepción:
IndexOutOfBoundsException.

Informática.
Metodos que producen nuevos objetos String
String toLowerCase(): devuelve un nuevo objeto String con todos los caracteres
del objeto actual en minúsculas.
String toUpperCase(): devuelve un nuevo objeto String con todos los caracteres
del objeto actual en mayúsculas.
String trim(): devuelve un nuevo objeto String con todos los caracteres del
objeto actual, pero elimina los espacios iniciales y finales.
static String format(String formato, ...): devuelve un nuevo objeto
String con el resultado de aplicar el formato especificado.
Conversiones (estáticas)
String String.valueOf(Tipo v): devuelve un nuevo objeto String con la
representación del valor especificado en v.
int Integer.parseInt(String c1): devuelve el resultado de obtener el valor del
número entero representado en c1.
double Double.parseDouble(String c1): devuelve el resultado de obtener el
valor del número real representado en c1.
Informática.
Metodos de comparación
boolean equals(String c2): devuelve true si el objeto actual y c2 son
iguales y false en otro caso.
boolean equalsIgnoreCase(String c2): igual que la anterior, pero sin
tener en cuenta las diferencias por mayúsculas y minúsculas.
int compareTo(String c2): devuelve un entero menor, igual o mayor que
cero cuando el objeto actual es menor, igual o mayor que c2.
int compareToIgnoreCase(String c2): igual que la anterior, pero sin
tener en cuenta las diferencias por mayúsculas y minúsculas.
ATENCIÓN c1 == c2 compara las referencias, es decir, si ambas variables
referencian al mismo objeto.
int hashCode(): devuelve el valor del código hash del objeto actual.

Informática.
El metodo split()
String[] split(String regex): devuelve un array de String resultado de
dividir la cadena de caracteres del objeto actual en substrings según los
delimitadores especificados por regex.
String[] split(String regex, int limit): igual que el anterior, pero
con un límite en la aplicación de la división.
Los delimitadores son expresiones regulares. Por ejemplo:
▸ "[,;:]" // Exactamente uno de entre ,;:
▸ "[,;:]+" // Uno o más de entre ,;:
▸ "[^a-zA-Z0-9]" // Cualquier carácter que no sea una letra o dígito
▸ "[,;:] ?" // Uno de entre ,;: seguido por un espacio opcional
▸ "\\s*[,;:]\\s*" // Uno de entre ,;: entre múltiples [ \t\n\r\f] opcionales
Ejemplo:
public static void main(String[] args) {
String s1 = "33456765M Juan 6.5";
String[] t1 = s1.split("[ ]"); // [33456765M] [Juan] [6.5]
String s2 = "El agua:es;buena";

String[] t2 = s2.split("[ :]"); // [El] [agua] [es;buena]
}

Informática.
Por ejemplo, dado el siguiente objeto de tipo String:

String str = "programas";
str String
• ▸ p r o g r a m a s
0 1 2 3 4 5 6 7 8
▸ int a = str.length(); // a toma el valor 9
▸ int b = str.indexOf('r'); // b toma el valor 1
▸ int c = str.lastIndexOf('r'); // c toma el valor 4
▸ char d = str.charAt(0); // d toma el valor 'p'
▸ char e = str.charAt(str.length()-1); // e toma el valor 's'
▸ String f = str.substring(3, 6); // f toma el valor "gra"

Informática.
El método de clase (estático) format()
Permite utilizar un String como un descritor de formato, de tal forma que se
creara un nuevo objeto String como resultado de aplicar el descriptor del
formato a diferentes valores y objetos.
Los formatos se especifican con el caracter de escape %, seguido opcionalmente
por una especificación de anchura de campo y una precisión, y finalmente una
descripción del tipo de datos del valor. Entre otras, se utilizan las siguientes
descripciones de valores:
%s: se aplica sobre cualquier objeto. Se utiliza toString() ( %20s).
%d: se aplica sobre números enteros (byte, short, int y long) ( %7d).
%f: se aplica sobre números de punto flotante (float, double) ( %9.2f).
%b: se aplica sobre valores lógicos (boolean).
%c: se aplica sobre caracteres (char).
Por ejemplo:
String str = "programas";
String s = String.format("La cadena [%12s] tiene [%3d] caracteres",
str, str.length());
System.out.println(s); // La cadena [ programas] tiene [ 9] caracteres

Informática.
El método de clase (estático) format()
Las clases PrintStream y PrintWriter incluyen el método printf(String
formato, ...) que permite mostrar una cadena de caracteres con formato.
Por ejemplo:
class A {
private int a;
public A(int s){ a = s; }
public String toString() { return "A(" + a + ")"; }
}
String s = String.format("Obj [%10s] de [%-5s] con [%3d]", new A(65), "pepe", 78);
System.out.println(s);
System.out.printf("Cadena [%10.7s]\n", "Esto es una cadena");
System.out.printf("Entero [%03d]\n", 34);
System.out.printf("Flotante [%6.2f]\n", 457.2345678);
System.out.printf(Locale.ENGLISH, "Flotante (EN) [%6.2f]\n", 457.2345678);
System.out.printf("Lógico [%b]\n", (3 == 3));
}
Obj [ A(65)] de [pepe ] con [ 78]
Cadena [ Esto es]
Entero [034]
Flotante [457,23]
Flotante (EN) [457.23]
Lógico [true]
Informática.
La clase java.util.StringJoiner
La clase StringJoiner resulta útil para crear una nueva cadena de caracteres
como resultado de unir varias cadenas de caracteres, de tal forma que la
cadena resultante se crea utilizando un prefijo, un sufijo, y un separador que
permite separar las cadenas que han sido unidas.
El constructor StringJoiner(String, String, String) permite
especificar tanto el separar, como el prefijo y el sufijo (en ese orden). El prefijo
y el sufijo se pueden omitir: StringJoiner(String)
El método add(String) permite añadir la cadena de caracteres especificada.
En caso de que el objeto a añadir (add) no sea de tipo String, entonces se
deberá utilizar su representación textual o.toString().
El método toString() devuelve el resultado de unir todas las cadenas
especificadas, considerando el separador, prefijo y sufijo especificados.
Ejemplo:
String[] datos = { "Pepe", "Lola", María" };
StringJoiner sj = new StringJoiner("; ", "{ ", " }");
for (String x : datos) {
sj.add(x); // sj.add(x.toString());
}
String res = sj.toString(); // "{ Pepe; Lola; María }"
Informática.
La clase java.lang.StringBuilder
Los objetos de la clase String en Java son inmutables.
Cuando se deben manipular cadenas de caracteres, se utiliza StringBuilder.
Cada objeto de la clase StringBuilder contiene una cadena de caracteres.
Las cadenas de caracteres de los objetos StringBuilder se pueden ampliar,
reducir y modificar mediante métodos.
Cuando la capacidad establecida se excede, se aumenta automáticamente.
Los objetos de esta clase se construyen de las siguientes formas:
▸ StringBuilder sb1 = new StringBuilder();
▸ StringBuilder sb2 = new StringBuilder(10); // capacidad inicial
▸ StringBuilder sb3 = new StringBuilder("hola"); // valor inicial
Métodos de consulta:
▸ int length();
▸ char charAt(int pos);
▸ int indexOf(String str);
▸ int lastIndexOf(String str);
Métodos para construir objetos String:
▸ String substring(int desde, int hasta); // sin incluir hasta
▸ String substring(int desde); // hasta el final
▸ String toString();
Informática.
La clase java.lang.StringBuilder
Métodos para modificar objetos StringBuilder:
▸ StringBuilder setCharAt(int pos, char car);
▸ StringBuilder deleteCharAt(int pos);
▸ StringBuilder append(String str);
▸ StringBuilder insert(int pos, String str);
▸ StringBuilder delete(int desde, int hasta);
▸ StringBuilder replace(int desde, int hasta, String str);
▸ StringBuilder reverse();
Ejemplo:
public class StringBuilderDemo {
String cadena = "hola, como estás ?";
StringBuilder sb = new StringBuilder(cadena);
for (int i = 0; i < sb.length(); i++) {
if (Character.isLowerCase(sb.charAt(i))
&& ((i == 0) || ! Character.isLetter(sb.charAt(i-1)))) {
sb.setCharAt(i, Character.toUpperCase(sb.charAt(i)));
}
if ((i+5 <= sb.length()) && sb.substring(i, i+5).equals("Estás")) {
sb.replace(i, i+5, "Vas");
}
}
sb.append(" Yo estoy bien.");
System.out.println(sb); // Hola, Como Vas ? Yo estoy bien.
}
}
Informática.
Las clases envoltorios (wrappers) de java.lang
Los valores de los tipos primitivos no son objetos.

Una variable de objeto almacena una referencia al objeto.
Una variable de tipo primitivo almacena el valor en sí.
A veces es útil manejar valores de tipos primitivos como si fueran objetos.
Para ello se utilizan las clases envoltorios de java.lang.
Los objetos de las clases envoltorios son inmutables.
Se envuelve y desenvuelve automáticamente cuando sea necesario.
Tipo Primitivo Envoltorio

boolean Boolean
char Character
byte Byte
short Short
int Integer
long Long
float Float
double Double

Informática.
Metodos de instancia de los envoltorios
Los Constructores crean envoltorios a partir de los valores o de cadenas de
caracteres. Se puede realizar automáticamente (boxing).
▸ Character oc = new Character('a'); // Character oc = 'a';
▸ Boolean ob = new Boolean("false"); // Boolean ob = false;
▸ Integer oi = new Integer(34); // Integer oi = 34;
▸ Double od = new Double("34.56"); // Double od = 34.56;
El método de instancia xxxValue() permite extraer el valor almacenado en el
envoltorio. Se puede realizar automáticamente (unboxing).
▸ char c = oc.charValue(); // char c = oc;
▸ boolean b = ob.booleanValue(); // boolean b = ob;
▸ int i = oi.intValue(); // int i = oi;
▸ double d = od.doubleValue(); // double d = od;
El método de instancia toString() permite crear cadenas de caracteres a
partir del valor almacenado en el envoltorio.
▸ String c = oc.toString();
▸ String b = ob.toString();
▸ String i = oi.toString();
▸ String d = od.toString();
Los métodos de instancia hashCode() y compareTo().
▸ int hc = oc.hashCode(); ▸ int cc = oc.compareTo(oc); // oc.compareTo('a');
▸ int hb = ob.hashCode(); ▸ int cb = ob.compareTo(ob); // ob.compareTo(false);
▸ int hi = oi.hashCode(); ▸ int ci = oi.compareTo(oi); // oi.compareTo(34);
▸ int hd = od.hashCode(); ▸ int cd = od.compareTo(od); // od.compareTo(34.56);
Informática.
Metodos de clase de los envoltorios
El método de clase valueOf() crea envoltorios a partir de valores o String.
▸ Character oc = Character.valueOf('a'); // sólo admite parámetro de tipo carácter
▸ Boolean ob = Boolean.valueOf("false");
▸ Integer oi = Integer.valueOf(234);
▸ Double od = Double.valueOf("34.67");
El método de clase parseXxx() crea valores a partir de String.
▸ boolean b = Boolean.parseBoolean("true");
▸ int i = Integer.parseInt("234");
▸ double d = Double.parseDouble("34.67");
El método de clase ‘toString()’ crea String a partir de valores.
▸ String c = Character.toString('a');
▸ String b = Boolean.toString(true);
▸ String i = Integer.toString(234);
▸ String d = Double.toString(34.67);
Metodos de clase adicionales del envoltorio Character.
▸ boolean b = Character.isDigit(char); ▸ boolean b = Character.isSpaceChar(char);
▸ boolean b = Character.isLetter(char);
▸ boolean b = Character.isLowerCase(char); ▸ char c = Character.toLowerCase(char);
▸ boolean b = Character.isUpperCase(char); ▸ char c = Character.toUpperCase(char);
Los métodos de clase hashCode() y compare().
▸ int hb = Boolean.hashCode(true); ▸ int cb = Boolean.compare(true, false); // > 0
▸ int hc = Character.hashCode('a'); ▸ int cc = Character.compare('a', 'b'); // < 0
▸ int hi = Integer.hashCode(234); ▸ int ci = Integer.compare(234, 456); // > 0
▸ int hd = Double.hashCode(34.67); ▸ int od = Double.compare(34.67, 12.7); // < 0
Informática.
Envolver y desenvolver automáticamente
(boxing/unboxing)
Cuando sea necesario, el compilador realiza de forma automática la

conversión de tipos primitivos a objetos envoltorios y viceversa.
Double[] lista = new Double[20];
lista[i] = 45.5; // Envuelve automáticamente
double d = 5.2 + lista[j]; // Desenvuelve automáticamente
Integer v1 = Integer.valueOf(3);
Integer v2 = Integer.valueOf("42"); // Integer.parseInt("42");
Integer v3 = 35;
v1 += 5;
++v2;
v3 += v1;
System.out.println(v1+" "+v2+" "+v3); // 8 43 43
System.out.println(v1+"<"+v2+" "+(v1<v2?"true":"false")); // 8<43 true
System.out.println(v2+"=="+v3+" "+(v2==v3?"true":"false")); // 43==43 true
Tanto el método de instancia compareTo(T) como el método de clase

compare(T,T) permiten comparar dos objetos o valores primitivos. Devuelven
< == > que cero.

Informática.
Ejemplo
Diseñe una aplicación que permita almacenar y gestionar personas, donde una
persona contiene el nombre y el teléfono de la misma. Así, la aplicación
permitirá las siguientes operaciones:
Añadir una persona a la estructura de datos, donde los datos de una persona se
especifican según las siguientes alternativas. En caso de que se llene el array, se
deberá duplicar su capacidad.
1 Un objeto Persona.
2 El nombre y el teléfono como dos String.
3 El nombre y el teléfono como un String en el formato "nombre # tfn".
Buscar y mostrar los datos de personas a partir de su nombre, y por prefijo.
Mostrar toda la información almacenada.
Dos personas son iguales si tienen el mismo nombre, independientemente del
caso (mayúsculas o minúsculas) de las letras que lo componen.
Lanzar excepciones cuando surjan situaciones anómalas.
Crear un sistema de selección de personas basado en interfaz

Informática.
El paquete java.util
El paquete java.util contiene clases de utilidades.

La clase Random: generador de números aleatorios.
La clase genérica Optional<T>: representa datos opcionales.
La clase Scanner: entrada de datos.
Las colecciones: colecciones de datos organizadas adecuadamente (tema 5).
Contiene también interfaces y excepciones.
Etc. (consultar la documentación para más información).

Informática.
La clase java.util.Random
La clase Random proporciona un generador de números pseudo-aleatorios.
Los objetos de la clase random permiten generar números pseudo-aleatorios
que siguen una determinada distribución de probabilidad.
java.util.Random rnd = new java.util.Random();
Los siguientes metodos de instancia permiten generar números aleatorios que
siguen un distribución de probabilidad uniforme.
▸ int nextInt(int n); // 0 <= r < n
▸ int nextInt(); // Integer.MIN_VALUE <= r <= Integer.MAX_VALUE
▸ int nextLong(); // Long.MIN_VALUE <= r <= Long.MAX_VALUE
▸ float nextFloat(); // 0.0 <= r < 1.0
▸ double nextDouble(); // 0.0 <= r < 1.0 equiv. double Math.random()
▸ boolean nextBoolean(); // false, true
El siguiente metodo de instancia permite generar números aleatorios que
siguen un distribución de probabilidad normal (gausiana) con media 0 y
desviación típica 1.
▸ double nextGaussian(); // media 0 y desviación típica 1 (-3 < 99.7% < 3)
0.4
0.3
0.2
34.1% 34.1%
0.1
2.1% 2.1%
0.1% 13.6% 13.6% 0.1%
0.0
−3σ −2σ −1σ 0 1σ 2σ 3σ

Informática.
Ejemplo de uso de la clase java.util.Random
Ejemplo de generación de números aleatorios enteros entre 0 y 9 (ambos inclusive):
import java.util.Random;
public class EjemploRandom1 { public class EjemploRandom2 {
private Random rnd = new Random();
private int[] datos; private int[] datos;
public EjemploRandom1(int nelms) { public EjemploRandom2(int nelms) {
datos = new int[nelms]; datos = new int[nelms];
for (int i = 0; i < datos.length; ++i) { for (int i = 0; i < datos.length; ++i) {
datos[i] = (int)(10 * Math.random()); datos[i] = (int)(10 * rnd.nextDouble());
} }
} }
} }
// Gen. dist. Normal números reales entre 0 y 10

import java.util.Random; import java.util.Random;
public class EjemploRandom3 { public class EjemploRandom4 {
private Random rnd = new Random(); private Random rnd = new Random();
private int[] datos; private double[] datos;
public EjemploRandom3(int nelms) { public EjemploRandom4(int nelms) {
datos = new int[nelms]; datos = new double[nelms];
for (int i = 0; i < datos.length; ++i) { for (int i = 0; i < datos.length; ++i) {
datos[i] = rnd.nextInt(10); datos[i] = rnd.nextGaussian()*5.0/3.0+5.0;
} if (datos[i] < 0.0) { datos[i] = 0.0; }
} if (datos[i] > 10.0) { datos[i] = 10.0; }
} }
}
}
Informática.
La clase genérica java.util.Optional<T>
La clase genérica java.util.Optional<T> permite modelar situaciones

donde un determinado objeto puede existir o no (en vez de utilizar null).
A veces, es una alternativa a lanzar una excepción.
Un objeto de la clase Optional puede contener a otro objeto de la clase T (o
derivada), pero también puede ser que este objeto contenido no exista.
Creación de objetos Optional:
▸ Optional<String> os1 = Optional.empty(); // objeto Optional vacío
▸ Optional<String> os2 = Optional.of(“hola”); // objeto Optional con contenido
Metodos de instancia:
▸ boolean isPresent(); // devueve true si el objeto contenido existe
▸ T get(); // devuelve el objeto contenido (NoSuchElementException)
▸ T orElse(T alt); // devuelve el objeto contenido o el alternativo
▸ boolean equals(Object o); // compara ambos objetos Optional y contenidos
▸ int hashCode(); // hashCode del contenido o cero si vacío

Informática.
Ejemplo de uso de java.util.Optional<T>
public static Optional<Persona> buscar(Persona[] datos, String nombre) {

int i = 0;
while ((i < datos.length)&&(! nombre.equals(datos[i].getName()))) {
++i;
}
Optional<Persona> r;
if (i < datos.length) {
r = Optional.of(datos[i]);
} else {
r = Optional.empty();
}
return r;
}
Persona[] datos /* = ... */ ;
Optional<Persona> op = buscar(datos, "Pepe");
if (op.isPresent()) {
System.out.println(op.get());
}
}

Informática.
La clase java.util.Scanner
La clase java.lang.System proporciona dos variables estáticas, out para el
flujo de salida de texto a consola (pantalla) e in para flujo de entrada de texto
desde teclado.
La clase Scanner permite crear objetos asociados a flujos de entrada para
realizar una entrada de datos fácil y flexible.
java.util.Scanner teclado = new java.util.Scanner(System.in);
Proporciona los siguientes métodos de instancia para la entrada de texto:
▸ String nextLine(); // lee y devuelve la siguiente línea como String
▸ String next(); // lee y devuelve el siguiente token como String
▸ int nextInt(); // lee y devuelve el siguiente token como int
▸ double nextDouble(); // lee y devuelve el siguiente token como double
▸ boolean nextBoolean(); // lee y devuelve el siguiente token como boolean
▸ Scanner skip(String regex); // salta y elimina los caracteres según regex
Lanzan las siguientes excepciones en caso de error:
▸ NoSuchElementException // si no hay más datos disponibles
▸ InputMismatchException // si el dato a leer no es del tipo esperado
Se debe cerrar el objeto scanner cuando finaliza el procesamiento de texto.
▸ void close();
Informática.
Tanto si la ejecución termina con éxito, como si se produce alguna excepción,
el objeto Scanner será cerrado automáticamente al utilizar la sentencia
“try-con-recursos”.
Nótese que en este caso, el flujo de entrada System.in también será cerrado
automáticamente, y no podrá ser utilizado posteriormente.
import java.util.Scanner;
class EjScanner {
try (Scanner teclado = new Scanner(System.in)) {
System.out.print("Introduzca su nombre:");
String nombre = teclado.next();
System.out.print("Introduzca su edad:");
int edad = teclado.nextInt();
// ...
} catch (InputMismatchException e) {
// ...
} catch (NoSuchElementException e) {
// ...
}
}
}

Informática.
Proporciona los siguientes métodos de instancia para comprobar si hay datos
disponibles del tipo adecuado:
▸ boolean hasNextLine(); // devuelve true hay una línea disponible
▸ boolean hasNext(); // devuelve true hay un token disponible
▸ boolean hasNextInt(); // devuelve true si el siguiente token es int
▸ boolean hasNextDouble(); // devuelve true si el siguiente token es double
▸ boolean hasNextBoolean(); // devuelve true si el siguiente token es boolean
Delimitadores para nextLine(): "\r\n|[\n\r\u2028\u2029\u0085]"
Por defecto los delimitadores para tokens son espacios, tabuladores y nueva
línea ("[ \t\n\r\f]+"), pero se pueden establecer otros:
▸ Scanner useDelimiter(String regex); // delimitadores para TOKENS
Los delimitadores son expresiones regulares. Por ejemplo:
▸ "[,;:]" // Exactamente uno de entre ,;:
▸ "[,;:]+" // Uno o más de entre ,;:
▸ "[^a-zA-Z0-9]" // Cualquier carácter que no sea una letra o dígito
▸ "[,;:] ?" // Uno de entre ,;: seguido por un espacio opcional
▸ "\\s*[,;:]\\s*" // Uno de entre ,;: entre múltiples [ \t\n\r\f] opcionale
Se puede especificar la localización para la lectura de números. Afecta, entre
otros, al símbolo del punto decimal:
▸ Scanner useLocale(Locale locale); // Locale.ENGLISH, Locale.FRENCH
Informática.
Tanto si la ejecución termina con éxito, como si se produce alguna excepción,
el objeto Scanner será cerrado automáticamente al utilizar la instrucción
“try-con-recursos”.
Podemos comprobar si los datos son correctos, y desechar los erróneos.
class EjScanner {
while ( ! teclado.hasNextInt() ) {
teclado.next(); // descartamos la entrada
System.out.print("Introduzca su edad de nuevo:");
}
// ...
// ...
// ...
}
}
} y Ciencias de la Computación. E.T.S.I.Tema
Dpto. Lenguajes Informática.
Podemos especificar el formato de la localidad en la entrada de datos:
import java.util.*;
class EjScanner {
public static double leerNumeroReal(Scanner sc) {
double valor;
try {
sc.useLocale(Locale.ENGLISH);
valor = sc.nextDouble();
sc.useLocale(Locale.FRENCH);
valor = sc.nextDouble();
}
return valor;
}
System.out.print("Introduzca su nota:");
double nota = leerNumeroReal(teclado);
System.out.printf("[%s] [%f]\n", nombre, nota);
System.out.printf(Locale.FRENCH, "[%s] [%f]\n", nombre, nota);
System.out.printf(Locale.ENGLISH, "[%s] [%f]\n", nombre, nota);
} catch (InputMismatchException e) { // ...
} catch (NoSuchElementException e) { // ...
}
}
}
Informática.
La clase java.util.Scanner. Extracción desde String
La clase Scanner también permite crear objetos scanner asociados a objetos
de tipo String, así como también sobre otras clases de entrada de datos.
public class Main {
try (Scanner sc = new Scanner("hola a ; todos. como-estas")) {
// Delimitadores: espacio . , ; - una o más veces (+)
sc.useDelimiter("[ .,;-]+");
while (sc.hasNext()) {
String cad = sc.next();
System.out.println("[" + cad + "]");
}
// muestra los tokens: [hola] [a] [todos] [como] [estas]
}
}
}
En este caso, la funcionalidad es similar al método split() de la clase
String. Sin embargo, existe una diferencia: el método next() de Scanner
salta los delimitadores iniciales y devuelve el siguiente token, y este hecho
afecta en el caso de que la cadena comience por un delimitador (en este caso,
el primer token devuelto por split() es un token vacío).
Informática.
Ejemplo de la clase java.util.Scanner
Los datos de las personas se especifican en líneas (separadas por \n). Cada
línea contiene el nombre y la edad de una persona (separados por uno de ,:-)
public class Main {
String datos = "Juan García, 23\nPedro González: 15\n"
+ "Luisa López - 19\nAndrés Molina-22\n";
try (Scanner sc1 = new Scanner(datos)) {
while (sc1.hasNextLine()) {
String linea = sc1.nextLine();
try (Scanner sc2 = new Scanner(linea)) {
sc2.useDelimiter("\\s*[,:-]\\s*");
String nombre = sc2.next();
int edad = sc2.nextInt();
Persona persona = new Persona(nombre, edad);
System.out.println(persona);
}
}
}
}
}

Informática.
Ejemplo de la clase java.util.Scanner
Los datos de las personas se especifican en líneas (separadas por .). Cada línea
contiene el nombre y la edad de una persona (separados por uno de ,:-)
public class Main {
String datos = "Juan García, 23. Pedro González: 15."
+ "Luisa López - 19. Andrés Molina-22";
try (Scanner sc1 = new Scanner(datos)) {
sc1.useDelimiter("\\s*[.]\\s*");
while (sc1.hasNext()) {
String linea = sc1.next();
try (Scanner sc2 = new Scanner(linea)) {
sc2.useDelimiter("\\s*[,:-]\\s*");
String nombre = sc2.next();
int edad = sc2.nextInt();
Persona persona = new Persona(nombre, edad);
System.out.println(persona);
}
}
}
}
}

Informática.
Realizar la entrada de datos orientada línea entremezclada con los otros
métodos orientados a tokens causa problemas.
class EjScanner {
for (int i = 0; i < 5; ++i) {
teclado.skip("\\s*"); // elimina todos los espacios y nl
String nombre = teclado.nextLine();
teclado.skip(".*\n"); // elimina todo hasta nueva línea
// ...
System.out.println("[" + nombre + ", " + edad + "]");
}
// ...
// ...
}
}
}
Informática.
Entrada/Salida. El paquete java.io
La entrada y salida de datos se refiere a la transferencia de datos entre un

programa y los dispositivos:
de almacenamiento (ej. disco, pendrive).
de comunicación.
con humanos (ej. teclado, pantalla, impresora).
con otros sistemas (ej. tarjeta de red, router).
La entrada (lectura) se refiere a los datos que recibe el programa y la salida
(escritura) se refiere a los datos que el programa envía.
Ya hemos visto la entrada de teclado y la salida a pantalla.
Ahora con el paquete java.io vamos a tratar la entrada/salida con ficheros.
El paquete java.io se compone de una serie de interfaces, clases y
excepciones destinadas a definir y controlar:
El sistema de ficheros.
Los distintos tipos de flujos de entrada y salida.
Las serializaciones de objetos.

Informática.
Ficheros
Los ficheros (archivos) permiten almacenar la información de forma

permanente en el sistema de almacenamiento.
Un fichero contiene cierta información codificada, que se almacena en una
memoria como una secuencia de bytes.
Cada fichero recibe un nombre (posiblemente con una extensión) y se ubica
dentro de un directorio (carpeta) que forma parte de una cierta jerarquía
(ruta, camino o vía de acceso).
El nombre y la ruta, o secuencia de directorios, que hay que atravesar para
llegar a la ubicación de un fichero, identifican a dicho fichero de forma
unívoca dentro del sistema de ficheros.
Se utilizará el símbolo / para separar los componentes de la ruta del fichero
(Unix, MacOSX y Windows).
En caso de utilizar la barra invertida como carácter separador en cadenas de
caracteres, entonces se debe duplicar (\\), ya que representa el símbolo de
escape (Windows).

Informática.
Operaciones con ficheros
Apertura: establece una conexión entre una variable (manejador del fichero)
dentro del programa y un determinado fichero dentro del sistema de
almacenamiento. En caso de apertura para entrada, el fichero debe existir. En
caso de apertura para salida, se borrará o creará un nuevo fichero.
Escritura: para poder almacenar información en un fichero, una vez abierto en
modo de escritura, hay que transferir la información organizada de alguna
forma mediante operaciones de escritura.
Lectura: para poder utilizar la información contenida en un fichero, debe estar
abierto en modo de lectura, y hay que utilizar las operaciones de lectura
adecuadas a la organización de la información contenida en dicho fichero.
Cierre: cuando se ha terminado de transferir la información a o desde el
fichero, se debe cerrar la conexión previamente establecida entre la variable
manejador del fichero y el fichero en el sistema de almacenamiento. Esta
operación se ocupa además de mantener la integridad del fichero, escribiendo
previamente la información que se encuentre en algún buffer intermedio en
espera de pasar al fichero.

Informática.
La clase java.io.File
Representa la identificación (caminos abstractos independientes del S.O.) de

un determinado fichero dentro de un sistema de ficheros.
Un objeto de esta clase contiene información sobre el nombre y la ruta de un
fichero o de un directorio dentro de un sistema de ficheros.
Los objetos de esta clase se pueden crear tanto para directorios y ficheros que
ya existan, como para aquellos que no existan.
Constructores:
▸ File(String ruta, String nombre);
▸ File(File ruta, String nombre);
▸ File(String ruta); // "/dir1/dir2/nombre.txt"
Algunos métodos públicos:

▸ boolean exists(); // comprueba si existe el directorio o fichero
▸ boolean delete(); // elimina el directorio o fichero especificado
▸ boolean mkdir(); // crea el directorio especificado
▸ boolean mkdirs(); // crea la jerarquía de directorios especificada
▸ boolean renameTo(File); // cambia el nombre de un directorio o fichero
▸ static final String separator; // especifica el carácter separador en la ruta

Informática.
Lectura de fichero con File y Scanner
1 Constructores de la clase Scanner:
▸ Scanner(String datos); // extrae la información de DATOS
▸ Scanner(File nombreFichero); // extrae la información del fichero
▸ Scanner(InputStream input); // System.in
2 Crear un objeto File sobre un nombre de fichero y crear un objeto Scanner
sobre el objeto File creado (puede lanzar FileNotFoundException).
java.util.Scanner sc = new java.util.Scanner(new java.io.File("datos.txt"));
3 Leer líneas con hasNextLine() y nextLine() las veces que sean necesarias.
También se pueden utilizar los otros métodos de entrada de la clase Scanner.
while (sc.hasNextLine()) {
String linea = sc.nextLine();
// ... procesar la información leída del fichero
}
4 En el caso de que el fichero esté organizado en líneas, se aconseja realizar la
lectura en dos niveles. En un primer nivel se leen las líneas con nextLine(),
y en un segundo nivel, se extrae la información de la línea y se procesa.
5 Cerrar el objeto Scanner. Si el objeto se crea dentro de una sentencia
“try-con-recursos”, entonces se cierra automáticamente.
sc.close();
Informática.
Lectura de fichero con File y Scanner
import java.io.File;
import java.io.IOException;
public class Ejemplo {
try (Scanner sc = new Scanner(new File("datos.txt"))) {
while (sc.hasNextLine()) {
String linea = sc.nextLine();
procesarLinea(linea);
}
} catch (IOException e) {
System.out.println("ERROR: no se puede leer del fichero");
}
}
private static void procesarLinea(String linea) {
try (Scanner sc = new Scanner(linea)) {
sc.useDelimiter("\\s*[,;:.]\\s*");
while (sc.hasNext()) {
String palabra = sc.next();
System.out.println(palabra);
}
}
}
private static void procesarLineaAlternativoSplit(String linea) {
String[] datos = linea.split("\\s*[,;:.]\\s*");
for (String palabra : datos) {
System.out.println(palabra);
}
}
} Lenguajes y Ciencias de la Computación. E.T.S.I.Tema
Dpto. Informática.
La clase java.io.PrintWriter
Los objetos de la clase PrintWriter permiten escribir objetos y tipos

primitivos sobre flujos de salida de texto.
Constructores:
▸ PrintWriter(String nombreFichero); // incluye la ruta completa
▸ PrintWriter(File fichero); // incluye la ruta completa
▸ PrintWriter(Writer out); // FileWriter
▸ PrintWriter(OutputStream out, boolean autoFlush); // (System.out, true)
Métodos de instancia para escribir todos los tipos básicos y objetos:
▸ void print(...); // escribe tipos primitivos y objetos
▸ void println(...); // escribe tipos primitivos y objetos
▸ void printf(String formato, ...); // escribe con formato
▸ void printf(Locale loc, String formato, ...); // escribe con loc y formato
▸ void flush(); // fuerza la salida de datos
Se debe cerrar el objeto PrintWriter cuando finaliza el procesamiento de
texto.
▸ void close();

Informática.
Escritura sobre un fichero de texto
1 Crear un objeto PrintWriter utilizando un nombre de fichero (puede lanzar

FileNotFoundException).
java.io.PrintWriter pw = new java.io.PrintWriter("datos.txt");
2 Escribir sobre el objeto PrintWriter las veces que sean necesarias,
atendiendo al formato del fichero.
pw.println("Hola a todos");
3 Cerrar el objeto PrintWriter. Si el objeto se crea dentro de una sentencia
“try-con-recursos”, entonces se cierra automáticamente.
pw.close();

Informática.
Escritura sobre un fichero de texto
import java.io.PrintWriter;

private static final String[] DATOS = { "hola", "como", "estás" };
private static void imprimirDatos(PrintWriter pw) {
for (String pal : DATOS) {
pw.println(pal);
}
}
// Crear un nuevo fichero de palabras
try (PrintWriter pw = new PrintWriter(args[0])) {
imprimirDatos(pw);
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("ERROR: falta el nombre del fichero");
System.out.println("ERROR: no se puede escribir en el fichero");
}
}
}

Informática.
Añadir datos a un fichero de texto ya existente (Append)
import java.io.FileWriter;
pw.println(pal);
}
}
// Añadir información a un fichero de palabras
try (PrintWriter pw = new PrintWriter(new FileWriter(args[0], true))) {
imprimirDatos(pw);
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("ERROR: falta el nombre del fichero");
System.out.println("ERROR: no se puede escribir en el fichero");
}
}
}

Informática.
Asociar un Objeto PrintWriter a la Consola System.out
pw.println(pal);
}
}
// Enviar información a consola a través de PrintWriter
// En este caso no se puede utilizar try-con-recursos
// ni tampoco se puede cerrar el PrintWriter, ya que
// entonces también cerraría la consola System.out
PrintWriter pw = null;
try {
pw = new PrintWriter(System.out, true); // TRUE --> auto-flush
imprimirDatos(pw);
} finally {
if (pw != null) {
pw.flush(); // flush fuerza el volcado de los datos a consola
}
}
}
}
Informática.
Ejemplo
Diseñe una aplicación que permita almacenar y gestionar personas, donde una
persona contiene el nombre y el teléfono de la misma. Así, la aplicación
permitirá las siguientes operaciones:
Añadir una persona a la estructura de datos, donde los datos de una persona se
especifican según las siguientes alternativas. En caso de que se llene el array, se
deberá duplicar su capacidad.
1 Un objeto Persona.
2 El nombre y el teléfono como dos String.
3 El nombre y el teléfono como un String en el formato "nombre # tfn".
Buscar y mostrar los datos de personas a partir de su nombre, y por prefijo.
Mostrar toda la información almacenada.
Cargar los datos de personas desde un fichero de texto, considerando que los
datos de cada persona se encuentran en una línea de texto, donde el nombre
está separado del teléfono por un símbolo #.
Guardar los datos almacenados en un fichero de texto, en un formato adecuado
según lo especificado por la operación de cargar.
Dos personas son iguales si tienen el mismo nombre, independientemente del
caso (mayúsculas o minúsculas) de las letras que lo componen.
Lanzar excepciones cuando surjan situaciones anómalas.
Crear un sistema de selección de personas basado en interfaz
Informática.

Poo 4 Cbasic

Cargado por

Copyright:

Formatos disponibles

Poo 4 Cbasic

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Poo 4 Cbasic

Cargado por

Copyright:

Formatos disponibles

Tema 4. Clases Básicas Predefinidas.

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I. Informática.

Programación Orientada a Objetos

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I.Tema

Tema 4. Clases básicas predefinidas. Entrada/Salida

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I.Tema

Un paquete en Java es un mecanismo de organización que permite agrupar

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I.Tema

Desde fuera de un paquete sólo se puede acceder a clases e interfaces

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I.Tema

La API de Java (Java Application Programming Interface) es la especificación

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I.Tema

La clase System proporciona objetos para entrada/salida, y funcionalidades del

- Etc. (consultar la documentación para más información).

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I.Tema

La clase Math proporciona constantes numéricas y funciones matemáticas.

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I.Tema

- Etc. (consultar la documentación para más información).

Usualmente NO es adecuada la implementación por defecto, y en caso de ser

boolean equals(Object o): indica si otro objeto es igual al objeto actual.

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I.Tema

boolean equals(Object o): indica si otro objeto es igual al objeto actual.

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I.Tema

Las cadenas de caracteres se representan en Java como secuencias de

Para manipular cadenas de caracteres, por razones de eficiencia, se utilizan dos

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I.Tema

Cada objeto de la clase String contiene una cadena de caracteres.

Los objetos de la clase String en Java son inmutables.

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I.Tema

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I.Tema

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I.Tema

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I.Tema

String s2 = "El agua:es;buena";

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I.Tema

Por ejemplo, dado el siguiente objeto de tipo String:

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I.Tema

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I.Tema

Los valores de los tipos primitivos no son objetos.

Tipo Primitivo Envoltorio

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I.Tema

Cuando sea necesario, el compilador realiza de forma automática la

Tanto el método de instancia compareTo(T) como el método de clase

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I.Tema

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I.Tema

El paquete java.util contiene clases de utilidades.

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I.Tema

−3σ −2σ −1σ 0 1σ 2σ 3σ

// Gen. dist. Normal números reales entre 0 y 10

La clase genérica java.util.Optional<T> permite modelar situaciones

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I.Tema

public static Optional<Persona> buscar(Persona[] datos, String nombre) {

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I.Tema

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I.Tema

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I.Tema

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I.Tema

La entrada y salida de datos se refiere a la transferencia de datos entre un

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I.Tema

Los ficheros (archivos) permiten almacenar la información de forma

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I.Tema