Arreglos

Taller de
Algoritmos y
Estructuras
de Datos I
1
Arreglos
Guardar tipos básicos de datos

Un array es una estructura de datos del tipo estructurada simple que

permite almacenar un conjunto de objetos del mismo tipo, ya sea primitivos
y objetos. Se accede a cada elemento individual del array mediante un
número entero denominado índice, siendo el índice del primer elemento 0
(cero) y n-1 el del último elemento, donde n es la dimensión del array
otorgada en el momento de la definición.

Los arrays son objetos en Java, el correcto uso supone los siguientes pasos:

1. Declarar el array
o Tipo [] nombreDelArray; //Sintaxis
o int[] numeros; //declarar un array de enteros escribimos
o
2. Crear el array
o numeros=new int[4]; //crear un array de 4 número enteros
o int[] numeros =new int[4]; //La declaración y la creación del
array en una línea
3. Inicializar los elementos del array
numeros[0]=278; //inicializar el array de 4 enteros
numeros[1]=-45;
numeros[2]=15;
numeros[3]=-125;

4. Usar el array

El uso de un array supone que puede declararlo, crearlo e inicializarlo en un

mismo renglón o en distintos lugares del programa, según sea necesario,
por ejemplo, se pueden inicializar en un bucle for como resultado de
alguna operación:

for(int i=0; i<4; i++)

{
numeros[i] = i +7;
}

Si bien es una estructura estática que conoce su longitud ya que está en su

creación, no necesita recordar el número de elementos del array, su
miembro dato length proporciona la dimensión del mismo. Su sintaxis es:

for(int i=0; i<numeros.length; i++)

{
numeros[i]=i +7;

}
Los arrays se pueden declarar, crear e inicializar en una misma línea, del
siguiente modo:

int[] numeros={278, -45, 15, -125};

String[] nombres={"lunes", "miércoles", "viernes", "domingo"};

¿Cómo se muestran los elementos almacenados en un Array?

Se utiliza una estructura repetitiva for para recorrerlo y sacar cada

elemento:

for(int i=0; i<vec.length; i++)

{
System.out.println(vec[i]);
}

¿Cómo se almacenan objetos en un Array?

Utilizando length Java verifica que el índice no sea mayor o igual que la
dimensión del array, garantizando que no accederá a un lugar que
supere la longitud y se interrumpa la ejecución del programa.

Suponga que debe almacenar objetos Integer en un array, la sintaxis es:

 Declarar
Integer [] num;
 Crear el array
num=new Integer[2]; //longitud, para 2 objetos enteros
 Inicializar los elementos del array
num[0]=new Integer(10); //se inicializa el objeto y almacena
num[1]=new Integer(30);

 Usar el array

Para calcular la suma de los valores almacenados

for(int i=0; i<num.length; i++){

Int total = total + num[i];
System.out.println(total);
//para mostrarlos como short llamo al método de la clase Integer
System.out.println(num[i]. shortValue());
}
Los Array pueden ser bidimensionales o multidimensionales, pero no es el
objeto de estudio y aplicación en este módulo, por lo que no lo
desarrollaremos.

CLASE VECTOR

Es una implementación heredada desde JDK 1.1. En JDK 1.2 fue adaptada
para que implementase List. De hecho deriva de AbstracList.
Su árbol dentro de Java está organizado de la siguiente forma:

java.util
Class Vector<E>

java.lang.Object

java.util.AbstractCollection<E>

java.util.AbstractList<E>

java.util.Vector<E>

All Implemented Interfaces:

Serializable, Cloneable, Iterable<E>, Collection<E>, List<E>,

RandomAccess

Si bien no es más rápida que las implementaciones ArrayList o

LinkedList, está sincronizada. Sus iterators también son rápidos.

La instancia de la clase Vector nos da una colección pseudodinámica, ya que

varía su longitud cuando se llena, por lo que no tiene desbordamiento.

Para usar la clase Vector debe importar el paquete java.util al principo del
archivo del código fuente
import java.util.*;

Para instanciar la clase Vector puede utilizar distintos constructores:

Vector vector=new Vector();

Cuando se utiliza el constructor sin argumentos la capacidad inicial es diez,

cuando se llena aumenta de tamaño duplicándose.

Vector vector = new Vector( capacidadInt)

El vector creado tiene la capacidad especificada, cuando se llena duplica su

tamaño, por ejemplo:
Vector vector = new Vector(5);
Inicialmente tiene una capacidad de 5, cuando se llena de elementos pasa a
tener una capacidad de 10.

Vector vector = new Vector( capacidadInt, incrementoInt )

El vector creado tiene la capacidad especificada. El segundo elemento es el

número en que la capacidad será incrementada cuando el tamaño sea

mayor que la capacidad. Por ejemplo:

Vector vector = new Vector(5, 3) //inicialmente tiene capacidad para 5

elementos, cuando se llena aumenta de a 3 lugares.

La menor dimensión es Vector(1,1), ya que de esta forma almacena un

elemento, se llena y agrega solo de a un lugar .

Los Métodos de la clase son:

addElement(objeto) Agrega un nuevo elemento al vector

capacity() Muestra la capacidad del vector

clone() Copia un vector en otro

elementAt(int) Regresa un elemento particular

elements() Muestra el total de elementos

firstElement() Primer elemento

indexOf(objeto) Muestra el índice de un elemento

insertElementAt(obj,int) Insertar objeto desde una posición

lastElement() Último elemento

setElementAt(obj,int) Escribe un elemento en una posición

size() Tamaño del vector

toString() Conversión a cadena

Vector() Constructor normal

