ARRAY DINMICO

Fundamentos de programacin

Equipo #2:
-

Romario Aguirre Alonso

Dolores Arlett Antele Temich
Juan Jos Ceba Hernndez
Juan Carlos Chapol Ponciano
Victor Hugo Chibamba Chipol
Diana Laura Chipol Temich
Sarahi de Milagros Coba Acua
Luis Angel Cobix Irineo
Gabriela Cruz Snchez
Imelda Jocelyn Garca Chipol
Luis Enrique Machucho Cortez
Cesar Noel Machucho Olgun
Luis Alberto Muoz Xolo
Armando Prez Domnguez
Denisse Ramrez Navarrete
Ninger Valencia Cardoza

Array Dinmico

ndice
Introduccin................................................................................................................ 2
Definicin de un array dinmico................................................................................... 3
Vector......................................................................................................................... 4
Declaracin e inicializacin de una variable vector.....................................................4
Capacidad de un vector.......................................................................................... 4
Declarar, redimensionar y trabajar con arrays dinmicos.............................................5
Aadir, eliminar y consultar elementos de un vector...................................................6
Arraylist...................................................................................................................... 7
Declaracin y creacin de un arraylist.......................................................................7
Copiar un arraylist................................................................................................. 9
Recorrer un arraylist............................................................................................. 10
Mtodos de arraylist............................................................................................. 10
Arraylist como parmetro de un mtodo..................................................................11
Rendimiento y comparacin con otras estructuras....................................................12
Bucles for each................................................................................................... 13
Conclusin................................................................................................................ 15

Array Dinmico

Introduccin
Un arreglo en Java es un grupo de posiciones de memoria contiguas, todas las cuales
tienen el mismo nombre y el mismo tipo.
Es una estructura de datos que permite almacenar un conjunto de datos de un mismo
tipo. El tamao de los arrays se declara en un primer momento y no puede
cambiar luego durante la ejecucin del programa, como s puede hacerse en
otros lenguajes.
Los arreglos en Java son dinmicos, pero no extensibles, lo cual significa que deben
ser creados con el tamao que tendrn hasta el final de su vida para declarar, por
ejemplo, un arreglo de nmeros enteros utilizaremos la siguiente sentencia:
int[] arrint;
Para crear el arreglo deberemos recurrir al operador new:
arrint = new int[10];
La forma de declararlos es la siguiente:

Unidimensionales:

Tipo nombre_array[]=new tipo[n];

Tipo nombre_array[]={valores};

Bidimensionales:

Tipo nombre_array[][]=new tipo[n][n];

Tipo nombre_array[][]={valores};

Array Dinmico

Definicin de un array dinmico

un array dinmico, es un arreglo de elementos que crece o mengua
dinmicamente conforme los elementos se agregan o se eliminan. Se suministra como
libreras estndar en muchos lenguajes modernos de programacin.
La forma ms sencilla de construir un arreglo dinmico es la asignacin de
espacio de tamao fijo dividido en dos partes: la primera es la parte ocupada de del
arreglo y la segunda est libre para su crecimiento. El nmero de elementos usados
por el contenido del arreglo dinmico es su tamao lgico o simplemente tamao,
mientras que el tamao del arreglo subyacente se denomina la capacidad dinmica,
que es el tamao mximo posible sin reubicacin de datos.
En aplicaciones donde el tamao lgico es conocido, las estructuras de tamao
fijo son las ms eficientes, como es evidente, por lo que es mejor usar en estos casos
arreglos asignados dinmicamente, cuyo tamao sea un parmetro de la ejecucin,
que pueda aumentarse cuando se detecta que se alcanzan los lmites, optimizando el
espacio ocupado.

Array Dinmico

Vector
Un objeto de tipo Vector contiene elementos que pueden ser accedidos por un
ndice y puede aumentar o disminuir su tamao dinmicamente en tiempo de ejecucin.

Declaracin e inicializacin de una variable vector

En el siguiente ejemplo podemos ver cmo se declara:
import java.util.Vector;
public class Prueba{
public static void main(String[] args){
Vector<String>v= new Vector<String>();
v.add("Hola Grupo 104-A");
v.add("Saludos...");
v.add("Bye...");
System.out.println("Elementos en v:" + v.size());
System.out.println("\n"+v.elementAt(0)+"\n"+ v.elementAt(1)+
"\n"+v.elementAt(2));
}
}

Al estar implementada esta funcionalidad mediante una clase, la variable v se

