INFORMÁTICA 1

Unidad 5: ARRAYS

“Un array es una secuencia de datos del mismo tipo. Los arrays de una
dimensión; vectores; y los de dos dimensiones; tablas o matrices; son los más
utilizados.”

1
ORIENTACIÓN DEL APRENDIZAJE

Cuando nos encontramos resolviendo un problema en particular, tenemos que tratar

con la organización de sus datos en forma estructurada; por lo tanto, seleccionar los
datos, adecuadamente, es un paso necesario y fundamental al definir y,
posteriormente, resolver el problema. Todas las formas posibles en que los datos
primitivos se relacionan lógicamente, definen distintas estructuras de datos. Una
estructura de datos es un conjunto de datos reunidos bajo un único nombre colectivo.
Las diferentes estructuras se distinguen por la forma en que sus componentes están
relacionadas y por el tipo de las mismas. Todos los datos estructurados deben, en
última instancia, ser construidos a partir de datos primitivos.
Dentro de las estructuras de datos más usadas se encuentra el array o arreglo. El
arreglo se puede considerar como una colección ordenada de variables, todas con el
mismo nombre y del mismo tipo.

Al finalizar esta unidad, usted estará en condiciones de alcanzar los siguientes

objetivos :

o Diferenciar entre un tipo simple y un tipo estructurado.

o Organizar colecciones de datos en una misma estructura de programación.

o Pasar arreglos a un método y distinguir entre paso por valor y paso por
referencia.

o Reconocer en un problema la conveniencia o no de utilizar

arreglos.

o Aplicar en los algoritmos de resolución el concepto de arreglo.

Los contenidos a analizar son :

1. Arrays. Declaración. Subíndices. Almacenamiento en memoria.

Tamaño. Inicialización.

2. Arrays de caracteres y cadenas de texto.

3. Arrays multidimensionales. Inicialización. Acceso. Lectura y

escritura.

4. Utilización de arrays como parámetros.

2
A continuación le presento el esquema conceptual de esta unidad

PROBLEMA

DATOS:

Entero variable
simple

variable
Datos simples Real simple

Carácter variable
simple

Lógico variable
Simple

Estructuras de datos Arreglo de tipo

de dato simple :

A [0] A [1] A [2] A [3] A [4] .....

Variable compuesta homogénea de tipo entero, o real, o carácter o lógico.

Un arreglo (array) es un tipo de dato estructurado en el que se puede almacenar una

colección de datos del mismo tipo por ejemplo, enteros o reales o carácter o lógicos.
Un arreglo es una colección ordenada de variables, todas con el mismo nombre
y del mismo tipo.

3
En las unidades anteriores se han descrito las características de los tipos de datos
básicos o simples -entero, real, carácter y lógico- de Java. En esta unidad
estudiaremos el tipo de dato estructurado array o arreglo, su concepto y tratamiento.
Un array almacena elementos del mismo tipo, por ejemplo diez enteros, treinta
números de coma flotante o veinticinco caracteres. Los arrays pueden ser de una
dimensión –vectores- que son los más utilizados; de dos dimensiones -tablas o
matrices-, y también de tres o más dimensiones. Un array puede almacenar
secuencias o cadenas de texto; debido a su importancia, Java proporciona la clase
String, y las operaciones con cadenas más comunes. En la próxima unidad
utilizaremos los arreglos para obtener información mediante el ordenamiento de su
elementos y la búsqueda de un determinado elemento del mismo.

Tema 1. Arrays. Declaración. Subíndices. Almacenamiento en memoria.

Tamaño. Inicalización.

- Arrays

Un array es una secuencia de datos del mismo tipo. Los datos se llaman elementos
del array y se numeran consecutivamente 0, 1, 2, 3…El tipo de elementos
almacenados en el array puede ser cualquier tipo de dato simple de Java, o de tipo
previamente declarado. Normalmente el array se utiliza para almacenar tipos tales
como char, int, o float.
Un array puede contener, por ejemplo, la edad de los alumnos de una clase, las
temperaturas de cada día de un mes de una ciudad determinada, o el número de
personas que residen en cada una de las diecisiete comunidades autónomas
españolas. Cada ítem del array se denomina elemento.
Los elementos de un array se numeran, consecutivamente 0, 1, 2, 3… Estos números
se denominan valores índice o subíndice del array. El término «subíndice» se utiliza,
ya que se especifica igual que en matemáticas, como una secuencia tal como
a 0 , a 1 , a 2 … Estos números localizan la posición del elemento dentro del array,
proporcionando acceso directo al array.
Si el nombre del array es a, entonces a [0] es el nombre del elemento que está en la
posición 0, a [1] es el nombre del elemento que está en la posición 1, etc. En general,
el elemento i-ésimo está en la posición i – 1. De modo que si el array tiene n
elementos, sus nombres son a [0], a [1],…, a [n - 1]. Gráficamente se representa así el
array a con seis elementos.

26.1 35.2 6.25 8.45 7.09 8.54

a

0 1 2 3 4 5

Figura 5.1. Array de seis elementos.

El array a tiene seis elementos: a [0] contiene 26.1, a [1] contiene 35.2, a [2] contiene
6.25, a [3] contiene 8.45, a [4] contiene 7.09 y a [5] contiene 8.54. El diagrama de la

4
Figura 5.1 representa realmente una región de la memoria de la computadora, ya que
un array se almacena siempre con sus elementos en una secuencia de posiciones de
memoria contigua.
En Java, los índices de un array siempre tienen como límite inferior 0, como índice
superior el tamaño del array menos 1.

- Declaración de un array

Al igual que con cualquier tipo de variable, se debe declarar un array antes de
utilizarlo. Un array se declara de modo similar a otros tipos de datos, excepto que se
debe indicar al compilador que es un array y esto se hace con los corchetes.

int [ ]v ;
float w [ ] ;

Los corchetes se pueden colocar de dos formas:

• Colocando los corchetes a continuación del tipo de datos.

• Colocando los corchetes a continuación del nombre del array.

Así, la sintaxis de declaración de variables array en Java:

tipo [ ] identificador ;
tipo identificador [ ] ;

