Módulo 5

Arreglos
Comenzando con arreglos
 Qué son los arreglos?
 Los arreglos son colecciones de objetos del mismo tipo. Los arreglos pueden
referenciar a un gripo de objetos con un nombre en común. Los arreglos de
cualquier tipo pueden ser creados y pueden tener una o más dimensiones. Un
elemento específico en un arreglo es accesado por su índice.
 Los arreglos pueden ser clasificados dentro de dos categorías:
– Arreglos de primitivos
char s[ ];
– Arreglos de tipo clase:
Point p[ ]; // where Point is a class
 En el lenguaje de programación de java, un arreglo es un objeto
idependientemente de los tipos de datos de sus elementos. Esto es verdadero
incluso si algún elemento del arreglo pertenece a los tipos de datos primitivos.
Consecuentemente, una variable referenciada es requerida para operar sobre
un objeto arreglo.
 Puedes usar un arreglo en cualquier parte donde puedas usar una variable.
Declaración de Arreglos
 La declaración de un arreglo es el primer paso requerido en la programación de arreglos.
En este paso, efectivamente declaras un identificador para ser usado como un tipo
refrenciado para operar sobre el array. Además para especificar el nombre del
identificador a ser usado, debes también especificar el número de dimensiones y el tipo
de datos de los elementos. Una vez declarado. Esto es, el identificador puede ser usado
para operar sobre cualquier arreglo que conforme con la declaración. Esto es, los
elementos pueden ser usados sobre un arreglo con el mismo número de dimensiones y
con los elementos del mismo tipo de datos como la declaración.
 La tecnología de java ofrece dos estilos de declaraciones de arreglos. El primero de estos
usa [ ] después del nmbre de la variables:
– char s[ ];
Point p[ ]; // where Point is a class
 El lenguaje de programación de java también permite una forma alternativa con los [ ] del
lado izquierdo del nombre de la variable:
– char [ ] s;
Point [ ] p;
Creando Arreglos
 Después de la declaración de una variable referenciada de un tipo array, el segundo paso
es crear el objeto array e inicializar la variable de refrenciacon la dirección del nuevo
objeto creado. Puedes crear arrays, como todos los objetos, usando la palabra clave new.
– s = new char[20];
p = new Point[100];
 La primera línea crea un arreglo char de 20 valores con cada valor inicializado a '\0000'.
Porque estos 20 valores son los elementos del arreglo, la creación del arreglo esta
completa. Esto es verdadero con cualquier array con elementos de tipos de datos
primitivos.
 Una vez que el arreglo ha sido creado puedes ahora asignar valores a los elementos individuales en el
arreglo. Por ejemplo:
 s[0] = 'A';
– s[1] = 'B';
 Los subíndices que se refieren a un elemento individual en el arreglo siempre comienzan
en 0.
 Para arreglos de tipos de datos referneciados, esto no completa el proceso de creación
de un arreglo. En el ejemplo anterior , la segunda línea crea un arreglo de 100 variables
referenciadas de tipo Point con cada valor inicializado en nulo. Estas variables
refrenciadas requieren la creación de 100 objetos Point para referenciar. Estos objetos
Point son elementos reales del arreglo.
 Cuando creas un arreglo, cada elemento es inicializado con un valor default al tipo de
dato del arreglo.
Ejemplo
p[0] = new Point();
p[1] = new Point();
.
.
.
 Alternativamente, podrías usar un ciclo para crear los objetos:
for (int i=0; i<100; i++) {
p[i] = new Point();
}
 Los subíndices usados para indexar los elementos individuales del
arreglo siempre comienzan desde 0 y deben ser mantenidos en un
rango legal o igual a cero y menor que la longitud del arreglo.
Cualquier tentativa de tener aceso a un elemento fuera de estos
límites causa un error en tiempo de ejecución.
Creando arreglos usando arreglos
inicializadores

 El lenguaje de programación de java te permite usar una

técnica para crear arreglos con valores iniciales. Ls siguientes
dos partes del código son equivalentes:
– String names [] = { "Duke", "Jen", "Simon", "Tom"};
– String names []; names = new String[4]; names[0] = "Duke";
names[1] = "Jen"; names[2] = "Simon"; names[3] = "Tom";
 Un arreglo inicializado es escrito usando una lista de coma
