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.

Días y Meses (For anidados)

¡Buenas tardes lectores! Acá mi profesor de Física 2 de mi ingeniería me trae algo atareado con algunas ejercicios de electromagnetismo, pero a petición de un lector escribo este breve post para aclarar un poco más el tema de los for anidados.

Como ya habíamos mencionado los for anidados no son más que un (o más) for dentro de otro for, y para explicarlo mejor escribí un pequeño programa que imprime el numero de meses de un año y en cada mes imprime el numero de los días del mes. Aquí el código:

//Archivo: ForAnidados.java

public class ForAnidados{
    
    public static void main(String args[]){
        
        for(int mes=1; mes<=12; mes++){
            System.out.println("Mes "+mes);
            
            for(int dia=1; dia<=30; dia++)
                System.out.println("\tDia "+dia);
        }
    }
}

Para este programa usamos 2 for, anidados. Hacemos nuestro main, y en la linea 7 hacemos un for que se encargara de la impresión de los meses, en la linea 10 anidamos otro for que se encargara de la impresión de los días.

En el primer for declaramos nuestra variable int mes que sera nuestro contador para ese for, y le establecemos la condición de que debe iterar mientras mes valga menos o igual a 12 (ya que son 12 los meses del año) y después le indicamos que nuestra variable mes debe incrementar en uno (++).

Cuando se entra al primer for, mes vale 1 e imprime el mensaje "Mes 1", después de imprimir ese mensaje en la linea 8 se pasa a la linea 10 donde se declara el segundo for, para este declaramos int dia (esta variable sera nuestro contador para este for) y le establecemos la condición de que siga iterando mientras dia sea menor o igual a 30 (ya que son los días que contiene un mes, le puse 30 por dafault, pero recuerde que hay meses que contienen mas o menos de 30 días) y después le damos un incremento a nuestra variable día. Después en la linea 11, imprimimos un mensaje en pantalla "Dia" y se le concatena lo que contenga nuestra variable día.

Tabular función: f(x) = x+1

No se espanten, esto será muy sencillo, le pediremos al usuario que introduzca un limite inferior y un limite superior, y dados estos limites haremos un programa que tabule la función f(x)=x+1 verán que fácil es:

//Archivo: Funcion.java

import javax.swing.JOptionPane;

public class Funcion{

 public static void main(String args[]){
 
  String valor=JOptionPane.showInputDialog("Limite inferior");
  int inferior=Integer.parseInt(valor);
  valor=JOptionPane.showInputDialog("Limite superior");
  int superior=Integer.parseInt(valor);
  int contador;
  
  for(contador=inferior ; contador>=inferior&&contador<=superior ; contador++)
   System.out.println("f("+contador+") = "+(contador+1));
 }
}

Como ven, pedimos 2 datos al usuario con el uso de JOptionPane y esos dos datos, que son los limites, los convertimos a formato int (o double) para poder operar con ellos. Una vez convertidos estos números  hacemos un for en el cual asignamos a contador lo que contiene nuestro limite inferior (esto es para que for empiece a contar desde el limite inferior que haya introducido el usuario), después daremos la condición para que siga iterando el for, y sera que contador debe ser mayor o igual a nuestro limite inferior y también contador debe ser menor o igual a nuestro limite superior (de modo que deja de iterar cuando el contador llegue hasta el limite superior que el usuario introdujo). En cada iteracion del for mostrará un mensaje que constara de la "f" de función, dentro del paréntesis el numero que valga la variable contador (las "x"), este numero irá variando de uno en uno desde el numero del limite inferior hasta el del numero superior, y posteriormente "=" seguido de la operación "x+1" osea lo que contenga nuestra variable contador más 1.

Cuidado al no usar parentesis

Analicen el siguiente código:

