Un array Java es una estructura de

datos que nos permite almacenar una

ristra de datos de un mismo tipo. El
tamaño de los arrays se declara en un
primer momento y no puede cambiar en
tiempo de ejecución como puede
producirse en otros lenguajes.

Arrays en
JAVA
Revista virtual

20 de abril del 2021

 “Un arreglo es un grupo de
posiciones de memoria
contiguas, todas las cuales
tienen el mismo nombre y el
mismo tipo”

En esta entrada
hablaremos sobre los arreglos Un arreglo es una estructura de
unidimensionales, la estructura
datos que puede almacenar un
de datos más simple pero
conjunto de datos de un mismo
básica para el tratamiento de tipo. Los datos se almacenan en
datos a una mayor escala en un
forma contigua. Observa en la
programa. figura 2 la diferencia entre un
arreglo y una variable estática
simple. Mientras que la variable
Una gran parte del x sólo puede almacenar un
procesamiento de la información único valor a la vez, el arreglo z
es precisamente la información. puede contener un conjunto de
Ya sea en su etapa inicial, en su n datos del mismo tipo. Sin
forma de datos, como en su embargo, tanto x como z son
etapa final, en forma de variables.
información, son el motivo de
que existan las tecnologías de la
información. Y hay incontables
ocasiones en que como
programadores se nos olvida
eso, y nos enfocamos más en el
“cómo” se hacen las cosas, que
en el “con qué”.
Como ya hemos comentado, la
estructura más básica es el Figura 2. Diferencia entre una variable simple
arreglo. Al arreglo también se le y un arreglo.
conoce con el nombre de vector
o array. Según Deitel & Deitel:
Declaración:
Para utilizar un arreglo, como
toda variable en Java, debe ser
primero declarado. La forma
general te la muestro en la Figura 4. Construcción de un arreglo.

figura 3. Con respecto al tamaño del

arreglo:
 Debe ser un valor entero
 Puede expresarse con
una constante numérica
(5, 10, 2000, etc.):
arreglo = new int[100];

Figura 3. Declaración de un arreglo.

 También puede
Los corchetes nos indican que expresarse con una
se tratará de un arreglo y no de constante simbólica:
una variable simple. En el caso
public static final constante = 10;
de los arreglos, la declaración …
por sí sola no crea arreglo = new int[constante];
inmediatamente el espacio de
almacenamiento, por lo que es  Y también puede usarse
necesario mediante el operador una variable entera,
new indicar el número de siempre y cuando, ya
casillas de memoria que utilizará haya sido inicializada
el arreglo. (De ahí su carácter antes de la creación del
de estructura de datos estática) arreglo:
Esto implica que es necesario
crear el arreglo, como se te
muestra en la figura 4, en la cual int t = 10;
se supone que el arreglo tuvo
arreglo = new int[t];
que haber sido declarado con
anterioridad.
Una vez que se ha asignado tamaño
de almacenamiento al arreglo se dice
que ha sido “construido”, y, por lo
tanto, se puede emplear en el
programa. Cuando esto sucede,
todos los elementos en el arreglo se
inicializan a cero en el caso de haber
sido declarado int, float o double;
false en el caso del tipo boolean o
null en el caso de ser un arreglo de
referencias.
.
CARACTERISTICAS:
Un arreglo unidimensional se
caracteriza por modelar listas de
elementos iguales. Arreglos se define
como una colección finita,
homogénea y ordenada de
elementos.
 HOMOGENEAS: Todos los
elementos deben ser del
mismo tipo.
 ORDENADAS: Debe haber un
primer elemento, un segundo
elemento y así sucesivamente
 FINITA: Debe determinarse
cuál será el número máximo
de elementos que podrán
formar parte del arreglo.
 TAMAÑO FINITO: El tamaño
del array debe ser conocido en
tiempo de compilación, todos
los elementos tienen
significado
VENTAJAS:
Algunas de las ventajas de los
arreglos unidimensionales son:
 son más seguras y claros. -
Menos problemas en cuanto a
los datos validos sean
eliminados por error o a que
existan datos no validos en el
arreglo. -Ocupan menos
recursos del ordenador.
 El acceso a los arreglos es
