Calificaciones de Alumnos, usando Arreglos

¡Hola! Ya hace mucho que no se ve actividad por aquí, así que decidí postear un programa algo interesante sobre lo que se puede hacer teniendo dos arreglos -uno de números y otro de letras-; Ahora vamos a jugar con los arreglos, vamos a tratar de manejarlos con más precisión; Anteriormente creábamos nuestro arreglos y nosotros mismos como programadores especificábamos el tamaño del arreglo, sin darle oportunidad al usuario de que el diera el tamaño de este, en este programa le preguntaremos al usuario de que tamaño desea su arreglo y crearemos el arreglo del tamo indicado. El programa almacenara el nombre de n cantidad de Alumnos y sus calificaciones y posteriormente los imprimirá en pantalla; para esto usaremos 2 arreglos: uno de tipo String que almacenara los nombres y otro de tipo int o double que guardara las calificaciones, habiendo explicado esto ¡Hagamos código!.

//Archivo: ArregloNombres.java

import javax.swing.JOptionPane;

public class ArregloNombres {

   public static void main(String args[]){
        
      //Pedir tamaño del Arreglo al usuario:
      int tamaño=Integer.parseInt(JOptionPane.showInputDialog
                ("¿De que tamaño desea su Arreglo?"));
        
      //Crear y establecer tamaño de los Arreglos:
      String nombres[] = new String[tamaño];
      int calific[] = new int[tamaño];
        
      //Insertar nombres de alumnos al Arreglo String:
      for(int contador=0; contador < nombres.length; contador++)
            nombres[contador]=JOptionPane.showInputDialog
                    ("Nombre?");
        
      //Insertar calificaciones de cada alumno al Arreglo int:
      for(int contador=0; contador < calific.length; contador++)
            calific[contador]=Integer.parseInt
                    (JOptionPane.showInputDialog
                    ("Cual es la calificacione de "
                    +nombres[contador]+"?"));
        
      //Mostrar alumno y su calificacion en pantalla:
      System.out.println("Nombre\tCalificacion");
      for(int contador=0; contador < nombres.length; contador++)
            System.out.println(nombres[contador]+"\t"
                    +calific[contador]);
    }
}

Analicemos el código. Declaramos int tamaño en la linea 10 para que ahí se guarde el tamaño que especifique el usuario cuando mediante una ventana de JOptionPane le preguntemos "¿De que tamaño desea su Arreglo?", cuando el usuario introduzca un numero para indicar el tamaño del arreglo, en realidad estará especificando cuantos alumnos desea almacenar (por por consecuencia, también cuantas calificaciones). Suponga que el usuario introdujo el numero 3.

Arreglos, una perspectiva Orientada a Objetos

Ahora estudiemos los Arreglos en Java con una visión más orientada a objetos, los arreglos son objetos, por lo que se consideran como tipos de referencia. Para declarar y crear un  objeto arreglo, y asignarle valores se hace de la siguiente manera:

int numeros[];

numeros = new int[5];

o en una sola linea:

int numeros[] = new int[5];

donde int numeros es el tipo de datos y el nombre del arreglo, la asiganacion new int nos indica que se esta creando un objeto arreglo de tipo int de tamaño 5 (para 5 elementos). Una vez creado nuestro objeto arreglo solo hace falta asignarle valores a sus indices, cuando los indices tengan valores ya podremos realizar operaciones con el arreglo de igual manera como lo hemos hecho en post anteriores.

//Archivo: OArreglos.java

public class OArreglos{
 
 public static void main(String args[]){
  
  //CREACION DEL ARREGLO
  int numeros[] = new int[5];
  
  //INSERTAR DATOS AL ARREGLO
  numeros[0]=10;
  numeros[1]=20;
  numeros[2]=30;
  numeros[3]=40;
  numeros[4]=50;
  
  //IMPRIMIR ELEMENTOS DEL ARREGLO
  System.out.println("Indice\tValor");
  for(int contador=0; contador < numeros.length; contador++)
   System.out.println(contador+"\t"+numeros[contador]);
  
  //SUMAR ELEMENTOS DEL ARREGLO
  System.out.println();
  int suma;
  suma=numeros[0]+numeros[1]+numeros[2]+numeros[3]+numeros[4];
  System.out.println("La suma del arreglo es: "+suma);
 }
}

