Fundamentos de
Programación 2
Ing. Marco Aedo López
Arreglos (Arrays) y ArrayList
Capítulo 1
9. Arreglos de Objetos
Ejercicio: crear un arreglo de n Personas,
almacenando datos que ingresemos para cada una.
Luego que los muestre
9. Arreglos de Objetos
9. Arreglos de Objetos
Ejercicio: mostrar al amigo más joven y al mayor de
todos
int minIdx = 0; //index to the youngest person
int maxIdx = 0; //index to the oldest person
for (int i = 1; i < misAmigos.length; i++)
if ( misAmigos[i].getAge() < misAmigos[minIdx].getAge() )
minIdx = i; //found a younger person
else if (misAmigos[i].getAge() > misAmigos[maxIdx].getAge() )
maxIdx = i; //found an older person
//misAmigos[minIdx] is the youngest and misAmigos[maxIdx] is the
oldest
9. Arreglos de Objetos
Ejercicio: crear un arreglo con capacidad máxima
de n Personas, almacenando datos que vayamos
ingresando, hasta que ya no querramos ingresar
más. Luego que los muestre
9. Arreglos de Objetos
Ejercicio: búsqueda y eliminación
10. Arreglos llenados parcialmente
Usamos parte de los elementos del arreglo, pero no
todos
Sería necesario llevar el rastro del número de
elementos llenados en el arreglo, de tal manera que
se procesarían sólo ellos, no todos los elementos del
arreglo
La variable elementosIngresados hace el
seguimiento de la cantidad de elementos ingresados
que tiene el arreglo
11. Copiando un arreglo
Recordar: como con todos los objetos y sus variables
de referencia, si asignamos una variable de referencia
de un arreglo a otra variable de referencia de otro
arreglo, ambas variables de referencia apuntarán al
mismo objeto arreglo
Si nuestra meta es hacer una copia de un arreglo
arr1, ¿cuál sería el problema?
arr2 = arr1;
11. Copiando un arreglo
Usualmente desearíamos que el original y la
copia del arreglo apunten a diferentes objetos
de arreglo
Hacerlo asignando los elementos, uno a uno
EJERCICIO
Tiene un arreglo con 6 precios que maneja la tienda en
Enero, se quiere un nuevo arreglo para Febrero con los
mismos valores de Enero, pero cambiando el segundo
valor a 10.99
Salida:
Ene Feb
1.29 1.29
9.99 10.99
22.00 22.00
4.55 4.55
7.35 7.35
6.49 6.49
11. Copiando un arreglo
11. Copiando un arreglo
Copiar datos de un arreglo a otro es una tarea común,
así Java nos brinda un método especial
System.arraycopy
Permite copiar un número de elementos desde cualquier
lugar en un arreglo a cualquier lugar en otro arreglo
System.arraycopy(preciosEnero,0,preciosFebrero,0,6);
preciosFebrero[1]=10.99;
Argumentos:
Nombre arreglo origen
Índice del primer elemento del origen a copiar
Nombre del arreglo de destino
Índice del primer elemento a reemplazar en el destino
Número total de elementos a copiar
12. Histogramas
Gráfico que muestra cantidades para un conjunto de
categorías. Muestra con barras, de mayor o menor
tamaño
12. Histogramas
Problema:
Suponga que tiene 3 monedas, al lanzar las 3 monedas una
cantidad de veces Ud. desea saber cuántas veces salió 0
caras, 1 caras, 2 caras y 3 caras. En otras palabras desea
saber la probabilidad (distribución de frecuencia) para el
número de caras
Solución:
Escribir un main() que simula el lanzamiento de 3 monedas
un millón de veces
Imprimir los resultados de la simulación en forma de
histograma:
Para cada posible caso (4 posibles), imprime una barra que
represente el número de veces que el caso ocurra
Para simular una barra, usar serie de *, donde cada uno
represente un 1% del número total de lanzamientos
12. Histogramas
Salida:
Número de veces que cada caso ocurría (0, 1, 2, 3 caras):
0 124685 ************
1 374759 *************************************
2 375420 **************************************
3 125136 *************
Tips para la implementación:
Usar un arreglo frequencia para mantener el seguimiento
del número de veces que cada valor de cuenta de caras
ocurre. La frecuencia[0] tiene el número de veces en que
ninguna de las 3 salió cara. La frecuencia[1] tiene el número
de veces en que salió 1 cara, etc.
Después de cada lanzamiento simulado, añadir 1 al elemento
apropiado
Histograms
public class Fundamentos2 {
public static void main(String[] args)
{
final int NUM_OF_COINS = 3; // numero de monedas a lanzar
final int NUM_OF_REPS = 1000000; // numero de lanzamientos o repeticiones
int[] frequency; //almacena la frecuencia
int heads; // numero de caras en el actual lanzamiento
float fractionOfReps; // numero de veces que una cantidad de caras salio, dividido por
el total de lanzamientos
int numOfAsterisks; // numero de asteriscos a considerar para cada caso
frequency = new int[NUM_OF_COINS + 1]; //4 casos
for (int rep=0; rep<NUM_OF_REPS; rep++)
{
heads = 0;
for (int i=0; i<NUM_OF_COINS; i++)
heads += (int) (Math.random() * 2); //1 es cara
frequency[heads]++; // actualiza la cuenta
}
System.out.println("Numero de veces en que cada contador de caras salio:");
for (heads=0; heads<=NUM_OF_COINS; heads++)
{
System.out.print(" " + heads + " " + frequency[heads] + " ");
fractionOfReps = (float) frequency[heads] / NUM_OF_REPS;
numOfAsterisks = Math.round(fractionOfReps * 100); //el número de * a representar
for (int i=0; i<numOfAsterisks; i++)
System.out.print("*");
System.out.println();
}
}
}
EJERCICIO
Ud. tiene el arreglo horas con la cantidad de horas que
debe trabajar desde hoy hasta dentro de 30 días. Este
arreglo debe actualizarse al día siguiente, desplazando
todas las cantidad de horas en 1 día hacia adelante, e
ingresando la cantidad de horas a trabajar en el día 30.
Ingresar la cantidad de días que desea que pasen y
simular cómo se va actualizando el arreglo horas día a
día
EJERCICIO
Tenemos el índice Dow Jones de la Bolsa de Valores de
New York para los últimos 4 días [9400, 9500, 9600, 9700]
(desde hace 4 días hasta ayer)
Al final de cada día, a partir de hoy, queremos saber el
promedio de los últimos 4 días incluyendo hoy
El programa pide ingresar la cantidad de días a evaluar y
nos irá mostrando el promedio día a día
Ingrese numero de dias: 4
Ingrese el nuevo valor: 9800
El promedio es 9650
Ingrese el nuevo valor: 9800
El promedio es 9725
Ingrese el nuevo valor: 9700
El promedio es 9750
Ingrese el nuevo valor: 9600
El promedio es 9725
13. Paso de arreglos a métodos
Los métodos también pueden aceptar argumentos de
tipo arreglo
Siempre lo hace por valor, pero no se pasa toda una
copia del arreglo
Se pasa una copia de la dirección del arreglo o
referencia al arreglo (con esa dirección se puede
alterar los valores del arreglo)
13. Paso de arreglos a métodos
Code A public int buscaMinimo(double[] number))
{
double[] arrayUno=new double[20];
…
minimo = buscaMinimo(arrayUno);
En A antes de buscaMinimo
arrayUno
A. Variable local
number no existe
antes de la ejecucion
del método
State of
Memory
13. Paso de arreglos a métodos
Code public int buscaMinimo(double[] number))
{
double[] arrayUno=new double[20]; B
minimo = buscaMinimo(arrayUno); …
La direccion se copia en B
arrayUno number
B. El valor del
argumento, que es una
direccion, es copiado en
el parametro
State of
Memory
13. Paso de arreglos a métodos
Code public int buscaMinimo(double[] number))
{
double[] arrayUno=new double[20];
…
minimo = buscaMinimo(arrayUno);
C
}
Mientras en C dentro del método
arrayUno number C. El arreglo es
accedido via
number dentro
del metodo.
State of
Memory
13. Paso de arreglos a métodos
Code public int buscaMinimo(double[] number))
{
double[] arrayUno=new double[20];
…
minimo = buscaMinimo(arrayUno);
D }
En D después de buscaMinimo
arrayUno D. El parametro
number es borrado. El
argumento arrayUno
aún apunta al mismo
objeto
State of
Memory
13. Paso de arreglos a métodos
13. Paso de arreglos a métodos
13. Paso de arreglos a métodos
PROBLEMA:
Método que me devuelva la suma de todos los
elementos de un arreglo
13. Paso de arreglos a métodos
13. Paso de arreglos a métodos
PROBLEMA:
Sumar 2 arreglos unidimensionales de tamaño 10 con
valores de notas enteras que vayan entre 0..20 y
almacenarlos en un nuevo arreglo. Luego que imprima los
valores de la suma con el formato:
“x + y = z”
Crear métodos:
1) generar genera los valores aleatorios de los 2 arreglos
2) sumar calcula la suma de los 2 arreglos
3) imprimir imprime con el formato indicado
13. Paso de arreglos a métodos
PROBLEMA:
Crear métodos ingresar(), modificar(), imprimir(),
que permitan ingresar los n enteros de un arreglo,
modificar multiplicando por 2 sus elementos e
imprimir sus elementos. Los métodos deben
permitir trabajar con arreglos unidimensionales de
cualquier tamaño. Crear un main() que pruebe
dichos métodos
4. Paso de arreglos a métodos
14. Buscando en un arreglo
Es frecuente la necesidad de determinar si un arreglo
contiene un valor en particular
Cuando mantenemos una colección de datos, una de
las operaciones que necesitaremos es un método de
búsqueda para localizar un elemento
Este es el planteamiento del problema:
Dado un valor x, devolver el índice de x en el arreglo,
si tal x existe. Caso contrario, retornar -1
(NO_ENCONTRADO). Asumimos que no existen
elementos duplicados en el arreglo
14. Buscando en un arreglo
Primera aproximación: Búsqueda Lineal (de inicio a fin)
numeros
0 1 2 3 4 5 6 7 8
23 17 5 90 12 44 38 84 77
Busqueda fallida: busqueda( 45 ) -1 (NO_ENCONTRADO)
Busqueda exitosa: busqueda( 12 ) 4
14. Buscando en un arreglo
Pseudocódigo Búsqueda Lineal:
busquedaLineal(lista[], valor)
para i desde 0 hasta lista.longitud-1 inc 1
si lista[i]==valor
retornar i
finSi
finCiclo
retornar -1
FIN
Implementar el método en Java
14. Buscando en un arreglo
Otra implementación de Búsqueda Lineal:
public int busquedaLineal ( int[] numeros, int valorBuscado )
{
int loc = 0;
while (loc < numeros.length && numeros[loc] != valorBuscado)
loc++;
if (loc == numeros.length) // No encontrado
return -1;
else
return loc; // Encontrado, retorna la posicion
}
Consideración de Diseño:
Cohesion
Note que el método busquedaLineal no muestra el
valor encontrado en el arreglo. Tampoco muestra un
mensaje si es que se encontró o no
En vez de eso, devuelve la posición en donde se
encontró el elemento ó -1 si es que no fue encontrado
Esto sigue el principio de cohesion - un método sólo
debe realizar una sola tarea. En este caso, debe dejarse
a quién llamo al método si algún mensaje debe ser
devuelto
14. Buscando en un arreglo
Problema:
Crear un programa que indique si se encontró o no
un id en un arreglo de ids, también que muestre en
qué posición logró encontrarlo
Escribir un método encontrarEstudiante que
busca un id dentro de un arreglo de ids
El método encontrarEstudiante debería recibir
el arreglo estudiantesIds y un id como
parámetros y retornar el valor del índice donde
encuentre el id dentro del arreglo
Si el id no se encontró, retornar -1
11. Buscando en un arreglo
14. Buscando en un arreglo
Problema:
¿En un arreglo ordenado?
Arreglos (Arrays) y ArrayList
Gracias