directo, nos permiten hacer un
conjunto de operaciones para
manipular los datos guardados
en ellos, estas operaciones
son: ordenar, buscar, insertar,
eliminar, modificar entre otras.
DESVENTAJAS:
Algunas de las desventajas de los
arreglos unidimensionales son:
 Los datos que se guarden en
los arreglos todos deben ser
del mismo tipo.
 Para implementar arreglos
unidimensionales se debe
reservar espacio en memoria.
 Limitan en cuanto a capacidad
de maniobra.
Veamos un ejemplo
Supongamos que queremos guardar las notas de los 20 alumnos
de una clase.
Para almacenar las notas utilizaremos un array de 20 elementos de
tipo double y en cada elemento del array guardaremos la nota de cada
alumno.
Podemos representar gráficamente el array de notas de la siguiente
forma:

Array notas:

Para acceder a cada elemento del array se utiliza el nombre del array
y un índice que indica la posición que ocupa el elemento dentro del
array.
El índice se escribe entre corchetes.
El primer elemento del array ocupa la posición 0, el segundo la
posición 1, etc. En un array de N elementos el último ocupará la
posición N-1.
En el ejemplo anterior, notas[0] contiene la nota del primer alumno y
notas[19] contiene la del último
Los índices deben ser enteros no negativos.
Ejercicio resuelto
Crea un array de números de un tamaño pasado por teclado, el array contendrá
números aleatorios primos entre los números deseados, por último nos indica cual
es el mayor de todos. Haz un método para comprobar que el número aleatorio es
primo, puedes hacer todos los métodos que necesites.

import javax.swing.JOptionPane;

