(Apuntes de Java)

APUNTES DE JAVA

1/89
(Apuntes de Java)

Secuencias de escape
●
Son constantes de caracter que podemos incluir dentro de
un texto para reproducir un comportamiento especial
Secuencia Qué hace Ejemplo

[Link]("Este es\n un\n ejemplo");

\n Inserta una nueva línea //Este es
// un
// ejemplo
[Link]("Este es\t un\t ejemplo");
\t Inserta un tabulador //Este es un ejemplo

[Link]("Este es\\ un\\ ejemplo");

\\ Inserta una contrabarra //Este es\ un\ ejemplo

[Link]("Este es \"un ejemplo\"");

\” Inserta una comilla doble //Este es "un ejemplo"

[Link]("Este es \'un ejemplo\'");

\’ Inserta una comilla simple //Este es 'un ejemplo'

2/89
(Apuntes de Java)

Math ([Link])
[Link]

Función Qué hace Ejemplo

[Link](v) Redondea al más cercano (float y double) [Link](2.6f); //3
[Link](34.36); //34
[Link](v) Calcula la raiz cuadrada de un double [Link](81.0); // 9.0
[Link](v) Devuelve el valor más bajo calculado a [Link](2.6f); //2.0
[Link](34.36); //34.0
partir del parámetro (valor suelo)
[Link](v) Devuelve el valor más alto calculado a [Link](2.6f); //3.0
[Link](34.36); //35.0
partir del parámetro
[Link](v) Devuelve el valor absoluto de un número [Link](2.6f); //2.6
[Link](-2.6f);//2.6
[Link](a,b) Devuelve el mayor de dos valores pasados [Link](14,5); //14
por argumento
[Link](a,b) Devuelve el menor de dos valores pasados [Link](14,5); //5
por argumento
[Link](a,b) Devuelve la potencia de a elevado a b [Link](2,3); //8
3/89
(Apuntes de Java)

El objeto String ([Link])

[Link]

Función Qué hace

[Link](v) Devuelve true si el parámetro (texto o caracter) está contenido en la
cadena, false en caso contrario

String texto="Con diez cañones por banda";

[Link]([Link]("por")); //true
[Link]([Link]("canción")); //false
[Link]([Link]("b")); //true
[Link]([Link]("h")); //false
[Link](v) Devuelve true si una cadena acaba con el texto incluído en el parámetro.

String texto="Con diez cañones por banda";

[Link]("banda"); //true
[Link]("da"); //true
[Link]("pa"); //false

4/89
(Apuntes de Java)

El objeto String ([Link])

[Link]

Función Qué hace

[Link](v) Devuelve true si la cadena es exactamente igual (idéntica) al
parámetro

String texto="Con diez...";

String texto2 ="Con diez...";
[Link](texto2); //true
[Link](num) Devuelve el carácter situado en la posición num del parámetro del
texto (empieza en 0)

String texto="Con diez...";

[Link]([Link](2)); // n
[Link]() Convierte a mayúsculas un texto.

String texto="Con diez cañones por banda...";

[Link]([Link]()); // CON DIEZ CAÑONES POR
BANDA...

5/89
(Apuntes de Java)

El objeto String ([Link])

[Link]

Función Qué hace

[Link]() Convierte a minúsculas un texto.

String texto="AGUA MINERAL NATURAL";

[Link]([Link]()); // agua
mineral natural
[Link](int inicio) Devuelve una subcadena de un texto desde la
posición inicio

String texto="Agua Mineral Natural";

[Link]([Link](5));
//Mineral Natural
[Link](int desde, int hasta) Devuelve una subcadena de un texto desde la
posición inicio hasta la posición final.
(*) hasta es no inclusive
String texto="Agua Mineral Natural";
[Link]([Link](5,10));
//Miner
6/89
(Apuntes de Java)

El objeto String ([Link])

[Link]

Función Qué hace

[Link](str) Devuelve un número que indica la primera posición donde se encuentra str
dentro de un texto. Devuelve -1 si no encuentra nada.
[Link](str, Si le pasamos el segundo parámetro ‘indice’, empieza a buscar desde este
indice) indice.

String texto="Con nada de dinero en mis bolsillos...";

[Link]("n"); //2
[Link]("nada"); //4
[Link]("dinero"); //12
[Link]("z"); //-1
[Link]("n", 2); //4
[Link](str) Similar a indexOf() pero empezando la búsqueda por el final del texto.
Si le pasamos el segundo parámetro ‘indice’, la búsqueda empezará desde
[Link](str, indice hasta el inicio del texto.
indice)
String texto="Con nada de dinero en mis bolsillos...";
[Link]("n"); //20
[Link]("nada"); //4
[Link]("dinero"); //12
[Link]("z"); //-1
[Link]("n", 6); //4
7/89
(Apuntes de Java)

El objeto String ([Link])

[Link]

Los objetos String en Java son en realidad un array de caracteres. Por ejemplo,
String saludo = “hola”; internamente es,
saludo[0]; → ’h’;
saludo[1]; → ’o’;
saludo[2]; → ’l’;
saludo[3]; → ’a’;

Los objetos String en Java son inmutables, esto es, no puede ser cambiados
internamente.
No podemos cambiar el valor de un caracter, [Link]., si queremos cambiar ‘o’ por ‘e’ en
la variable saludo de la siguiente forma saludo[1] = ‘e’; Java nos dará un error.

La forma como podemos obtener el resultado sería declarar una nueva variable String:
String saludoTemp = [Link](0)+"e"+[Link](2); //hela

8/89
(Apuntes de Java)

Recoger un valor desde terminal

import [Link]; Necesitamos importar la clase Scanner desde [Link]
...

