ASIGNATURA Estructura de Datos

TEMA Arreglos
PROFESOR Marco A. Coral
ALUMNO
CODIGO
FECHA
CICLO
TURNO
SEMESTRE 2011-I

1. OBJETIVOS

Que el estudiante:
• Aprenda a declarar un arreglo tanto de tipo simple como de tipo compuesto o abstracto
• Aprenda a utilizar el arreglo como medio de almacenamiento de datos.

2. INTRODUCCION TEORICA

Un uso muy común en diseños de Software es agrupar distintos valores relacionados entre sí en una sola
variable, lo cual permite una manipulación más eficiente de datos; en el lenguaje Java existen diversos
mecanismos para agrupar datos en conjunto, una de ellas que ha venido siendo utilizada a lo largo de los
distintos programas en este curso es denominada: Arreglo.

A través de un Arreglo es posible generar agrupaciones de cualquier tipo de Objeto simplemente agregando
una simbología de corchetes , ya sea seguido de la definición de Clase o bien la referencia en cuestión, a
continuación se describen diversos ejemplos más amplios de Arreglos:

2.1. Declaración de arreglos

Los arreglos en Java son dinámicos, pero no extensibles, lo cual significa que deben ser creados con el
tamaño que tendrán hasta el final de su vida.

Un arreglo se declara de la siguiente forma:

<tipo>[] <nombre>;

O sea, para declarar, por ejemplo, un arreglo de números enteros utilizaremos la siguiente sentencia:

int[] arrInt;

Es importante notar que el arreglo aún no ha sido creado, sino meramente declarado. Para crear el arreglo
(reservar su memoria e inicializarlo) deberemos recurrir al operador new:

arrInt = new int[10];

Este comportamientodebe comprenderse de esta forma: en Java todo es un objeto, y los objetos deben ser
creados mediante el operador new. El caso de los arreglos no es diferente, el tipo de datos del arreglo (int[]
en este caso) es una clase y cada una de sus instancias debe ser creada explícitamente, el tamaño puede
pensarse como un parámetro al constructor de la clase.

A partir de este momento podemos utilizar arrInt como un arreglo de cualquier otro lenguaje.
Una de las características que hacen de Java un entorno de programación seguro, y que se relaciona con el
manejo de los arreglos es que el lenguaje no permite la indexación de arreglos fuera de rango, o sea, una
asignación de este tipo generará una excepción:
 ArrInt[25] = 1;

Otra forma de declararlos es la siguiente:

UNIDIMENSIONALES:

tipo nombre_array[]=new tipo[nº];

tipo nombre_array[]={valores};

BIDIMENSIONALES:

tipo nombre_array[][]=new tipo[nº][nº];

tipo nombre_array[][]={valores};

2.2. Algunas de sus características más importantes de los arrays son las siguientes:

1. Los arrays se crean con el operador new seguido del tipo y número de elementos.
2. Se puede acceder al número de elementos de un array con la variable miembro implícita length (por
ejemplo, vect.length).
3. Se accede a los elementos de un array con los corchetes [] y un índice que varía de length-1.
4. Se pueden crear arrays de objetos de cualquier tipo. En principio un array de objetos es un array de
referencias que hay que completar llamando al operador new.
5. Los elementos de un arrayse inicializan al valor por defecto del tipo correspondiente (cero para valores
numéricos, el carácter nulo para char, false para boolean, null para Strings y para referencias).
6. Como todos los objetos, los arrays se pasan como argumentos a los métodos por referencia.
7. Se pueden crear arrays anónimos (por ejemplo, crear un nuevo array como argumento actual en la
llamada a un método).

2.3. Algunas operaciones con arreglos

Declaración de un arreglo:

int A[]; // A es un arreglo de enteros

int A[10]; // error, el tamaño no va aquí
int[] A; // A es un arreglo de enteros
int A,B[]; // A es un entero, B un arreglo
int[] A,B; // A y B son arreglos
String S[]; // S es un arreglo de strings
S[1]="" // error, el arreglo no ha sido
// creado

Creación de un arreglo

int A[]= new int[10]; // 10 enteros

Subindicación de un arreglo:

A[0], A[1], ..., A[9] // correcto