separando expresiones encerradas por un par de llaves '{' y
'}'.La longitud de los arreglos construidos equivalen al número
de expresiones. Cada expresión especifica un valor para un
elemento en el arreglo. Cada elemento será añadido al arreglo
en el orden que aparecen entre '{' y '}'.
Inicialización de Arreglos

 El código de abajo ilustra varios arreglos

siendo inicializados.
double weights [ ] = {2.5, 5.2, 1.7, 8.8}; // 4 element array
of double
MiDate dates [ ] = {new MiDate(), null, null, new MiDate()};
int values [ ] = {3, 4, 12, 9, 5};
Array Bounds
 En el lenguaje de programación de java, todos los subíndices
del arreglo empiezan en 0. El número de elementos en un
arreglo es guardado como parte del objeto array, como el
atributo length (longitud). Este valor es usado para realizar la
comprobación del límite de todos los accesos en tiempo de
ejecución.
 Usa el atributo length para iterar sobre un arreglo como sigue:
int [ ] list = new int [10];
int total = list.length; // get total number of elements
for (int i = 0; i < total; i++) {
System.out.println(list[i]);
}
Trabajando con elementos de
arreglos

 Para todos los arreglos, puedes leer o

escribir (conjunto) un valor de un elemento.
Además, para los arreglos de tipos de datos
object, puedes leer o escribir a los atributos e
invocar métodos sobre los objetos
referenciados por los elementos del arreglo
Funcionamiento sobre elementos del
arreglo
char s [ ]; // declarando un arreglo de rpiitivos
s = new char[20]; // creando un arreglo de 20 elementos de primitovos char
s[0] = 'H'; // escribirndo un valor a el primer elemento de s
s[1] = 'I'; //escribiendo un valor para el segundo elemento de s.
char firstLetter = s[0]; // leyendo el primer elemento de s
MiDate dates [ ]; //declarando un arreglo de tipo objeto
dates = new MiDate[5]; // creando un arreglo de tipo de tipo MiDate
dates[2] = new MiDate(); // inicializando (escribirndo) tercer elemento
// con un objeto MiDate.
MiDate today = dates[2]; // leyendo el tercer elemento
dates[2].addDays(5); // llamando un método MiDate sobre el tercer
elemento
int oneDay = dates[2].day; // leyendo el atributo day del objeto MiDate
// refreneciado por el tercer elemento.
dates[2].month = 5; //ajustando el atributo month del objeto MiDate
// referenciado por el tercer elemento
 Trabajando con arreglos
multidimensionales

 Declarando y creando un arreglo multidimensional

– El lenguaje de programación de java no provee de arreglos
multidimensionales del mismo modo que otros lenguajes. Porque puedes
declarar un arreglo que tiene cualquier tipo base, puedes crear arreglos de
arreglos (y arreglos de arreglos de arreglos, y aun más). Aparte de una
diferencia, un arreglo multidensional es declarado de forma similar que los
arreglos de una dimensión. La diferencia esta que por cada dimensión,
debes declarar un par de paréntesis cuadrados ([ ]) debe ser declarado;
por ejemplo:
 int twoDim [ ][ ];
 int threeDim [ ][ ][ ];
– Note: Puedes colocar los brackets ([ ]) del lado izquierdo de la variable o
del lado derecho.
– Teniendo declarado un arreglo multidimensional, el siguiente paso es crear
un objeto de arreglo dimensional y asignarle la dirección a la variable
declarada, La opción mas simple es crear objetos de arreglos
multidimensionales simetricos (también cocnocido como rectangular).
 twoDim = new int[4][5];
 threeDim = new int[7][3][8];
Trabajando con arreglos
multidimensionales

– En el lenguaje de
programación de java,
todos los arreglos
multidimensionales son
compuestos de arrglos
de una dimensión.
 Inicializando arreglos
multidimensionales

 La JVM sigue reglas Tipo Valor por