/**
* Archivo: Parentesis.java
* @author BelloCerecero
* @version 1.00
* @since 2011/11/17
*/
public class Parentesis
{
 public static void main (String[] args)
 {
  //declaramos dos variables de tipo int
  int resultado;
  int resultado2;
  
  //le asignamos una operacion sin parentesis
  resultado = 8 + 4 / 2;
  
  //le asignamos una operacion con parentesis
  resultado2 = (8 + 4)/2;
  
  System.out.println(resultado);
  System.out.println(resultado2);
 }  
}

Ola mejor algunos pensaran que las dos variables deberán de tener el mismo valor puesto que se les asigna lo mismo matemáticamente hablando sumar 8 + 4 y dividir entre dos, pero en java hay jerarquía de operaciones si no utilizamos paréntesis java lo que hace es dividir primero y luego sumar, dado que la división es de mayor prioridad que la suma.

Operador ? ( y no es pregunta )

Al operador cuando lo conocí me decían que se le decía el "if de una linea" y esto como que me generaba algunas dudas y pues después de unos ejercicio me di cuenta de que no es muy difícil este operador es como el if pero el ? devuelve un valor dado no una expresión correcta, asi en pocas palabras la declaración de este operador seria así:

variableQueSeLeAsignaraElValorDevuelto = condicion?valorSiEsVerdadera:valorSiEsFalsa;

Para dejar esto mas en claro hice este pequeño programa que es prácticamente igual al de mi publicación anterior solo le agregue unas cositas casi nada chequenlo:

public class IfDeUnaLinea
{
 public static void main (String[] args)
 {
  //declaramos dos variables de tipo boolean
  boolean esMayorDeEdad, esMenorDeEdad;
  
  //declaramos e inicializamos una variable de tipo int
  int edad = 17;
  
  esMayorDeEdad = (edad >= 18)? true:false;
  esMenorDeEdad = !esMayorDeEdad;
  
  System.out.println(esMayorDeEdad);
  System.out.println(esMenorDeEdad);
 }
}

como vemos en la linea 17 esta la utilización del ? si la condición se cumple a "esMayorDeEdad" se le asignara true, de lo contrario se le asignara falsa, no solo puede devolver valores booleanos si no que también int o cualquier otro tipo.

Tu primer menú en JAVA y Calculador de Áreas

Hace tiempo (el 30/07/11) en el post Calcular Áreas con Datos Preestablecidos explicamos programas muy sencillos que calculaban el área de varias figuras, un programa para calcular el área de una figura. En esta ocasion con el uso de switch les mostrare como hacer un programa que calcule el area de cualquier figura, así el mismo programa podrá calcular el área de un rombo circulo, rectángulo, triangulo, trapecio; Para lo anterior crearemos un sencillo menú en el cual el usuario pueda elegir la figura de la que desea calcular su área. Posteriormente a que el usuario haya elegido la figura, nuestro programa pedirá al usuario los datos necesarios para calcular el área de la figura elegida. En java esto es así:

//Archivo: Areas.java

import javax.swing.JOptionPane;

public class Areas{

 public static void main(String args[]){
 
  String valor=JOptionPane.showInputDialog("Elija el numero de la figura\n1.-Circulo\n2.-Rectangulo\n3.-Triangulo\n4.-Trapecio");
  int opcion=Integer.parseInt(valor);
  
  switch(opcion){
  
   case 1:{
    valor=JOptionPane.showInputDialog("Radio");
    double radio=Double.parseDouble(valor);
    double area=3.1416*(radio*radio);
    System.out.println("El area es: "+area);
   }
   break;
   
   case 2:{
    valor=JOptionPane.showInputDialog("Base");
    double base=Double.parseDouble(valor);
    valor=JOptionPane.showInputDialog("Altura");
    double altura=Double.parseDouble(valor);
    double area=base*altura;
    System.out.println("El area es: "+area);
   }
   break;
   
   case 3:{
    valor=JOptionPane.showInputDialog("Base");
    double base=Double.parseDouble(valor);
    valor=JOptionPane.showInputDialog("Altura");
    double altura=Double.parseDouble(valor);
    double area=(base*altura)/2;
    System.out.println("El area es: "+area);
   }
   break;
   
   case 4:{
    valor=JOptionPane.showInputDialog("Base mayor");
    double base1=Double.parseDouble(valor);
    valor=JOptionPane.showInputDialog("Base menor");
    double base2=Double.parseDouble(valor);
    valor=JOptionPane.showInputDialog("Altura");
    double altura=Double.parseDouble(valor);
    double area=(base1+base2)*altura/2;
    System.out.println("El area es: "+area);
   }
   break;
   
   default:
    System.out.println("Opcion no validad");
  }
 }
}