A[10] // error, índice fuera
// de rango

Modificación de un arreglo:

A[3]= 8;
 Tamaño de un arreglo:

A.length // correcto
A.length() // error, sin paréntesis

Inicialización de un arreglo:

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

A[i]= i;

Asignación de punteros a arreglos

int B[];
B= A; // A y B son el mismo arreglo
if (A==B) // Comparación de punteros
// true!
...
A[0]= 10;
B[0] // también 10

Copia de un arreglo:

B= (int[])A.clone();

2.4. Ventajas y desventajas

Ventajas
• Costo de acceso a un elemento es constante
• Estructura de fácil uso

Desventajas
• Tamaño constante
• Búsqueda lenta en arreglo desordenado
• Insertar o eliminar toma mucho tiempo

Ejemplo 1

Usando la POO escriba un programa en java que le permita eliminar de un arreglo de alumnos en cada ciclo
académico a los alumnos desaprobados. Guarde en un arreglo la cantidad de alumnos desaprobados, y el
ciclo académico en que desaprobaron.

package hola;
import java.io.*;
import java.util.*;

class ALUMNO{
int codigo;
String nomb;
float nota;
Scanner n=new Scanner(System.in);
void ing(){
System.out.println("leer codigo : ");codigo=n.nextInt();
System.out.println("leer nombre : ");nomb=n.next();
System.out.println("leer nota : ");nota=n.nextFloat();
}
void mos(){
 System.out.println(codigo+" "+nomb+" "+nota);
}
float RetorNota(){
return nota;
}
}

class CONTROL{
int cantdesaprobados;
String ciclo;
void registrar(int c){
Scanner n=new Scanner(System.in);
cantdesaprobados=c;
System.out.println("leer ciclo : ");ciclo=n.next();
}
void visualizar(){
System.out.println(cantdesaprobados+" "+ciclo);
}
}

public class Main {

public static void main(String arg[]) {
ALUMNO a[]=new ALUMNO[100]; int ia=0;
CONTROL c[]=new CONTROL[10];int ic=0;
Scanner p = new Scanner(System.in);
int k,j,i;
for (;;) {
System.out.println("Ingresar<1>\n Mostrar<2>\n " +
"\n Eliminar <3>\n Salir<4>");
int op = p.nextInt();
switch (op) {
case 1: a[ia]=new ALUMNO();
a[ia].ing(); ia++;
break;
case 2:for( i=0; i<ia; i++)
a[i].mos();
break;
case 3:k=0;
for( j=0; j<ia; j++)
if(a[j].RetorNota()>=10.5)k++;
c[ic]=new CONTROL();
c[ic].registrar(ia-k);
ic++;
for( j=0; j<ic; j++)
c[j].visualizar();
ia=0;
break;
case 4:
System.exit(0);
break;
}
}
}
}

Ejemplo 2
Usando la POO escriba un programa en java que le permita insertar un alumno en un arreglo. En otro
arreglo lleve un registro de todas las inserciones hechas como el alumno insertado y posición que ocupa
ahora en el arreglo.

package hola;
import java.io.*;
import java.util.*;

class ALUMNO{
int codigo;
String nomb;
Scanner n=new Scanner(System.in);
void ing(){
System.out.println("leer codigo : ");codigo=n.nextInt();
System.out.println("leer nombre : ");nomb=n.next();
}
void mos(){
System.out.println(codigo+" "+nomb);
}
boolean insertar(ALUMNO a[], int tot, ALUMNO x, int pos){
boolean encontro=false;
ALUMNO temp=new ALUMNO();
int i=0;
while(i<tot && !encontro){
if(i ==pos) encontro=true;
else i++;
}
if (encontro){
while (i<tot){
temp=a[i];
a[i]=x;
x=temp;
i++;
}
a[i]=x;
}
return encontro;
}
}

class BITACORA{
private int posicion;
private ALUMNO a;//=new ALUMNO();
void registrar(int c, ALUMNO x){
posicion=c;
a=x;
}
void visualizar(){
System.out.println("posicion= "+posicion);
a.mos();
}
}

