Declaración Manipulacion y Asignación de Vectores
Declaración Manipulacion y Asignación de Vectores
Objetivos
Una vez que se haya leído y estudiado este capítulo, usted podrá:
• Organizar colecciones de ítems en una misma estructura de programación.
• Diferenciar entre un tipo simple y un tipo estructurado.
• Declarar variables array de una dimensión y distinguir una declaración de definición.
• Aplicar el operador new para determinar el máximo número de elementos de
un array.
• Escribir cadenas constantes en los programas Java.
• Declarar variables String e inicializarlas a una cadena constante.
• Conocer las distintas operaciones de la clase String.
• Definir no sólo arrays de una dimensión, sino de dos o mas dimensiones.
• Pasar arrays a un método y distinguir paso por valor y paso por referencia
Contenido
Arrays (arreglos).
Arrays multidimensionales.
Utilización de arrays como parámetros.
Cadenas. Clase String.
Clase Vector.
RESUMEN
EJERCICIOS
PROBLEMAS
Introducción
En este capítulo se examinará el tipo array (lista o tabla). Aprenderá el concepto y tratamiento de los arrays.
Un array almacena muchos elementos del mismo tipo, tales como veinte enteros, cincuenta números de coma flotante o quince caracteres. Los arrays pueden ser de una dimensión vectores, que son los mas utilizados ; de dos dimensiones tablas o matrices ; también de tres o más dimensiones. Java proporciona la clase String, que representa una secuencia de caracteres y las operaciones con cadenas más comunes, y también dispone de la clase especializada StringBuffer para procesar cadenas que pueden sufrir cambios. Una cadena se considera como un objeto de la clase String que no puede modificarse
ARRAYS (arreglos)
Un array o arreglo (lista o tabla) 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 dato simple de Java o de un tipo previamente declarado como una clase. 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 en 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, como ya se ha comentado, 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 especifica, igual que en matemáticas, una secuencia tal como a0, a1, a2... 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.
El array a tiene 6 elementos: a[0] contiene 25.1, a[1] contiene 34.2, a[2] contiene 5.25, a[3] contiene 7.45, a[4] contiene 6.09 y a[5] contiene 7.54. El diagrama de la Figura 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 y como índice superior el tamaño del array menos 1.
Declaración de un array
Un array se declara de modo similar a otros tipos de datos, excepto que se debe indicar al compilador que es un array, lo que se hace con los corchetes.
int [] v;
float w[];
NOTA: En latinoamérica, el término inglés array se suele traducir por el término español arrreglo. En España, se suele utilizar el término en su acepción en inglés.
Los corchetes se pueden colocar de dos formas:
• A continuación del tipo de datos.
• A continuación del nombre del array.
Así, la sintaxis de declaración de variables array en Java es:
tipo [] identificador;
tipo identificador[];
El primer formato indica que todos los identificadores son arrays del tipo. En el segundo formato, array es sólo el identificador al que le siguen los [].
Ejemplo
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 indicar el número de elementos en la declaración de una variable array.Por ejemplo, la declaración int numeros[12] el compilador producirá un error.
Creación de un array
Java considera que un array es una referencia a un objeto. En consecuencia, para que realmente se cree (instancie) el array, usa el operador new junto al tipo de los elementos del array y su número. Por ejemplo, para crear un array que guarde las notas de la asignatura de música en un aula de 26 alumnos:
float [] notas;
notas = new float[26];
Se puede escribir en una misma sentencia:
float [] notas = new float[26];
La sintaxis para declarar y definir un array de un número de elementos determinado es:
tipo nombreArray[] = new tipo[numeroDeElementos];
o bien,
tipo nombreArray[];
nombreArray = new tipo[numeroDeElementos];
Ejemplo
Se declaran y se crean arrays de diferentes tipos de datos.
1. int a[] = new int [10];
a es un array de 10 elementos de tipo int.
2. final int N = 20;
float [] vector;
vector = new float[N];
Se ha creado un array de N elementos de tipo float. 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 .
Subíndices de un array
El índice de un array se denomina, con frecuencia, subíndice del array. El término procede de las matemáticas, en las que un subíndice se utiliza para representar un elemento determinado.
numeros0 equivale a numeros[0]
numeros3 equivale a numeros[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. Se utiliza para que el índice de un elemento del array sea siempre igual que el número de “pasos” desde el elemento inicial numeros[0] a ese elemento.
Por ejemplo,
numeros[3] está a 3 pasos o posiciones del elemento numeros[0].
Ejemplo :
Acceso a elementos de diferentes arrays.
1. int []mes = new int[12]; mes contiene 12 elementos: el primero, mes[0], y el último, mes[11].
float salarios[]; Declara un array de tipo float.
salarios = new float[25]; Crea el array de 25 elementos.
mes[4] = 5;
salario[mes[4]*3]; Accede al elemento salario[15].
2. final int MX = 20;
Racional []ra = new Racional[MX]; Declara un array de 20 objetos Racional.
ra[MX - 4]; Accede al elemento ra[16].
En los programas se pueden referenciar elementos del array utilizando fórmulas para los subíndices.
Siempre que el subíndice pueda evaluarse a un entero, se puede utilizar una constante, una variable o una expresión para el subíndice
Tamaño de los arrays. Atributo length
Java considera cada array como un objeto que, además de tener capacidad para almacenar elementos, dispone del atributo length con el número de elementos.
double [] v = new double[15];
System.out.print(v.length); //escribe 15, número de elementos de v.
Java conoce el número de elementos de un array cuando se establece su tamaño con el operador new, o bien con una expresión de inicialización. length está protegido, no puede ser modificado ya que está definido con el cualificador final.
Ejemplo
Haciendo uso del atributo length se calcula la suma de los elementos de un array de tipo double.
double suma (double [] w)
{
double s = 0.0;
for (int i = 0; i < w.length; i++)
s += w[i];
return s;
}
Precaución
El número de elementos de un array es un campo del array, no un método:w.length; // es correcto
w.length(); // es un error
Verificación del índice de un array
Java, al contrario que el lenguaje C, verifica que el índice de un array esté en el rango de definición.
Si, por ejemplo, se define un array a de 6 elementos, los índices válidos están en el rango 0 a 5, entonces el acceso a[6] es detectado por el compilador y genera un mensaje de error. Durante la ejecución del programa también puede producirse el acceso a un elemento fuera de los índices, y provocará que el programa se “rompa” en tiempo de ejecución, generando una excepción
Ejemplo
Protección frente a errores en el intervalo (rango) de valores de una variable de índice que
representa un array
int datos(double a[])throws Exception
{
int n;
System.out.println("Entrada de datos, cuantos elementos: ? ");
n = Integer.parseInt(entrada.readLine());
if (n > a.length)
return 0;
for (int i = 0; i < n; i++)
a[i]= Double.valueOf(entrada.readLine()).doubleValue();
return 1;
}
Inicialización de un array
Los elementos del array se pueden inicializar con valores constantes en una sentencia que, además, determina su tamaño. Estas constantes se separan por comas y se encierran entre llaves,
como en los siguientes ejemplos:
int numeros[] = {10, 20, 30, 40, 50, 60}; /* Define un array de 6 elementos
y se inicializan a las constantes */
int n[] = {3, 4, 5} // Define un array de 3 elementos
char c[] = {'L','u','i','s'}; // Define un array de 4 elementos
El array numeros tiene 6 elementos, n tiene 3 elementos y el array c 4 elementos.
Nota
La serie de valores entre llaves sólo puede ser usada para inicializar un array, no en
sentencias de asignación posteriores.
int cuenta[] = {15, 25, -45, 0, 50};
El compilador asigna automáticamente cinco elementos a cuenta.
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:
final int ENE = 31, FEB = 28, MAR = 31, ABR = 30, MAY = 31,
JUN = 30, JUL = 31, AGO = 31, SEP = 30, OCT = 31,
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 -1 se puede utilizar la siguiente sentencia:
for (i = 0; i < numeros.length; i++)
numeros[i] = -1;
Por defecto, Java inicializa cada elemento de un array a ceros binarios, ya sea de tipo int, char, ...
Ejercicio
El programa escrito a continuación lee NUM enteros en un array, multiplica los elementos del array y visualiza el producto.
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 total = 1;
System.out.println("Por favor, introduzca " + NUM + " datos");
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.print(" " + nums[i]);
total *= nums[i];
}
System.out.println("\nEl producto de los números es " + total);
}
}
Copia de arrays
En Java, los nombres de arrays son referencias a un bloque de memoria distribuida según el número de elementos; por ello, si se hace una asignación entre dos variables array, éstas se refieren al mismo array. Por ejemplo:
double [] r, w;
r = new double[11];
w = new double[15];
for (int j = 0; j < r.length; j++)
r[j] = (double) 2*j-1;
// asignación del array r a w
w = r;
Esta asignación hace que se pueda acceder a los elementos desde r o desde w, pero no se ha creado un nuevo almacenamiento para los elementos; los 15 elementos que inicialmente se referencian desde w se han perdido.
Los elementos de un array se pueden asignar a otro array del mismo tipo. Se construye un bucle que accede a cada elemento del origen y destino; el array destino debe estar definido con al menos los mismo elementos.
Por ejemplo:
final int N = 12;
int v1[] = new int[N], v2[] = new int[N];
for (int i = 0; i < N; i++)
v1[i] = (int)Math.random()*199 +1 ;
// Los elementos de v1 son copiados a v2
for (int i = 0; i < N; i++)
v2[i] = v1[i];
Esta copia se puede hacer con un método de la clase System, arraycopy(). Para copiar los N elementos que tiene el array v1 en v2 con el método arraycopy()se especifica la posición inicial del vector desde el que se copia, la posición del vector destino donde se inicia la copia y el
número de elementos:
System.arraycopy(v1,0,v2,0,N);
La sintaxis del método arraycopy:
System.arraycopy(arrayOrigen,inicioOrigen,arrayDestino,inicioDestino,numElementos)
arrayOrigen: nombre del array desde el que se va a copiar.
inicioOrigen: posición del array origen desde el que se inicia la copia.
arrayDestino: nombre del array en el que se hace la copia.
inicioDestino: posición del array destino donde empieza la copia.
numElementos: número de elementos del array origen que se van a copiar
Ejercicio
Definir dos arrays de tipo double, v y w con 15 y 20 elementos respectivamente. En el array v se guardan los valores de la función e2x-1 para x ≥ 1.0; el array w se inicializa cada elemento al ordinal del elemento. A continuación se copian los 10 últimos elementos de v a partir del elemento 11 de w. Por último, se escriben los elementos de ambos arrays.
El programa que se escribe a continuación sigue los pasos indicados en el enunciado. Se
usa la función exp() de la clase Math para el cálculo de la función e2x-1 ; así como el método
arraycopy() para realizar la copia de elementos de array pedida.
import java.io.*;
class copiArray
{
public static void main(String [] a)
{
final int N = 15;
final int M = 20;
double [] v = new double[N], w = new double [M];
double x = 1.0;
for (int i = 0; i < N; x += 0.2, i++)
v[i] = Math.exp(2*x-1);
for (int i = 0; i < M; i++)
w[i] = (double)i;
// Se imprimen los elementos del vector v
System.out.println("\n Valores del vector v");
for (int i = 0; i < N; i++)
System.out.print(v[i] + " ");
System.out.flush();
// Es realizada la copia de v a w
System.arraycopy(v, (N-1)-10 +1, w, 10, 10);
// Se impimen los elementos del vector w
System.out.println("\n Valores del vector w");
for (int i = 0; i < M; i++)
System.out.print(w[i] + " ");
System.out.flush();
}
}
Precaución
Ha de haber espacio suficiente en el array destino para realizar la copia de elementos desde el array fuente; en caso contrario, se provoca un error en la ejecución.
ARRAYS MULT IDIMENSIONALES
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 listas. Los arrays multidimensionales son aquellos que tienen más de una dimensión y, en consecuencia, más de un índice. Los 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, ya sean tres, cuatro o más.Un array de dos dimensiones (m × n) equivale a una tabla con múltiples filas y múltiples columnas (Figura ).
En el array bidimensional de la Figura 3.2, si las 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 es 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>;
Ejemplos de declaración de matrices :
char pantalla[][];
int puestos[][];
double [][]matriz;
Estas declaraciones no reservan memoria para los elementos de la matriz, 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][24]; // matriz con 80 filas y 24 columnas
puestos = new int[10][5]; // matriz de 10 filas por 5 columnas
final int N = 4;
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 es:
<tipo de datoElemento> <nombre array>[][]=
new <tipo de datoElemento> [<NúmeroDeFilas<] [<NúmeroDeColumnas>];
Atención
Java requiere que cada dimensión esté encerrada entre corchetes. La sentencia int
equipos[][] = new int[4,5] no es válida.
Un array de dos dimensiones es en realidad un array de arrays, es decir, un array unidimensional,
y cada elemento no es un valor entero, de coma flotante o carácter, sino que cada elemento
es otro array.
Los elementos de los arrays se almacenan en la 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. La Tabla 3.1 presenta todos los elementos
y sus posiciones relativas en la memoria del array, int [][]tabla = new int[4][2].
Inicialización de arrays multidimensionales
La inicialización se hace encerrando entre llaves la lista de constantes, separadas por comas, que
forma cada fila, como en los ejemplos siguientes:
1. int tabla1[][] = { {51, 52, 53},{54, 55, 56} };
Define una matriz de 2 filas por 3 columnas cada una.
O bien con este formato más amigable:
int tabla1[][] = { {51, 52, 53},
{54, 55, 56} };
2. int tabla2[][] = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
};
Java trata los arrays de dos o más dimensiones como arrays de arrays, por esa razón se pueden crear arrays de dos dimensiones no cuadradas.
Ejemplo
Declaración y creación de arrays bidimensionales de distinto número de elementos por fila.
1. double tb[][] = { {1.5, -2.5}, {5.0, -0.0, 1.5} };
Se ha definido una matriz de 2 filas, la primera con dos columnas y la segunda con 3.
2. int[] a = {1,3,5};
int [] b = {2,4,6,8,10};
int mtb[][] = {a, b};
Se ha definido el array a de 3 elementos, el b de 4 elementos y la matriz mtb de 2 filas,
la primera con 3 elementos o columnas y la segunda con 4.
Java permite crear matrices de distintas formas, la definición que se realiza en el Ejemplo siguienteespecifica primero el número de filas y, a continuación, el número de elementos de cada fila.
Ejemplo
Creación de arrays bidimensionales de distinto número de elementos por fila. Primero se crean
las filas y, después, las columnas de cada fila.
1. double [][]gr = new double[3][];
Define la matriz gr de 3 filas. A continuación los elementos de cada fila:
gr[0] = new double[3];
gr[1] = new double[6];
gr[2] = new double[5];
2. int [][]pres = new int[4][];
Define la matriz pres de tipo entero con 4 filas. A continuación, los elementos de cada
fila se definen con sentencias de inicialización:
pres[0] = {1,3,5,7};
pres[1] = {2,6,8};
pres[2] = {9,11};
pres[4] = {10};
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
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 arrays bidimensionales
El acceso a los elementos de arrays bidimensionales sigue el mismo formato que el acceso a los elementos de un array unidimensional. En este caso, con las matrices deben especificarse los índices de la fila y la columna.
El formato general para la asignación directa de valores a los elementos es:
inserción de elementos
<nombre array>[indice fila][indice columna] = valor elemento;
extracción de elementos
<variable> = <nombre array> [indice fila][indice columna];
Con dos bucles anidados se accede a todos los elementos de una matriz. 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 se puede obtener con el atributo length. Con este atributo,
la sintaxis para acceder a los elementos es:
<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];
Ejercicio
Codificar un programa para dar entrada y posterior visualización de un array de dos dimensiones.
El método leer() da entrada a los elementos de la matriz que se pasan como argumento, y el método visualizar() muestra la tabla en la pantalla.
import java.io.*;
class tabla
{
public static void main(String [] a) throws Exception
{
int v[][]= new int[3][5];
leer(v);
visualizar(v);
}
static void leer(int a[][])throws Exception
{
int i,j;
BufferedReader entrada = new BufferedReader
(InputStreamReader(System.in));
System.out.println("Entrada de datos de la matriz");
for (i = 0; i < a.length; i++)
{
System.out.println("Fila: " + i);
for (j = 0; j < a[i].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 < a.length; i++)
{
for (j = 0; j < a[i].length; j++)
System.out.print(a[i][j] + " ");
System.out.println(" ");
}
}
}
Arrays de más de dos dimensiones
Java proporciona la posibilidad de almacenar varias dimensiones, aunque raramente 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 la Figura 3.5. Un array tridimensional se puede considerar como un conjunto de arrays bidimensionales combinados 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. A continuación se declara y define un array tridimensional equipos:
int equipos[][][]= new int[3][15][10];
Ejemplo
Crear un array tridimensional para representar los caracteres de un libro y diseñar los bucles
de acceso.
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 los elementos son caracteres.
El método más fácil para acceder a los caracteres es mediante bucles anidados. Dado que
el libro se compone de un conjunto de páginas, el bucle más externo es el bucle de página, y el
bucle de columnas es el bucle más interno. Esto significa que el bucle de filas se insertará entre
los bucles de página y de columna.
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]>
UTLIZACIÓN DE ARRAYS COMO PARÁMETROS
En Java, todas las variables de tipos primitivos (double, float, char, int, boolean) se pasan por valor. Por contra, los objetos siempre se pasan por referencia, y como los arrays son objetos, también se pasan por referencia (dirección). Esto significa que cuando se llama a un método y se utiliza un array como parámetro, se puede modificar el contenido de los elementos del array en el método. La Figura 3.6 ayuda a comprender el mecanismo.
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 array bidimensional:
void SumaDeMats(double m1[][], double m2[][]);
Al método SumaDeMats() se pueden 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);
Ejercicio
Paso de arrays a métodos. Se lee un array y se escribe el producto de los elementos positivos.
El número de elementos del array se establece en la ejecución del programa. Al método leerArray() se le pasa el array para dar entrada a sus valores. Al método producto() también se le pasa el array; devuelve 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 Exception
{
double v[];
int n;
System.out.print("Número de elementos: ");
n = Integer.parseInt(entrada.readLine());
v = new double[n];
leerArray(v);
System.out.println("El producto de los elementos= " +
producto(v));
}
static void leerArray(double a[])throws Exception
{
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 n = w.length - 1;
while (n > 0)
if (w[n] > 0.0)
pd *= w[n--];
else
n--;
return pd;
}
}
Precauciones
Un método conoce cuántos elementos existen en el array pasado como argumento. Puede ocurrir que no todos los elementos sean significativos, si esto ocurre hay que pasar un segundo argumento que indique el número real de elementos.
Ejemplo
El método SumaDeEnteros() suma los valores de los n elementos de un array y devuelve
la suma.
int SumaDeEnteros(int[]arrayEnteros, int n)
{
int i, s;
for (i = s = 0; i < n; )
s += arrayEnteros[i++];
return s;
}
Aunque SumaDeEnteros() conoce la capacidad del array a través del atributo length,
no sabe cuántos elementos hay que sumar y por ello se le pasa el parámetro n con el número
verdadero de elementos. Una posible llamada al método es la siguiente:
int lista[] = new int[33];
n = 10;
SumaDeEnteros(lista, n);
Nota
Se pueden utilizar dos formas alternativas para permitir que un método conozca el número de elementos 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 ese momento;
• pasar un segundo argumento que indica el número de elementos del array.
Ejercicio
Se lee una lista de, como máximo, 21 números enteros; a continuación, se calcula su suma y el valor máximo. La entrada de datos termina al introducir la clave -1.
El programa consta del método entrada(), que lee desde el teclado los elementos del array hasta que se lee el dato clave y devuelve el número de elementos leídos 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 y se pasan dos parámetros, el array y el número de elementos. El método maximo() tiene los mismos parámetros que sumaEnteros(), determina el valor máximo.
import java.io.*;
class SumaMax
{
public static void main(String [] a)throws Exception
{
final int NUM = 21;
int items[] = new int[NUM];
int n;
n = entrada(items); // devuelve el número real de elementos
System.out.println("\nSuma de los elementos: " +
sumaEnteros(items,n));
System.out.println("\nValor máximo: " + maximo(items,n));
}
static int entrada(int w[])throws Exception
{
int k = 0, x;
BufferedReader entrada = new BufferedReader(
new InputStreamReader(System.in));
Integer.parseInt(entrada.readLine());
if (x != -1 )
w[k++] = x;
}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++)
mx = (w[i]>mx ? w[i]: mx);
return mx;
}
}