public static void main(String[] args) {

Scanner in = new Scanner([Link]);

[Link]("Escribe unas palabras...");

String linea = [Link](); //recojemos un texto
[Link]("Has introducido el texto: "+linea);

[Link]("Escribe un numero...");
int numero = [Link](); //recojemos un numero
[Link]("Has introducido el numero entero: "+numero);

[Link]("Escribe un numero con decimales...");

float numeroDecimal = [Link](); //recojemos un numero con
decimales
[Link]("Has introducido el numero tipo float:
"+numeroDecimal);
}

9/89
(Apuntes de Java)

El operador ternario

result = (condición) ? valor true : valor false

int val1 = 10;

int val2 = 20;
int max = (val1 >= val2) ? val1 : val2; // max = 20

int num = 8;
String mensaje = (num > 10) ? "El número es mayor de 10" : "El número es igual o menor que 10";
//El número es igual o menor que 10

double num = -5.5;

String resultado;
resultado = (num > 0.0) ? "positivo" : "no positivo"; //no positivo

10/89
(Apuntes de Java)

Excepciones
●
Cuando se produce un error en código, Java
internamente lanza/arroja (throw) una excepción y
se para la ejecución

●
Existe una forma de intentar (try) capturar (catch)
estos errores, y poder tratarlos para no interrumpir
la ejecución del código: con try-catch

●
Existen diferentes tipo de errores/excepciones en
Java dependiendo de su naturaleza o causa.

11/89
(Apuntes de Java)

Excepciones
●
Una excepción puede ocurrir por diversas causas,
por ejemplo:
– Un usuario introduce incorrectamente un carácter
cuando el programa pedía un número
– Un fichero que se va a leer no existe en la ruta
proporcionada
– Una conexión se pierde en mitad de una comunicación
– El JVM (máquina virtual de Java) se queda sin memoria
12/89
(Apuntes de Java)

Excepciones
●
Java reconoce tres categorías o fuentes de errores:

Excepciones controladas Excepciones no controladas Errores

o comprobadas o no comprobadas (no capturables)
(checked) (unchecked)

13/89
(Apuntes de Java)

Excepciones
Excepciones controladas o comprobadas (checked)
El programador/a no es el responsable del error ([Link]. un fichero que no se ha
encontrado en su sitio).Son excepciones detectadas por el compilador: el
programa no compilará a no ser que se capturen las excepciones

Excepciones no controladas o no comprobadas (unchecked)

el programa es correcto sintácticamente y por tanto compilado, pero la
excepción surge durante la ejecución del programa, son llamadas también
Runtime Exceptions. El programador/a sí es el responsable

Errores (*)
cualquier error ajeno al programa y no manejable o capturable

(*) Según la documentación oficial de Java:

“An Error is a subclass of Throwable that indicates serious problems that a reasonable application should not
try to catch. Most such errors are abnormal conditions.”
“Un Error es una subclase de Throwable que indica problemas serios que una aplicación razonable no debería
intentar capturar (try-catch). La mayoría de estos errores se producen en condiciones anormales”
14/89
(Apuntes de Java)

Árbol de clases Java

correspondiente al
tratamiento de errores

Cada vez que se produce un error en Java

se devuelve un objeto de un tipo que
hereda o bien de la clase Exception, o bien
de la clase Error, y en última instancia de
la clase Throwable

Todas las subclases de Exception (excepto RuntimeException

y sus subclases) se consideran excepciones comprobadas o
controladas (checked exceptions)
([Link]

RuntimeException: excepciones en tiempo de ejecución

(no comprobadas, unchecked)

15/89
(Apuntes de Java)

Ejemplo de Excepción en tiempo de ejecución

(Runtime Exception) (no controlada)
Este indice no existe, por lo tanto Java arroja una
excepción del tipo
public class EjRuntimeException { ArrayIndexOutOfBoundsException (fuera de los
límites):
public static void main(String[] args) {
Exception in thread "main"
int[] unArray = {0,1,2}; [Link]

int posicionCuarta = unArray[3];

[Link]("PosicionCuarta es:" + posicionCuarta);
}
}
En las excepciones no controladas es el programador/a el
responsable del error producido, es decir, el error se produce
por un ‘descuido’ del programador.

16/89
(Apuntes de Java)

Ejemplo de Excepción en tiempo de ejecución

(Runtime Exception) (no controlada)
public class EjRuntimeException {
public static void main(String[] args) {
int[] unArray = {0,1,2};

try {
int posicionCuarta = unArray[3];
[Link]("PosicionCuarta es:" + posicionCuarta);

} catch (ArrayIndexOutOfBoundsException excepcionCapturada){

[Link]("Se ha producido un error:" +
excepcionCapturada);
}
[Link]("Sigo ejecutando código...");
}
}
17/89
(Apuntes de Java)

Ejemplo de Excepción controlada (checked exception)

import [Link]; En las excepciones controladas,
import [Link]; Java obliga a utilizar try-catch antes
import [Link];
de compilar el código para capturar el
public class EjIOException { posible error que pudiera ocurrir.
Nótese que la clase FileReader lanza
public static void main(String[] args) { (throws) una excepción en su
//Ejemplo de checked exception declaración del constructor
File file=new File("c://[Link]");

try {
FileReader fr = new FileReader(file);
} catch (FileNotFoundException e) {
[Link]("Excepción capturada: El fichero no existe.");
}
}
} Nota: en las excepciones no controladas,
Java no obliga a utilizar try-catch
18/89
(Apuntes de Java)

Excepciones: lanzamiento

Las excepciones pueden lanzarse para

posteriormente ser recogidas o
capturadas por un try-catch.
Este lanzamiento puede realizarse
mediante throw o throws

19/89
(Apuntes de Java)

Excepciones: lanzamiento - throws

●
Cuando un método lleva throws en su declaración significa que si hay un error se
lanzará una Excepción de un tipo concreto que deberá ser recogida en algún otro
lugar del programa. Es decir, se delega la responsabilidad de capturar la Excepción
en otro método.
En el ejemplo de arriba, si hay un error se lanzará una Excepción (un objeto
perteneciente a la clase FileNotFoundException), pero si todo va bien, el constructor
hará lo que tenga que hacer cumpliendo con su código.
●
Podemos lanzar cualquier tipo de Excepción, tanto de la clase RuntimeException
y sus subclases (excepciones no controladas) como de la clase Exception y sus
subclases (excepciones controladas)

20/89
(Apuntes de Java)

Excepciones: lanzamiento - throws

En caso de utilizar Exception (excepción general) o una de sus subclases (todas
excepto RuntimeException), Java nos obligará a utilizar try-catch durante su
compilación, y si estamos utilzando Eclipse, durante su escritura.
No sucederá así si lanzamos una RuntimeException o alguna de sus subclases, es
decir, Java no obligará a capturar la excepción a través de un try-catch.
public class ExceptionPruebas {

public static void main(String[] args) {

try {
[Link](division(6,0));
} catch(Exception e) {
[Link]("Se ha producido un error:"+e);
}
}

public static int division(int numerador, int denominador) throws Exception

{
if (denominador == 0) {
throw new Exception("Se necesita un denominar distinto de cero");
}

return numerador/denominador;
}
}
21/89
(Apuntes de Java)

Excepciones: lanzamiento - throw

●
Throw nos permite como programadores lanzar la Excepción cuando lo
deseemos.
●
Se denomina lanzamiento manual de Excepciones porque es el
programador/a el que define el momento de su lanzamiento.
●
Las diferencias entre throw y throws:
- throws se declara en la declaración del método e indica la
posibilidad de que pueda surgir un error y por tanto poderse capturar
en otra zona del programa. La Excepción se lanza cuando
efectivamente se produce el error.
- throw indica el lugar del código dónde se lanzará la Excepción. El
programador/a define cuándo y bajo qué circunstancias se lanzará.

22/89
(Apuntes de Java)

Excepciones: lanzamiento - throw

public static void main(String[] args) {
Y aquí se
try { recoge la
int resultado = division(10,0); excepción
lanzada
[Link]("Division:" + resultado);

} catch ([Link] excepcionAritmetica) {

[Link]("Ha ocurrido un error: division entre 0");
}
}
public static int division(int numerador, int denominador) {
if (denominador == 0) {
throw new [Link](); se lanza
} la excepción

return numerador/denominador;
}
23/89
(Apuntes de Java)

Excepciones: anidar catch

public class TryCatchEjemplo {

public static void main(String[] args) {

int[] unArray = {0,1,2};
try {
int posicionCuarta = unArray[3];

[Link]("PosicionCuarta es:" + posicionCuarta);

} catch ([Link] excepcionDeArray){
[Link]("Se ha producido un error. Del tipo
ArrayIndexOutOfBoundsException");
} catch (Exception excepcionCapturada){
[Link]("Se ha producido un error. Del tipo:" +
excepcionCapturada);
}

[Link]("Sigo ejecutando código...");

}
}
24/89
(Apuntes de Java)

Excepciones: try-catch-finally
Imaginemos que estamos cocinando algo en el horno… Sea cual fuera
el resultado de la cocción, tanto si se ha horneado correctamente
como si no, al final de la cocción apagaremos el horno.
●
El código que englobe la cláusula finally se ejecutará
tanto si try-catch ha capturado una excepción como si no.

int[] unArray = {0,1,2};

try {
int posicionCuarta = unArray[3];
[Link]("PosicionCuarta es:" + posicionCuarta);
}catch ([Link] excepcionDeArray) {
[Link]("Se ha producido un error. Del tipo ArrayIndexOutOfBoundsException");
} finally{
[Link]("Finalmente, muestro el array:" + [Link](unArray));
}

[Link]("Sigo ejecutando código...");

25/89
(Apuntes de Java)

Excepciones: notas
●
Muchas veces por miedo a que el programe falle o se
interrumpa, el código se llena con sentencias try-catch, y
esto no es lo correcto. Los errores son fuentes de
información que una vez corregidos y tratados hacen que
un programa sea más estable. Es mejor preveer los
posibles errores que utilizar try-catch.
●
Utilizar try-catch en un código muy extenso es caro
computacionalmente hablando, es preferible utilizar
pequeños try-catch localizados con pocas líneas de
código a uno que incluya código muy extenso.
26/89
(Apuntes de Java)

Excepciones: notas
●
La diferencia entre errores y excepciones es que
los errores pueden corregirse y anticiparse,
pueden ser equivocaciones en la escritura de
código o maltinterpretaciones del Contexto, y las
excepciones son errores excepcionales. Un error
puede tratarse de antemano, por ejemplo, si
hemos hecho un programa que escriba líneas de
texto en un fichero, nos podría dar un error si
sobrepasamos el límite de tamaño del fichero, y
este error es previsible. Una excepción sería si en
el momento de escribir en el fichero se va la luz,
el disco duro se estropea o nuestro gato empieza
a pulsar teclas: son errores excepcionales.
27/89
(Apuntes de Java)

Tipos enumerados: enum

●
Es un tipo de dato especial que agrupa un conjunto
predefinido de constantes
●
Ejemplos:
enum PuntoCardinal { NORTE, SUR, ESTE, OESTE}
enum DiaSemana {LUNES, MARTES, MIÉRCOLES, JUEVES,
VIERNES, SÁBADO, DOMINGO}
public enum Provincia {ALICANTE, VALENCIA, CASTELLÓN}
public enum OpcionMenu {NUEVO, ABRIR_FICHERO, CERRAR,
GRABAR, IMPRIMIR, SALIR}
28/89
(Apuntes de Java)

enum – Ejemplo 1
public class PruebasEnum {

enum PuntoCardinal { NORTE, SUR, ESTE, OESTE}

public static void main(String[] args) {

PuntoCardinal punto = [Link];
String mensaje="";
switch(punto) {
case NORTE:
mensaje="Rumbo al Norte!";
break;
case SUR:
mensaje="Hacia los mares del Sur!";
break;
case ESTE:
mensaje="En el Este están las riquezas!";
break;
case OESTE:
mensaje="Viremos al Oeste!";
break;
}
[Link](mensaje);
}
}

29/89
(Apuntes de Java)

enum – Ejemplo 2
import [Link];
public class PruebasEnum2 {
enum PuntoCardinal { NORTE, SUR, ESTE, OESTE}
public static void main(String[] args) {
Scanner entrada=new Scanner([Link]);
[Link]("Hacia dónde iremos capitán? (NORTE, SUR, ESTE, OESTE)");
String respuesta = [Link]().toUpperCase(); //convertimos lo escrito a mayúsculas
//Para convertir la respuesta al tipo enumerado PuntoCardinal haremos lo siguiente
PuntoCardinal punto = [Link]([Link], respuesta);
String mensaje="";
switch(punto) {
case NORTE:
mensaje="Rumbo al Norte!";
break;
case SUR:
mensaje="Hacia los mares del Sur!";
break;
case ESTE:
mensaje="En el Este están las riquezas!";
break;
case OESTE:
mensaje="Viremos al Oeste!";
break;
}
[Link](mensaje);
}
}
30/89
(Apuntes de Java)

Tipos enumerados: enum

●
Para saber los valores que contiene un enum, podemos utilizar su método
static values()
PuntoCardinal[] puntos = [Link]();
for (PuntoCardinal p : puntos){
[Link](p);
}

●
Para extraer el nombre de una constante utilizaremos el método name()

[Link]([Link]());

●
Los tipos enumerados funcionan como clases especiales que pueden tener
métodos propios y atributos (ver ejemplo siguiente)
31/89
(Apuntes de Java)

import [Link];
public enum PlanetaEnum { enum
enum –– clases
clases especiales
especiales
//Ejemplo extraído de [Link]
MERCURIO (3.303e+23, 2.4397e6),
VENUS (4.869e+24, 6.0518e6),
LA_TIERRA (5.976e+24, 6.37814e6),
MARTE (6.421e+23, 3.3972e6), Java obliga a que las
JUPITER (1.9e+27, 7.1492e7), constantes sean
SATURNO (5.688e+26, 6.0268e7),
URANO (8.686e+25, 2.5559e7), definidas primero
NEPTUNO (1.024e+26, 2.4746e7);
private final double masa, radio; // en kilos y en metros
public static final double G = 6.67300E-11; //constante gravitatoria universal
PlanetaEnum(double masaArg, double radioArg) {
[Link] = masaArg;
[Link] = radioArg; Constructor privado (obligado)
}
double gravedadEnSuperficie() {
return G * masa / (radio * radio);
}
double pesoEnSuperficie(double otherMass) {
return otherMass * gravedadEnSuperficie(); Al igual que una Clase
}
podemos incluir el
public static void main(String[] args) {
Scanner entrada = new Scanner([Link]); método main
[Link]("Cuál es tu peso?:");
double pesoEnLaTierra=[Link]();
double masaEnLaTierra = pesoEnLaTierra / LA_TIERRA.gravedadEnSuperficie();
for (PlanetaEnum planeta : [Link]()) {
[Link]("Tu peso sobre %s es %f%n", planeta, [Link](masaEnLaTierra));
}
[Link]();
}
}
32/89
(Apuntes de Java)

Tipos enumerados: enum

●
¿Y si queremos asociar números a los valores constantes de
nuestro enum? public enum OpcionMenu{
NUEVO(0),
ABRIR_FICHERO(1),
CERRAR(2),
GRABAR(3),
IMPRIMIR(4),
SALIR(5);

private final int numero;

OpcionMenu(int numeroArg) {
numero = numeroArg;
}

public int getValor() { return [Link]; }

public static void main(String[] args) {

[Link]([Link]()); //3
}
}
33/89
(Apuntes de Java)

Colecciones
●
Una colección es un objeto que representa un grupo de objetos
●
Pertenecen al framework Java Collections Framework que es
un conjunto de Clases e Interfaces utilizadas para el
tratamiento de colecciones de elementos.
●
Java Collections Framework es una jerarquía de clases
enfocadas en el tratamiento especializado de los elementos
que componen una colección.
●
En la cúspide de esta jerarquía tenemos dos interfaces
principales: [Link] y [Link]

34/89
(Apuntes de Java)

Colecciones

35/89
(Apuntes de Java)

Colecciones

36/89
(Apuntes de Java)

Colecciones: interface List

●
Representa una secuencia de elementos que pueden repetirse
●
Al igual que los arrays su índice empieza en 0
●
El/La programador/a puede:
➢
insertar un elemento donde decida
➢
insertar elementos que sean idénticos (equals)
➢
insertar elementos null (objetos sin referencia)
➢
puede acceder a los elementos incluídos a través de su
posición o índice
➢
puede buscar un elemento en la secuencia
37/89
(Apuntes de Java)

Colecciones: Interface List

add(E e) Añade un elemento al final de la lista
add(int index, E Añade un elemento en una posición específica
element)

clear() Limpia todos los elementos de la lista

contains(Object o) Devuelve true si la lista contiene un elemento específico
get(int index) Devuelve el elemento que esté en la posición especificada en la
lista

indexOf(Object o) Devuelve el índice de la primera ocurrrencia del elemento

especificado, o -1 si la lista no contiene el elemento

isEmpty() Devuelve true si la lista no contiene elementos

38/89
(Apuntes de Java)

Colecciones: Interface List

iterator() Devuelve un objeto Iterator que permite recorrer la lista en una sola dirección
(del primero al último elemento)
listIterator() Devuelve un objeto ListIterator sobre los elementos de la lista que permite
recorrer la lista en dos direcciones (del primero al último, y del último al
primero)
remove(int index) Quita un elemento de la lista en una posición especificada. Automáticamente el
espacio se rellena por el siguiente elemento de la lista (toda la parte derecha
se mueve para continuar la secuencia)

set(int index, E element) Sustituye el elemento ubicado en la posición index por el elemento pasado por
argumento

size() Devuelve el número de elementos en esta lista

toArray() Devuelve un array que contiene todos los elementos de la lista

39/89
(Apuntes de Java)

Colecciones: ArrayList
●
Es una colección que tiene la estructura de un array y además
implementa la interface List

●
Es muy usada por su funcionalidad y flexibilidad

●
Muchos programadores/as prefieren utilizar ArrayList a un Array

●
Permite añadir elementos de diferente naturaleza y de una
forma dinámica cambiando su tamaño, así pues no tiene tamaño
fijo como un Array ni está fuertemente tipado (elementos del
mismo tipo)

40/89
(Apuntes de Java)

Colecciones: ArrayList
//Array Un array de longitud fija.
[Link]("Array de longitud fija");
int[] arreglo= {4,5,7,3}; Lo que hemos visto siempre
for (int cont=0; cont<[Link]; cont++) { hasta el momento.
[Link](arreglo[cont]);
}

//ArrayList
[Link]("Array dinámico, de longitud variable");
ArrayList unaLista = new ArrayList();
[Link](4);
Array dinámico, de add()
[Link](5);
Longitud variable [Link](7);
4
[Link](3);
un String !?: correcto
5
7 [Link]("Un texto"); size()
3
Un texto for (int cont=0; cont<[Link](); cont++) {
[Link]([Link](cont));
}
get()

41/89
(Apuntes de Java)

Colecciones: ArrayList y Genéricos

ArrayList también puede tratar con tipos de datos dedicados, lo que se
denomina Genéricos (Generics <>). Si optamos por usarlos, tendremos que
insertar el mismo tipo de dato en cada elemento de la lista.

ArrayList<Integer> unaLista = new ArrayList<Integer>();

[Link](4);
[Link](5); Da error de compilación ya
[Link](7); que no es un Integer y
[Link](3); hemos utilizado un Generic
//[Link]("Un texto"); de tipo <Integer>

for (int cont=0; cont<[Link](); cont++) {

[Link]([Link](cont));
}

42/89
(Apuntes de Java)

Colecciones: ArrayList
4 formas de crear un ArrayList (y una Colección en general):

1) Arraylist unaLista = new ArrayList();

2) Utilizando Generics:
Arraylist<String> unaLista = new ArrayList<String>();

3) Utilizando Polimorfismo:
List unaLista = new ArrayList();