public class Main {

void proceso(){
ALUMNO a[]=new ALUMNO[100]; int ia=0;
BITACORA c[]=new BITACORA[10];int ib=0;
ALUMNO b=new ALUMNO();

Scanner p = new Scanner(System.in);

 int j,i,posicion;
for (;;) {
System.out.println("Ingresar<1>\n Mostrar<2>\n Insertar <3>\n Salir<4>");
int op = p.nextInt();
switch (op) {
case 1: a[ia]=new ALUMNO();
a[ia].ing(); ia++;
break;
case 2:for( i=0; i<ia; i++)
a[i].mos();
break;
case 3:ALUMNO d=new ALUMNO();
d.ing();
System.out.println("Ingrese posicion en donde insertar");
posicion = p.nextInt();
if(b.insertar(a,ia, d, posicion)){
c[ib]=new BITACORA();
c[ib].registrar(posicion, d);
ib++;
ia++;
System.out.println("ib=" +ib+ " ia= "+ia);
}
System.out.println("MOSTRANDO BITACORA");
for( i=0; i<ib; i++)
c[i].visualizar();
break;
case 4:
System.exit(0);
break;
}
}
}
public static void main(String arg[]) {
Main m=new Main();
m.proceso();
}

}
Ejemplo 3

Usando la POO escriba un programa que registre comisiones de trabajo en la facultad. Una comisión esta
formada por un docente, un trabajador y un alumno. Cada miembro de la comisión tiene datos como código,
nombre y otros datos más que los diferencian. Muestre un reporte del arreglo.

package hola;

import java.io.*;
import java.util.*;

class ALUMNO{
int codigo;
String nomb;
float pp;
Scanner n=new Scanner(System.in);
void ing(){
System.out.println("leer codigo de ALUMNO : ");codigo=n.nextInt();
System.out.println("leer nombre de ALUMNO : ");nomb=n.next();
System.out.println("leer nota de ALUMNO : ");pp=n.nextFloat();
}
 void mos(){
System.out.println(codigo+" "+nomb+ " "+pp);
}
}
class DOCENTE{
int dni;
String nomb;
String categoria;
float sueldo;
Scanner n=new Scanner(System.in);
void ing(){
System.out.println("leer dni de DOCENTE : ");dni=n.nextInt();
System.out.println("leer nombre de DOCENTE : ");nomb=n.next();
System.out.println("leer categoria de DOCENTE : ");categoria=n.next();
System.out.println("leer sueldo de DOCENTE : ");sueldo=n.nextFloat();
}
void mos(){
System.out.println(dni+" "+nomb+" "+categoria+" "+sueldo);
}
}
class TRABAJADOR{
int dni;
String nomb;
String cargo;
float sueldo;
Scanner n=new Scanner(System.in);
void ing(){
System.out.println("leer dni de TRABAJADOR : ");dni=n.nextInt();
System.out.println("leer nombre de TRABAJADOR : ");nomb=n.next();
System.out.println("leer cargo de TRABAJADOR : ");cargo=n.next();
System.out.println("leer sueldo de TRABAJADOR : ");sueldo=n.nextFloat();
}
void mos(){
System.out.println(dni+" "+nomb+" "+cargo+" "+sueldo);
}
}

class COMISION{
private ALUMNO a;
private DOCENTE d;
private TRABAJADOR t;
void registrar(ALUMNO aa, DOCENTE dd, TRABAJADOR tt){
a=aa;
d=dd;
t=tt;
}
void visualizar(){
a.mos(); d.mos(); t.mos();
}
}

