Arreglos 1. Compile y ejecute el programa 2. Realice un diagrama

Arreglos
Los arreglos son estructuras de datos que consisten de elementos de datos relacionados, del mismo tipo. Los arreglos
son entidades son entidades de longitud fija: conservan la misma longitud una vez creados, aunque puede reasignarse
una variable tipo arreglo de tal forma que haga referencia a un nuevo arreglo de distinta longitud.
En Java, un arreglo es un grupo de variables (llamados elementos o componentes) que contienen valores, todos del
mismo tipo.
Los tipos en Java se dividen en dos categorías; tipos primitivos y tipos de referencia.
El número de la posición de elementos se conoce formalmente como el índice o subíndice del elemento.
Un programa puede hacer referencia a cualquiera de estos elementos mediante una expresión de acceso a un arreglo
que incluye el nombre del arreglo, seguido por el índice del elemento específico encerrado entre corchetes ([]).
El primer elemento en cualquier arreglo tiene el índice cero, y se conoce como elemento cero.
Los elementos del arreglo c son c[0], c[1], c*2+,…
Un programa puede utilizar una expresión como índice. Por ejemplo:
Si a es 5, y b es 6 entonces c[ a + b ] += 2; suma dos al elemento c[11] del arreglo.
Declaración y creación de arreglos.
Los objetos arreglo ocupan espacio en memoria. Al igual que los demás objetos, los arreglos se crean con la palabra
new. La siguiente declaración y expresión crea un objeto arreglo, que contiene 12 elementos int, y almacena la
referencia del arreglo en la variable c:
int c[ ] = new int[ 12 ];
Otra forma de hacerlo es:
int c[ ];
// declara la variable arreglo
c = new int[ 12 ]; // crea el arreglo; lo asigna a la variable tipo arreglo
Para cada programa:
1.
2.
3.
4.
Compile y ejecute el programa
Realice un diagrama de flujo del mismo
Identifique y explique cada uno de los métodos con los que esta compuesto el programa
Enviar los resultados por e-mail y publicarlos en el blog
Ejemplo de inicialización de arreglos y de manipulación de elementos
// InicArreglo.java
// Creación de un arreglo.
public class InicArreglo
{
public static void main( String args[] )
{
int arreglo[]; // declara un arreglo con el mismo nombre
arreglo = new int[ 10 ]; // crea el espacio para el arreglo
System.out.printf( "%s%8s\n", "Indice", "Valor" ); // encabezados
de columnas
// imprime el valor de cada elemento del arreglo
for ( int contador = 0; contador < arreglo.length; contador++ )
System.out.printf( "%5d%8d\n", contador, arreglo[ contador ] );
} // fin de main
} // fin de la clase InicArreglo
Inicialización de un arreglo.
Un programa puede crear un arreglo e inicializar sus elementos con un inicializador de arreglo, que
es una lista de expresiones separadas por comas encerrada entre llaves ( { } ); la longitud del
arreglo se determina en base al numero de elementos en la lista inicializadora.
int n[ ] = { 10, 20, 30, 40, 50 }
// InicArreglo.java
// Inicialización de los elementos de un arreglo con un inicializador de
arreglo.
public class InicArreglo
{
public static void main( String args[] )
{
// la lista inicializadora especifica el valor para cada elemento
int arreglo[] = { 32, 27, 64, 18, 95, 14, 90, 70, 60, 37 };
System.out.printf( "%s%8s\n", "Indice", "Valor" ); // encabezados
de columnas
// imprime el valor del elemento de cada arreglo
for ( int contador = 0; contador < arreglo.length; contador++ )
System.out.printf( "%5d%8d\n", contador, arreglo[ contador ] );
} // fin de main
} // fin de la clase InicArreglo
Cálculo de valores a guardar en un arreglo. El siguiente ejemplo crea un arreglo de elementos y
asigna a cada elemento uno de los enteros pares del 2 al 20 (2, 4, 6, …, 20). Después, la aplicación
muestra el arreglo en forma tabular. La instrucción for calcula el valor de un elemento del arreglo,
multiplicando el valor actual de la variable de control contador por 2, y después le suma 2.
Si trata de modificar una variable final después de inicializarla en su declaración, el compilador
genera el siguiente mensaje:
Cannot assign a value to final variable nombrevariable
Si se trata de accede al valor de una variable final antes de inicializarla, el compilador produce lo
siguiente:
Variable nombreVariable migth not have been initialized
// InicArreglo.java
// Cálculo de los valores a colocar en los elementos de un arreglo.
public class InicArreglo
{
public static void main( String args[] )
{
final int LONGITUD_ARREGLO = 10; // declara la constante
int arreglo[] = new int[ LONGITUD_ARREGLO ]; // crea el arreglo
// calcula el valor para cada elemento del arreglo
for ( int contador = 0; contador < arreglo.length; contador++ )
arreglo[ contador ] = 2 + 2 * contador;
System.out.printf( "%s%8s\n", "Indice", "Valor" ); // encabezados
de columnas
// imprime el valor de cada elemento del arreglo
for ( int contador = 0; contador < arreglo.length; contador++ )
System.out.printf( "%5d%8d\n", contador, arreglo[ contador ] );
} // fin de main
} // fin de la clase InicArreglo
Uso de gráficos de barra para mostrar los datos de un arreglo en forma
gráfica: Con frecuencia los valores numéricos se muestran como barras en
un gráfico de barras, los datos numéricos en forma gráfica muestran cada
valor numérico con una barra de asteriscos.
// SumaArreglo.java
// Cálculo de la suma de los elementos de un arreglo.
public class SumaArreglo
{
public static void main( String args[] )
{
int arreglo[] = { 87, 68, 94, 100, 83, 78, 85, 91, 76, 87 };
int total = 0;
// suma el valor de cada elemento al total
for ( int contador = 0; contador < arreglo.length; contador++ )
total += arreglo[ contador ];
System.out.printf( "Total de los elementos del arreglo: %d\n",
total );
} // fin de main
} // fin de la clase SumaArreglo
Programa para imprimir gráficos de barras.
// GraficoBarras.java
// Programa para imprimir gráficos de barras.
public class GraficoBarras
{
public static void main( String args[] )
{
int arreglo[] = { 0, 0, 0, 0, 0, 0, 1, 2, 4, 2, 1 };
System.out.println( "Distribucion de calificaciones:" );
// para cada elemento del arreglo, imprime una barra del gráfico
for ( int contador = 0; contador < arreglo.length; contador++ )
{
// imprime etiqueta de la barra ( "00-09: ", ..., "90-99: ", "100: " )
if ( contador == 10 )
System.out.printf( "%5d: ", 100 );
else
System.out.printf( "%02d-%02d: ",
contador * 10, contador * 10 + 9 );
// imprime barra de asteriscos
for ( int estrellas = 0; estrellas < arreglo[ contador ]; estrellas++ )
System.out.print( "*" );
System.out.println(); // inicia una nueva línea de salida
} // fin de for externo
} // fin de main
} // fin de la clase GraficoBarras
Uso de los elementos de un arreglo como contadores
Los programas utilizan variables tipo contador para sintetizar datos, como los resultados de una encuesta. El
siguiente ejercicio utiliza contadores separados, para tirar dados y rastrear el número de veces que
aparecería cada una de las caras de un dado con seis lados, al tiempo que la aplicación tiraba el dado 6000
veces.
// TirarDado.java
// Tira un dado de seis lados 6000 veces.
import java.util.Random;
public class TirarDado
{
public static void main( String args[] )
{
Random numerosAleatorios = new Random(); // generador de números
aleatorios
int frecuencia[] = new int[ 7 ]; // arreglo de contadores de
frecuencia
// tira el dado 6000 veces; usa el valor del dado como índice de
frecuencia
for ( int tiro = 1; tiro <= 6000; tiro++ )
++frecuencia[ 1 + numerosAleatorios.nextInt( 6 ) ];
System.out.printf( "%s%10s\n", "Cara", "Frecuencia" );
// imprime el valor de cada elemento del arreglo
for ( int cara = 1; cara < frecuencia.length; cara++ )
System.out.printf( "%4d%10d\n", cara, frecuencia[ cara ] );
} // fin de main
} // fin de la clase TirarDado
Instrucción for mejorada.
Para esto la instrucción for itera a través de los elementos en un
arreglo. La sintaxis de una instrucción for mejorada es:
for ( parámetro : nombreArreglo )
instrucción
en donde parámetro tiene dos partes: un tipo y un identificador (por
ejemplo, int numero), y nombreArreglo es el arreglo a través del cual se
iterará. El tipo del parámetro debe concordar con el tipo de elementos de
un arreglo.
// PruebaForMejorado.java
// Uso de la instrucción for mejorada para sumar el total de enteros en
un arreglo.
public class PruebaForMejorado
{
public static void main( String args[] )
{
int arreglo[] = { 87, 68, 94, 100, 83, 78, 85, 91, 76, 87 };
int total = 0;
// suma el valor de cada elemento al total
for ( int numero : arreglo )
total += numero;
System.out.printf( "Total de elementos del arreglo: %d\n", total );
} // fin de main
} // fin de la clase PruebaForMejorado
Paso de arreglos a los métodos
Para pasar un argumento tipo arreglo a un método, se especifica el nombre
del arreglo sin corchetes. Por ejemplo, si el arreglo TemperaturasPorHora
se declara como
double temperaturasPorHora[ ] = new double[ 24 ];
entonces la llamada al método
modificarArreglo( temperaturasPorHora)
pasa
la
referencia
del
arreglo
temperaturasPorHora
al
método
modificarArreglo. Todo objeto arreglo “conoce” su propia longitud ( a
través de su campo length)
Cuando un argumento para un método es todo, o un elemento individual de
un arreglo de un tipo por referencia, el método llamado recibe una copia
de la referencia. Cuando un argumento para un método es un elemento
individual de un arreglo de un tipo primitivo, el método llamado recibe
una copia del valor del elemento. Dichos valores primitivos se conocen
como escalares o cantidades escalares. Para pasar un elemento individual
de un arreglo a un método, se debe usar el nombre indexado del elemento
del arreglo como argumento en la llamada al método.
Paso de arreglos y elementos individuales de un arreglo a los métodos.
// PasoArreglo.java
// paso de arreglos y elementos individuales de un arreglo a los métodos.
public class PasoArreglo
{
// main crea el arreglo y llama a modificarArreglo y a
modificarElemento
public static void main( String args[] )
{
int arreglo[] = { 1, 2, 3, 4, 5 };
System.out.println(
"Efectos de pasar una referencia a un arreglo completo:\n" +
"Los valores del arreglo original son:" );
// imprime los elementos originales del arreglo
for ( int valor : arreglo )
System.out.printf( "
%d", valor );
modificarArreglo( arreglo ); // pasa la referencia al arreglo
System.out.println( "\n\nLos valores del arreglo modificado son:"
);
// imprime los elementos modificados del arreglo
for ( int valor : arreglo )
System.out.printf( "
%d", valor );
System.out.printf(
"\n\nEfectos de pasar el valor de un elemento del arreglo:\n" +
"arreglo[3] antes de modificarElemento: %d\n", arreglo[ 3 ] );
modificarElemento( arreglo[ 3 ] ); // intento por modificar
arreglo[ 3 ]
System.out.printf(
"arreglo[3] despues de modificarElemento: %d\n", arreglo[ 3 ] );
} // fin de main
// multiplica cada elemento de un arreglo por 2
public static void modificarArreglo( int arreglo2[] )
{
for ( int contador = 0; contador < arreglo2.length; contador++ )
arreglo2[ contador ] *= 2;
} // fin del método modificarArreglo
// multiplica el argumento por 2
public static void modificarElemento( int elemento )
{
elemento *= 2;
System.out.printf(
"Valor del elemento en modificarElemento: %d\n", elemento );
} // fin del método modificarElemento
} // fin de la clase PasoArreglo
Almacenar las calificaciones de los estudiantes en un arreglo en la clase LibroCalificaciones
El arreglo de calificaciones se declara como una variable de instancia (7), cada objeto de LibroCalificaciones
mantiene su propio conjunto de calificaciones. El constructor de la clase (10-14) tiene dos parámetros; el
nombre del curso y un arreglos de calificaciones. Cuando una aplicación crea un objetoLibroCalificaciones, la
aplicación pasa un arreglo int existente en el constructor, el cual asigna la referencia del arreglo a la variable
de instancia de calificaciones (13). El tamaño del arreglo calificaciones se determina en base a la clase que
pasa el arreglo al constructor
Por lo tanto, un objeto LibroCalificaciones puede procesar un numero de calificaciones variable.
// LibroCalificaciones.java
// Libro de calificaciones que utiliza un arreglo para almacenar las
calificaciones de una prueba.
public class LibroCalificaciones
{
private String nombreDelCurso; // nombre del curso que representa este
LibroCalificaciones
private int calificaciones[]; // arreglo de calificaciones de
estudiantes
// el constructor de dos argumentos inicializa nombreDelCurso y el
arreglo calificaciones
public LibroCalificaciones( String nombre, int arregloCalif[] )
{
nombreDelCurso = nombre; // inicializa nombreDelCurso
calificaciones = arregloCalif; // almacena las calificaciones
} // fin del constructor de LibroCalificaciones con dos argumentos
// método para establecer el nombre del curso
public void establecerNombreDelCurso( String nombre )
{
nombreDelCurso = nombre; // almacena el nombre del curso
} // fin del método establecerNombreDelCurso
// método para obtener el nombre del curso
public String obtenerNombreDelCurso()
{
return nombreDelCurso;
} // fin del método obtenerNombreDelCurso
// muestra un mensaje de bienvenida al usuario de LibroCalificaciones
public void mostrarMensaje()
{
// obtenerNombreDelCurso obtiene el nombre del curso
System.out.printf( "Bienvenido al libro de calificaciones
para\n%s!\n\n",
obtenerNombreDelCurso() );
} // fin del método mostrarMensaje
// realiza varias operaciones sobre los datos
public void procesarCalificaciones()
{
// imprime el arreglo de calificaciones
imprimirCalificaciones();
// llama al método obtenerPromedio para calcular la calificación
promedio
System.out.printf( "\nEl promedio de la clase es %.2f\n",
obtenerPromedio() );
// llama a los métodos obtenerMinima y obtenerMaxima
System.out.printf( "La calificacion mas baja es %d\nLa calificacion
mas alta es %d\n\n",
obtenerMinima(), obtenerMaxima() );
// llama a imprimirGraficoBarras para imprimir el gráfico de
distribución de calificaciones
imprimirGraficoBarras();
} // fin del método procesarCalificaciones
// busca la calificación más baja
public int obtenerMinima()
{
int califBaja = calificaciones[ 0 ]; // asume que calificaciones[ 0
] es la más baja
// itera a través del arreglo de calificaciones
for ( int calificacion : calificaciones )
{
// si calificación es menor que califBaja, se asigna a califBaja
if ( calificacion < califBaja )
califBaja = calificacion; // nueva calificación más baja
} // fin de for
return califBaja; // devuelve la calificación más baja
} // fin del método obtenerMinima
// busca la calificación más alta
public int obtenerMaxima()
{
int califAlta = calificaciones[ 0 ]; // asume que calificaciones[ 0
] es la más alta
// itera a través del arreglo de calificaciones
for ( int calificacion : calificaciones )
{
// si calificacion es mayor que califAlta, se asigna a califAlta
if ( calificacion > califAlta )
califAlta = calificacion; // nueva calificación más alta
} // fin de for
return califAlta; // devuelve la calificación más alta
} // fin del método obtenerMaxima
// determina la calificación promedio de la prueba
public double obtenerPromedio()
{
int total = 0; // inicializa el total
// suma las calificaciones para un estudiante
for ( int calificacion : calificaciones )
total += calificacion;
// devuelve el promedio de las calificaciones
return (double) total / calificaciones.length;
} // fin del método obtenerPromedio
// imprime grafico de barras que muestra la distribución de las
calificaciones
public void imprimirGraficoBarras()
{
System.out.println( "Distribucion de calificaciones:" );
// almacena la frecuencia de las calificaciones en cada rango de 10
calificaciones
int frecuencia[] = new int[ 11 ];
// para cada calificación, incrementa la frecuencia apropiada
for ( int calificacion : calificaciones )
++frecuencia[ calificacion / 10 ];
// para cada frecuencia de calificación, imprime una barra en el
gráfico
for ( int cuenta = 0; cuenta < frecuencia.length; cuenta++ )
{
// imprime etiquetas de las barras ( "00-09: ", ..., "90-99: ",
"100: " )
if ( cuenta == 10 )
System.out.printf( "%5d: ", 100 );
else
System.out.printf( "%02d-%02d: ",
cuenta * 10, cuenta * 10 + 9 );
// imprime barra de asteriscos
for ( int estrellas = 0; estrellas < frecuencia[ cuenta ];
estrellas++ )
System.out.print( "*" );
System.out.println(); // inicia una nueva línea de salida
} // fin de for externo
} // fin del método imprimirGraficoBarras
// imprime el contenido del arreglo de calificaciones
public void imprimirCalificaciones()
{
System.out.println( "Las calificaciones son:\n" );
// imprime la calificación de cada estudiante
for ( int estudiante = 0; estudiante < calificaciones.length;
estudiante++ )
System.out.printf( "Estudiante %2d: %3d\n",
estudiante + 1, calificaciones[ estudiante ] );
} // fin del método imprimirCalificaciones
} // fin de la clase LibroCalificaciones
La clase PruebaLibroCalificaciones para demostrar la clase libroCalificaciones
// LibroCalificaciones.java
// Libro de calificaciones que utiliza un arreglo para almacenar las
calificaciones de una prueba.
public class LibroCalificaciones
{
private String nombreDelCurso; // nombre del curso que representa este
LibroCalificaciones
private int calificaciones[]; // arreglo de calificaciones de
estudiantes
// el constructor de dos argumentos inicializa nombreDelCurso y el
arreglo calificaciones
public LibroCalificaciones( String nombre, int arregloCalif[] )
{
nombreDelCurso = nombre; // inicializa nombreDelCurso
calificaciones = arregloCalif; // almacena las calificaciones
} // fin del constructor de LibroCalificaciones con dos argumentos
// método para establecer el nombre del curso
public void establecerNombreDelCurso( String nombre )
{
nombreDelCurso = nombre; // almacena el nombre del curso
} // fin del método establecerNombreDelCurso
// método para obtener el nombre del curso
public String obtenerNombreDelCurso()
{
return nombreDelCurso;
} // fin del método obtenerNombreDelCurso
// muestra un mensaje de bienvenida al usuario de LibroCalificaciones
public void mostrarMensaje()
{
// obtenerNombreDelCurso obtiene el nombre del curso
System.out.printf( "Bienvenido al libro de calificaciones
para\n%s!\n\n",
obtenerNombreDelCurso() );
} // fin del método mostrarMensaje
// realiza varias operaciones sobre los datos
public void procesarCalificaciones()
{
// imprime el arreglo de calificaciones
imprimirCalificaciones();
// llama al método obtenerPromedio para calcular la calificación
promedio
System.out.printf( "\nEl promedio de la clase es %.2f\n",
obtenerPromedio() );
// llama a los métodos obtenerMinima y obtenerMaxima
System.out.printf( "La calificacion mas baja es %d\nLa calificacion
mas alta es %d\n\n",
obtenerMinima(), obtenerMaxima() );
// llama a imprimirGraficoBarras para imprimir el gráfico de
distribución de calificaciones
imprimirGraficoBarras();
} // fin del método procesarCalificaciones
// busca la calificación más baja
public int obtenerMinima()
{
int califBaja = calificaciones[ 0 ]; // asume que calificaciones[ 0
] es la más baja
// itera a través del arreglo de calificaciones
for ( int calificacion : calificaciones )
{
// si calificación es menor que califBaja, se asigna a califBaja
if ( calificacion < califBaja )
califBaja = calificacion; // nueva calificación más baja
} // fin de for
return califBaja; // devuelve la calificación más baja
} // fin del método obtenerMinima
// busca la calificación más alta
public int obtenerMaxima()
{
int califAlta = calificaciones[ 0 ]; // asume que calificaciones[ 0
] es la más alta
// itera a través del arreglo de calificaciones
for ( int calificacion : calificaciones )
{
// si calificacion es mayor que califAlta, se asigna a califAlta
if ( calificacion > califAlta )
califAlta = calificacion; // nueva calificación más alta
} // fin de for
return califAlta; // devuelve la calificación más alta
} // fin del método obtenerMaxima
// determina la calificación promedio de la prueba
public double obtenerPromedio()
{
int total = 0; // inicializa el total
// suma las calificaciones para un estudiante
for ( int calificacion : calificaciones )
total += calificacion;
// devuelve el promedio de las calificaciones
return (double) total / calificaciones.length;
} // fin del método obtenerPromedio
// imprime grafico de barras que muestra la distribución de las
calificaciones
public void imprimirGraficoBarras()
{
System.out.println( "Distribucion de calificaciones:" );
// almacena la frecuencia de las calificaciones en cada rango de 10
calificaciones
int frecuencia[] = new int[ 11 ];
// para cada calificación, incrementa la frecuencia apropiada
for ( int calificacion : calificaciones )
++frecuencia[ calificacion / 10 ];
// para cada frecuencia de calificación, imprime una barra en el
gráfico
for ( int cuenta = 0; cuenta < frecuencia.length; cuenta++ )
{
// imprime etiquetas de las barras ( "00-09: ", ..., "90-99: ",
"100: " )
if ( cuenta == 10 )
System.out.printf( "%5d: ", 100 );
else
System.out.printf( "%02d-%02d: ",
cuenta * 10, cuenta * 10 + 9 );
// imprime barra de asteriscos
for ( int estrellas = 0; estrellas < frecuencia[ cuenta ];
estrellas++ )
System.out.print( "*" );
System.out.println(); // inicia una nueva línea de salida
} // fin de for externo
} // fin del método imprimirGraficoBarras
// imprime el contenido del arreglo de calificaciones
public void imprimirCalificaciones()
{
System.out.println( "Las calificaciones son:\n" );
// imprime la calificación de cada estudiante
for ( int estudiante = 0; estudiante < calificaciones.length;
estudiante++ )
System.out.printf( "Estudiante %2d: %3d\n",
estudiante + 1, calificaciones[ estudiante ] );
} // fin del método imprimirCalificaciones
} // fin de la clase LibroCalificaciones
La clase PruebaLibroCalificaciones para demostrar la clase LibroCalificaciones
// Fig. 7.15: PruebaLibroCalificaciones.java
// Crea objeto LibroCalificaciones, usando un arreglo de calificaciones.
public class PruebaLibroCalificaciones
{
// el método main comienza la ejecución del programa
public static void main( String args[] )
{
// arreglo unidimensional de calificaciones de estudiantes
int arregloCalif[] = { 87, 68, 94, 100, 83, 78, 85, 91, 76, 87 };
LibroCalificaciones miLibroCalificaciones = new
LibroCalificaciones(
"CS101 Introduccion a la programacion en Java", arregloCalif );
miLibroCalificaciones.mostrarMensaje();
miLibroCalificaciones.procesarCalificaciones();
} // fin de main
} // fin de la clase PruebaLibroCalificaciones