4) Utilizando Polimorfismo + Generics:

List<String> unaLista = new ArrayList<String>();
43/89
(Apuntes de Java)

Colecciones: Iterators
●
Los elementos de una colección deben poder
recorrerse o iterarse para obtener sus valores o
contenidos
●
Es por esto que cada clase que implemente la
interface Collection tiene un interador interno
( .iterator() ) que permite recorrer su
contenido y elementos
●
Este iterador viene de la interface Iterable que
es implementada por la Interface Collection
●
Una forma cómoda de recorrer una colección es
utilizar for-each

44/89
(Apuntes de Java)

Colecciones: Iterators
public class EjemArrayListIterator {
public static void main(String[] args) {
[Link] unaLista = new [Link]();
[Link](4);
[Link](5);
[Link](7); (*) Elemento de la lista:4
[Link](3); Elemento de la lista:5
[Link]("Un texto"); Elemento de la lista:7
Elemento de la lista:3
Iterator<Object> iterador = [Link](); Elemento de la lista:Un texto
while ([Link]()) {
[Link]("Elemento de la lista:" + [Link]());
}
}
}

(*) También hubiera sido válido:

Iterator iterador = [Link]();

45/89
(Apuntes de Java)

Colecciones: ListIterators
Permiten recorrer una colección en ambas direcciones: hacia delante o hacia atrás
public class EjemploListIterator {
public static void main(String[] args) { (*) ListIterator es una interface
ArrayList unaLista = new ArrayList();
[Link](4);
[Link](5);
[Link](7); Hacia delante (next):
[Link](3); 4
[Link](6);
5
ListIterator listIterador=[Link](); 7
3
[Link]("Hacia delante (next):"); 6
//Hacia delante
while ([Link]()) { Hacia atrás (previous):
[Link]([Link]());
} 6
3
[Link]("Hacia atrás (previous):"); 7
//Hacia atrás 5
while ([Link]()) { 4
[Link]([Link]());
}
}
}
46/89
(Apuntes de Java)