El primer formato indica que todos los identificadores son arrays del tipo. El segundo
formato es array sólo el identificador al que le siguen los [ ].

Ejemplo 5.1 Se escriben distintas declaraciones de arrays.

1. char cad [ ], p ;
cad es un array de tipo char ; p es una variable de tipo char.

2. int [ ] v, w ;
tanto v como w son declarados arrays unidimensionales de tipo int.

3. double [ ] m, t [ ], x ;
m y x son array de tipo double, t es un array de array con elementos de tipo
double.

Precaución

Java no permite en la declaración de una variable array indicar el número de

elementos. Así, por ejemplo, la declaración int numeros [30] ; el compilador
producirá un error.

Para indicar el número de elementos que tiene un array se utiliza el operador new. Por
ejemplo, para crear una array que guarde las notas de la asignatura de Informática en
un aula de 30 alumnos:

float [ ] notas ;

5
 notas = new float [30] ;

Se puede escribir en una misma sentencia:

float [ ] notas = new float [30] ;

La sintaxis para declarar y definir un array de un número determinado de elementos

es:

tipo nombreArray [ ] = new tipo [numeroDeElementos] ;

o bien,

tipo nombreArray [ ] ;
nombreArray = new tipo [numeroDeElementos] ;

Por ejemplo, para crear un array (vector o lista) de diez variables de tipo entero se
escribe:

int a [ ] = new int [10] ;

Esta declaración hace que el compilador reserve espacio suficiente para contener 10
datos de tipo entero. En Java, los enteros ocupan, normalmente cuatro bytes, de modo
que un array de diez enteros ocupa 40 bytes de memoria. A esta memoria hay que
añadir cuatro bytes más que utiliza Java para guardar el número de elementos del
array. La Figura 5.2 muestra el esquema de un array de diez elementos; cada
elemento puede tener su propio valor.
Se puede acceder a cada elemento del array utilizando un índice en el nombre del
array. Por ejemplo,

System.out.print (a [4] ) ;

visualiza el valor del elemento 5 del array. Los arrays siempre comienzan en el
elemento 0. Así pues, el array a contiene los siguientes elementos individuales:

a [0] a [1] a [2] a [3] a [4] a [5] a [6] a [7] a [8] a [9]

Array de datos enteros: a

