Nuestro Canal

Conoce nuestra metodología de enseñanza.

El ProfeEnlinea en Youtube

import java.util.Scanner;
public class Matriz5 {
    private Scanner teclado;
    private int[][] mat;
    
    public void cargar() {
        teclado=new Scanner(System.in);
        System.out.print("Cuantas fila tiene la matriz:");
        int filas=teclado.nextInt();
        System.out.print("Cuantas columnas tiene la matriz:");
        int columnas=teclado.nextInt();
        mat=new int[filas][columnas];
        for(int f=0;f<mat.length;f++) {
            for(int c=0;c<mat[f].length;c++) {
                System.out.print("Ingrese componente:");
                mat[f][c]=teclado.nextInt();
            }
        }
    }
    
    public void imprimir() {
        for(int f=0;f<mat.length;f++) {
            for(int c=0;c<mat[f].length;c++) {
                System.out.print(mat[f][c]+" ");
            }
            System.out.println();
        }
    }
    
    public void imprimirUltimaFila() {
    	System.out.println("Ultima fila");
        for(int c=0;c<mat[mat.length-1].length;c++) {
             System.out.print(mat[mat.length-1][c]+" ");
        }
    }
    
    public static void main(String[] ar) {
        Matriz5 ma=new Matriz5();
        ma.cargar();
        ma.imprimir();
        ma.imprimirUltimaFila();
    }   
}

 

import javax.swing.*;
import java.awt.Event.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;


public class AreaRectangulo extends JFrame implements ActionListener {

JLabel titulo1;
JLabel base;
JLabel altura;
JLabel resultado;
JTextField b;
JTextField a;
JButton calcular;

public AreaRectangulo(){
setLayout(null);
titulo1=new JLabel("AREA DEL RECTANGULO");
titulo1.setBounds(20, 10, 200, 20);
add(titulo1);

base=new JLabel("Ingrese la base: ");
base.setBounds(20, 60, 200, 20);
add(base);

altura=new JLabel("ingrese la altura: ");
altura.setBounds(20, 80, 200, 20);
add(altura);

b=new JTextField();
b.setBounds(130, 60, 60, 20);
add(b);

a=new JTextField();
a.setBounds(130, 80, 60, 20);
add(a);

calcular=new JButton("CALCULAR");
calcular.setBounds(20, 120, 100, 20);
add(calcular);
calcular.addActionListener(this);

resultado=new JLabel("El area del rectangulo es: ");
resultado.setBounds(20, 180, 200, 20);
add(resultado);
}
public void actionPerformed(ActionEvent e){
Area_Rectangulo obj = new Area_Rectangulo();

if(e.getSource()==calcular){

double B=Double.parseDouble(b.getText());//Convertir texto a un double
double A=Double.parseDouble(a.getText());
double Area;
Area=A*B;

resultado.setText("El area del rectangulo es: "+Area);


}


}

public static void main(String[] args) {
Area_Rectangulo form = new Area_Rectangulo();
form.setBounds(0, 0, 400, 250);
form.setVisible(true);
form.setDefaultCloseOperation(EXIT_ON_CLOSE );


}

}

 

 

INTERFACES SET Y SORTEDSET

Vamos a estudiar dos interfaces del paquete java.util del api de java que son muy usadas. Se trata de las interfaces SET y SORTEDSET. Estas interfaces tratan respectivamente lo que se conoce como un conjunto de elementos (SET) y un conjunto de elementos ordenados (SORTEDSET). Debido a su similitud hemos decidido comentarlas conjuntamente en lugar de por separado.

 

SET

La interface SET como hemos comentado es la encargada del tratamiento de conjuntos en el api de Java. Un conjunto en Java es una colección de elementos que, como el conjunto en matemáticas, no permite elementos duplicados dentro de ella y no tiene orden entre sus elementos. Más formalmente, no permite elementos e1, e2 tales que: e1.equals(e2) sea true. Además nos obliga a implementar determinados métodos, por ejemplo el método hashCode() entre otros.

 

SORTEDSET

Esta interfaz es muy similar a la interface SET. Tan solo se diferencia en que SORTEDSET permite que los elementos dentro del conjunto de la colección estén ordenados totalmente, facilitando por tanto su acceso en búsquedas y haciendo más rápido su consulta.

Los elementos son ordenados usando su orden natural, o bien usando un Comparator. El concepto de orden natural y Comparator los hemos estudiado en apartados anteriores del curso.

 

HASHSET