Colecciones: LinkedList
●
Funciona de forma parecida a ArrayList, ya que comparte la misma Interface
List (además de otra llamada Deque)
●
La diferencia se encuentra en su interior. LinkedList es una lista
enlazada de elementos a través de direcciones de memoria. Los
elementos aquí se llaman nodos. ArrayList es una consecución de
elementos uno detrás de otro.

47/89
(Apuntes de Java)

Colecciones: LinkedList
●
La ventaja de LinkedList frente a ArrayList se encuentra al introducir o quitar
elementos: en un ArrayList si introducimos un elemento por la mitad, se tendrán que
mover todos los demás hacia la derecha. Si la lista es larga, tardará bastante en mover
todos los elementos.
●
Con un LinkedList, al estar enlazados los elementos, si insertamos por la mitad,
solamente habrá que modificar pocos elementos.
ArrayList LinkedList
Inserción de 10 millones de elementos (en milisegundos)
(promedio):
2558 ms (2,5 s) 11055 ms (11 s)
Inserción de 10 millones de elementos + inserción de
55000 elementos a partir de la posición 5000 (en
milisegundos) (promedio):
247260 ms (4,1 mins) 16880 ms (16,8 s)
48/89
(Apuntes de Java)

Colecciones: Vector
●
Al igual que ArrayList y LinkedList, Vector implementa la interface List y
toda su funcionalidad.
●
Ofrece un rendimiento más bajo que ArrayList en la búsqueda, adición,
actualización o borrado de sus elementos, por lo que ArrayList es preferible.
●
Vector y su clase especializada Stack están desde el principio de Java,
incluso antes del Java Collection Framework
●
Vector tiene una característica que es su capacidad (capacity()). Es una
propiedad interna que añade y reserva un espacio para los siguiente
elementos. Una vez superada esta capacidad por el número de elementos, se
dobla automáticamente.
No confundir con size() que es la cantidad de elementos que contiene esta
colección.
49/89
(Apuntes de Java)