Vector(int) Constructor con tamaño de vector

Vector(int, int) Constructor con incrementos

 Veamos un ejemplo:

import java.lang.*;
import java.util.*;

class CVector {
public static void main(String Args[]) {
int j;
Vector v=new Vector(7,5);

for(j = 0; j < 14; j++) {

v.addElement(new Integer(j)); // ingresa elementos enteros, los valores de j
}

System.out.println("vector en el orden original: ");

for(j = 0; j < v.size(); j++) { // usa como tope de elementos v.size()

System.out.print(v.elementAt(j) + " "); // muestra los elementos del vector
}

System.out.println();
System.out.println("vector en reversa: ");

for(j = v.size() - 1; j >= 0; j--) {

System.out.print(v.elementAt(j)+" ");
}

System.out.println();
System.out.println("imprime el vector como cadena: ");
System.out.println(v.toString()); // convierte en string los elemento
System.out.println("cantidad de elementos: " + v.size());
System.out.println("capacidad del vector: " + v.capacity());
}
}

vector en el orden original :

0 1 2 3 4 5 6 7 8 9 10 11 12 13
vector en reversa :
13 12 11 10 9 8 7 6 5 4 3 2 1 0
imprime el vector como cadena :
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
cantidad de elementos: 14
capacidad del vector: 17

Algunos métodos importantes de la Clase Vector, que podrán serle de

utilidad en otros programas:

 Para insertar un elemento en el vector del ejemplo anterior puede

utilizar el método insertElementAt(elemento a insertar, lugar)
Por ejemplo:
v.insertElementAt(8, 2);

 Para saber cuántos elementos guarda un vector, utilice el método

size().

 Para saber la dimensión actual de un vector se llama al método

capacity()

Por ejemplo, en la porción de código hemos guardado 14 elementos en el

vector v. La dimensión de v es 17, ya que se ha superado la dimensión
inicial de 7 establecida en la llamada al constructor cuando se ha creado el
vector v, aunmentando 5 posiciones a 12 y nuevamente 5 posiciones más.
System.out.println("cantidad de elementos " + v.size());
System.out.println("capacidad del vector: " + v.capacity());

 Se puede eliminar todos los elementos de un vector, llamando al

método removeAllElements.
 Se puede eliminar un elemento concreto, llamando al método
v.removeElement(elemento);
 Se puede eliminar dicho elemento, si especificamos su índice.
v.removeElementAt(2);

Acceso a los elementos de un vector

En vez de dar un índice como en el Array, se utiliza el método

elementAt(índice). Por ejemplo, v.elementAt(4) sería equivalente a
v[4], si v fuese un array.

 Para acceder a todos los elementos del vector, se puede utilizar una
estructura repetitiva, como en el ejemplo anterior.

for(int i=0; i<v.size(); i++) {

System.out.print(v.elementAt(i)+"\t");
}

Existe otra alternativa, que es la de usar las funciones de la interfaz

Enumeration.

Esta interfaz declara dos funciones pero no implementa ninguna de

ellas.

Enumeration permite acceder a los elementos de una estructura de datos

de forma secuencial, su código es:

public interface Enumeration

{
boolean hasMoreElements();
Object nextElement();
}
Referencia Bibliográfica
Mark Allen Weiss, “Estructuras de Datos en Java”, ed. Addison Wesley.

Deitel y Deitel, “Java cómo programar ”, séptima edición, ed. Pearson, 2008.

Pressman Roger, (2006), “Ingeniería de Software. Un enfoque práctico” 6ta.

edición, Ed. McGraw Hill

ORACLE, Oracle 10g: Programación Java, Guía del Alumno, 2003

 La función miembro elements de la clase Vector devuelve un objeto de la
clase VectorEnumerator que implementa el interface Enumeration
y tiene que definir las dos funciones hasMoreElements y nextElement.

Veamos un ejemplo simple:

Import java.util.*;
import java.util.Enumeration;

final class VectorEnumerator {

public static void main(String[] args) {

Vector<String> v = new Vector<String>();
v.add("A");
v.add("B");

Enumeration e = v.elements();
while (e.hasMoreElements()) {
System.out.println(e.nextElement());
}
}
}

¿Cómo saber qué utilizar? ¿Vectores o Array?

Los arreglos ofrecen tres ventajas sobre el Vector:

1. Pueden almacenar directamente tipos de datos primitivos.
2. Sus elementos pueden ser accedidos sin necesidad de mensajes,
por lo que el código es más rápido que si se usara un Vector
3. Como los arreglos son tipados, ofrecen una verificación en
tiempo de compilación que no la tiene el Vector. Si
almacenamos accidentalmente un objeto String en un Vector
donde tenemos almacenados objetos de Integer, Java lo
permite. Pero Java nos daría un error de compilación si
tratamos de almacenar un String en un arreglo de referencias a
Integer.

Sin embargo, los arreglos también presentan algunas desventajas sobre el

Vector:
1. Son de tamaño fijo y no crecerán.
2. No nos ofrece un conjunto de operaciones ricas como la clase
Vector (a través de métodos como insertElementAt()).
Referencia Bibliográfica
Mark Allen Weiss, “Estructuras de Datos en Java”, ed. Addison Wesley.

Deitel y Deitel, “Java cómo programar ”, séptima edición, ed. Pearson, 2008.

Pressman Roger, (2006), “Ingeniería de Software. Un enfoque práctico” 6ta.

edición, Ed. McGraw Hill

ORACLE, Oracle 10g: Programación Java, Guía del Alumno, 2003

www.uesiglo21.edu.ar