inicializa creando una instancia de la clase con la llamada a new vector()
Por otra parte, en la declaracin indicamos el tipo de objetos que pretendemos
almacenar (en el ejemplo, objetos de tipo string). Es posible no indicar el tipo de
objeto, pero en ese caso el compilador genera un mensaje de aviso (aunque realiza
la compilacion). Si queremos mantener la libertad de almacenar todo tipo de
objetos, pero evitar el aviso que genera el compilador, siempre podemos definir el
vector como vector<object>
A continuacin, se aaden elementos mediante llamadas al mtodo add()
Tambin podemos ver que nmero de elementos que contiene el vector se
obtiene con el mtodo size()
Por ltimo, vemos que para acceder a un elemento del vector se utiliza el
mtodo elementat(ndice), en donde el ndice del elemento n es n-1, porque
comienzan a contarse a partir de cero.

Capacidad de un vector
Cada vez que se aade un elemento a un vector, el sistema tiene que ubicar la
memoria necesaria para albergarlo. Para mejorar el rendimiento cuando se trabaja con

Array Dinmico
vectores que deben contener un elevado nmero de elementos, en al crear el objeto
vector se puede definir una capacidad inicial, y un incremento de capacidad del vector:
iInt capacidadinicial = 1000;
int capacidadincremento = 100;
Vector v = new Vector(capacidadinicial, capacidadincremento);
Adems, disponemos de los siguientes mtodos relacionados con la capacidad del
vector:
int capacity() devuelve la capacidad actual del vector (siempre sera mayor o
igual a su tamao actual)
Ensurecapacity(int capacidad) incrementa la capacidad del vector si es menor
que la que se indica (pero no la reduce si es mayor)
trimtosize() reduce la capacidad del vector para que coincida con el tamao del
vector

Declarar, redimensionar y trabajar con arrays dinmicos

Un array dinmico habr de redimensionarse al menos una vez (para poder ser usado),
pero podr modificarse tantas veces para declarar un array dinmico, simplemente
declrelo sin indicar las dimensiones del mismo:
Var
Arraydinamico : array of string; //array dinmico de string
Antes de que puede utilizar un array dinmico debe reserver la memoria para el mismo
asignndole una dimensin:
//reserva espacio para 10 elementos
Setlength (arraydinamico, 10);
Una vez que se ha reservado la memoria, puede acceder a los elementos del array
como uno normal:
Arraydinamico[0] := 'esto es una prueba';
Textoobtenido := arraydinamico[0];
Los arrays dinmicos son gestionados durante su vida, por lo que no es necesario que
los libere cuando acabe de utilizarlos, ya que se liberarn cuando dejen el mbito en el
que fueron creados. Sin embargo, si en alguna ocasin necesita liberarlos (por ejemplo

Array Dinmico
cuando utilizan gran cantidad de memoria) lo nico que tiene que hacer es asignar el
array dinmico a "nil":
Arraydinamico := nill; //libera arraydinamico de memoria

Aadir, eliminar y consultar elementos de un vector

Disponemos de los siguientes mtodos para alterar el contenido del vector:

addElement(e) aade un elemento al vector

add (idx, e), insertElementat(e, idx) inserta el elemento en la posicin indicada.
set (idx, e), setElementat(e, idx) sustituye el elemento en el ndice idx por el
elemento e
get (idx), elementAt(idx) devuelve el elemento en el ndice idx del vector
firstElement(), lastelEment() devuelven respectivamente el primer y ltimo
elemento del vector
remove (idx), removeElementAt(idx) devuelve el elemento en el ndice idx, y lo
elimina del vector. El ndice de los elementos posteriores disminuye en una
unidad, de modo que el elemento en la posicin idx+1 pasa a ser el nuevo
elemento en la posicin idx
removeRange(idx1, idx2) elimina los elementos con indices idx1 <= idx < idx2
contains( e ) devuelve true si el vector contiene el objeto e

Array Dinmico

Arraylist
Es una clase que permite almacenar datos en memoria de forma similar a los
Arrays, con la ventaja de que el nmero de elementos que almacena, lo hace de forma
dinmica, es decir, que no es necesario declarar su tamao como pasa con los Arrays.

Declaracin y creacin de un arraylist

De forma general un arraylist en java se crea de la siguiente forma:
Arraylist nombrearray = new arraylist();
Esta instruccin crea el arraylist nombrearray vaco.
Un arraylist declarado as puede contener objetos de cualquier tipo.
Por ejemplo:
import java.util.ArrayList;
public class Prueba{
public static void main(String[] args){
ArrayList v= new ArrayList();
v.add("lenguaje");
v.add(3);
v.add('a');
v.add(23.5);
System.out.println("Los elementos del ArrayList son: \n" + v.get(0)+"\n"
+v.get(1)+"\n"+v.get(2)+"\n"+ v.get(3));
}
}