Colecciones: Vector
public static void main(String[] args) {

Vector<Integer> unVector=new Vector<Integer>();

[Link]("Capacidad del Vector:" + [Link]()); //10

[Link](100); //0
[Link](200); //1 Capacidad del Vector:10
[Link](300); //2 Elemento en posicion 5: 600
[Link](400); //3 Capacidad del Vector:20
[Link](500); //4 Elemento en posicion 0: 100
[Link](600); //5
[Link]("Elemento en posicion 5: " + [Link](5)); //600
//[Link]("Elemento en posicion 6: " + [Link](6)); //Error
[Link](700);
[Link](800);
[Link](900);
[Link](1000);
[Link](1100);
[Link]("Capacidad del Vector:" + [Link]()); //20

[Link]("Elemento en posicion 0: " + [Link](0));

}
50/89
(Apuntes de Java)

Collections: Stack
●
Clase especializada de Vector, heredad su funcionalidad y a su vez la funcionalidad
de la Interface List

●
Se traduce como Pila o apilar

●
Sigue el proceso LIFO (Last Input First Output o “el último en entrar es el primero
en salir”)

51/89
(Apuntes de Java)

Collections: Stack
●
Añade a Vector las siguientes funciones:

push() Introduce un elemento en la pila

pop() Extrae un elemento de la pila
peek() Nos da el primer elemento de la pila
empty() Devuelve true si la pila no contiene ningún
elemento
search() Busca un elemento dentro de la pila y
devuelve la posición (un int) en la que se
encuentra. Importante: el primer elemento
devolverá la posición 1 (difiere de get())
●
[Link](0) devolverá el primer elemento

52/89
(Apuntes de Java)

