Unidad Didáctica 5
Arrays, Cadenas y Vectores
Tipos Genéricos
Fundamentos de Programación
Departamento de Lenguajes y Sistemas Informáticos
Versión 1.2.1
Introducción
Según lo visto hasta ahora
“¿Cómo representaría N vectores en el espacio 3D?”:
Integer v1_x=1, v1_y=4, v1_z=6;
Integer v2_x=7, v2_y=3, v2_z=5;
…
Y
v2
v1
Z
Todo L.P. hace posible agrupar varios valores en una misma
variable
Al reducir el nº de variables los programas son más fáciles de
desarrollar, entender y, por tanto, mantener
Integer[ ] v1 = {1, 4, 6};
Integer[ ] v2 = {7, 3, 5};
…
UD5: Arrays, Cadenas y Vectores. Tipos Genéricos
X
Arrays: definición
Un array es un conjunto finito de elementos del mismo tipo almacenados
en posiciones consecutivas de memoria.
Dado que:
A y B hacen posible el acceso directo a los elementos de un array.
El acceso directo permite acceder y modificar cualquier elemento del array
del mismo modo que una variable independiente.
El acceso directo en los arrays se lleva a cabo por indexación mediante el
operador corchete: [ ]
Cada elemento de un array de tamaño N tiene asociado un índice:
A: Todos los elementos de un mismo tipo “requieren” los mismos bytes.
B: Siempre se conoce la dirección de memoria de una variable.
El primer elemento tiene índice 0 y el último tiene índice N–1
Los arrays pueden contener elementos de cualquier tipo, arrays inclusive.
Un array es un objeto y su tamaño no puede cambiarse tras
crearse.
UD5: Arrays, Cadenas y Vectores. Tipos Genéricos
Arrays: inicialización
int[ ] v1 = {2, 34, 5};
/* v1 es un array con 3 elementos de tipo básico int:
el primer elemento es 2, el segundo es 34 y el tercero es 5 */
Integer[ ] v2 = new Integer[7];
// v2 es un array vacío con capacidad para 7 elementos de tipo objeto Integer
double[ ] v3;
// v3 es un array de elementos de tipo básico double
Diferencias entre v1, v2 y v3:
•
•
•
v1 está inicializado (“tiene valores”)
v2 no está inicializado (“no tiene valores”)
v3 no es un array “todavía” (v3==null)
UD5: Arrays, Cadenas y Vectores. Tipos Genéricos
Arrays: operaciones
Suponiendo:
int[ ] v1 = {2, 34, 5};
Integer[ ] v2 = new Integer[7];
Acceso a un elemento:
Modificación de un elemento:
int x = v1[0]; // x==2
Integer y = v2[0] ; // y==null (NULO, SIN VALOR)
x=v1[-2]; y=v2[7]; MAL (ArrayIndexOutOfBoundsException)
v2[0] = v1[1]; // Autoboxing
Consultar el tamaño:
int tams = v1.length + v2.length;
// tams es una variable de tipo básico int inicializada con el valor 10 (3+7)
UD5: Arrays, Cadenas y Vectores. Tipos Genéricos
Arrays de dos dimensiones
int[ ][ ] m1 = {{3, 7, 4}, {2, 5, 9}};
/* m1 es un array de arrays que alberga 2 arrays con 3 elementos int cada uno.
m1 representa a una matriz rectangular de enteros con 2 filas y 3 columnas */
int x = m1[0][1]; // x==7
Integer[ ][ ] m2 = new Integer[7][ ];
// m2 es una matriz que tendrá 7 filas, pero ninguna fila está creada todavía
m2[3] = new Integer[8];
// la cuarta fila de m2 está creada pero no está inicializada
Integer y = m2[3][6]; // y==null, no existe el elemento
y = m2[5][1]; MAL (ArrayIndexOutOfBoundsException)
UD5: Arrays, Cadenas y Vectores. Tipos Genéricos
Arrays de objetos
tablaPuntos [0] = new PuntoImpl(1.0,1.0);
tablaPuntos [1] = new PuntoImpl(1.0,2.0);
tablaPuntos [2] = new PuntoImpl(1.0,3.0);
tablaPuntos [3] = new PuntoImpl(1.0,4.0);
tablaPuntos
1.0
1.0
1.0
2.0
1.0
3.0
1.0
4.0
2.0
5.0
tablaPuntos [3] = new PuntoImpl(2.0,5.0);
tablaPuntos = new PuntoImpl[5];
UD5: Arrays, Cadenas y Vectores. Tipos Genéricos
String
Representan cadenas de caracteres
Clase perteneciente al lenguaje (paquete java.lang)
ENCAPSULA un array de elementos de tipo char
y le añade funcionalidad
Los objetos de tipo String son INMUTABLES
La clase String no puede tener clases hijas
Un literal (valor) String es toda secuencia de
caracteres UNICODE encerrada entre dobles
comillas (“…”)
UD5: Arrays, Cadenas y Vectores. Tipos Genéricos
String: ejemplo de uso
Inicialización:
Consultar el número de caracteres:
int tam = saludo.length(); // tam==4
Pasar a mayúsculas:
String saludo = “Hola”;
String s2 = saludo.toUpperCase(); //”HOLA”
Comparar dos cadenas:
boolean iguales = saludo.equals(s2); //iguales==false
UD5: Arrays, Cadenas y Vectores. Tipos Genéricos
String: métodos de uso frecuente
public final class String … {
public int length( ) {…}
public char charAt(int i) {…}
public String concat(String s) {…}
public boolean contains(CharSequence s) {…}
public int indexOf(int c) {…}
public String substring(int i1, int i2) {…}
public String replace(char c1, char c2) {…}
public String trim( ) {…}
public String toLowerCase( ) {…}
public String toUpperCase( ) {…}
….
public boolean equals(Object o) {…}
}
UD5: Arrays, Cadenas y Vectores. Tipos Genéricos
Vector
Clase perteneciente al paquete java.util (IMPORTAR)
ENCAPSULA un array de OBJETOS y le añade
funcionalidad.
Los vectores tienen capacidad "ilimitada"
Los vectores no pueden albergar tipos básicos.
Todos los elementos de un vector deben ser del mismo
tipo:
O bien ser creados todos con la misma clase,
O bien ser creados con clases que implementen una interfaz
común.
UD5: Arrays, Cadenas y Vectores. Tipos Genéricos
Vector: ejemplo de uso
Inicialización:
Consultar el número de elementos:
Double x = v.get(1); // x==2.7
Modificar un elemento según su índice:
v.add(0, 4.9);
Obtener un elemento según su índice:
v.add(2.7);
Añadir un elemento al principio:
int tam = v.size(); // tam==0
Añadir un elemento al final:
Vector<Double> v = new Vector<Double>();
v.set(1, 3.5);
Comprobar si contiene un elemento:
boolean contiene = v.contains(2.7); //contiene==false
UD5: Arrays, Cadenas y Vectores. Tipos Genéricos
Vector: métodos de uso frecuente
public class Vector<T> ... {
public Vector( ) {…}
public int size( ) {…}
public T get(int index) {…}
public T set(int index, T element ) {…}
public boolean add(T element ) {…}
public void add(int index, T element ) {…}
public boolean isEmpty( ) {…}
public boolean contains(Object o) {…}
public int indexOf(Object o) {…}
…
public boolean equals(Object o) {…}
}
UD5: Arrays, Cadenas y Vectores. Tipos Genéricos
Tipos genéricos: concepto
Un parámetro genérico T representa a un tipo conocido en la
definición de una clase o interfaz
public class Vector<T> ... {
private T[ ] elems; public class TestGenerico extends Test {
public Vector( ){…} public static void main(String[] args) {
Vector<Integer> v;
public T get(int index) {…}
v.add(6);
public T set(int index, T element
) {…}
mostrar(v);
public boolean add(T element
) {…}
} T element ) {…}
public void add(int index,
}
…
}
Los parámetros genéricos deben sustituirse por tipos
concretos para poder usar objetos de tal clase o interfaz
UD5: Arrays, Cadenas y Vectores. Tipos Genéricos
Tipos genéricos: sintaxis
Si una interfaz tiene métodos genéricos se indica con
<*> tras su nombre
Si una clase tiene atributos genéricos se indica con <*>
tras su nombre
* = Un solo tipo genérico se indica con T, varios tipos
genéricos se indican con T1, T2,T3, …
interface Comparable<T> {
int compareTo(T e);
}
public class ParejaImpl<T1,T2> {
private T1 e1;
private T2 e2;
…
}
UD5: Arrays, Cadenas y Vectores. Tipos Genéricos
Tipos genéricos: sintaxis
Si una clase no tiene atributos genéricos pero implementa
métodos genéricos, estos se indican tras sus modificadores
public class TestGenerico2 extends Test {
public class Utiles {
public static void main(String[] args) {
…
Integer x = 3;
public static <T> Vector<T> aVector(T a) {
String s = "Hola";
Vector<T> v = new Vector<T>();
Vector<Integer> v1 = Utiles.aVector(x);
v.add(a);
Vector<String> v2 = Utiles.aVector(s);
return v;
mostrar(v1);
}
mostrar(v2);
…
}
}
}
En un método genérico al menos uno de sus parámetros o su
tipo de retorno pueden cambiar en distintas llamadas al método
UD5: Arrays, Cadenas y Vectores. Tipos Genéricos
Tipos genéricos: sintaxis
Un atributo genérico se concretará al crear o instanciar un
objeto de la clase a la que pertenece el atributo
public class ParejaImpl<T1,T2> … {
private T1 e1;
private T2 e2;
…
}
public class TestGenerico3 extends Test {
public static void main(String[] args) {
Pareja<Integer, String> p = new ParejaImpl<Integer, String>( );
…
}
}
UD5: Arrays, Cadenas y Vectores. Tipos Genéricos
Tipos genéricos: consideraciones
Los operadores con un tipo como operando NO
admiten tipos genéricos. Ejemplo: instanceof
NO es posible:
constructores de un tipo T
Inicializar arrays de un tipo T
a instanceof Vector
a instanceof Vector<T>
a instanceof T
T a = new T( );
T[ ] = new T[10];
T a = (T) new Object();
// bien (tipo crudo)
// mal
// mal
// mal
// mal
// warning
UD5: Arrays, Cadenas y Vectores. Tipos Genéricos
0