Operadores Lógicos parte III (NOT)

En matemáticas discretas vemos que NOT es la negación, por ejemplo si tenemos 1 y a este lo negamos el valor que tendrá sera 0, para dejar esto mas claro hice un pequeño programa para ver como funciona el NOT ( ! en java).

/**
* Archivo: Not.java
* @author BelloCerecero
* @version 1.00
* @since 2011/11/17
*/
public class Not
{
 public static void main (String[] args)
 {
  //declaramos dos variables de tipo boolean
  boolean esMayorDeEdad, esMenorDeEdad;
  
  //declaramos e inicializamos una variable de tipo int
  int edad = 20;
  
  esMayorDeEdad = (edad >= 18);
  esMenorDeEdad = !esMayorDeEdad;
  
  System.out.println(esMayorDeEdad);
  System.out.println(esMenorDeEdad);
 }
}

En la linea 17 a la variable "esMenorDeEdad" se le asignara lo que de como resultado la condición "edad >= 18" (edad es mayor o igual a 18?), si esto es cierto a "esMayorDeEdad" se le asignara true (verdadero) si es la condición no se cumple se le asignara false (falso), en la linea 18 a "esMenorDeEdad" se le asignara lo que tenga "esMayorDeEdad" pero como observamos tiene el signo "!" esto es por que con este sigo niega lo que contenga la variable "esMayorDeEdad" (si es true lo cambiara a false, si es false lo cambiara a true), ya en la linea 20 y 21 imprimimos en consola lo que contengan "esMayorDeEdad" y "esMenorDeEdad".

Arreglos en JAVA

Los arreglos en JAVA están catalogados como estructuras de datos y son objetos, estos no son mas que una colección de datos del mismo tipo; de otro modo podríamos decir que es un conjunto de variables de un solo tipo. Como los arreglos tienen varios elementos, a cada elemento se le llama "indice" y estos van enumerados desde el 0 hasta n-1 (donde n es la cantidad de elementos que nosotros establecemos para nuestro arreglo); los arreglos son de tamaños fijos (el tamaño que nosotros le indiquemos). Por ejemplo supongamos que tenemos 5 números: 10, 20, 30, 40 y 50, esta es una colección de datos de un mismo tipo, por tanto es un arreglo y se representa así:

numeros [ 0 ]	10
numeros [ 1 ]	20
numeros [ 2 ]	30
numeros [ 3 ]	40
numeros [ 4 ]	50

La representación anterior es un arreglo de nombre "numeros" de tamaño 5 (osea que contiene 5 variables, 5 elementos), los números que están entre corchetes son los subíndices (como dijimos, los subíndices se empiezan a enumerar desde el numero 0) y los números que están en letras amarillas son los elementos del arreglo, son el conjunto de variables de tipo int. Entonces, la manera de representar en java a un arreglo es mediante los corchetes, para representar el esquema anterior en java, basta con indicar el tipo de elementos que contiene, el nombre del arreglo y los corchete para indicar que es un arreglo, de tal modo que seria algo asi: int numeros[].

Llevando esto a la programación, los arreglos se declaran o crean así:

//Archivo: Arreglo.java

public class Arreglo{
 
 public static void main(String args[]){
  
  int numeros[];
  numeros = new int[5];
 }
}