Collections: Stack
public static void main(String[] args) {
Stack<String> pila=new Stack<String>();
[Link]("Plato uno"); //También valdría [Link]("Plato uno")
[Link]("Plato dos");
[Link]("Plato tres");
[Link]("Primer elemento: " + [Link]()); //Plato tres
String elementoExtraido=[Link]();
[Link]("Elemento extraido:"+ elementoExtraido); //Plato tres
String otroExtraido=[Link]();
[Link]("Otro elemento extraido:"+ otroExtraido); //Plato dos

int posicionPlatoTres = [Link]("Plato tres");

[Link]("Posicion plato tres:"+ posicionPlatoTres); //-1
int posicionPlatoUno = [Link]("Plato uno");
[Link]("Posicion plato uno:"+ posicionPlatoUno); //1 Primer elemento: Plato tres
Elemento extraido:Plato tres
for (String plato: pila) { Otro elemento extraido:Plato dos
[Link]("Plato: "+ plato); Posicion plato tres:-1
} Posicion plato uno:1
} Plato: Plato uno
53/89
(Apuntes de Java)

Colecciones (cont.)

54/89
(Apuntes de Java)

Collections: interface Queue (Colas)

La interface Queue define una funcionalidad basada en una Cola
siguiendo el proceso FIFO (First Input First Output o “Primero en
entrar, primero en salir”) (diferente de LIFO de Stack).

cola cabecera

55/89
(Apuntes de Java)

Collections: Queue (Colas)

Las implementaciones de la interface Queue son LinkedList (que
también implementa de la interface List) y PriorityQueue

add(E e) Inserta un elemento en la cola (al final) devolviendo true si ha sido correcta la
inserción o devolviendo una excepción si no ha sido correcta
element() Devuelve el elemento situado en la cabecera de la cola sin eliminarlo. También
devuelve una excepción si no hay elementos en la cola.
offer(E e) Inserta un elemento en la cola devolviendo true si ha sido correcta la inserción y
false (a diferencia de add()) si no se ha insertado correctamente
peek() Devuelve el elemento situado en la cabecera de la cola sin eliminarlo. Devuelve null
si la cola no tiene elementos (está vacía) (no devuelve excepción)
poll() Devuelve el elemento situado en la cabecera de la cola eliminándolo de la cola.
Devuelve null si la cola no tiene elementos.
remove() Devuelve y elimina el elemento situado en la cabecera de la cola.
56/89
(Apuntes de Java)

Collections: Queue - LinkedList

public static void main(String[] args) {

Queue<String> cola = new LinkedList<String>();

//El primero en entrar a la cola

boolean insertadoOk=[Link]("Cliente 1");

[Link]("Inserción correcta?: "+insertadoOk);

[Link]("Cliente 2");
[Link]("Cliente 3");
[Link]("Cliente 4");

[Link]("Elemento situado en la cabecera:"+[Link]());

[Link](); //Quitamos Cliente 1

[Link](); //Quitamos Cliente 2
[Link](); //Quitamos Cliente 3
[Link](); //Quitamos Cliente 4
//element() es similar a peek(), pero devuelve excepción si no hay elementos
[Link]("Elemento situado en la cabecera:"+[Link]());
}
57/89
(Apuntes de Java)

Collections: Queue - PriorityQueue

●
PriorityQueue implementa la funcionalidad de Queue. Por esto sigue el método
FIFO para la inserción y extracción de elementos.
●
Su orden de prioridad y de ordenación es en forma de árbol binario (dos
nodos), utilizando la estructura de datos “priority heap”
[Link]
[Link]

58/89
(Apuntes de Java)

Collections: Queue - PriorityQueue