El primer objeto que se aade es el string lenguaje. El resto no son objetos. Son
datos de tipos bsicos pero el compilador los convierte automticamente en objetos de
su clase envolvente (clase contenedora o wrapper) antes de aadirlos al array.

Array Dinmico
Una alternativa a esta declaracin es indicar el tipo de objetos que contiene. En
este caso, el array solo podr contener objetos de ese tipo.
De forma general:
Arraylist<tipo> nombrearray = new arraylist<tipo>();
Tipo debe ser una clase. Indica el tipo de objetos que contendr el array.
No se pueden usar tipos primitivos. Para un tipo primitivo se debe utilizar su clase
envolvente.

Arraylist() construye un arraylist con capacidad cero por defecto, pero crecer
segn le vayamos aadiendo:
Arraylist al = new arraylist();
Arraylist(int capacidadinicial) construye un arraylist vaco con una capacidad
inicial especificada:
Arraylist al2 = new arraylist(5);
Para insertar un objeto al arraylist debemos llamar a sus mtodos con el
operador punto:
al.add("el manual de java");

// aade una cadena

al.add(new double(40.00));
clase envoltorio (wrapper class)

// aade un dato de tipo double de una

System.out.println(al.size()); // presenta el tamao del arreglo

Para navegar por los elementos del arraylist se utiliza la clase iterator y
sus mtodos hasnext y next:
Iterator alit = al.iterator();
While (alit.hasnext()) {
System.out.println(alit.next() + " ");
}

Array Dinmico

Copiar un arraylist
El nombre de un arraylist contiene la referencia al arraylist, es decir, la direccin
de memoria donde se encuentra el arraylist, igual que sucede con los arrays estticos.
Si disponemos de un arraylist de enteros llamado ventas:

la instruccin:
Arraylist<integer> ventas1 = ventas;
No copia el array ventas en el nuevo array ventas1 sino que crea un alias:

De esta forma tenemos dos formas de acceder al mismo arraylist: mediante la

referencia ventas y mediante la referencia ventas1.
Para hacer una copia podemos hacerlo de forma manual elemento a elemento
o se puede pasar la referencia del arraylist original al constructor del nuevo:
Arraylist<integer> ventas1 = new arraylist<integer>(ventas);

Array Dinmico

Recorrer un arraylist
Podemos recorrerlo de forma clsica con un bucle for:
For(int i = 0;i<array.size();i++){
System.out.println(array.get(i));
}
Con un bucle foreach:
Si suponemos el array de enteros llamado numeros:
For(integer i: numeros){
System.out.println(i);
}
Si el array contiene objetos de tipos distintos o desconocemos el tipo:
For(object o: nombrearray){
System.out.println(o);
}
Utilizando un objeto iterator.
La ventaja de utilizar un iterador es que no necesitamos indicar el tipo de objetos
que contiene el array.
Iterator tiene como mtodos:
Hasnext: devuelve true si hay ms elementos en el array.
Next: devuelve el siguiente objeto contenido en el array.

Mtodos de arraylist
Algunos mtodos que proporciona arraylist son:
Mtodo

Descripcin

Size()

Devuelve el nmero de elementos (int)

Add(x)

Aade el objeto x al final. Devuelve true.

Add(posicin, x)

Inserta el objeto x en la posicin indicada.

Get(posicion)
Remove(posicion)

Devuelve el elemento que est en la posicin

indicada.
Elimina el elemento que se encuentra en la

10

Array Dinmico
posicin indicada. Devuelve el elemento eliminado.
Remove(x)

Elimina la primera ocurrencia del

Devuelve true si el elemento est en la lista.

Clear()

objeto

x.

Elimina todos los elementos.

Set(posicin, x)

Sustituye el elemento que se encuentra en la

posicin indicada por el objeto x. Devuelve el elemento
sustituido.

Contains(x)

Comprueba si la coleccin contiene al objeto x.

Devuelve true o false.

Indexof(x)

Devuelve la posicin del objeto x. Si no existe

devuelve -1

Arraylist como parmetro de un mtodo

Un arraylist puede ser usado como parmetro de un mtodo. Adems un mtodo
puede devolver un arraylist mediante la sentencia return.
Ejemplo: mtodo que recibe un arraylist de string y lo modifica invirtiendo su
contenido:

Import java.util.*;
Public class arraylist4 {
Public static void main(string[] args) {
Arraylist<string> nombres = new arraylist<string>();
Nombres.add("ana");
Nombres.add("luisa");
Nombres.add("felipe");
Nombres.add("pablo");
System.out.println(nombres);
Nombres = invertir(nombres);
System.out.println(nombres);
}

11

Array Dinmico
Public static arraylist<string> invertir(arraylist<string> nombres) {
// crea una lista para el resultado del mtodo
Arraylist<string> resultado = new arraylist<string>();
// recorre la lista de nombres en orden inverso
For (int i = nombres.size() - 1; i >= 0; i--) {
// aade cada nombre al resultado
Resultado.add(nombres.get(i));
}
Return resultado;
}
}

Rendimiento y comparacin con otras estructuras

Los arreglos dinmicos tienen un rendimiento similar a un arreglo esttico, con la
adicin de nuevas operaciones para aadir y eliminar elementos al final:

Al obtener o establecer el valor de un ndice en particular: (1) (tiempo

constante)

Recorrer sus elementos en orden: (n) (tiempo lineal, buen uso del cach de
lectura)

Insertar o eliminar un elemento no al final del arreglo: (n) (tiempo lineal)

Insertar o eliminar
constante amortizado)

un

elemento

al

final

del

arreglo:

(1)

(tiempo

Espacio desperdiciado: (n)5

Los arreglos dinmicos se benefician de muchas de las ventajas de los arreglos

estticos, incluido buena localizacin por referencia y uso de cach de datos, tamao
reducido (bajo uso de memoria) y capacidad de acceso aleatorio. Por lo general tienen
solo una pequea sobrecarga fija adicional para almacenar informacin sobre tamao y
capacidad. Esto hace de los areglos dinmicos una herramienta atractiva para la
construccin de estructuras de datos amigables y sencillas de usar.

12

Array Dinmico

Bucles for each

Una nueva forma de usar el for, a la que se denomina for extendido o for each.
Esta forma de uso del for, que ya exista en otros lenguajes, facilita el recorrido de
objetos existentes en una coleccin sin necesidad de definir el nmero de elementos a
recorrer. La sintaxis que se emplea es:
for ( TipoARecorrer nombreVariableTemporal : nombreDeLaColeccin ) {
Instrucciones
}
El ciclo for-each es una herramienta muy til cuando tenemos que realizar
recorridos completos de colecciones, por lo que lo usaremos en numerosas ocasiones
antes que ciclos for o while que nos obligan a estar pendientes de ms cuestiones (por
ejemplo en este caso con el while, de llevar un contador, llamar en cada iteracin a un
mtodo, etc.). Un for extendido en principio recorre todos y cada uno de los elementos
de una coleccin. Sin embargo, podemos introducir un condicional asociado a una
sentencia break; que aborte el recorrido una vez se cumpla una determinada condicin.
Ejemplo:
import java.util.*;
import java.io.*;
public class ArrayList2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
ArrayList<Integer> numeros = new ArrayList<Integer>();
int n;
do {
System.out.println("Introduce nmeros enteros. 0 para acabar: ");
System.out.println("Numero: ");
n = sc.nextInt();
if (n != 0)
numeros.add(n);
}while (n != 0);
System.out.println("Ha introducido: " + numeros.size() + " nmeros:");
//mostrar el arrayList completo
System.out.println(numeros);
//recorrido usando un iterador para mostrar un elemento por lnea
Iterator it = numeros.iterator();
13

Array Dinmico
while(it.hasNext())
System.out.println(it.next());
//recorrido usando foreach para sumar los elementos
double suma = 0;
for(Integer i: numeros){
suma = suma + i;
}
System.out.println("Suma: " + suma);
System.out.println("Media: " + suma/numeros.size());
}
}

14

Array Dinmico

Conclusin
Hemos llegado a la conclusin que los array (arreglos) dinmico como aquel que
es declarado con un nmero de elementos componente indefinido. Dicha indefinicin
se hace constar, al declarar el array en cabecera de mdulo o programa, dejando los
parntesis vacos, los arreglos pueden variar dependiendo sus dimensiones. Estos
pueden ser unidimensionales y bidimensionales; a los primeros se les conoce como
vectores y como su nombre lo indica poseen una dimensin o una lista de datos del
mismo tipo y los bidimensionales poseen dos dimensiones; se usan para representar
datos que pueden verse como una tabla con filas y columnas y se les conoce como
matrices.
La codificacin es algo tan simple como lo que realizamos a diario cuando
transformamos imgenes visuales o entidades conceptuales en palabras, oraciones,
textos y las comunicamos a aquellos que nos rodean. Conocemos a la codificacin
como cualquier operacin que implique la asignacin de un valor de smbolos o
caracteres a un determinado mensaje verbal con el propsito de transmitirlo a otros
individuos o entidades que compartan el cdigo.

15