Download ARREGLOS EN JAVA

ISTP CIDET – COMPUTACION E INFORMATICA
Arreglos en Java
ARREGLOS EN JAVA
I. INTRODUCCIÓN
En las sesiones anteriores, los datos manejados en los programas han sido datos simples (carácter, entero, reales). En
un gran número de problemas es necesario manejar un conjunto de datos más o menos grande que están
relacionados entre sí, de tal forma que constituyen una unidad para su tratamiento. Por ejemplo si se quiere
manipular una lista de 100 edades de personas, es conveniente tratar el conjunto de datos de forma unitaria en lugar
de utilizar 100 variables para cada dato simple.
.
Un conjunto de datos homogéneo que se tratan como una sola unidad se denomina estructura de datos. Si una
estructura de datos reside en memoria central (memoria RAM), se llama estructura de datos interna. Recíprocamente
si reside en un soporte externo (disquete, disco, cd, memoria USB, cinta, se denomina estructura de datos externa.
La estructura de datos más importante desde el punto de vista de utilización es una matriz, que es implementado en
la totalidad de lenguajes de programación.
Esta estructura corresponde con los conceptos matemáticos de vector, matriz o poliedro.
II. DEFINICION
Un arreglo (lista o tabla) es una secuencia de datos del mismo tipo (estructura homogénea), los datos se llaman
elementos del arreglo enumerados consecutivamente 0,1,2,3,…. y se encuentran almacenados consecutivamente en
memoria. Cada elemento puede ser accedido directamente por el nombre de la variable matriz seguido de uno o más
subíndices.
matriz m
0
1
2
3
4
5
6
7
8
9
Un arreglo puede contener, por ejemplo, la edad de los estudiantes de una clase, las horas diarias laboradas por un
trabajador, el número de estudiantes por ciclo de Ingeniería de Sistemas, etc.
En general, la representación de un arreglo se hace mediante variables suscritas o de subíndices y pueden tener una o
varias dimensiones (subíndices).
III. CLASIFICACIÓN DE ARREGLOS
Los arreglos según su dimensión se clasifican en unidimensionales, bidimensionales y multidimensionales; y según su
contenido en numéricas, de caracteres y de referencia a objetos.
1. ARREGLOS UNIDIMENSIONALES (Vectores)
Son arreglos de una sola dimensión, tienen un solo índice. Cada elemento del vector se accesa mediante su
nombre seguido del número correspondiente al subíndice que se escribe entre corchetes. Por ejemplo,
supongamos que tenemos un vector de enteros llamada m, el cual contiene 8 elementos. Estos elementos se
identificaran de la siguiente forma:
Vector m
Acceso al cuarto elemento es m[3]
5
4
8
7
3
2
1
6
m[0]
m[1]
m[2]
m[3]
m[4]
m[5]
m[6]
m[7]
Elementos del Vector
Subíndices
El arreglo unidimensional tiene ocho elementos: m[0] contiene 5, m[1] contiene 4, m[2] contiene 8, m[3] contiene
7, m[4] contiene 3, m[5] contiene 2, m[6] contiene 1, m[7] contiene 6. El diagrama representa realmente una
región de la memoria de la computadora, ya que un arreglo se almacena siempre con sus elementos en una
secuencia de posiciones de memoria contigua.
En Java, los índices del arreglo siempre tienen como limite inferior 0, y como índice superior el tamaño del arreglo
menos 1.
Igual que sucede con otras variables, antes de utilizar un arreglo primero hay que declararla. La declaración de un
arreglo especifica el nombre del arreglo y el tipo de elemento de la misma. Para crear y utilizar un arreglo hay que
realizar tres operaciones: declararla, crearla e iniciarla.
1º. DECLARAR UN ARREGLO UNIDIMENSIONAL
La declaración de un arreglo unidimensional, se realiza de las 2 formas siguientes:
tipoDato[ ] nombreVariable;
tipoDato nombreVariable[ ];
CURSO: Estructura de la Información
1
DOCENTE: Ing. Fabián Silva Alvarado
ISTP CIDET – COMPUTACION E INFORMATICA
Arreglos en Java
donde tipoDato indica el tipo de datos de los elementos del arreglo, que pueden ser de cualquier tipo
primitivo o referenciado; y nombreVariable es un identificador que nombra al arreglo. Los corchetes
modifican la definición normal del identificador para que sea interpretado por el compilador como un arreglo.
Veamos algunos ejemplos.
int[ ] m;
declara un arreglo de tipo int
float[ ] temperatura;
declara un arreglo de tipo float
Note que las declaraciones no especifican el tamaño del arreglo. El tamaño será especificado cuando se cree
el arreglo, operación que se hará durante la ejecución del programa. Los corchetes también se pueden colocar
después del nombre del arreglo.
int
m[ ];
float temperatura[ ];
2º. CREAR UN ARREGLO UNIDIMENSIONAL
Después de haber declarado un arreglo, el siguiente paso es crearla o construirla. Crear un arreglo significa
reservar la cantidad de memoria necesaria para contener todos sus elementos y asignar al nombre del arreglo una
referencia a ese bloque. Esto puede expresarse genéricamente así:
nombreVariable = new tipoDato[tamaño]
donde nombreVariable es el nombre del arreglo previamente declarado, tipoDato es el tipo de datos de
los elementos del arreglo; y tamaño es una expresión entera que especifica los números de elementos. El hecho de
utilizar el operador new significa que Java implementa los arreglos como objetos, por lo tanto serán tratadas como
cualquier otro objeto.
Las siguientes líneas de código crean los arreglos de una dimensión declaradas en el ejemplo anterior:
m = new int [10];
temperatura = new float[31];
Crea un arreglo identificada por m con 10 elementos de
tipo int; es decir, puede almacenar 10 valores enteros;
el primer elemento es m[0], el segundo es m[1],… y el
ultimo es m[9].
Crea una matriz de temperatura de 31 elementos
de tipo float.
Es bastante común declarar y crear un arreglo en una misma línea. Esto puede hacerse así:
tipoDato[ ] nombreVariable = new tipoDato[tamaño];
tipoDato nombreVariable[ ] = new tipoDato[tamaño];
Veamos un ejemplo:
int[ ] m = new int[10];
float[ ] temperatura = new float[31]
Más Ejemplos:
int Edad[ ] = new int[100];
Declara un arreglo llamado Edad que contiene 100 elementos de tipo enteros (int).
String Nombres[ ] = new String [25] ;
Declara un arreglo llamado Nombres que puede almacenar 25 nombres de personas.
double Salario[ ] = new double[50] ;
Declara un arreglo llamado Salario que puede almacenar 25 elementos de tipo doublé.
Cuando se crea un arreglo, el tamaño del mismo puede ser también especificado durante la ejecución a través de
una variable a la que se asignara como valor el número de elementos requeridos.
int nElem;
nElem=Integer.parseInt(JOptionPane.showInputDialog(“Ingrese # de elementos del arreglo“);
int [ ] m = new int[nElem];
3º. INICIAR UN ARREGLO UNIDIMENSIONAL
Un arreglo es un objeto, por lo tanto, cuando es creada, sus elementos son automáticamente iniciados, igual que
sucedía con las variables miembro de una clase. Si el arreglo es numérico sus elementos son iniciados a 0 y si no es
numérico, a un valor análogo a 0; por ejemplo un elemento booleano es inicializado a false y las referencias a
objetos a null.
Si deseamos iniciar un arreglo con otros valores diferentes a los predeterminados, podemos hacerlo de la siguiente
forma:
double[] ingresos={1000,5000,7000,10000,12000,15000};
CURSO: Estructura de la Información
2
DOCENTE: Ing. Fabián Silva Alvarado
ISTP CIDET – COMPUTACION E INFORMATICA
Arreglos en Java
el ejemplo crea un arreglo ingresos de tipo double con tantos elementos como valores se hayan especificado entre
llaves.
Para practicar la teoría vamos a realizar un programa que asigne datos a un arreglo unidimensional m de
nElementos y, a continuación, como comprobación del trabajo realizado, escriba el contenido de dicho arreglo. La
solución será similar a la siguiente:
Numero de elementos del Arreglo: 10
Ingrese los valores del Arreglo:
m[0]=1
m[1]=2
m[2]=3
.
.
.
m[9]=10
Los Elementos ingresados son:
1 2 3 … 10
Para ello, en primer lugar definimos la variable nElem para fijar el número de elementos del arreglo, creamos el
arreglo m con ese número de elementos y definimos el subíndice i para acceder a los elementos de dicho arreglo.
int nElem;
nElem=Integer.parseInt(JOptionPane.showInputDialog(“Ingrese # de elementos del arreglo“);
int m[]= new int[nElem];
// crear el arreglo
int i = 0;
// subíndice
m
El paso siguiente es asignar un valor desde el teclado a cada elemento de la matriz.
for (i=0; i<nElem; i++)
{
m[i]=Integer.parseInt(JOptionPane.showInputDialog("m[" + i + "] = "));
}
Una vez leído los elementos para el arreglo visualizamos para comprobar el trabajo realizado.
String AreaSalida="Los Elementos ingresados son: \n";
for(int i=0;i<nElem;i++)
{
AreaSalida = AreaSalida + " " + m[i];
}
JOptionPane.showMessageDialog(null, Salida);
El Programa completo se muestra a continuación:
import javax.swing.JOptionPane;
public class Clase_Arreglos001
{
public static void main(String[] args)
{
int nElem=0;
nElem=Integer.parseInt(JOptionPane.showInputDialog("Ingrese # de elementos del arreglo "));
int m[]=new int[nElem];
int i=0; //Subindice
//Asignar valores al arreglo
for(i=0;i<nElem;i++)
{
m[i]=Integer.parseInt(JOptionPane.showInputDialog("m [" + i + "] = "));
}
//Visualizar datos
String Salida="Los Elementos ingresados son: \n";
for(i=0;i<nElem;i++)
{
Salida = Salida + " " +m[i];
}
JOptionPane.showMessageDialog(null, Salida);
}
CURSO: Estructura de la Información
3
DOCENTE: Ing. Fabián Silva Alvarado
ISTP CIDET – COMPUTACION E INFORMATICA
Arreglos en Java
}
TAMAÑO DE UN ARREGLO. Atributo length
Java considera cada arreglo como un objeto, debido a ello se puede conocer el numero de elementos de un arreglo
accediendo al campo length. Por ejemplo, la última parte del ejercicio anterior podríamos escribirla también así.
//Visualizar datos
String Salida="Elementos ingresados: \n";
for(i=0;i<m.length;i++)
{
Salida = Salida + " " +m[i];
}
JOptionPane.showMessageDialog(null, Salida);
APLICACIONES EMPLEANDO ARRAYS UNIDIMENSIONALES
1. Programa que incluye un arreglo con elementos inicializados con valores diferentes a los predeterminados:
Diseñar la siguiente interfaz y agregue el siguiente código para el botón.
//Código para el botón
private void btnVisualizarActionPerformed(java.awt.event.ActionEvent evt) {
//Declarar e inicializar el arreglo
int miarreglo[]={15,20,14,10,19,17};
//Visualizar Datos
String Salida="";
for(int i=0;i<miarreglo.length;i++)
{
Salida=Salida+miarreglo[i]+"\n";
}
txtLista.setText(Salida);
}
2. Programa que incluye un arreglo de enteros y los datos son asignados directamente en el código:
CURSO: Estructura de la Información
4
DOCENTE: Ing. Fabián Silva Alvarado
ISTP CIDET – COMPUTACION E INFORMATICA
Arreglos en Java
//Código para el botón
private void btnVisualizarActionPerformed(java.awt.event.ActionEvent evt) {
//Declarar y crear el arreglo
También
una asignación
asignacióncon
con
Tambiénpodemos
podemos hacer
hacer una
double miarreglo[]=new double[5];
números
números aleatorios
aleatorios
//Asignar
miarreglo[0]=15;
miarreglo[1]=20;
miarreglo[2]=14;
miarreglo[3]=10;
miarreglo[4]=19;
//Visualizar Datos
String Salida="";
for(int i=0;i<miarreglo.length;i++)
{
Salida=Salida+miarreglo[i]+"\n";
}
txtLista.setText(Salida);
Hay que recordar que el número generado es del tipo
double. Es por ello que para finalizar deberemos de
hacer un casting a un entero.
}
3. Programa que incluye un arreglo de enteros y los datos son asignados por teclado:
private void btnAgregarActionPerformed(java.awt.event.ActionEvent evt) {
//Leer la caja de texto
int tam=Integer.parseInt(txtElem.getText());
//Declarar y crear el arreglo
int miarreglo[]=new int[tam];
//Asignar
for(int i=0;i<tam;i++)
{
miarreglo[i]=Integer.parseInt(JOptionPane.showInputDialog("Elem ["+i+"]"));
}
//Visualizar
String Salida="";
for(int i=0;i<tam;i++)
{
Salida=Salida+miarreglo[i]+"\n";
}
txtLista.setText(Salida);
}
CURSO: Estructura de la Información
5
DOCENTE: Ing. Fabián Silva Alvarado
ISTP CIDET – COMPUTACION E INFORMATICA
Arreglos en Java
4. Programa que incluye un arreglo de enteros y los datos son asignados desde un cuadro de texto:
Diseñe el formulario teniendo en cuenta el nombre de
los controles
Programa funcionando
txtArreglo
//Código del programa
OPERACIONES CON ARREGLOS:
I. SUMA DE 2 ARREGLOS
A
i=0
i=1
i=2
B
10
15
20
C
20
10
15
+
30
25
35
=
.
i=n-1
X
Y
X+Y
C[i]= A[i] + B[i]
En Código:
II. PRODUCTO DE 2 ARREGLOS
A
i=0
i=1
i=2
for(i=0;i<n;i++)
{
C[i]= A[i] + B[i];
}
B
10
15
20
C
20
10
15
*
=
200
150
300
.
.
i=n-1
X
Y
X*Y
C[i]= A[i] * B[i]
En Código:
for(i=0;i<n;i++)
{
C[i]= A[i] * B[i];
}
CURSO: Estructura de la Información
6
DOCENTE: Ing. Fabián Silva Alvarado
ISTP CIDET – COMPUTACION E INFORMATICA
Arreglos en Java
III. DIFERENCIA DE 2 ARREGLOS
En Código:
for(i=0;i<n;i++)
{
C[i]= A[i] - B[i];
}
IV. DIVISION DE 2 ARREGLOS
En Código:
for(i=0;i<n;i++)
{
C[i]= A[i] / B[i];
}
Ejemplo:
Imprimir la planilla de salarios de los trabajadores de una empresa de acuerdo al siguiente formato:
--------------------------------------------------------------------------------------------------------------------------------------------------------------PLANILLA DEL MES DE JULIO 2011
--------------------------------------------------------------------------------------------------------------------------------------------------------------CODIGO APELLIDOS Y NOMBRES
SAL_BAS
BONIF
SAL_PARC
DSCTO
SAL_NETO
---------------------------------------------------------------------------------------------------------------------------------------------------------------
****
****
****
****
******************
******************
******************
*******************
****.**
****.**
****.**
****.**
***.**
***.**
***.**
***.**
****.**
****.**
****.**
****.**
***.**
***.**
***.**
***.**
****.**
****.**
****.**
****.**
---------------------------------------------------------------------------------------------------------------------------------------------------------------
TOTALES
*****.**
******.**
--------------------------------------------------------------------------------------------------------------------------------------------------------------Especificaciones:
a)
b)
c)
d)
e)
f)
Cada trabajador se identifica con su nombre y su código
Cada Trabajador tiene un salario básico (SAL_BAS) entre 1000 y 2000.
Cada trabajador tiene una bonificación (BONIF) del 12% del Salario Básico
El Salario Parcial (SAL_PARC) es igual a SAL_BAS+ BONIF.
Cada trabajador tiene un descuento (DSCTO) del 9% del SAL_PARC
El Salario Neto (SAL_NETO) es igual a SAL_PARC – DSCTO.
Codigo[i]
Ape_Nomb[i]
Sal_Bas[i]
Bonif[i]
Sal_Parc[i]
Descuento[i]
Sal_Neto[i]
i=0
i=1
i=2
.
.
.
i=99
Implementar en Java
CURSO: Estructura de la Información
7
DOCENTE: Ing. Fabián Silva Alvarado