En el codigo anterior estamos creando un arreglo de 5 elementos tipo int. En la linea 7 se declara el arreglo int numeros[] y en la linea 8 creamos el objeto y le damos el tamaño a nuestro arreglo. En el simple código anterior solo creamos nuestro arreglo con 5 elementos, pero todos esos elementos tienen valor de 0, ya que 0 es el valor predeterminado para las variables int; y no podemos ver esos elementos, solo sabemos que están ahi y los imaginamos.

Un programa que te sea leal .equals()

¿Alguna ves han pensado en un programa que te sea leal? un programa que solo te responda a ti. Pues con el la función .equal() podemos hacer posible esto, ya que esta función compara cadenas de caracteres; hasta ahora solo hemos trabajado condiciones comparando numero, pero con la función mencionada empezaremos a comparar cadenas de texto en nuestras condicionales, así que echando a volar nuestra imaginación hagamos un programa que sea leal solo a nosotros:

//Archivo: Acceso.java

import javax.swing.JOptionPane;

public class Acceso{
 
 public static void main(String args[]){
  
  String nombre=JOptionPane.showInputDialog("¿Cual es tu nombre?");
  
  if(nombre.equals("Pedro")){
   System.out.println("Acceso concedido");
   System.out.println("¡Bienvenido Sr. "+nombre+"!");
   System.out.println("¡Que tenga buen dia!");
  }
  else
   System.out.println("Acceso denegado");
 }
}

La funcion .equals() recibe como parametro una cadena de caracteres, obviamente, así que dentro de los paréntesis de esta función escribimos entre comillas algún texto que queramos comparar, en este caso escribimos la cadena de caracteres "Pedro". Este programa sencillo solo indica si usted a accedido al programa, si accede le dará un mensaje de bienvenida y le saludara; si no accede al programa solo le mostrara un mensaje que diga: "Acceso denegado".

Cuando salga la ventana del JOptionPane para preguntarnos el nombre -supongamos que usted se llama Luis-, usted introducirá su nombre en la caja de texto creada por JOptionPane y al dar "Aceptar" la variable String nombre contendrá una cadena de caracteres con su nombre (Luis). Cuando el programa llegue a la linea 11 donde usamos un if, ocupando .equals(), decimos que el nombre que el usuario introdujo debe ser igual a "Pedro", y como en nuestro ejemplo usted se llama "Luis" la condición del if no se cumplirá y se pasara al else donde le enviara un mensaje que diga "Acceso denegado". De este modo, el programa solo accesará y solo saludara a la persona cuyo nombre sea "Pedro".

Calificaciones (Rangos condicionales)

En muchas ocasiones necesitamos establecer un rango condicional para que se evalué un valor, por ejemplo si queremos saber si una persona es mayor de edad o no, es muy fácil saberlo, ya que para que sea mayor de edad debe tener 18 o más, entonces, a pesar de que hay un rango de edad: de 0 a 18 años no es mayor de edad, solo se necesita establecer una sola condición para evaluar lo anterior, por ejemplo:

                                              int edad=14;
                                              if(edad>=18)
                                                   System.out.println("Mayor de edad");
                                              else
                                                   System.out.println("Menor de edad");

Basto con solo una condición (la que esta en letras rojas) para poder validar si es mayor o no, pero no hay un rango condicional (un rango que se sitúe en medio de 2 condiciones) y en ocasiones para algunos otros problemas se necesitan que haya dos condiciones para poder evaluar un valor, para esto Java cuenta con los operadores lógicos. Para entenderlo mejor se plantea el siguiente ejercicio:

Haremos un programa que pida al usuario su promedio final de semestre y que nuestro programa muestre los siguientes mensajes de acuerdo a su calificación (la calificación va desde 1 a 100). Si su promedio es de 100 a 95 debe mostrar "Excelente", si es de 94 a 85 "Muy bien", de 84 a 75 "Bien", de 74 a 70 "Regular" y de 70 a 0 "No acreditado".

// Archivo: Promedio.java

