1. Operaciones con Arreglos
Utilizar un arreglo para hacer operaciones con el, en la mayoría de las veces implica el uso de
la instrucción for, pues para poder tomar o actualizar cada elemento del arreglo, es necesario
utilizar índice, y es por esto que el for es la instrucción ideal.
Por ejemplo como lo vimos en el tema pasado, para inicializar un arreglo ya una vez definido
podemos utilizar
int arreglo[] = new int [10];
for (int i=0; i<10; i++) {
arreglo [i] = i;
}
Pero también podemos utilizar la variable length, la cual es definida para todo arreglo en
Java, y esta representa el número máximo de posiciones en el arreglo, es decir para el
ejemplo anterior quedaría como:
int arreglo[] = new int [10];
for (int i=0; i < arreglo.length; i++) {
arreglo [i] = i;
}
Al hacer operaciones con arreglos es muy común que utilicemos también una constante para
definir el máximo valor a utilizar en el arreglo, es decir para el ejemplo anterior quedaría
como:
int final MAX = 10;
int arreglo[] = new int [MAX];
for (int i=0; i < MAX; i++) {
arreglo [i] = i;
}
Donde MAX es una constante (definida así al usar la cláusula final) que valdrá 10 durante la
ejecución del método, clase o parte donde se encuentre definida.
Sacando el mayor de un arreglo
Cuando deseamos obtener el valor mayor de todos los valores definidos en un arreglo,
debemos recorrer todo el arreglo y utilizar una variable que nos ayude en esta comparación.
La mejor manera de inicializar esta variable es utilizar el primer valor del arreglo, por
III. Desarrollo de aplicaciones con manejo
de datos en la memoria

2. ejemplo:
int mayor = arreglo[0]; // se toma el primer valor como el mayor
// se revisa cada elemento en el arreglo empezando por el segundo
for (int i=1; i < arreglo.length; i++) {
// si el elemento del arreglo es mayor
if (arreglo[i] > mayor) {
mayor = arreglo[i]; // cambiamos el valor del mayor
}
}
System.out.println(“El valor mayor es “ + mayor);
Tomando el índice en el que se encuentra
Para hacer esto definimos otra variable, la cual debe empezar con 1 y si el valor del arreglo
es mayor, además de hacer el cambio de mayor, actualizamos la posición de donde se
encontró el mayor, el ejemplo quedaría como:
int posición = 0;
int mayor = arreglo[0]; // se toma el primer valor como el mayor
// se revisa cada elemento en el arreglo desde el segundo
for (int i=1; i < arreglo.length; i++) {
// si el elemento del arreglo es mayor
if (arreglo[i] > mayor) {
mayor = arreglo[i]; // cambiamos el valor del mayor
posicion = i; // se actualiza la posicion
}
}
System.out.println(“El valor mayor es “ + mayor);
System.out.println(“Y esta en la posicion “ + (posición+1));
Si queremos saber en que posición se encontró el mayor valor, entonces debemos utilizar un
índice, el cual empieza en 0 (si es que tomamos como referencia inicial el primer valor) y
después al detectar que el valor del arreglo es mayor, se hace el cambio con mayor y se
actualiza la posición, al desplegar la posición le añadimos uno mas, ya que empieza desde
cero.
Sacando el menor de un arreglo y su posición
Para obtener el valor menor, solo se cambia la comparación y en lugar de comparar contra
mayor, solo se compara contra menor, el ejemplo lo vemos como sigue:
int posición = 0;
int menor = arreglo[0]; // se toma el primer valor como el menor
// se revisa cada elemento en el arreglo desde el segundo
for (int i=1; i < arreglo.length; i++) {
// si el elemento del arreglo es menor
if (arreglo[i] < menor) {
menor = arreglo[i]; // cambiamos el valor del menor

3. posicion = i; // se actualiza la posicion
}
}
System.out.println(“El valor menor es “ + menor);
System.out.println(“Y esta en la posicion “ + posicion);
Obteniendo el promedio del arreglo
Para obtener el promedio de un arreglo, se debe de sumar los elementos y dividir entre
cuantos sean, el ejemplo lo vemos como sigue:
double promedio;
double suma = 0; // se inicializa la suma en cero
// se tomara cada elemento para sumarlo
for (int i=0; i < arreglo.length; i++) {
suma += arreglo[i];
}
promedio = suma / arreglo.length;
System.out.println(“El promedio es “ + promedio);
A continuación se presenta una aplicación que utiliza todos estos conceptos para su
visualización:
public class AplicacionArreglo2 {
private static final int MAX = 10;
public static void main(String[] args) {
// se define el arreglo a utilizar
int arreglo[] = {12, 75, -5, 99, 124, 8, -45, 12, 25, 0};
int posicion; // para las posiciones
int mayor, menor; // para el mayor y el menor
double promedio; // para obtener el promedio
int suma = 0; // se inicializa la suma en cero
// se despliegan los valores
for (int i=0; i < arreglo.length; i++) {
System.out.println("Elemento " + (i+1) + " = " + arreglo[i]);
}
mayor = arreglo[0]; // se toma el primer valor como el mayor
posicion = 0; // para definir mayor en la posicion primera
// se revisa cada elemento en el arreglo desde el segundo
for (int i=1; i < arreglo.length; i++) {
// si el elemento del arreglo es mayor
if (arreglo[i] > mayor) {
mayor = arreglo[i]; // cambiamos el valor del mayor
posicion = i; // se actualiza la posicion
}
}
System.out.println("El valor mayor es " + mayor);
System.out.println("Y esta en la posicion " + (posicion + 1));
menor = arreglo[0]; // se toma el primer valor como el mayor

4. posicion = 0; // para definir menor como el primer valor
// se revisa cada elemento en el arreglo desde el segundo
for (int i=1; i < arreglo.length; i++) {
// si el elemento del arreglo es mayor
if (arreglo[i] < menor) {
menor = arreglo[i]; // cambiamos el valor del mayor
posicion = i; // se actualiza la posicion
}
}
System.out.println("El valor menor es " + menor);
System.out.println("Y esta en la posicion " + (posicion+1));
// se tomara cada elemento para sumarlo
for (int i=0; i < arreglo.length; i++) {
suma += arreglo[i];
}
promedio = suma / arreglo.length;
System.out.println("El promedio es " + promedio);
}
}
En la aplicación hay varias cosas que debemos tomar en cuenta, primero, es posible definir
un arreglo con sus valores iniciales, como se muestra en la instrucción:
int arreglo[] = {12, 75, -5, 99, 124, 8, -45, 12, 25, 0};
Aquí solo se define que es un arreglo de enteros y entre corchetes se definen cuantos enteros
tendrá, esto es como haber dicho arreglo = new int[10]; y después dar los valores.
Por otra parte en el println que definimos para escribir la posición, estamos utilizando
System.out.println("Y esta en la posición " + (posicion+1));
Donde posición + 1 está entre paréntesis.
Primero que nada utilizamos posición + 1, ya que en Java (igual que C++) los arreglos
empiezan desde cero y si por ejemplo dice que es la posición 3 internamente en el arreglo
esta en el índice 2, donde cero es el primero.
Utilizamos paréntesis ya que el + en el println funciona como concatenación y si no le
ponemos paréntesis le añadirá el 1 al numero, es decir en lugar de desplegar 3, desplegará
21, ya que al 2 (que es la i) le concatena el 1.