public class Main {

void proceso(){
COMISION comi[]=new COMISION[20]; int ic=0;
Scanner p = new Scanner(System.in);
int j,i,posicion;
for (;;) {
System.out.println("Ingresar<1>\n Mostrar<2>\n Salir<3>");
int op = p.nextInt();
switch (op) {
 case 1:
ALUMNO a=new ALUMNO();
DOCENTE d=new DOCENTE();
TRABAJADOR t=new TRABAJADOR();
a.ing(); d.ing(); t.ing();
comi[ic]=new COMISION();
comi[ic].registrar(a,d,t);
ic++;
break;
case 2:for( i=0; i<ic; i++){
System.out.println("COMISION No: "+(i+1));
comi[i].visualizar();
}
break;
case 3:
System.exit(0);
break;
}
}
}
public static void main(String arg[]) {
Main m=new Main();
m.proceso();
}

3. REQUERIMIENTOS O MATERIAL Y EQUIPO

• Entorno de programación Netbeans, versión 6.0 como mínimo.

• Versión 1.6 de las jdk como mínimo

4. EJERCICIOS PROPUESTOS

Ejercicio 1

Usando la POO se pide implementar en java un programa que permita ingresar cada fin de mes a los
trabajadores de una empresa con el total de su comisión por venta de libros. Si el 50% de los trabajadores
percibe montos que están sobre el promedio de las comisiones por venta de libros el sistema debe informar
que la venta fue buena, de lo contrario debe informar que fue mala.

Ejercicio 2

Usando la POO escriba un programa en java para registrar a los docentes de la facultad. Los docente son
de tres categorías, principales, asociados y auxiliares. Encuentre por categoría cual es el docente que
percibió más dinero por concepto de horas adicionales trabajadas., si la hora esta a 25 soles

Ejercicio 3

Usando la POO escriba un programa en java que le permita registrar en un arreglo solo las notas de los
alumnos (sin código y nombres). Una vez registradas genere un reporte de las notas sin redundancias.si es
que varios alumnos tuvieran una misma nota.

Ejercicio 4
Usando la POO escriba un programa que permita a los alumnos inscribirse en sus asignaturas para el cicilo
académico. Maximo se pueden colocar en 4 asignaturas. Luego genere un reporte para saber por
asignatura cuantos alumnos se han matriculado en una asignatura. El reporte debe informar también del
código y créditos que tiene la asignatura.

Ejercicio 5

Usando la POO escriba un programa en java que le permita saber en que categoría de alumnos en la FISC
hay mas alumnos. En caso halla empate, mostrar las categorías en las que hay empate.

Ejercicio 6

Usando la POO se pide implementar en java un juego de naipes en el que se cuenta con un mazo de cartas,
un numero máximo de 5 jugadores, c/u con su apuesta respectiva y un repartidor o controlador del juego. El
juego comienza con el reparto de 5 cartas a c/jugador. Gana el que tenga las 5 cartas ordenadas
consecutivamente y del mismo tipo.
Durante el juego c/jugador puede pedir cartas al repartidor para reemplazar la carta que desee. Reemplazar
c/carta cuesta 20 dólares, la cual tiene que pedirla al repartidor, además la carta reemplazada ya no regresa
al mazo.

Ejercicio 7

Usando la POO, hacer un programa en java para una tienda que vende libros a través de varios
vendedores. Cuando un cliente quiere un libro lo solicita al vendedor el cual se fija en el catalogo para
ubicarlo por código y luego con el dato ir a la base de datos de libros en la Pc y ver si esta en venta. Cuando
la venta se efectúa, registra los datos del cliente, datos del libro y sus datos de vendedor para efectos de
comisiones (5% del precio de venta) por venta de libros.

Se piden los siguientes reportes:

• Reporte de existencias de los libros

• Reporte del documento de venta con respecto a algún cliente especifico en una determinada fecha.
• Reporte de las ventas efectuadas (clientes y productos) por un vendedor.

5. ANALISIS DE RESULTADOS

• Un arreglo en java agrupa valores que están relacionados entre si.

• Los arreglos en java son dinámicos pero no extensibles
• Se accede a los elementos de un array con los corchetes y un índice que varia de length-1
• Se pueden crear arreglos de tipos básicos como de TAD

6. BIBLIOGRAFIA

• Fco. Javier Ceballos. Java 2 Curso de Programación

• Jhon Zukowski. Java 2 J2SE 1.4.
• Bruce Eckel. Piensa en Java.
• Luis Joyanes Aguilar. Programación Orientada a Objetos
• Bertrand Meyer. Construcción de Software Orientado a Objetos
• Grady Booch. Análisis y Diseño Orientado a Objetos.
• James Rumbaugh, Modelado y Diseño Orientado a Objetos, Metodología OMT
• Herbert Schildt. Turbo C/C++ Manual de Referencia
• Budd. Timothy. Introducción a la POO