Cuando insertamos o quitamos elementos de PriorityQueue la ordenación puede
cambiar, siguiendo el orden de prioridad y la estructura “priority heap”
public static void main(String[] args) {
PriorityQueue<Integer> cola=new PriorityQueue<Integer>();
[Link](10);
[Link](30); Elementos de la cola:[10, 30, 32, 60, 40, 35]
[Link](32); Quitamos el primer elemento (cabecera)
[Link](60); Elementos de la cola:[30, 35, 32, 60, 40]
[Link](40); Seguimos quitando el primer elemento (cabecera)
[Link](35); Elementos de la cola:[32, 35, 40, 60]

[Link]("Elementos de la cola:" + [Link]());

[Link]("Quitamos el primer elemento (cabecera)");
[Link]();

[Link]("Elementos de la cola:" + [Link]()); El orden de los

[Link]("Seguimos quitando el primer elemento elementos cambian,
(cabecera)"); ¿porqué?
[Link]();
[Link]("Elementos de la cola:" + [Link]());
}
59/89
(Apuntes de Java)

Collections: Queue - PriorityQueue

¿Porqué el orden de los elementos de una PriorityQueue cambian?
En este ejemplo se observa qué ocurre cuando eliminamos el primer elemento
(cabecera) de la colección y cómo se reordenan siguiendo una estructura de árbol

[10, 30, 32, 60, 40, 35] [10, 30, 32, 60, 40, 35]

Los nodos se
comparan con sus
nodos próximos y
Entrada de datos mediante offer() Eliminamos la cabecera (10) se reordenan
y el último nodo ocupa su
posición
[30, 35, 32, 60, 40]
60/89
(Apuntes de Java)

Collections: Queue - PriorityQueue

PriorityQueue<Integer> cola=new PriorityQueue<Integer>();
[Link](30);
[Link](40);
[Link](35);
[Link](60); [30, 40, 35, 60, 10, 32, 39]
[Link](10);
[Link](32); Salida:[10, 30, 32, 60, 40, 35, 39]
[Link](39);
[Link]("Salida:" + [Link]());

[30, 40, 35, 60, 10, 32, 39]

Salida:
[10, 30, 32, 60, 40, 35, 39]

61/89
(Apuntes de Java)

Collections: Deque
●
La interface Deque representa una colección que permite
la inserción y extracción de elementos en ambos
extremos (a diferencia de Queue)
●
Deque significa ‘double ended queue’ (cola de doble
terminación, doble entrada o doble extremo)
●
Las clases que implementan esta interface son
ArrayDeque y LinkedList
●
Se comporta como un Queue (FIFO) o como un Stack
(LIFO) según los métodos que usemos
62/89
(Apuntes de Java)

Collections: Deque - ArrayDeque

●
ArrayDeque es una implementación de Deque
●
No permite la inserción de elementos null
(head / front) (tail / end)

addFirst() addLast()

63/89
(Apuntes de Java)

Collections: Deque - ArrayDeque

import [Link];
import [Link];
public class EjemploArrayDeque {
public static void main(String[] args) {
ArrayDeque<Integer> miArrayDeque = new ArrayDeque<Integer>();
// También valdría:
// Deque<Integer> miArrayDeque = new ArrayDeque<Integer>();
[Link](1);
[Link](2);
[Link](3); // [1,2,3]
[Link](4);
[Link](5);
[Link](6); // [6,5,4,1,2,3]
[Link]([Link]([Link]()));
}
}
64/89
(Apuntes de Java)

Collections: Deque - ArrayDeque

Primer Elemento (Head) Último Elemento (Tail)
Lanza excepcion Devuelve un Lanza Devuelve un
valor excepcion valor
Insertar addFirst(e) offerFirst(e) addLast(e) offerLast(e)
Quitar removeFirst() pollFirst() removeLast() pollLast()
Examinar getFirst() peekFirst() getLast() peekLast()

(*) Devuelve un valor significa que puede devolver un booleano

(true/false), null, o un elemento del deque, dependiendo del método que
se esté usando

[Link]

65/89
(Apuntes de Java)

Collections: Deque - ArrayDeque

Un Deque puede comportarse como un Queue (FIFO) (cola) o como
un Stack (LIFO) (pila)

Método Método Método Método

Deque equivalente Deque equivalente
Queue Stack
addLast(e) add(e) addFirst(e) push(e)
offerLast(e) offer(e) removeFirst() pop()
removeFirst() remove() peekFirst() peek()
pollFirst() poll()
getFirst() element()
peekFirst() peek()
66/89
(Apuntes de Java)

Colecciones (cont.)

67/89
(Apuntes de Java)

Colecciones: interface Set

●
Set (conjunto) hace referencia a una colección de
objetos sin elementos duplicados. Formalmente, que un
elemento e1 y otro elemento e2 no cumplan la
condición [Link](e2).
●
Dependiendo de la implementación (HashSet,
LinkedHashSet, TreeSet) se permite la introducción de
elementos null

68/89
(Apuntes de Java)

Collections: Set - HashSet

●
HashSet es una implementación de Set que tiene estas
características:
●
No permite duplicación de elementos (por Set)
●
Permite la introducción de elementos null (uno solamente)
●
El orden de los elementos está basado a su hashCode (código
interno que java asigna a los objetos en memoria), no en el
orden de inserción
Es el mejor tipo de colección para realizar búsquedas
●
Su capacidad inicial es de 16 elementos y se va ampliando en
un factor de 0.75

69/89
(Apuntes de Java)

Collections: Set - HashSet

public class EjemploHashSet {
public static void main(String[] args) {
HashSet hs=new HashSet();
String elem1=null, elem2=null, elem4 =null;
int elem5 = 5, elem6 = 7, elem7 = 23, elem8 = 2, elem9 = 2, elem10=6;
[Link](elem1);
[Link](elem2);
[Link]("elem3"); [null, 2, elem3, 5, 7, 23]
[Link](elem4); Añadimos el valor 6...
[Link](elem5); [null, 2, elem3, 5, 6, 7, 23]
[Link](elem6); (el 6 no se añade al final, se realiza un orden interno propio)
[Link](elem7);
[Link](elem8);
[Link](elem9); //intentamos añadir un 2 duplicado
[Link]([Link]([Link]()));
[Link](elem10); //añadimos el 6
[Link]("Añadimos el valor 6...");
[Link]([Link]([Link]()));
[Link]("(el 6 no se añade al final, se realiza un orden interno
propio)");
}
}
70/89
(Apuntes de Java)

Collections: Set - LinkedHashSet

●
LinkedHashSet es una implementación de Set que tiene estas
características:
●
No permite duplicación de elementos (por Set)
●
Permite la introducción de elementos null (uno solamente)
●
Mantiene el orden de inserción de los elementos
●
Internamente establece enlaces entre los elementos

71/89
(Apuntes de Java)

Collections: Set - LinkedHashSet

public static void main(String[] args) {
LinkedHashSet hs=new LinkedHashSet();

String elem1=null, elem2=null, elem4 =null;

int elem5 = 5, elem6 = 7, elem7 = 23, elem8 = 2, elem9 = 2, elem10=6;
[Link](elem1);
[Link](elem2);
[Link]("elem3"); [null, elem3, 5, 7, 23, 2]
[Link](elem4); Añadimos el valor 6...
[Link](elem5); [null, elem3, 5, 7, 23, 2, 6]
[Link](elem6); (el 6 sí se añade al final)
[Link](elem7);
[Link](elem8);
[Link](elem9); //intentamos añadir un 2 duplicado

[Link]([Link]([Link]()));
[Link](elem10); //añadimos el 6
[Link]("Añadimos el valor 6...");
[Link]([Link]([Link]()));
[Link]("(el 6 sí se añade al final)");
}

72/89
(Apuntes de Java)

Collections: Set - TreeSet

TreeSet es una implementación de SortedSet (que a su vez
implementa Set) que tiene estas características:
●
No permite duplicación de elementos (por Set)
●
No permite la introducción de elementos null, devuelve
Excepción en tal caso
●
Mantiene el orden de inserción de los elementos
●
Es una colección muy rápida para la inserción (add) y
extracción (remove) y búsqueda de si existe un elemento
(contains)

73/89
(Apuntes de Java)

Collections: Set - TreeSet

public static void main(String[] args) {
TreeSet<Object> ts=new TreeSet<Object>();

//String elem1=null;
int elem5 = 5, elem6 = 7, elem7 = 23, elem8 = 2, elem9 = 2, elem10=6;
//[Link](elem1); //Devuelve excepción (null)

[Link](elem5);
//[Link]("elem3"); //Devuelve excepción porque es de diferente tipo al
primer elemento introducido
[Link](elem6);
[Link](elem7);
[Link](elem8); [2, 5, 7, 23]
[Link](elem9); //intentamos añadir un 2 duplicado Añadimos el valor 6...
[2, 5, 6, 7, 23]
[Link]([Link]([Link]())); (ordena consecutivamente)
[Link](elem10); //añadimos el 6
[Link]("Añadimos el valor 6...");
[Link]([Link]([Link]()));
[Link]("(ordena consecutivamente)");
}

74/89
(Apuntes de Java)

Colecciones (cont.)

75/89
(Apuntes de Java)

Colecciones: interface Map

●
Representa una colección de claves-valores: una
clave está unida a un valor, buscando esta clave
obtendremos el valor y viceversa
●
NO permite claves duplicadas (son únicas) pero sí se
pueden repetir los valores
●
Implementaciones (entre
otras): TreeMap, HashMap

76/89
(Apuntes de Java)

Colecciones: HashMap
●
Permite introducir valores null, y la clave null
●
No se garantiza el orden de la inserción según la clave (no hay un
orden específico ni fijo), y además éste puede ser variable en el
tiempo
●
No está sincronizado (not synchronized) con lo cual si varios hilos
(threads) de una aplicación concurrente acceden a los valores de
un HashMap podrían dar resultados diferentes si alguno de estos
hilos los modifica. La solución pasa por utilizar la clase
ConcurrentHashMap
●
No permite introducir claves duplicadas (por la interface Map)

77/89
(Apuntes de Java)

Colecciones: TreeMap
●
Las entradas se ordenan según el orden natural de sus keys,
esto es, si son números de menor a mayor, si son cadenas en
orden alfabético
●
Esto garantiza que las keys siempre se ordenarán acorde a
un orden específico y estable (a diferencia de HashMap)
●
Es una implementación de NavigableMap y por tanto
funciona internamente como árbol de búsqueda
autobalanceado (red-black tree)

78/89
(Apuntes de Java)

Colecciones: Hashtable

79/89
(Apuntes de Java)

Colecciones: SortedMap

80/89
(Apuntes de Java)

Ficheros e I/O
●
Clases contenidas en el package [Link]
●
I/O = Input/Output
●
Unido al concepto de Stream (traducido como corriente
o torrente): es una secuencia de información
(normalmente bytes) a través de un canal
●
Hay 2 clases abstractas de Stream principales:
– De entrada al programa (lectura): InputStream
– De salida a un destino (escritura): OutputStream

81/89
(Apuntes de Java)

Ficheros e I/O
●
Conceptos relacionados
– Flush(): vaciar la secuencia de salida y obliga a escribir los bytes de
salida almacenados en el búfer.
– Close(): cierra el stream y libera todos los recursos del sistema
asociados con la secuencia.
– Read(): lectura desde un Stream de entrada
– Write(): escritura en un Stream de salida
– Buffer / Buffering: es una área de memoria donde poder almacenar y
leer información finita.

82/89
(Apuntes de Java)

Ficheros e I/O

83/89
(Apuntes de Java)

Ficheros I/O
●
FileOutputStream : escribir información (un byte) a un fichero
import [Link];
import [Link];

public class EjemploFileOutputStream {

// Ejemplo que escribe solamente un byte en un fichero llamado [Link]
public static void main(String args[]) throws IOException {
FileOutputStream fichSalida = null;
try {
//Debe existir el directorio c:\temp
fichSalida = new FileOutputStream("c:\\temp\\[Link]");
[Link](65);

[Link]("Fichero escrito...");
} catch (Exception e) {
[Link](e);
} finally {
if (fichSalida != null) [Link]();
}
}
}
84/89
(Apuntes de Java)

Ficheros I/O
●
FileOutputStream (escribir un array de bytes a fichero)
import [Link];
import [Link];

public class EjemploFileOutputStream2 {

public static void main(String args[]) throws IOException {
FileOutputStream ficheroSalida = null;
try {
ficheroSalida = new FileOutputStream("c:\\temp\\[Link]");
String texto = "Una cadena de texto.";
byte[] unArrayBytes = [Link]();
[Link](unArrayBytes);
[Link]();
[Link]("Fichero escrito...");
} catch (Exception e) {
[Link](e);
} finally {
if (ficheroSalida != null)
[Link]();
}
}
}
85/89
(Apuntes de Java)

Ficheros e I/O
●
FileInputStream: obtiene o lee bytes (información) desde un
fichero ([Link]. audio, video, imágenes, etc.)
import [Link];
import [Link];
public class EjemploFileInputStream {
// Lee un solo byte de un fichero llamado [Link]
public static void main(String args[]) throws IOException {
FileInputStream elStream = null;
try {
elStream = new FileInputStream("C:\\temp\[Link]");
int elByte = [Link](); // lee un byte
[Link]((char) elByte);
} catch (Exception e) {
[Link](e);
} finally {
if (elStream != null)
[Link]();
}
}
}

86/89
(Apuntes de Java)

Ficheros e I/O
●
FileInputStream (leer todos los bytes de un fichero)
import [Link];
import [Link];

public class EjemploFileInputStream2 {

// Lee todos los bytes de un [Link]
public static void main(String args[]) throws IOException {
FileInputStream elStream = null;
try {
elStream = new FileInputStream("c:\\temp\\[Link]");
int unbyte = 0;
while ((unbyte = [Link]()) != -1) {
[Link]((char) unbyte);
}
} catch (Exception e) {
[Link](e);
} finally {
if (elStream != null) [Link]();
}
}
}
87/89
(Apuntes de Java)

Ficheros I/O
●
FileWriter: clase especializada en la escritura de texto en un fichero
import [Link];
import [Link];

public class EjemploFileWriter {

public static void main(String[] args) throws IOException {
FileWriter escritor = null;
try {
// El directorio c:\temp tiene que existir
escritor = new FileWriter("c:\\temp\\[Link]");
[Link]("Este es un ejemplo de FileWriter.");

} catch (Exception e) {
[Link](e);
} finally {
if (escritor != null)
[Link]();
}
[Link]("Fichero escrito...");
}
}
88/89
(Apuntes de Java)

Ficheros I/O
●
FileReader: clase especializada en la lectura de ficheros
import [Link];
import [Link];
public class EjemploFileReader {
public static void main(String[] args) throws IOException {
FileReader lector = null;
int i=0;
try {
// El fichero tiene que existir
lector = new FileReader("c:\\temp\\[Link]");
while((i=[Link]())!=-1)
[Link]((char)i);
} catch (Exception e) {
[Link](e);
} finally {
if (lector != null)
[Link]();
}
[Link]("Fichero leido...");
}
}
89/89