public class Ejercicio_DiscoDurodeRoer_Arrays_3 {

public static void main(String[] args) {

//Indicamos el tamaño
String texto=JOptionPane.showInputDialog(" Introduce
un tamaño ");
int num[]=new int[Integer.parseInt(texto)];

//Invocamos las funciones

rellenarNumPrimosAleatorioArray(num, 1, 100);

mostrarArray(num);

//Saco el primo mayor

int primoMayor=mayor(num);
System.out.println(" El primo más grande es el
"+primoMayor);
}

public static void rellenarNumPrimosAleatorioArray(int

lista[], int a, int b){

int i=0;

//Usamos mejor un while, ya que solo aumentara cuando

genere un primo
while(i<lista.length){
int num=((int)Math.floor(Math.random()*(a-
b)+b));
if (esPrimo(num)){
lista[i]=num;
i++;
 }
}
}
private static boolean esPrimo (int num){

//Un numero negativo, el 0 y el 1, son directamente

no primos.
if (num<=1){
return false;
}else{

//declaracion
int prueba;
int contador=0;
//Hacemos la raiz cuadrada y lo usamos para
dividir el numero original
prueba=(int)Math.sqrt(num);
//Bucle que cuenta los numeros divisibles,
podemos hacerlo con while
for (;prueba>1;prueba--){
if (num%prueba==0){
contador+=1;
}
}
return contador < 1;
}
}

public static void mostrarArray(int lista[]){

for(int i=0;i<lista.length;i++){
System.out.println("En el indice "+i+" esta el
valor "+lista[i]);
}
}

public static int mayor(int lista[]){

int mayor=0;
for(int i=0;i<lista.length;i++){
if(lista[i]>mayor){
mayor=lista[i];
}
}

return mayor;
}

}
 Es muy común llamarles
arreglos bidimensionales, arreglos 2d,
o matrices, pero en realidad, se tratan Al igual que los arreglos
de un arreglo de arreglos. Sólo que unidimensionales, las dimensiones de
para su manipulación lógica, ha sido una matriz deben:
más conveniente pensar en ellos
 Ser un valor entero.
como una tabla de valores.
 Pueden expresarse como
Declaración constantes numéricas (10,
100, 1000, etc)
La declaración de un arreglo
bidimensional en Java se muestra a
arreglo = new int[10][5];
continuación:

 También pueden expresarse

como una constante simbólica,
ya sea las dos dimensiones o
sólo una de ellas.

public static final R = 10;

public static final C = 6;

Figura 2. Declaración de un arreglo
bidimensional …

Como puedes observar ahora matriz = new boolean[R][C];

tenemos dos dimensiones: el número  Y también pueden usarse
de renglones y el número de filas del variables enteras previamente
arreglo. inicializadas.
Al igual que los arreglos
unidimensionales, el proceso de int renglones = 12;
declaración y construcción puede
realizarse en una sola sentencia o en int columnas = 8;
dos. En la figura 3 puedes ver la
instrucción que crea una matriz. matriz = new double[renglones]
[columnas];
  La primera dimensión se Ventajas
refiere al total de renglones de
la matriz, y la segunda se Algunas de las ventajas de los
refiere al total de columnas. arreglos bidimensionales son:

Características  Fácil acceso a los elementos

 Fácil acceso a los reglones.
 Es un vector de vectores.  Fácil extensión al caso
 Un arreglo bidimensional se multidimensional.
denomina también tabla o  Puede ser muy eficiente si se
matriz. puede programar de manera
 Los arreglos bidimensionales adecuada
se referencian con dos
subíndices Desventajas
 El primero se refiere a la
Algunas de las desventajas de los
fila.
arreglos bidimensionales son:
 El segundo se refiere a
la columna.  Uso limitado como argumento
de una función
 El acceso a elementos
requiere mayor cuidado y el
cálculo de la posición donde se
demuestra dentro del arreglo
lineal.

Veamos un ejemplo
Este arreglo es de tamaño 3 x 5
Los arreglos bidimensionales se usan
para representar datos que pueden 3 filas
verse como una tabla con filas y
columnas. La primera dimensión del 5 columnas
arreglo representa las columnas,
cada elemento contiene un valor y
cada dimensión representa una
relación.

La representación en memoria se
realiza de dos formas:
almacenamiento por columnas o por
renglones.
Ejercicio resuelto
Crear una matriz de 5 filas y n columnas (se pide al usuario). Rellenarlo con
números aleatorios entre 0 y 10.

1. import java.util.Scanner;
2.
3. public class Ejercicio_2 {
4.
5.
6. public static void main(String[] args) {
7.
8. Scanner sn=new Scanner(System.in);
9.
10. System.out.println("Escriba un numero de columnas ");
11. int columnas=sn.nextInt();
12.
13. int matriz[][]=new int[5][columnas];
14.
15. for(int i=0;i<matriz.length;i++){
16. for(int j=0;j<matriz[0].length;j++){
17. matriz[i][j]=generaNumAleatorio(0,9);
18. System.out.print(matriz[i][j]+" ");
19. }
20. System.out.println("");
21.
22. }
23.
24. }
25.
26. public static int generaNumAleatorio(int minimo,int maximo){
27.
28. Return (int)Math.floor(Math.random()*(minimo-
(maximo+1))+(maximo+1));
29.
30. }
31.
32.}

La clase Vector es una
estructura dinámica (no como el
vector que hacemos comúnmente),
esta clase pertenece a las librerías
propias de Java, y en ocasiones
puede llegar a ser muy útil y es muy
fácil de usar.
Esta clase contiene una serie
de métodos con los que podemos
entre otras cosas: agregar un
elemento, remover un elemento,
modificar un elemento, insertar un
elemento en una posición dada. Otra
característica de este "vector" es que
al ser dinámico no ocupa que le
demos un tamaño predeterminado, él
puede agrandarse y encogerse
cuando lo requiera así que no va a
gastar espacio innecesariamente
conteniendo espacios vacíos (al
menos que ustedes lo agreguen).
Declaración
Para importarlo escribimos
esta línea:
1. import java.util.Vector;
La inicialización sería así:
1. Vector nombreDeMiVector =
new Vector();
Características
La clase Vector, al igual que
ArrayList o LinkedList, también
implementa a List, pero de un modo
especial. Este modo especial es
sincronizado, lo que permite que se
pueda usar en entornos concurrentes
(es decir, en varios procesos que se
ejecutan al mismo tiempo y hacen
uso posiblemente de los mismos
recursos). Esta además es la
principal característica que la
diferencia de otras clases como
ArrayList.
Vamos a ver las principales
características de esta clase, que
además es muy parecida a ArrayList.
Un objeto de tipo Vector
contiene elementos que pueden ser
accedidos por un índice y puede
aumentar o disminuir su tamaño
dinámicamente en tiempo de
ejecución.
Un vector es similar a un array,
la diferencia estriba en que un vector
crece automáticamente cuando
alcanza la dimensión inicial máxima.
Además, proporciona métodos
adicionales para añadir, eliminar
elementos, e insertar elementos entre
otros dos existentes.
Veamos un ejemplo
Vamos a realizar un ejemplo de uso sobre la clase Vector, donde añadiremos
elementos, eliminaremos elementos y consultaremos la capacidad del vector. Para
ello también usaremos la clase Persona:

Vamos a escribir ahora el siguiente código con el que vamos a trabajar:

Como podemos observar en el código, hemos creado una variable v de la clase

Vector<Persona> sobre la que consultamos sus capacidades en distintos
momentos (antes de insertar elementos en el vector, y tras realizar inserciones o
cambios). Hemos utilizado algunos métodos que comentaremos ahora.

El diagrama de clases que podemos ver en BlueJ será similar al siguiente:

La salida que obtendremos por consola será similar a esta:

Como hemos visto la capacidad inicial cuando creamos un nuevo vector es 10

(capacidad que asigna Java por defecto si no se especifica otra), y el incremento
definido en caso de ampliación del vector es 0. El incremento en caso de
ampliación establece cómo se aumentará el tamaño del vector en caso de que su
capacidad vaya a ser excedida al incrementarse el número de elementos en él y
podemos establecerlo en 10, 20, 50, etc. elementos (los que nosotros queramos).
Tanto la capacidad inicial como el incremento definido pueden establecerse
usando constructores especiales que incluyen estos parámetros. En caso de no
usar estos constructores, Java utiliza valores por defecto. El valor por defecto 0
para el incremento significa que si se necesita ampliar la capacidad lo que se hace
por defecto es duplicar la capacidad del vector.

Recordar que si quisiéramos una determinada capacidad inicial y un determinado

incremento por defecto nos bastaría con crear el vector pasando los parámetros
de forma adecuada en el constructor. Puedes consultar los constructores
disponibles en la documentación de la clase.
 Este concepto se da cuando hay una relación entre las componentes de
igual subíndice (misma posición) de un vector y otro.

Si tenemos dos vectores de 5 elementos cada uno. En uno se almacenan

los nombres de personas en el otro las edades de dichas personas.

Decimos que el vector nombres es paralelo al vector edades si en la

componente 0 de cada vector se almacena información relacionada a una persona
(Juan - 12 años)

Es decir hay una relación entre cada componente de los dos vectores.

Esta relación la conoce únicamente el programador y se hace para facilitar

el desarrollo de algoritmos que procesen los datos almacenados en las estructuras
de datos.

Veamos un ejemplo
Desarrollar un programa que permita cargar 5 nombres de personas y sus edades
respectivas. Luego de realizar la carga por teclado de todos los datos imprimir los
nombres de las personas mayores de edad (mayores o iguales a 18 años)
import java.util.Scanner;
public class PruebaVector10 {
private Scanner teclado;
private String[] nombres;
private int[] edades;

public void cargar() {

teclado=new Scanner(System.in);
nombres=new String[5];
edades=new int[5];
for(int f=0;f<nombres.length;f++) {
System.out.print("Ingrese nombre:");
nombres[f]=teclado.next();
System.out.print("Ingrese edad:");
edades[f]=teclado.nextInt();
}
}

public void mayoresEdad() {

System.out.println("Personas mayores de
edad.");
for(int f=0;f<nombres.length;f++) {
if (edades[f]>=18) {
System.out.println(nombres[f]);
}
}
}

public static void main(String[] ar) {

PruebaVector10 pv=new PruebaVector10();
pv.cargar();
pv.mayoresEdad();
}
}
 Realizada por:

Manuel Zambrano

C.I: 28.150.444

Sección: 06S-2613-D1

Lenguaje de programación III

Prof. Steven Suarez