import javax.swing.JOptionPane;

 public class Promedio {
 
  public static void main(String args[]){
  
  String cal="";
  cal=JOptionPane.showInputDialog("Introduce tu calificacion");
  
  if(cal==null)
   System.out.println("Usted ha cancelado la operacion");
  else{
   int calif=Integer.parseInt(cal);
   
   if(calif>=95&&calif<=100)
    System.out.println("Excelente");
   else
    if(calif>=85&&calif<=94)
     System.out.println("Muy Bien");
    else
     if(calif>=75&&calif<=84)
      System.out.println("Bien");
     else
      if(calif>=70&&calif<=74)
       System.out.println("Regular");
      else
       if(calif<70&&calif>=0)
        System.out.println("No Acreditado");
       else
        System.out.println("Esa calificacion no es valida");
  }
 }
}

Promedio (for)

Se realizara un programa con el uso de for, que pida al usuario varios números y que promedie estos. Haciendo un análisis del problema, solo vamos a sumar todos los números que el usuario introduzca y los vamos a dividir entre la cantidad de números que haya introducido.

//Archivo: Promediofor.java

import javax.swing.JOptionPane;

public class Promediofor{

 public static void main(String args[]){
 
  String valor=JOptionPane.showInputDialog("¿Cuantas calificaciones desea evaluar?");
  int num=Integer.parseInt(valor);
  int contador;
  int suma=0;
  
  for(contador=1 ; contador<=num ; contador++){
   valor=JOptionPane.showInputDialog("Introduce calificacion"+contador);
   int cal=Integer.parseInt(valor);
   suma+=cal;
  }
  
  int prom = suma/num;
  System.out.println("El resultado es: "+prom);
 }
}

Pedimos al usuario la cantidad de números que desea promediar, esto a nosotros nos servirá para establecer la condición de los ciclos de repetición. Declaramos un contador para el for y una variable int suma, que nos servirá como recipiente para ir almacenando la suma de los numero que el usuario vaya introduciendo para promediarlos.

Dentro del for establecemos que los ciclos se repetirán hasta cuando contador deje de ser igual o menor que el numero de elementos que el usuario especifico en la linea 9. Dentro del cuerpo del for reutilizamos la variable valor para pedir el primer numero a promediar, después lo convertimos a int y se almacena en int cal, acto seguido se sumara lo que contiene la variable suma mas cal y el resultado de esto se guardara en la misma variable int suma.

Después vienen la siguientes vueltas en el ciclo hasta que se rompa la condición, para cuando esto suceda, la variable suma ya tendrá almacenado la suma de todos los números que el usuario introdujo, por tanto, ya fuera del for, declaramos int prom y le asignamos lo que resulte de lo que contiene suma dividido entre num (el numero de calificaciones que se iban a evaluar introducido por el usuario). Y para finalizar solo le mostramos el resultado al usuario con un System.out.println("El resultado es: "+prom); O si lo prefiere también puede mostrar el resultado usando JOptionPane.showMessageDialog().

Operadores Lógicos en Java parte2 ( || )

Ahora hablaremos del operador lógico || al cual se le conoce como OR, bueno da como resultado false si al evaluar cada uno de los operandos el resultado es false. Si uno de ellos es t r u e , el resultado es true . Para que esta definición quede un poco mas claro lo ejemplificare con este sencillo programa que no hace otra cosa mas que imprimir en consola la operación realizada por el operador OR y así darnos cuenta en que circunstancia podremos entrar al if utilizándolo.

/**
* Archivo: Or.java
* @author Bello Cerecero
* @version 1.0
* @since 11/11/2011
*/
public class Or
{
   public static void main(String[] args)
   {
     int operador1 = 1;
     int operador2 = 1;

     //Si el operador1 es falso o el operador2 es verdadero
     if(operador1 == 2 || operador2 == 1)
       System.out.println("Si entra al if.");
     else
       System.out.println("No entra al if.");

     //Si el operador1 es falso o el operador2 es falso
     if(operador1 == 2 || operador2 == 2)
       System.out.println("Si entra al if.");
     else
       System.out.println("No entra al if.");

     //Si el operador1 es veradadero o el operador2 es falso
     if(operador1 == 1 || operador2 == 2)
       System.out.println("Si entra al if.");
     else
       System.out.println("No entra al if.");

     //Si el operador1 es verdadero o el operador2 es verdadero
     if(operador1 == 1 || operador2 == 1)
       System.out.println("Si entra al if.");
     else
       System.out.println("No entra al if.");
   }
}