Suma de los elementos de un Arreglo

Ahora haremos un programa que sume los elementos de un arreglo, es muy sencillo, a continuación el código:

//Archivo: SumaArreglo.java public class SumaArreglo{               public static void main(String args[]){                           int numeros[] = {10, 20, 30, 40, 50};                           //BLOQUE 1: Mostrar elementos del arreglo:              System.out.println("Indice\tValor");              for(int contador=0; contador<numeros.length; contador++)                     System.out.println(contador+"\t"+numeros[contador]);                                  //BLOQUE 2: Sumar los elementos del arreglo:              System.out.println();              int suma=0;              for(int contador=0; contador<numeros.length; contador++)                     suma+=numeros[contador];                                  System.out.println("La suma de los elementos del arreglo es\n"+suma);        } }

Este programa tambien lo "dividi" en dos bloques, en el primer bloque se muestran los elementos del arreglo tal cual los insertamos. En el segundo bloque es donde realizamos la suma de todos los elementos insertados en el arreglo, y se hizo del modo siguiente: primero imprimimos una linea en blanco (esto para separar lo que se imprimió primero, los elementos del arreglo). Ahora declaramos int suma y la inicializamos en 0, esto para que en esa variable se vaya guardando más adelante la suma de nuestro elementos. Ahora hacemos un for que recorra nuestro arreglo (como el primer for), hacemos un contador y lo inicializamos en 0, después le damos la condición de que itere mientras contador sea menor al tamaño de nuestro arreglo (numeros.length) y hacemos un incremento en contador. Ahora en el cuerpo del for, solo vamos sumando los elementos del arreglo, en esa linea se indica que a suma se le va a asignar lo que resulte de sumar lo que contiene la variable suma más lo que contiene el arreglo numeros en la posición contador.

Por ejemplo: en la primera vuelta del for, contador vale 0, por tanto nuestro arreglo numeros en la posicion contador es numeros[contador] que es igual a numeros[0] (arreglo numeros en la posicion 0) y el elemento en la posicion 0 de nuestro arreglo tiene el valor de 10, como se indica en la siguiente tabla:

Imprimir un Arreglo de manera Inversa

Hace unos dias (como 10 o mas dias para ser precisos) un lector preguntaba como invertir un arreglo sin utilizar otro arreglo, es muy sencillo, para mostrar eso solo hace falta imprimir el arreglo ya creado de forma inversa con el for:

//Archivo: InvertirArreglo.java public class InvertirArreglo{               public static void main(String args[]){                           int numeros[] = {10, 20, 30, 40, 50};                            //Bloque 1: Impresion de nuestro arreglo.              System.out.println("Indice\tValor");              for(int contador=0; contador<numeros.length; contador++)                     System.out.println(contador+"\t"+numeros[contador]);                            //Bloque 2: Impresión invertida del arreglo.              System.out.println();              System.out.println("Indice\tValor");              for(int contador=numeros.length-1; contador>=0; contador--)                     System.out.println(contador+"\t"+numeros[contador]);        } }

Se declara int numeros[] y se le asignan valores de 10, 20, 30, 40 y 50. En el bloque 1 se imprime nuestro arreglo de manera normal, ordenado en el orden en que fuimos insertando los elementos en el arreglo.

En el bloque 2 se imprimen los elementos de nuestro arreglo de forma inversa a como los fuimos insertando (de atrás hacia adelante). Para esto usamos un for indicando que nuestro contador empezara a contar desde  lo que retorne la función numeros.length (que retorna el tamaño de nuestro arreglo, en este caso: 5) menos 1, osea empezara a contar desde 4, que es el ultimo indice de nuestro arreglo numeros[], y le damos de condición de que pare de iterar hasta que contador llegue a 0 y en esta ocasión hacemos decremento de nuestro contador (así irá recorriendo nuestro arreglo de atrás para adelante: 4, 3, 2, 1 y 0 que son los indices de nuestro arreglo). Y finalmente en el cuerpo del for le indicamos que vaya imprimiendo cada linea, cada indice de nuestro arreglo con su respectivo valor.