HashSet es la clase que vamos a utilizar para implementar la interfaz SET ya que es quizás la más usada para implementar esta interface. Esta clase implementa la interface SET basada en una tabla hash (a modo resumen para nosotros una tabla hash será una tabla que se construye en base a claves que permiten localizar objetos. Por ejemplo un DNI podría ser la clave para localizar a una persona. En esta clase la clave da la posición del objeto en la tabla, permitiendo un acceso directo al elemento. Este acceso directo hace que esta clase sea ideal para búsqueda, inserción y borrado de elementos en base a una clave o llave. No hay garantía de orden (por ejemplo si hacemos un recorrido de los objetos dentro de un HashSet no siempre los obtendremos en igual orden) y se permite el uso de elementos nulos.

 

TREESET

TreeSet es la clase que vamos a utilizar como implementación de la interface SORTEDSET. Esta implementación está basada en el uso de una estructura de árbol permitiendo que los elementos estén ordenados bien por orden natural o bien por orden total definido por un Comparator y por tanto haciendo muy rápido las búsquedas, inserciones y borrados de sus elementos. A efectos prácticos, la diferencia principal de esta clase con HashSet es que sus elementos están ordenados. Otra diferencia es la estructura de datos que sirve para almacenar datos, en un caso una tabla y en otro un árbol.

 

 

EJEMPLO DE USO DE SET Y SORTEDSET

A continuación vamos a crear una clase Persona a partir de la cual vamos a definir un conjunto (set) de personas y otro conjunto ordenado (sortedset) también de personas en nuestro programa principal. Añadiremos las mismas personas al conjunto y al conjunto ordenado, imprimiendo al final todas las personas que tienen ambos conjuntos. Comenzaremos escribiendo el siguiente código de la clase Persona en nuestro editor:

 

import java.util.Objects;

public class Persona implements Comparable<Persona>{

    public int idPersona;       public String nombre;       public int altura;

 

    public Persona(int idPersona, String nombre, int altura) {

        this.idPersona = idPersona;   this.nombre = nombre;    this.altura = altura;}

 

    @Override

    public String toString() { return "Persona-> ID: "+idPersona+" Nombre: "+nombre+" Altura: "+altura+"\n";  }

 

    @Override

    public int compareTo(Persona o) { return this.altura-o.altura; }

 

    @Override

    public int hashCode() { return altura + nombre.hashCode() + idPersona; }

 

    @Override

    public boolean equals(Object obj) {

        if (obj == null) {   return false;  }

        if (getClass() != obj.getClass()) {  return false;   }

        final Persona other = (Persona) obj;

        if (this.idPersona != other.idPersona) {  return false;    }

        if (!Objects.equals(this.nombre, other.nombre)) {    return false;     }

        if (this.altura != other.altura) {     return false;   }

        return true;

    }

}

 

 

En la anterior definición de clase Persona, se puede ver que hemos implementado la interfaz Comparable y que por tanto vamos a trabajar con el orden natural por simplicidad pero si quisiéramos podríamos implementar la interfaz Comparator como se explicó anteriormente. En el método compareTo hemos definido que una persona “es mayor” que otra si su altura es mayor. Este criterio de orden lo usamos simplemente a modo de ejemplo.

También podemos ver que se han sobreescrito los métodos toString(), hashCode() y equals(), sobreescritura que hemos considerado necesaria para el buen funcionamiento en las interfaces correspondientes. En el método hashCode() hemos implementado que se devuelva un número único como clave, no prestaremos ahora demasiada atención a este método. En el método equals hemos definido un criterio de igualdad entre personas, criterio implementado simplemente a modo de ejemplo.

Escribe ahora el código de nuestro programa que hará uso de las clases HashSet y TreeSet:

/* Ejemplo Interface Set y SortedSet, clase HashSet y TreeSet aprenderaprogramar.com */

import java.util.HashSet;

import java.util.Set;

import java.util.SortedSet;

import java.util.TreeSet;

 

public class Programa  {

    public static void main (String []args)      {

        Set<Persona> cjsp = new HashSet<Persona>();

        SortedSet<Persona> cjssp = new TreeSet<Persona>();

        Persona p = new Persona(1,"Marta",165);

        cjsp.add(p);

        cjssp.add(p);

        p = new Persona(2,"Elena",155);

        cjsp.add(p);

        cjssp.add(p);

        p = new Persona(3,"María",170);

        cjsp.add(p);

        cjssp.add(p);

        System.out.println("Personas en el conjunto: "+cjsp);

        System.out.println("Personas en el conjunto ordenado: "+cjssp);

    }

}

 

 

En la clase de nuestro programa podemos ver cómo hemos creado nuestros conjuntos (un set y un sortedset) de personas y hemos añadido a 3 personas (Marta, Elena y María). El diagrama de clases es el siguiente:

 

 

El resultado de ejecución del programa nos devuelve la siguiente salida:

 

 

Tras observar la salida de nuestro programa vemos que el primer cojunto mantiene los datos desordenados como era de prever, mientras que el conjunto ordenado nos ha introducido a todas las personas ordenadas por su orden natural. En este caso el orden natural viene dado por la altura de las personas, porque así lo hemos definido al implementar el método compareTo. Si hubiéramos definido el orden natural en base a otro criterio (por ejemplo orden alfabético de nombres), la clase SortedSet hubiera devuelto a las personas ordenadas por este otro criterio. Con el criterio empleado la primera persona en el conjunto ordenado es Elena con una altura de 155 centímetros, después Marta con 165 centímetros y por último María con 170 centímetros.

 

 

CONCLUSIONES

Como conclusión de estas 2 interfaces y estas 2 clases que las implementan podemos decir que la interfaz Set es más sencilla de implementar ya que nos evitamos el tener que usar ordenación, necesario para la interfaz SortedSet. Sin embargo, tenemos un conjunto de elementos de los que no tenemos garantía de orden de ningún tipo y según el caso tendremos que valorar si esto nos resulta conveniente o no. En cambio con SortedSet tenemos el orden establecido bien por orden natural de los elementos contenidos o por un orden total que asignemos con un Comparator, sin que esto suponga demasiado esfuerzo. La sobreescritura de ciertos métodos como hashCode() para implementar HashSet y compareTo() para implementar TreeSet es habitual para conseguir que estas clases funcionen como nosotros queremos. Por el mismo motivo es habitual sobreescribir toString(), ya que si no lo sobreescribimos el resultado obtenido con el método no es adecuado.

 

 

 

 

 

/*
 * Programa que permite simular el funcionamiento  de un cajero automatico.
 * Autor: Ing. Steven Preciado
 * Fecha: Septiembre 15 de 2016
 */
package steven;

import java.util.Scanner;
public class Cajeroelectronico {

 
    public static void main(String[] args) {
     int clave=123;
     int saldo=500000;
     int valor_aretirar;
     int clave_leida;
     int opcion=0;
     int cantidadAtransferir=0;
     int cuentaAtransferir;
   
     
       Scanner lector= new Scanner (System.in);
        
       System.out.print("ingrese la clave: ");
        clave_leida=Integer.parseInt(lector.next());
         if(clave==clave_leida) {
             
            do {
             System.out.println("*****************************************");
             System.out.println("******** Bienvenido al cajero ATSteven ********");
             System.out.println("     ****** Seleccione una opcion ******     ");
             System.out.println("*****************************************");
             System.out.println("1. Retirar efectivo");
             System.out.println("2. Cambiar clave");
             System.out.println("3. Realizar transferencia");
             System.out.println("4. Ver ultimos movimientos");
             System.out.println("5. Consultar saldo");
             System.out.println("6. Salir ");
             
             opcion = lector.nextInt();
               switch (opcion) {
                   case 1:
                      System.out.println("Por favor ingres la cantidad a retirar");
                      valor_aretirar = lector.nextInt();
                      if (valor_aretirar <= saldo ) {
                          saldo = saldo - valor_aretirar;
                         System.out.println("Su nuevo saldo es: " + saldo);
                      } else {
                          System.out.println("Fondos Insuficientes, su saldo es: " + saldo);
                      }
                      break;
                   case 2:
                      System.out.println(" Por favor ingrese su nueva clave");
                      clave = lector.nextInt();
                      System.out.println(" Su clave ha sido modificada con exito");
                      break;
                   case 3:
                      System.out.println("Por favor ingrese la cantidad a tranferir");
                      cantidadAtransferir = lector.nextInt();
                      if (cantidadAtransferir <= saldo) {
                            System.out.println("Por favor ingrese el numero de cuenta donde va a transferir el dinero");
                           cuentaAtransferir = lector.nextInt();
                           saldo = saldo - cantidadAtransferir;
                           System.out.println("Transferencia satisfactoria por valor de : " + cantidadAtransferir);
                           System.out.println("Su nuevo saldo es: " + saldo);
                        }
                      break;
                   case 4:
                      System.out.println("No tiene movimeintos en la ultima semana");
                      break;
                   case 5:
                      System.out.println("Su saldo Actual es: " + saldo);
                      break;
                   case 6:
                      System.out.println("Gracias por usar nuestro cajero...");
                      
                      System.exit(0);
                      break;
                      
                      
                      
               }
               System.out.println("Para seguir digite 0, para salir digite 6");
               opcion = lector.nextInt();
            } while (opcion != 6);
            System.out.println("Gracias por usar nuestro cajero...");
         } else {
             System.out.println(" La Clave es incorrecta");
         }
             
        
      
             
    }
    
}

 

 

// El mismo pero mejorado usando un arreglo y un cliclo repetitivo

import java.util.Scanner; // Clase que permite leer datos por teclado

public class EjercicioSwitchCase {


    public static void main(String[] args) {
        
     Scanner lector= new Scanner (System.in);   
     int clave=123;
     int saldo=500000;
     int valor_aretirar;
     int clave_leida;
     int opcion=0;
     int cantidadAtransferir=0;
     int cuentaAtransferir;
     int operaciones [] = new int[5];
     int k=0;
    // arreglo operaciones de tipo entero
          
      System.out.print("ingrese la clave: ");
        //clave_leida=Integer.parseInt(lector.next());
         clave_leida = lector.nextInt();
         if(clave==clave_leida) {
             
                                
          do {
         
             System.out.println(" Bienvenido al cajero ATSteven **");
             System.out.println("     Seleccione uan opcion     ");
             System.out.println("***************");
             System.out.println("1. Retirar efectivo");
             System.out.println("2. Cambiar clave");
             System.out.println("3. Realizar transferencia");
             System.out.println("4. Ver ultimos movimientos");
             System.out.println("5. Consultar saldo");
             System.out.println("6. Salir ");
             
             opcion=lector.nextInt();
            switch(opcion){
                case 1:
                    operaciones[k]=opcion;
                 System.out.println("1. Retirar efectivo");
                 System.out.println("Por favor ingrese la cantidad a retirar");
                      valor_aretirar = lector.nextInt();
                      if (valor_aretirar <= saldo ) {
                          saldo = saldo - valor_aretirar;
                         System.out.println("Su nuevo saldo es: " + saldo);
                      } else {
                          System.out.println("Fondos Insuficientes, su saldo es: " + saldo);
                      }
                      k++;
                 break;
                case 2:
                    operaciones[k]=opcion;
                 System.out.println("2. Cambiar clave");
                 System.out.println("Por favor ingrese su nueva clave");
                        clave = lector.nextInt();
                        System.out.println("Su nueva clave es "+clave);
                        k++;
                 break;
                case 3:
                    operaciones[k]=opcion;
                 System.out.println("3. Realizar transferencia");
                 System.out.println("Por favor ingrese el valor que desea transferir ");
                    cantidadAtransferir = lector.nextInt();
                    if (cantidadAtransferir <= saldo ){
                        saldo = saldo - cantidadAtransferir;
                        System.out.println("Digite el numero de cuenta al que desea transferir");
                        cuentaAtransferir = lector.nextInt();
                        System.out.println("Ud realizo una transaccion al numero de cuenta "+cuentaAtransferir+" por valor de "+cantidadAtransferir);
                        System.out.println("Su nuevo saldo es de "+saldo);
                 } else{
                        System.out.println("Ud No tiene fondos suficientes para realizar esta transferencia , su saldo es de "+saldo);
                    }
                    k++;
                 break;
                case 4:
                    
                 System.out.println("4. Ver ultimos movimientos");
                

              if (operaciones.length ==0) {

                  System.out.println("Ud no tiene ultimos movimientos");

             } else {
                 for (int j=0; j<operaciones.length; j++){
                       switch(operaciones[j]) {
                           case 1:
                               System.out.println("Realizo un reiro");
                               break;
                           case 2:
                               System.out.println("Realizo un cambio de clave");
                               break;    
                           case 3:
                               System.out.println("Realizo una transferencia");
                               break;
                           case 4:
                               System.out.println("Listo sus ultimos movimientos");
                               break;   
                          case 5:
                               System.out.println("Consultó su saldo");
                               break;     
                       }
                 }
                      

               }

                
                 break;
                 case 5:
                    operaciones[k]=opcion;
                 System.out.println("5. Consultar saldo");
                 System.out.println("Su saldo es de : "+ saldo);
                 k++;
                 break;
                case 6:
                 System.out.println("6. Salir ");
                  System.out.println("Gracias por usar nuestro cajero...");
                      
                  System.exit(0);
                 break;
                default:
                 System.out.println("NO Selecciono una opcion valida");
                
        }
        
            System.out.println("Para seguir digite 0, para salir digite 6");
               opcion = lector.nextInt();
            } while (opcion != 6);
    }  else {
             System.out.println(" La Clave es incorrecta...");
         }
}
    
}


public class Ejemplo_While {

    int x=10;
public void ciclo_while() {
    
    while(x > 0) {
        System.out.println("El valor de x es " + x);
        x=0;
    }
    System.out.println("Programa Finalizado, el valor de x es " + x);
}
    public static void main(String[] args) {
        Ejemplo_While objeto =new Ejemplo_While();
        objeto.ciclo_while();
       
    }
    
}