La salida del programa seria la siguiente:


Todas las definiciones del AND y OR fueron obtenidas del libro "Java 2, Manual de Programación, Joyanes Aguilar Luis"

JOptionPane.showMessageDialog();

El showMessageDialog() es un método mas de la clase JOptionPane, este método realiza una tarea muy sencilla cuando se manda a llamar: JOptionPane.showMessageDialog() solo muestra un mensaje en un cuadro de dialogo en la pantalla; Hace una función similar al System.out.println(), pero System.out.println imprime el mensaje que le indiquemos en consola y JOptionPane.showMessageDialog muestra el mensaje en el cuadro de dialogo con un botón de "Aceptar" para cuando el usuario termine de leer el mensaje:.

El siguiente es un programa que pide al usuario 2 números, los suma y muestra su resultado en pantalla, pero en lugar de mostrar el resultado en consola con el System.out.println, lo haremos en un cuadro de dialogo con el JOptionPane.

//Archivo: PruebaMessage.java

import javax.swing.JOptionPane;

public class PruebaMessaje{
 
 public static void main(String args[]){
  
  String nombre=JOptionPane.showInputDialog("¿Como te llamas?");
  String valor;
  valor=JOptionPane.showInputDialog("Introduzca un numero:");
  int num1=Integer.parseInt(valor);
  valor=JOptionPane.showInputDialog("Introduzca otro numero:");
  int num2=Integer.parseInt(valor);
  
  JOptionPane.showMessageDialog(null,"El programa sumara los numeros");
  
  int suma=num1+num2;
  
  JOptionPane.showMessageDialog(null, "Hola "+nombre+", tu suma es: "+suma);
 }
}

Para este programa importamos la libreria JOptionPane en la linea 3, ya que haremos usos de algunos metodos ahi contenidos. En la linea nueve declaramos String nombre que va a contener lo que reciba del JOptionpane.showInputDialog(), en la linea 10 declaramos String valor, esta variable servirá de soporte para crear otras, por eso solo la declaramos. En la linea 11 hacemos el primer uso de la variable valor y en esa variable guardamos lo que reciba el JOptionPane, después en la linea 12 asignamos a int num1 lo que resulte de la conversión de String valor. En la linea 13 reutilizaremos la variable String valor, por tanto, al principio String valor contenía lo que se le ingreso en el JOptionPane en la linea 11, pero como se vuelve a reutilizar con otro JOptionPane, se borra lo que tenia con anterioridad y se escribe el nuevo valor obtenido por el JOptionPane de la linea 13 y en la linea 14 se declara int num2 y se le asigna lo que resulte de la conversión de String valor.

En la linea 16 hacemos uso de nuestro primer JOptionPane.showMessageDialog(), estableciendo en el parámetro primero null y después el mensaje que mostraremos, en este caso: "El programa sumara los números" y aparecerá un cuadro de dialogo en pantalla así:

Operadores Lógicos en Java parte1 (&&)

Los operadores lógicos o booleanos actúan sobre operandos de tipo lógico para

devolver un resultado también de tipo lógico.

La regla del funcionamiento del && es la siguiente: si el primer operando es false, el segundo no es evaluado. Esta propiedad se denomina evaluación en cortocircuito. Por ejemplo, la siguiente expresión evitaría calcular la raíz cuadrada de números negativos:

(X >= O) && (Math.sqrt(x) >= 2)

Para dejar mas en claro el funcionamiento del &&, con el siguiente programa se ejemplifica.