10
10
a [0] [[[[1] [2] [3] [4] [5] [6] [7] [8] [9]
Un array de enteros se almacena en bytes consecutivos de memoria. Cada elemento utiliza
cuatro bytes. Se accede a cada elemento de array mediante un índice que comienza en cero.
Así, el acceso al elemento quinto es a [4].

Figura 5.2. Almacenamiento de un array en memoria.

Si, por ejemplo, se quiere crear un array de números reales, se puede indicar su
tamaño por una constante representada por una variable protegida (final).

final int N = 20 ;
float vector [ ] ;
vector = new float [N] ;

6
Para acceder al tercer elemento y leer un valor de entrada:

vector [2] = (Float.valueOf (entrada.readLine ( ))).floatValue ( ) ;

Precaución

Es un error frecuente acceder a un elemento de un array fuera del rango en que

está definido. Java comprueba en tiempo de compilación que los índices estén
dentro de rango, en caso contrario genera un error. Durante la ejecución del
programa un acceso fuera de rango genera una excepción (error en tiempo de
ejecución).

- Subíndices de un array

El índice de un array se denomina con frecuencia, subíndice del array. El término

procede de la matemática, en la que un subíndice se utiliza para representar un
elemento determinado.

a 0 equivale a a [0]
a 3 equivale a a [3]

El método de numeración del elemento i-ésimo con el índice o subíndice i – 1 se

denomina indexación basada en cero. Su uso tiene el efecto de que el índice de un
elemento del array es siempre el mismo que el número de «pasos» desde el momento
inicial a[0] a ese elemento. Por ejemplo, a[3] está a tres pasos o posiciones del
elemento a [0].

Ejemplos

int [ ] edad = new int [5] ; Array edad contiene cinco elementos: el primero,
edad [0], y el último, edad [4].

int [ ] longitud; Declara un array de enteros (no asigna

tamaño).

float salarios [ ] ; Declara un array de 25 elementos float.

salarios = new float [25] ;

double temperaturas [ ] ; Declara un array de 50 elementos double.

temperaturas = new double [50] ;

char [ ] letras = new char [25] ; Declara un array de caracteres.

Racional [ ]ra = new Racional [5] ; Declara un array de 5 objetos Racional.

final int MX = 20 ; Declara un array de caracteres de tamaño

char buffer [ ] = new char [MX + 1] ; MX + 1, el primer elemento es buffer [0] y
el último buffer [MX].

7
En los programas se puede referenciar elementos del array utilizando fórmulas para
los subíndices. Mientras que el subíndice pueda ser evaluado a un entero, se puede
utilizar una constante, una variable o una expresión para el subíndice. Así, algunas
referencias individuales a elementos son:

edad [4]
ventas [total + 5]
bonos [mes]
salario [mes [ i ] *5]

- Almacenamiento de los arrays en memoria

Los elementos de los arrays se almacenan en bloques contiguos. Así, por ejemplo, los
arrays

int edad [ ] ;
char codigo [ ] ;
edad = new int [5] ;
codigo = new char [5]

se representan gráficamente en memoria en la Figura 5.3.

edad [0] codigo [0]

[1] [1]
[2] [2]
[3] [3]
[4] [4]

Figura 5.3. Almacenamiento de arrays en memoria.

Nota

Todos los subíndices de los arrays en Java comienzan con 0.

Los arrays de caracteres funcionan de igual forma que los arrays numéricos, partiendo
de la base de que cada carácter ocupa normalmente dos bytes. Así, por ejemplo, un
array llamado nombre se puede representar en la Figura 5.4.

8
 nombre

C [0]
a [1]
r [2]
l [3]
o [4]
s [5]

Figura 5.4. Almacenamiento de un array de caracteres en memoria.

- Tamaño de un array. Atributo length

Java considera cada array un objeto, debido a ello se puede conocer el número de
elementos de un array accediendo al campo length. Este campo resulta muy útil
cuando se pasa un array a un método.

double [ ] v = new double [10] ;

System.out.print (v.length) ; / / escribe 10, número de elementos de v.

Java conoce el número de elementos de un array cuando se asigna el número de

elementos con el operador new, o bien con una expresión de inicialización. El campo
length está protegido, no puede ser modificado, ya que está definido como final.

Ejemplo 5.2 El método suma ( ) tiene como argumento un array de tipo double.
Se quiere que devuelva la suma de sus elementos.

Para escribir este método, se define una variable que acumula los elementos del
array. En un bucle con tantas iteraciones como elementos (longitud) se determina la
suma.

double suma (double [ ] w)

{
double s = 0.0 ;
for (int i = 0; i < w.length; i=i+1)
s = s + w [ i ];
return s ;
}

Precaución

El número de elementos de un array es un campo del array, no es un método:

w.length ; / / es correcto
w.length ( ) ; / / es un error

9
- Inicialización de un array.

Se deben asignar valores a los elementos del array antes de utilizarlos, tal como se
asignan valores a variables. Para asignar valores a cada elemento del array de
enteros a, se puede escribir:

a [0] = 10 ;
a [1] = 20 ;
a [2] = 30 ;
a [3] = 40 ;
…

La primera sentencia fija a [0] al valor 10, a [1] al valor 20, etc. Sin embargo, este
método no es práctico cuando el array contiene muchos elementos. El método usado,
normalmente, es inicializar el array completo en una sola sentencia.
Cuando se inicializa un array, el tamaño del array se puede determinar
automáticamente por las constantes de inicialización. Estas constantes se separan por
comas y se encierran entre llaves, como en los siguientes ejemplos:

int precio [ ] = {10, 20, 30, 40, 50, 60} ; / * Define un array de 6 elementos y
se inicializan a las constantes * /

int a [ ] = {2, 3, 4} / / Define un array de tres elementos

int c [ ] = {¨’a’, ‘e’, ‘i’, ‘u’} ; / / Define un array de cuatro elementos

El array precio tiene seis elementos, a tiene tres elementos, y c tiene cuatro
elementos.

Nota

La serie de valores entre corchetes sólo puede ser usada para inicializar un array y
no en sentencias de asignación posteriores.
int cuenta [ ] = {15, 35, -45, 0, 60}
El compilador asigna automáticamente cinco elementos a cuenta.
int edades [ ] = new int [5] ;
edades [ ] = {14, 32, 17, 20, 50} ; / / es una sentencia errónea.

El método de inicializar arrays mediante valores constantes después de su definición

es adecuado cuando el número de elementos del array es pequeño. Por ejemplo, para
inicializar un array (vector o lista) de 10 enteros a los valores 10 a 1, y a continuación
visualizar dichos valores en orden inverso, se puede escribir:

int a [ ] = {10, 9, 8, 7, 6, 5, 4, 3, 2,1} ;

for (i = 9; i >= 0; i--)
System.out.println (“cuenta descendente ” + i + “ = ” + a [ i ] ) ;

Se pueden asignar valores numéricos representados mediante variables protegidas

por la cláusula final, de modo que las sentencias siguientes son válidas:

final int ENE = 31, FEB = 28, MAR = 31, ABR = 30, MAY = 31,
JUN = 30, JUL = 31, AGO = 31, SEP = 30, OCT = 31,

10
 NOV = 30, DIC = 31 ;
…
int meses [ ] = {ENE, FEB, MAR, ABR, MAY, JUN,
JUL, AGO, SEP, OCT, NOV, DIC } ;

Pueden asignarse valores a un array utilizando un bucle for o while/do-while, y éste

suele ser el sistema más empleado normalmente. Por ejemplo, para inicializar todos
los valores del array numeros al valor -2, se puede utilizar la siguiente sentencia:

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

numero [ i ] = -2 ;

debido a que el valor del subíndice i varía de cero al número de elementos -1, cada
elemento del array numero se inicializa a -1.

Ejemplo 5.3 El siguiente programa lee 5 enteros, los almacena en un arreglo, y a

continuación visualiza el producto de los mismos.

import java.io.* ;
class Inicial
{
public static void main (String [ ] a) throws IOException
{
final int NUM = 5;
BufferedReader entrada = new BufferedReader (
new InputStreamReader (System.in)) ;
int numero [ ] = new int [NUM ] ;
int total = 1 ;
System.out.println (“Por favor, introduzca” + NUM + “datos”) ;
System.out.flush ( ) ;
for (int i = 0; i < NUM; i++)
{
numero [ i ] = Integer.parseInt (entrada.readLine ( )) ;
}
System.out.print (“ \ nLista de números: ”) ;
for (int i = 0; i < NUM; i++)
{
System.out.println (“ ” + numero [ i ] ) ;
total *= numero [ i ] ;
}
System.out.println (“ \ nEl producto de los números es ” + total) ;
}
}

Los arrays en Java se inicializan a 0 por defecto. Para ello, la ejecución del siguiente
programa visualiza 0 para los 10 valores del array:

int a [ ] = new int [10] ;

for (int j = 0; j <= 9; j++)
System.out.print (“ \ n lista ” + j + “ = ” + a [ j ] ) ;

11
 Nota

El compilador Java inicializará cualquier array con un valor por defecto, ceros
binarios, ya sea el array de tipo entero, real o de caracteres.

Actividad de proceso Nº 1

Desarrollar un programa Java que lea 10 números enteros, los almacene en un

arreglo, y a continuación visualice la suma de los mismos.

Tema 2. Arrays de caracteres y cadenas de texto.

Una cadena de texto es un conjunto de caracteres, tales como “AEIOU”. Java soporta
cadenas de texto utilizando la clase String y StringBuffer implementada en el paquete
Java.lang.

String cadena = “AEIOU” ;

Es importante comprender la diferencia entre un array de caracteres y una cadena de

caracteres. Los Strings son objetos en los que se almacenan las cadenas, tienen
diversos constructores y métodos. Los arrays de tipo char son una secuencia de
caracteres, con las mismas características que los arrays de otros tipos.

String cad = “Programador Java” / / crea objeto cadena

char datos [ ] = {´M´, ´a´, ´r´, ´t´, ´a´} ; / / define array de 5 elementos

String dat = new String (datos) ; / * crea un objeto cadena con el constructor
que tiene como argumento un array de caracteres * /

System.out.println (dat) ; / / muestra la cadena dat: “Marta”

System.out.println (datos) ; / / es un error, datos no es una cadena

Las cadenas se deben almacenar en objetos de tipo String o de tipo StringBuffer.

Una vez que un objeto String es creado e inicializado con una cadena, no puede
modificarse. Los métodos definidos en String para concatenar o cambiar caracteres,
no modifican la cadena, sino que devuelven otro objeto String. Se puede decir que las
cadenas de tipo String son de sólo lectura.
Para concatenar constantes de cadena se utiliza el operador +, como ya se ha hecho
en la salida mediante print ( ) o println ( ). El operador está sobrecargado para poder
convertir otros tipos de datos a tipo cadena y poder realizar la concatenación. Así:

int h =12 ;

12
 System.out.print (“valor de h = ” + h) ; / * concatena y forma la
cadena “valor de h = 12” * /

System.out.print (“valor de h = ” + h + h) ; / * concatena y forma la

cadena “valor de h = 1212” * /

System.out.print (“valor de h = ” + (h + h)) ; / * concatena y forma la

cadena “valor de h = 24” * /

Ejemplo 5.4 El programa crea un array de cadenas con las líneas de texto leídas
desde el teclado.

El programa define un array de objetos cadena: String cads [ ]; el máximo de líneas

que van a ser leídas es 23. Una vez terminada la entrada, se muestran por pantalla.

import java.io.* ;
class Cadenas
{
public static void main (String [ ] a) throws IOException
{ int i;
final int NUM = 10 ;
BufferedReader entrada = new BufferedReader (
new InputStreamReader (System.in)) ;
String [ ] cads = new String [NUM] ;
System.out.println (“ \ n\ tIntroduzca” + NUM + “líneas”) ;
for (i = 0; i < NUM; i++)
cads [ i ] = entrada.readLine ( ) ;
System.out.println (“ \ n\ tLíneas tecleadas”) ;
for (i = 0; i < NUM; i++)
System.out.println (i + “:” + cads [ i ] ) ;
}
}

Actividad de proceso Nº 2

Desarrolle un programa Java que lea los nombres de 10 personas y los imprima en
pantalla.

Tema 3. Arrays multidimensionales. Inicialización. Acceso. Lectura y

escritura.

Los arrays vistos anteriormente se conocen como arrays unidimensionales (una sola
dimensión) y se caracterizan por tener un solo subíndice. Estos arrays se conocen
también por el término vectores o listas. Los arrays multidimensionales son aquellos
que tienen más de una dimensión y, en consecuencia, más de un índice. Los arrays
más usuales son los de dos dimensiones, conocidos también por el nombre de tablas
o matrices. Sin embargo, es posible crear arrays de tantas dimensiones como
requieran sus aplicaciones, esto es, tres, cuatro o más dimensiones.

13
Un array de dos dimensiones equivale a una tabla con múltiples filas y múltiples
columnas (Fig. 5.5).

0 1 2 3 n
0

Figura 5.5. Estructura de un array de dos dimensiones.

Obsérvese que en el array multidimensional de la Figura 5.5, si la filas se etiquetan de

0 a m y las columnas de 0 a n, el número de elementos que tendrá el array será el
resultado del producto (m +1) * (n +1). El sistema de localizar un elemento será por las
coordenadas representadas por su número de fila y su número de columna (a, b). La
sintaxis para la declaración de un array de dos dimensiones es:

<tipo de datoElemento> <nombre array > [ ] [ ] ;

o bien,
<tipo de datoElemento> [ ] [ ] <nombre array > ;

Algunos ejemplos de declaración de tablas:

char pantalla [ ] [ ] ;
int puestos [ ] [ ] ;
double [ ] [ ] matriz ;

Estas declaraciones no reservan memoria para los elementos de la matriz o tabla,

realmente son referencias. Para reservar memoria y especificar el número de filas y de
columnas se utiliza el operador new. Así, a partir de las declaraciones anteriores:

pantalla = new char [80] [20] ; / / matriz con 80 filas y 20 columnas

puestos = new int [12] [5] ; / / matriz de 12 filas por 5 columnas

14
 final int N =3 ;
matriz = new double [N] [N] ; / / matriz cuadrada de N*N elementos

El operador new se puede aplicar a la vez que se hace la declaración. La sintaxis para
definir una matriz:

<tipo de datoElemento> <nombre array > [ ] [ ] =

new <tipo de datoElemento> [< NúmeroDeFilas>] [<Número de
Columnas>] ;

Atención

Java requiere que cada dimensión esté encerrada entre corchetes. La sentencia

int equipos [ ] [ ] = new int [3, 4] ;

no es válida

Un array de dos dimensiones en realidad es un array de arrays. Es decir, es un array

unidimensional, y cada elemento no es un valor entero, o de coma flotante o carácter,
sino que cada elemento es otro array.
Los elementos de los arrays se almacenan en memoria de modo que el subíndice más
próximo al nombre del array es la fila y el otro subíndice, la columna. En la Tabla 5.1
se representan todos los elementos y sus posiciones relativas en memoria del array,
int a [ ] [ ] = new int [4] [2], suponiendo que cada entero ocupa cuatro bytes.

Tabla 5.1. Un array bidimensional

Elemento Posición relativa de memoria

a [0] [0] 0
a [0] [1] 4
a [1] [0] 8
a [1] [1] 12
a [2] [0] 16
a [2] [1] 20
a [3] [0] 24
a [3] [1] 28

- Inicialización de arrays multidimensionales

Los arrays multidimensionales de pueden inicializar, al igual que los de una dimensión,
cuando se declaran. La inicialización se hace utilizando llaves, encerrando entre llaves
la lista de constantes separadas por comas de que consta cada fila como en los
ejemplos siguientes:

15
 1. int tabla1 [ ] [ ] = { {11, 12, 13}, {14, 15, 16} } ;
Se ha definido una matriz de dos filas por tres columnas cada fila.

O bien en estos otros formatos más amigables:

int tabla1 [ ] [ ] = { {11, 12, 13},

{14, 15, 16} } ;

int tabla1 [ ] [ ] = {
{11, 12, 13}
{14, 15, 16}
};

2. int tabla2 [ ] [ ] = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
};

tabla1 [ ] [ ]
0 1 2 Columnas

Filas 0 11
1 12 13

1 14 15 16

tabla2 [ ] [ ]
0 1 2 3 Columnas

Filas 0 1 2 3 4

1 5 6 7 8

2 9 10 11 12

Figura 5.6. Tablas de dos dimensiones.

Java trata los arrays de dos o más dimensiones como array de arrays, por ello se
pueden crear arrays de dos dimensiones no cuadradas. En los siguientes ejemplos se
crean arrays de distintos elementos cada fila.

1. double tb [ ] [ ] = { {1.5, 2.5}, {5.0, 0.0, 1.5} } ;

Se he definido una matriz de dos filas, la primera con dos columnas y la
segunda con tres.

2. int [ ] a = {1, 2, 3}, b = {2, 4, 6, 8, 10} ;

int mtb [ ] = {a, b} ;

Se ha definido el array a de tres elementos, el b de cuatro elementos y la matriz mtb

de dos filas, la primera con tres elementos o columnas, y la segunda con cuatro.

16
 Nota

En un array bidimensional tabla, al ser un array de arrays, el atributo length de

tabla contiene el número de filas. El atributo length de cada array fila contiene el
número de columnas.
float ventas [ ] [ ] = { {0., 0., 0.,}, {1.0, 1.0}, {-1.0} } ;
System.out.print (ventas.length) ; / / escribe 3
System.out.print (ventas[0].length) ; / / escribe 3
System.out.print (ventas[1].length) ; / / escribe 2
System.out.print (ventas[2].length) ; / / escribe 1

ventas length

length ventas [0] [0]

ventas [0]
ventas [1]
ventas [2] ventas [0] [2]

length
ventas [1] [0]
ventas [1] [1]

length
ventas [2][0]

Figura 5.7. Disposición en memoria de ventas [ ] [ ].

Precaución

En la definición de un array bidimensional no es posible omitir el número de filas,

así la declaración:

double vt [ ] [ ] = new double [ ] [4] ;

es errónea, ya que no se ha especificado el número de filas y el tamaño queda

indeterminado.

- Acceso a los elementos de los arrays bidimensionales

Se puede acceder a los elementos de arrays bidimensionales de igual forma que a los
elementos de un array unidimensional. La diferencia reside en que en los elementos
bidimensionales deben especificarse los índices de la fila y la columna.
El formato general para asignación directa de valores a los elementos es:

inserción de elementos

17
 <nombre array> [indice fila] [indice columna] = valor elemento ;

extracción de elementos

<variable> = <nombre array> [indice fila] [indice columna] ;

Algunos ejemplos de inserciones:

Tabla [2] [3] = 4.5 ;

Resistencias [2] [4] =50 ;

Asientos libres [5] [12] = 5 ;

y de extracción

Ventas = Tabla [1] [1] ;

Dia = Semana [3] [6] ;

- Lectura y escritura de elementos de arrays bidimensionales

Los métodos de entrada o salida se aplican de igual forma a los elementos de un array
bidimensional. Por ejemplo:

int tabla [ ] [ ] = new int [3] [4] ;

double resistencias [ ] [ ] = new double [4] [5] ;

boolean asientosLibres [ ] [ ] =new boolean [28] [18] ;

BufferedReader entrada = new BufferedReader (

new InputStreamReader (System.in) ) ;

tabla [1] [1] = Integer.parseInt (entrada.readLine( )) ;

System.out.println (tabla [1] [1] ) ;

resistencias [2] [1] =

Double.valueOf (entrada.readLine ( )).doubleValue ( ) ;

if (asientosLibres [3] [1] )

System.out.println (“Asiento disponible) ;

else
System.out.println (“Asiento ocupado”) ;

Acceso a elementos mediante bucles

18
Se puede acceder a los elementos de arrays bidimensionales mediante bucles
anidados. Su sintaxis es:

int fila, col ;

for (fila = 0; fila < NumFilas; ++fila)

for (col = 0; col < NumCol; ++col)

Procesar elemento Matriz [fila] [col] ;

El número de filas y de columnas de puede obtener con el atributo length. Con este
atributo, la sintaxis para acceder a los elementos:

<tipo> Matriz [ ] [ ] ;

<especificación de filas y columnas con operador new>

for (fila = 0; fila < Matriz.length; ++fila)

for (col = 0; col < Matriz[fila].length ; ++col)

Procesar elemento Matriz [fila] [col] ;

Ejemplo 5.5 Define una matriz a, el número de filas y de columnas son datos de
entrada. Rellena la tabla con datos de entrada y se muestran por pantalla.

float a [ ] [ ] ;

int fila, col, NumFilas, NumCols ;

System.out.print (“Número de filas: ”) ;

System.out.flush ( ) ;

NumFilas = Integer.parseInt (entrada.readLine ( )) ;

System.out.print (“Número de columnas: ”) ;

System.out.flush ( ) ;

NumCols = Integer.parseInt (entrada.readLine ( )) ;

a = new float [NumFilas] [NumCols] ;

/ / Entrada de datos

for (fila = 0; fila < NumFilas; fila++)

for (col = 0; col < NumCols ; col++)

{
a [fila] [col] =
Float.valueOf (entrada.readLine ( )).floatValue ( ) ;
}
}

}
System.out.println (“ ”) ;
} 19
 / * Visualizar la tabla * /