identicas para inicializar defecto
arreglos de una dimensión y byte 0
multidimensionales durante short 0
la creación del arreglo.
Cuando creas un arreglo int 0
multidimensional, cada long 0L
elemento es inicializado por float 0.0F
default con un valor inicial
double 0.0
correspondiente al tipo de
dato del arreglo. char '\U0000'
boolean false
Reference type null
 Arreglos multidimensionales no-
simétricos
 En el lenguaje de programación de java, los arreglos necesitan no ser
simetricos. Para crear arreglos no-simétricos, no especifiques todas las
dimensiones cuando se crea el arreglo. Por ejemplo, si la variable
twoDim es declarada como un arreglo de dos dimensiones del tipo de
dato int, entonces lo siguiente también es legal
twoDim = new int[4][];
 El objeto se crea en un arreglo que contiene 4 elementos. Cada
elemento es una referencia nula para un elemento del array de tipo int,
y cada elemento debe ser inicializado separadamente como también
cada elemento que apunta al arreglo. Esto permite crear por separado
el tamaño del arreglo unidimensional refrerido por cada uno de los
cuatro elementos creados en esta sentencia. Por lo tanto, si amplias la
sintaxis de lo anterior, podrías tener :
int twoDim [ ][ ] = new int [4][ ];
twoDim[0] = new int[2];
twoDim[1] = new int[2];
twoDim[2] = new int[6];
twoDim[3] = new int[8];
 Creando un arreglo
multidimensional

 Para crear un arreglo multidimensional usando arreglos

inicilizadores, debe jerarquizar los arreglos inicializadores. La
profundidad de la jerarquía determina la dimensión del arreglo.
El siguiente código contiene dos ejemplos de arreglos creados
usando la jerarquización de arrglos inicializados. El primer
ejemplo muestra la creación de un arreglo simétrico de dos
dimensiones llamado polygons. El segundo ejemplo muestra la
creación de un arreglo no simétrico de dos dimensiones
llamado names.
int polygons [ ][ ] ={{8, 7, 9, 2, 5}, {4, 3, 7, 4, 2},
{2, 1, 6, 8, 5}};
String names [ ][ ] = {{"Robert", "James", "Smith"},
{"Jane", "Weaver"},
{"Karis", "Joy", "Sullivan"},
{"Steven", "Patrick", "William", "Wong"}};
 Límites de los arreglos

 Los límites de un arreglo son determinados por su

longitud. En la tecnoilogía de java un arreglo
multidimensional consiste de un arreglo de arreglos,
cada constituyente del arreglo multidimensional tiene
su propio atributo de llongitud. El código de abajo
ilustra el atributo de longitud en arreglos
multidimensionales.
int twoDim [][] = new int [4][]; // twoDim.length is 4
twoDim[0] = new int[2]; // twoDim[0].length is 2
twoDim[1] = new int[2]; // twoDim[1].length is 2
twoDim[2] = new int[6]; // twoDim[2].length is 6
twoDim[3] = new int[8]; // twoDim[3].length is 8
 Copiando arreglos

 El lenguaje de programación de java provee de un especial método en

la clase System, arraycopy, para copiar arreglos. El método arraycopy
toma los siguientes argumentos arraycopy(Object src, int src_posición,
Object dst, int dst_posición, int length). Este método copia desde la
posición especificada del arreglo destino. Por ejemplo , puedes usar el
métdo arraycopy como sigue:
// original array
int myArray [] = { 1, 2, 3, 4, 5, 6 };
// new larger array
int hold [] = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
// copy all of the myArray array to the hold
// array, starting with the 0th index
System.arraycopy(myArray, 0, hold, 0, myArray.length);
 El arreglo hold contendría lo siguiente: 1, 2, 3, 4, 5, 6, 4, 3, 2, 1.
– El métdo de system.arraycopy copia refrencias, no objetos. El objeto no se
cambia a si mismo
 Redimensionar arreglos

 Después de crear un arreglo, no lo

redimensionarás, puedes usar la misma
variable refrenciada para referirte a un
arreglo nuevo:
int myArray [] = new int[6];
myArray = new int[10];
 En este caso, el primer arreglo es
efectivamente perdido a no ser que otra
refrencia sea conservada en otra parte.