/**
* Archivo: And.java
* @author Bello Cerecero
* @version 1.0
* @since 11/11/2011
*/
public class And
{
   public static void main(String[] args)
   {
     int operador1 = 1;
     int operador2 = 1;
 
     //Si el operador1 es falso y el operador2 es verdadero
     if(operador1 == 2 && operador2 == 1)
       System.out.println("Si entra al if.");
     else
       System.out.println("No entra al if.");
 
     //Si el operador1 es falso y el operador2 es falso
     if(operador1 == 2 && operador2 == 2)
       System.out.println("Si entra al if.");
     else
       System.out.println("No entra al if.");
 
     //Si el operador1 es veradadero y el operador2 es falso
     if(operador1 == 1 && operador2 == 2)
       System.out.println("Si entra al if.");
     else
       System.out.println("No entra al if.");
 
    //Si el operador1 es verdadero y el operador2 es verdadero
    if(operador1 == 1 && operador2 == 1)
      System.out.println("Si entra al if.");
    else
      System.out.println("No entra al if.");
   }
}

Break y Continue

Las instrucciones break y continue son instrucciones que sirven para interrumpir al flujo de ejecución de las instrucciones de repetición (bucles). Estas instrucciones siempre deben de ir dentro de un bucle ya sea for o while, porque de caso contrario Java nos botara un error de compilación; usualmente estas instrucciones van después de un if para que si la condición se cumple se ejecuten estas instrucciones, pero no necesariamente deben ir después de un if. Como ya mencionamos debemos situar estas instrucciones dentro de un bucle, pero en el caso del break también puede ser utilizado dentro de un switch como ya lo hemos estudiado con anterioridad.

break

La instrucción break sera fácil de entender puesto que ya la hemos estudiado con el uso del switch; tiene la misma función que en el switch, cuando el programa encuentra nuestra instrucción break dentro del ciclo, interrumpe el ciclo, se sale del ciclo y se empieza a ejecutar la primera linea fuera del for o while.

//Archivo: Break.java

public class Break{
 
 public static void main(String args[]){
  
  int contador;
  
  for(contador=1; contador<=5; contador++){
   
   if(contador==3)
    break;
   
   //esta linea no se ejecutara despues
   //de la tercera iteracion:
   System.out.println("Contando iteracion: "+contador);
  }
  
  System.out.println("Ha salido del for");
 }
}

En este programa haremos uso de un for, declaramos un contador en la linea 7 y en la linea 9 nuestro for, inicializando el contador en 1, estableciendo que para que se cicle contador debe ser menor o igual a 5 (osea que tendrá 5 iteraciones), y dentro del cuerpo del for en la linea 11 establecemos un if con la condición de que cuando contador valga 3 se ejecute la instrucción break (osea que se saldrá del for). Y entonce se brincara hasta la linea 19 donde se imprime un mensaje en consola que dirá: "Ha salido del for".

Al momento de que el programa ejecute el for, entrará, después pasara al condición y como contador vale 1 no se cumple la condición y no se ejecuta el break, y se imprime en consola "Contando iteracion: 1". Para la segunda vuelta se cumple la condición del for y contador vale 2, tampoco se cumple la condición del if y se ejecuta otra impresión en pantalla: "Contando iteracion: 2". Pero para la tercera vuelta (iteracion) pasa el for y contador valdrá 3, por tanto se cumple la condición del if y se ejecuta el break y nos saca del ciclo y ejecuta la primera linea después del cuerpo del for, osea que ejecutara el mensaje en pantalla: "Ha salido del for".

continue

Método de la Burbuja en JAVA

La Ordenación de burbuja (Bubble Sort en inglés) es un sencillo algoritmo de ordenamiento. Funciona revisando cada elemento de la lista que va a ser ordenada con el siguiente, intercambiándolos de posición si están en el orden equivocado. Es necesario revisar varias veces toda la lista hasta que no se necesiten más intercambios, lo cual significa que la lista está ordenada. Este algoritmo obtiene su nombre de la forma con la que suben por la lista los elementos durante los intercambios, como si fueran pequeñas "burbujas". También es conocido como el método del intercambio directo. Dado que solo usa comparaciones para operar elementos, se lo considera un algoritmo de comparación, siendo el más sencillo de implementar.