for (fila = 0; fila < NumFilas; fila++)

{
for (col = 0; col < NumCols ; col++)
{
System.out.print (a [fila] [col] + “ “) ;

Actividad de proceso Nº 3

Desarrolle un programa Java que permita la lectura y visualización de un array de dos

dimensiones (matriz o tabla ) mediante los métodos leer( ) y visualizar( ).

Arrays de más de dos dimensiones

Java proporciona la posibilidad de almacenar varias dimensiones, aunque rara vez los
datos del mundo real requieren más de dos o tres dimensiones. El medio más fácil de
dibujar un array de tres dimensiones es imaginar un cubo tal como se muestra en el
Figura 5.8.
Un array tridimensional se puede considerar como un conjunto de arrays
bidimensionales combinados juntos para formar, en profundidad, una tercera
dimensión. El cubo se construye con filas (dimensión vertical), columnas (dimensión
horizontal) y planos (dimensión en profundidad). Por consiguiente, un elemento dado
se localiza especificando su plano, fila y columna. Una definición de un array
tridimensional equipos es:

int equipos [ ] [ ] [ ] = new int [3] [15] [10] ;

Un ejemplo típico de un array de tres dimensiones es el modelo libro, en el que cada

página del libro es un array bidimensional construido por filas y columnas. Así, por
ejemplo, cada página tiene cuarenta y cinco líneas que forman las filas del array y
ochenta caracteres por línea, que forman las columnas del array. Por consiguiente, si
el libro tiene quinientas páginas, existirán quinientos planos y el número de elementos
será 500 x 80 x 45 = 1.800.000.

20
 3

Figura 5.8. Un array de tres dimensiones (4x5x3).

Una aplicación práctica

El array libro tiene tres dimensiones [PAGINAS] [LINEAS] [COLUMNAS], que definen
el tamaño del array. El tipo de datos del array es char, ya que todos los elementos son
caracteres.
¿Cómo se puede acceder a la información del libro? El método más fácil es mediante
bucles anidados. Dado que el libro se compone de un conjunto de páginas, el bucle
más externo será el de página, y el bucle de columnas será el más interno. Esto
significa que el bucle de filas se insertará entre los bucles página y columna. El código
siguiente permite procesar el array:

int pagina, linea, columna ;

final int PAGINAS = 500 ;
final int LINEAS = 45 ;
final int COLUMNAS = 80 ;
char libro [ ] [ ] [ ] = new char [PAGINAS] [LINEAS] [COLUMNAS] ;
for (pagina = 0; pagina < PAGINAS; ++pagina)
for (linea = 0; linea < LINEAS; ++linea);
for (columna = 0; columna < COLUMNAS; ++columna)
<procesar libro [pagina] [linea] [columna] >

21
Ejercicio 5.1 Comprobar si una matriz de números enteros es simétrica respecto a la
diagonal principal.
La matriz se genera internamente, va a tener valores de 0 a 7 que se obtienen con el
método random ( ) multiplicado por N (8). El tamaño de la matriz se pide como dato de
entrada. El método lógico simétrica ( ) determina si la matriz es simétrica. El método
main ( ) genera matrices hasta encontrar una que sea simétrica y la escribe en
pantalla.
/*
Determina si una matriz es simétrica. La matriz se genera con números
aleatorios de 0 a 7. El programa itera hasta encontrar una matriz
simétrica.
*/
import java.io.* ;
class MatrizSimetrica
{
public static void main (String [ ] arg) throws IOException
{ BufferedReader entrada = new BufferedReader (
new InputStreamReader (System.in)) ;
int a[ ][ ] ;
int n, i, j ;
boolean es_sim ;
System.out.print ("Número de filas/columnas: ") ;
System.out.flush ( ) ;
n = Integer.parseInt (entrada.readLine ( )) ;
a = new int [n][n] ;
do {
gen_mat (a) ;
es_sim = simetrica (a) ;
if (es_sim)
{
System.out.println (" \n\t Encontrada matriz simetrica.\n") ;
escribe_mat (a) ;
}
}while (!es_sim) ;
}
static void gen_mat (int a [ ] [ ] )
{
int i, j ;
final int N = 8 ;
for (i = 0; i < a.length; i++)
for (j = 0; j < a [ i ].length; j++)
a[ i ] [ j ] = (int)( Math.random ( )*N );
}

22
 static boolean simetrica (int a [ ] [ ] )
{
int i, j ;
boolean es_simetrica = true ;
for (i =0; i < a.length - 1 && es_simetrica; i++)
{
for (j = i + 1; j < a [ i ].length && es_simetrica; j++)
// asigna false si no coincide
es_simetrica = a [ i ] [ j ] == a [ j ] [ i ] ;
}
return es_simetrica ;
}

static void escribe_mat (int a [ ] [ ] )

{
int i, j ;
System.out.println (" \tMatriz analizada") ;
System.out.println (" \t \n") ;
for (i = 0; i < a.length; i++)
{
System.out.print ("\n");
for (j = 0; j < a [ i ].length; j++)
System.out.print (" "+a [ i ] [ j ] );
}
}

Tema 4. Utilización de arrays como parámetros.

En Java, todas las variables de tipos primitivos, double, float, char, int, boolean se
pasan por valor. Los objetos siempre se pasan por referencia, los arrays en Java se
considera que son objetos y por tanto se pasan por referencia (dirección). Esto
significa que cuando se llama a un método o función y se utiliza un array como
parámetro, se debe tener cuidado de no modificar el array en una función llamada.

public static void palabra

main (String [ ] a)
{
char
palabra [ ] = {``A´, `B´,`C´, `D´}
cambiar (palabra) ; void
} cambiar (char c [ ] )
{
c [2] = `c´;
}

Figura 5.9. Paso de un array por dirección.

23
Dadas las declaraciones

final int MAX = 100 ;

double datos [ ] = new double [MAX]

se puede declarar un método que acepte un array de valores double como parámetro.

El método SumaDeDatos ( ) tiene la cabecera:

double SumaDeDatos (double w [ ] ) ;

En la llamada al método SumaDeDatos ( ) el argumento array se pone escribiendo el

identificador del array:

SumaDeDatos (datos) ;

El método SumaDeDatos ( ) no es difícil de escribir. Un simple bucle for suma los

elementos del array y una sentencia return devuelve el resultado del método llamador:

double SumaDeDatos (double w [ ] )

{
double suma = 0.0 ;
for (int i ; i<w.length ; i++)
suma += w [ ì ] ;
return suma;
}

El argumento del método que se corresponde con un array se declara poniendo el tipo
de los elementos, el identificador y los corchetes en blanco, tantos corchetes como
dimensiones. El número de elementos del array no se pasa como argumento, ya que
el tamaño del array se conoce con el atributo length. El método SumaDeMats ( ) tiene
dos argumentos arrays bidimensional:

void SumaDeMats (double m1 [ ] [ ], double m2 [ ] [ ] ) ;

Al método SumaDeMats ( ) se pueden entonces pasar dos argumentos de tipo array.

Por ejemplo:

final int N = 5 ;
double mat1 [ ] [ ] = new double [N] [N] ;
double mat2 [ ] [ ] = new double [N] [N] ;
SumaDeMats (mat1, mat2) ;

El código que se utiliza para pasar un array a un método incluye el tipo de elemento
del array y su nombre. El número de elementos no se pasa mediante una variable
entera independiente, sino que se obtiene con el atributo length. Cuando se pasa un
array a un método, se pasa realmente sólo la dirección de memoria donde comienza el
array. Este valor se representa por el nombre del array a. El método puede cambiar
entonces el contenido del array accediendo directamente a las celdas de memoria en
donde se almacenan los elementos del array.

24
 Actividad de proceso Nº 4

Desarrollar un programa Java que mediante un método leerArray lea los datos de un
array unidimensional de tipo double y mediante un método producto calcule el
producto de sus elementos pares, debiendo imprimir este resultado en el programa
principal.

25
Ejemplo 5.6 Paso de arrays a métodos o funciones. En el ejemplo se lee un array y se
escribe el producto de los elementos positivos.

El array tiene un número de elementos que es determinado en la ejecución del

programa. Al método leerArray ( ) se le pasa el array para leer sus valores. Al método
producto ( ) también se le pasa el array para poder calcular el producto de los
elementos positivos.

import java.io.* ;
class ProductoMat
{

public static void main (String [ ] ar) throws IOException

{

BufferedReader entrada = new BufferedReader (new InputStreamReader

(System.in)) ;
double v [ ] ;
int n ;
System.out.print ("Número de elementos: ") ;
System.out.flush ( ) ;
n = Integer.parseInt (entrada.readLine ( )) ;
v = new double [n] ;
leerArray (v) ;
System.out.print ("El producto de los elementos positivos es = "
+producto (v)) ;
}

static void leerArray (double [ ] a) throws IOException

{BufferedReader entrada = new BufferedReader (new InputStreamReader
(System.in)) ;
int n = 0 ;
System.out.println ("Introduzca " + a.length + "datos") ;
for (; n < a.length; n++)
{
a [n] = (Double.valueOf (entrada.readLine ()).doubleValue() );
}
}

static double producto (double w [ ] )

{
double pd = 1.0 ;
int i ;
for ( i=0 ; i < w.length ; i++)
if (w [ i ] > 0.0 )
pd*= w [ i ] ;
return pd ;
}
}

26
 Ejecución

Número de elementos: 4
Introduzca 4 datos
2.0
-15.25
40.0
0.0
El producto de los elementos positivos es = 80.0

Ejercicio 5.2 Escribir un método que calcule el máximo de los elementos de un array
especificado.

double maximo (double a [ ] )

{
double mx ;
int i ;
mx = a [0] ;
for (i = 1; i < a.length ; i++)
if ( a [ i ] > mx )
mx = a [ i ] ;
return mx ;
}

Aunque un array entero siempre se pasa por referencia, elementos individuales del
array de tipo de datos primitivos se pasan por valor como si fueran variables del tipo
de datos del array. En el siguiente ejemplo se pasa el array cuantos y su primer
elemento cuantos[0] al método mayorque ( ) :

int cuanto [ ] = new int [20]

mayorque (cuantos, cuantos [0] ) ;

Precauciones

Cuando se utilice una variable array como argumento de un método, éste conoce
cuántos elementos existen en el array. Puede ocurrir que no todos los elementos sean
significativos, en ese caso hay que pasar un segundo parámetro que indique el
número real de elementos, siempre los elementos se ajustan a la izquierda desde el
índice 0 al último elemento real.
El método SumaDeEnteros ( ) suma los valores de los n elementos de un array y
devuelve el total.

int SumaDeEnteros (int [ ] ArrayEnteros, int n)

{
int i, s = 0 ;
for (i =0; i < n ; i ++ )
s += ArrayEnteros [ i ] ;
return s ;
}

/ / la llamada al método

27
 int lista [ ] = new int [33] ;
n = 10 ;
SumaDeEnteros (lista, n) ;

Aunque SumaDeEnteros ( ) conoce cuántos elementos hay en el array a través del

atributo length, no sabe cuántos elementos reales hay que sumar, por ello se le pasa
el parámetro n.

En caso necesario, se pueden utilizar dos métodos alternativos para permitir que
un método conozca el número de argumentos asociados con un array que se pasa
como argumento al método:

• Situar un valor de señal al final del array que indique al método que se ha de
detener el proceso en el momento de alcanzar el valor señal.
• Pasar un segundo argumento que indica el número de elementos del array.

Ejemplo 5.7 Este programa introduce una lista de cómo máximo 21 números enteros
y calcula su suma y el valor máximo. La entrada de datos termina al introducir el dato
clave -1.

El programa consta del método entrada ( ), que lee desde el teclado los elementos del
array hasta se lee el dato clave, devuelve el número de elementos leído, que nunca
puede ser mayor que el máximo de elementos (atributo length). El método
sumaEnteros ( ) calcula la suma de los elementos introducidos en el array, para ello se
pasa el array y el número de elementos. El método maximo ( ) tiene los mismos
parámetros que sumaEnteros ( ) y determina el valor máximo.

import java.io.*;
class Sumamax
{
public static void main (String [ ] a) throws IOException
{
final int NUM = 21 ;
int items [ ] = new int [NUM] ;
int n ;
n = entrada (items) ; // devuelve el número real de elementos
System.out.println (" \n Suma de los elementos: " +n+"="+
sumaEnteros (items, n)) ;
System.out.println (" \n Valor máximo: " + maximo (items, n)) ;
}

28
 static int entrada (int w [ ] ) throws IOException
{
int k=0 ;
BufferedReader entrada = new BufferedReader (
new InputStreamReader (System.in)) ;
System.out.println ("Introduzca un máximo de " + w.length +

"datos, terminar con -1") ;

int x ;
do {
x=Integer.parseInt(entrada.readLine()) ;
if (x!=-1)
{
w [k] = x ;
k++;
}
} while ((k < w.length) && (x != -1)) ;
return k ;
}

static int sumaEnteros (int w [ ], int n)

{
int i, total = 0 ;
for (i = 0; i < n; i++)
total += w [ i ] ;
return total ;
}
static int maximo (int w [ ], int n)
{
int mx, i ;
mx = w [0] ;
for (i = 1; i < n; i++)
if ( w [ i ] > mx )
mx = w [ i ] ;
return mx ;
}
}

Nota: Java trata las cadenas como objetos de la clase String, por ello las reglas para
pasar arrays de caracteres como argumentos a métodos son las mismas que para
arrays de otro tipo primitivo de datos.

29
Respuestas a las Actividades de Proceso

1. El siguiente programa Java lee 10 enteros, los almacena en un arreglo, y a

continuación visualiza la suma de los mismos.

import java.io.* ;
class Inicial
{
public static void main (String [ ] a) throws IOException
{
final int NUM = 10;
BufferedReader entrada = new BufferedReader (
new InputStreamReader (System.in)) ;
int nums [ ] = new int [NUM ] ;
int suma = 0 ;
System.out.println (“Por favor, introduzca” + NUM + “datos”) ;
System.out.flush ( ) ;
for (int i = 0; i < NUM; i++)
{
nums [ i ] = Integer.parseInt (entrada.readLine ( )) ;
}
System.out.print (“ \ nLista de números: ”) ;
for (int i = 0; i < NUM; i++)
{
System.out.println (“ ” + nums [ i ] ) ;
suma+= nums [ i ] ;
}
System.out.println (“ \ nLa suma de los números es ” + suma) ;
}
}

2. El siguiente programa Java lee los nombres de 10 personas y los imprime en

pantalla.

import java.io.* ;
class Cadenas
{
public static void main (String [ ] a) throws IOException
{
final int NUM = 10 ;
BufferedReader entrada = new BufferedReader (
new InputStreamReader (System.in)) ;
String [ ] cads = new String [NUM] ;
System.out.println (“ \ n\ tIntroduzca” + NUM + “nombres”) ;
for (int i = 0; i < NUM; i++)
cads [ i ] = entrada.readLine ( ) ;
System.out.println (“ \ n\ tNombres”) ;
for (int i = 0; i < NUM; i++)
System.out.println (i + “:” + cads [ i ] ) ;
}
}

30
3. Programa Java que permita la lectura y visualización de un array de dos
dimensiones ( matriz o tabla ) mediante los métodos leer( ) y visualizar( ).

El método leer ( ) lee un array de dos dimensiones (matriz o tabla) y el método

visualizar ( ) presenta la tabla en la pantalla.

import java.io.* ;
class Tabla
{
public static void main (String [ ] a1) throws IOException
{
int a [ ] [ ] = new int [3] [5] ;
leer (a) ;
visualizar (a) ;
}
static void leer (int a [ ] [ ] ) throws IOException
{
int i, j ;
BufferedReader entrada = new BufferedReader (
new InputStreamReader (System.in)) ;
System.out.println (“Entrada de datos de la matriz”) ;
for (i = 0; i < a.length; i++)
{
System.out.println (“Fila: ” + i) ;
System.out.flush ( ) ;
for (j = 0; j < a.length; j++)
a [ i ] [ j ] = Integer.parseInt (entrada.readLine ( )) ;
}
}
static void visualizar (int a [ ] [ ] )
{
int i, j ;
System.out.println (“ \n\t Matriz leida \n ”) ;
for (i = 0; i < length; i++)
{
for (j = 0; j < a [ i ].length; j++)
System.out.println (a [ i ] [ j ] + “ ”) ;
System.out.println (“ ”) ;
}
}
}

31
4. Programa Java que mediante un método leerArray lea los datos de un array
unidimensional de tipo double y mediante un método producto calcule el producto de
sus elementos pares, debiendo imprimir este resultado en el programa principal.
El array tiene un número de elementos que es determinado en la ejecución del
programa. Al método leerArray( ) se le pasa el array para leer sus valores. Al método
producto( ) también se le pasa el array para poder calcular el producto de los
elementos positivos.
import java.io.* ;
class ProductoMat
{
static BufferedReader entrada = new BufferedReader (
new InputStreamReader (System.in)) ;
public static void main (String [ ] a) throws IOException
{
double v [ ] ;
int n ;
System.out.print (“Número de elementos: ”) ;
System.out.flush ( ) ;
n = Integer.parseInt (entrada.readLine ( )) ;
v = new double [n] ;
leerArray (v) ;
System.out.print (“El producto de los elementos = ” +
producto (v)) ;
}

static void leerArray (double [ ] a) throws IOException

{
int n = 0 ;
System.out.println (“Introduzca ” + a.length + “datos”) ;
for (n=0; n < a.length; n++)
{
a [n] = (Double.valueOf (entrada.readLine ( )).doubleValue ( ) ;
};
}

static double producto (double w [ ] )

{
double pd = 1.0 ;
int n = w.length – 1 ;
while (n > 0)
if (w [n] %2== 0)
pd *= w [n -- 1] ;
else
n -- ;
return pd ;
}
}

32
 Actividades de Autoevaluación

1. Escribir un programa que luego de cargar un array unidimensional (vector) de n

elementos, imprima la cantidad de elementos mayores al promedio.

2. Escribir un programa que permita cargar dos arreglos unidimensionales

(vectores) de n elementos cada uno, el primero conteniendo el legajo y el
segundo la nota de cada alumno. Se quiere saber que alumnos tienen una nota
mayor al número K ingresado desde el teclado.

33