Descripción:

Una manera simple de expresar el ordenamiento de burbuja en pseudocódigo es la siguiente:

Este algoritmo realiza el ordenamiento de una lista a de n valores, en este caso de n términos numerados del 0 al n-1, consta de dos bucles anidados uno con el índice i, que da un tamaño menor al recorrido de la burbuja en sentido inverso de 2 a n, y un segundo bucle con el índice j, con un recorrido desde 0 hasta n-i, para cada iteración del primer bucle, que indica el lugar de la burbuja.

La burbuja son dos términos de la lista seguidos, j y j+1, que se comparan, si el primero es menor que el segundo sus valores se intercambian.

Esta comparación se repite en el centro de los dos bucles, dando lugar a la postre a una lista ordenada, puede verse que el número de repeticiones sola depende de n, y no del orden de los términos, esto es, si pasamos al algoritmo una lista ya ordenada, realizara todas las comparaciones exactamente igual que para una lista no ordenada, esta es una característica de este algoritmo.

El algoritmo del método es el siguiente:

/**
 * Archivo: MetodoDeLaBurbuja.java
 * @author Bello Cerecero
 * @version 1.0
 * @since 10/11/2011
 */
public class MetodoDeLaBurbuja 
{
    public static int[] burbuja(int[] arreglo)
    {
      int auxiliar;
      int[] arregloOrdenado;
      for(int i = 2; i < arreglo.length; i++)
      {
        for(int j = 0;j < arreglo.length-i;j++)
        {
          if(arreglo[j] > arreglo[j+1])
          {
            auxiliar = arreglo[j];
            arreglo[j] = arreglo[j+1];
            arreglo[j+1] = auxiliar;
          }   
        }
      }
      arregloOrdenado = arreglo;
      return arregloOrdenado;
    }
    
    public static void main(String[] args) 
    {
      //Valores que tiene el arreglo desordenado.
      int arreglo[] = {8,6,7,2,1,8,6,8,7,1,9,7,7,10};
      int arregloOrdenado[] = burbuja(arreglo);
 
      //imprimimos el arreglo ordenado.
      for(int i = 0; i < arregloOrdenado.length;i++)
        System.out.println(arregloOrdenado[i]);
    }
}

Estaciones de Año

Usando switch haremos un programa que pida al usuario un numero de mes y que se muestre en pantalla la estación del año a la que pertenece ese mes; Para lo anterior vamos a enumerar los meses del 1 al 12 (enero=1, febrero=2... diciembre=12) y vamos a considerar la siguiente tabla:

Numero de mes	Mes	Estación del año
1	Enero	Invierno
2	Febrero	Invierno
3	Marzo	Primavera
4	Abril	Primavera
5	Mayo	Primavera
6	Junio	Verano
7	Julio	Verano
8	Agosto	Verano
9	Septiembre	Otoño
10	Octubre	Otoño
11	Noviembre	Otoño
12	Diciembre	Invierno

Código:

// Archivo: Estaciones.java

import javax.swing.JOptionPane;

public class Estaciones{

 public static void main(String args[]){
 
  String valor=JOptionPane.showInputDialog("Introduce un numero de mes");
  int mes=Integer.parseInt(valor);
 
  switch(mes){
  
   case 3:
   case 4:
   case 5:
    System.out.println("Estas en Primavera");
   break;
   
   case 6:
   case 7:
   case 8:
    System.out.println("Estas en Verano");
   break;
   
   case 9:
   case 10:
   case 11:
    System.out.println("Estas en Otoño");
   break;
   
   case 12:
   case 1:
   case 2:
    System.out.println("Estas en Invierno");
   break;
   
   default:
    System.out.println("Mes y estacion no existen");
  }
 }
}