programación de sistemas 2

 Entrada y salida de datos 

1.Para utilizar la clase Scanner, primero debes importarla: import java.util.Scanner;

2.Luego, puedes crear una instancia de la clase Scanner proporcionando una fuente de entrada, como por ejemplo, la consola: Scanner scanner = new Scanner(System.in);

3.Una vez creado el objeto Scanner, puedes utilizar sus métodos para leer diferentes tipos de datos.


import java.util.Scanner;


public class Main {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);

        System.out.print("Ingresa un número entero: ");

        int num = scanner.nextInt();

        System.out.print("Ingresa una cadena de texto: ");

        String str = scanner.nextLine();

        System.out.print("Ingresa un valor booleano: ");

        boolean b = scanner.nextBoolean();

        System.out.println("El número ingresado es: " + num);

        System.out.println("La cadena de texto ingresada es: " + str);

        System.out.println("El valor booleano ingresado es: " + b);

    }

}


Reloj

1. Diseñar una clase llamada reloj con los atributos enteros, hora, minutos y segundos con el método siguiente.
2. Un constructor que analice los atributos a valores pasados como parámetros.
3. Un método llamado decrementa que disminuya la hora en segundos.
4. Un método que convierta sring la hora mediante la concatenación de sus atributos y devuelva loa cadena con el formato d 12h.

public class Reloj {
    int modo,hora, minutos,segundos;

    int getmodo(){

    return modo;

    }


    public void setmodo(int modo){

    this.modo=modo;
    }

    int gethora(){

    return hora;

    }


    public void sethora(int hora){

    this.hora=hora;
    }

    public int getminutos(){

    return minutos;

    }


    public void setminutos(int minutos){

    this.minutos=minutos;
    }

    public  int getsegundos(){

    return segundos;

    }


   public  void setsegundos(int segundos){

    this.segundos=segundos;
    }

   public  Reloj(){
    modo=24; /*por defecto ponemos 24horas*/
    hora=0;
    minutos=0;
    segundos=0;


    }

    public Reloj( int h, int m, int s){
        this.modo=24;
        this.hora=h %24;
        this.minutos=m % 60;
        this.segundos=s % 60;

    }


   public void ponerEnHora(int md, int hh, int mm, int ss){
      modo=md;
      hora=hh % 24;
      minutos=mm % 60;
      segundos=ss % 60;
   }

   public void incrementar(){
    segundos++;
    if (segundos==60){
    segundos=0;
    minutos++;
    if(minutos==60){
    minutos=0;
    hora=(hora+1)%24;
    }

    }

    }

   public void decrementa(){
    segundos--;
    if(segundos<00){
        segundos=59;
        minutos--;
        if(minutos<00){
        minutos=59;
        hora=(hora-1) %24;

        }
    }
   }
   public String verHora(){

       String hms="Son las ";

       if (modo==12){//modo 12 horas    
           hms+=(hora>12)?hora-12:hora;
           hms+= ":"+minutos+":"+segundos;
           hms+=(hora>=12)?"pm":"am";

       }else{//modo 24h
       hms+=hora+":"+minutos+":"+segundos;
       }
   return (hms);
   }
}




Pila

Una pila es una estructura que nos permite apilar elementos y recopilarlos en el orden inverso al cual los apilamos mediante operaciones de desapilar. Esto es lo que se conoce como estructuras LIFO (Last In First Out). De esta manera una pila suele tener 3 operaciones básicas:

  • apilar, añade un elemento a la lista.
  • desapilar, retira un elemento de la lista
  • ¿está vacía?, comprueba si la lista está vacía.

Clase  ya mando Nodo
package pilas;
/**
 * Clase que define los elementos que debe tener un Nodo de la lista.
 * @author xavier
 */
public class Nodo {
    // Variable en la cual se va a guardar el valor.
    private int valor;
    // Variable para enlazar los nodos.
    private Nodo siguiente;
    /**
     * Constructor que inicializamos el valor de las variables.
     */
    public void Nodo(){
        this.valor = 0;
        this.siguiente = null;
    }
    
    // Métodos get y set para los atributos.
    
    public int getValor() {
        return valor;
    }

    public void setValor(int valor) {
        this.valor = valor;
    }

    public Nodo getSiguiente() {
        return siguiente;
    }

    public void setSiguiente(Nodo siguiente) {
        this.siguiente = siguiente;
    }   
}

Esta es la segunda 
Clase Yamada Pila:
package pilas;
/**
 * Clase que define las operaciones básicas que debe tener una pila.
 * @author xavier
 */
public class Pila {
    // Puntero que indica el inicio de la pila o tambein conocida como el
    // tope de la pila.
    private Nodo inicio;
    // Variable para registrar el tamaño de la pila.
    private int tamanio;
    /**
     * Constructor por defecto.
     */
    public void Pila(){
        inicio = null;
        tamanio = 0;
    }
    /**
     * Consulta si la pila esta vacia.
     * @return true si el primer nodo (inicio), no apunta a otro nodo.
     */
    public boolean esVacia(){
        return inicio == null;
    }
    /**
     * Consulta cuantos elementos (nodos) tiene la pila.
     * @return numero entero entre [0,n] donde n es el numero de elementos
     * que contenga la lista.
     */
    public int getTamanio(){
        return tamanio;
    }
    /**
     * Agrega un nuevo nodo a la pila.
     * @param valor a agregar.
     */
    public void apilar(int valor){
        // Define un nuevo nodo.
        Nodo nuevo = new Nodo();
        // Agrega al valor al nodo.
        nuevo.setValor(valor);
        // Consulta si la pila esta vacia.
        if (esVacia()) {
            // Inicializa la pila con el nuevo valor.
            inicio = nuevo;
        }
        // Caso contrario agrega el nuevo nodo al inicio de la pila.
        else{
            nuevo.setSiguiente(inicio);
            inicio = nuevo;
        }
        // Incrementa el contador del tamaño.
        tamanio++;
    } 
    /**
     * Elimina el elemento que se encuentra en el tope de la piala.
     */
    public void retirar(){
        if (!esVacia()) {
            // Asigna como primer nodo al siguiente de la pila.
            inicio = inicio.getSiguiente();
            // Decrementa el contador del tamaño de la pila
            tamanio--;
        }
    }
    /**
     * Consulta el valor del nodo que se encuentra en la cima de la pila
     * @return valor del nodo.
     * @throws Exception 
     */
    public int cima() throws Exception{
        if(!esVacia()){
            return inicio.getValor();
        } else {
            throw new Exception("La pila se encuentra vacia.");
        }
    }
    /**
     * Busca un elemento en la pila.
     * @param referencia valor del nodo a buscar.
     * @return true si el valor de referencia existe en la pila.
     */
    public boolean buscar(int referencia){
        // Crea una copia de la pila.
        Nodo aux = inicio;
        // Bandera para verificar si existe el elemento a buscar.
        boolean existe = false;
        // Recorre la pila hasta llegar encontrar el nodo o llegar al final
        // de la pila.
        while(existe != true && aux != null){
            // Compara si el valor del nodo es igual que al de referencia.
            if (referencia == aux.getValor()) {
                // Cambia el valor de la bandera.
                existe = true;
            }
            else{
                // Avanza al siguiente nodo.
                aux = aux.getSiguiente();
            }
        }
        // Retorna el valor de la bandera.
        return existe;
    }
    /**
     * Elimina un nodo de la pila ubicado por su valor.
     * @param referencia valor de referencia para ubicar el nodo.
     */  
    public void remover(int referencia){
        // Consulta si el valor existe en la pila.
        if (buscar(referencia)) {
            // Crea una pila auxiliar para guardar los valores que se 
            // vayan desapilando de la pila original.
            Nodo pilaAux = null;
            // Recoore la pila hasta llegar al nodo que tenga el valor
            // igual que el de referencia.
            while(referencia != inicio.getValor()){
                // Crea un nodo temporal para agregarlos a la pila auxiliar.
                Nodo temp = new Nodo();
                // Ingresa el valor al nodo temporal.
                temp.setValor(inicio.getValor());
                // Consulta si la pila auxiliar no a sido inicializada.
                if(pilaAux == null){
                    // Inicializa la pila auxiliar.
                    pilaAux = temp;
                }
                // Caso contrario si la pila auxiliar ya contiene elementos
                // los agrega al inicio.
                else{
                    temp.setSiguiente(pilaAux);
                    pilaAux = temp;
                }
                // Elimina el nodo del tope de la pila hasta llegar al nodo
                // que se desea eliminar.
                retirar();
            }
            // Elimina el nodo que coincide con el de referencia.
            retirar();
            // Regresa los valores de la pila auxiliar a la pila original
            // mientras la pila auxiliar tenga elementos.
            while(pilaAux != null){
                // Utiliza el metodo apilar para regresar los elementos a 
                // la pila original.
                apilar(pilaAux.getValor());
                // Avansa al siguiente nodo de la pila auxiliar.
                pilaAux = pilaAux.getSiguiente();
            }
            // Libera la memoria utilizada por la pila auxiliar.
            pilaAux = null;
        }
    }    
    /**
     * Actualiza el valor de un nodo en la pila.
     * @param referencia valor del nodo para ubicar el que se desea actualizar.
     * @param valor por el cual se desea remplazar el valor del nodo.
     */
    public void editar(int referencia, int valor){
        // Consulta si el nodo existe en la pila
        if (buscar(referencia)) {
            // Crea una pila auxiliar.
            Nodo pilaAux = null;
            // Recoore la pila hasta llegar al nodo que tenga el valor
            // igual que el de referencia.
            while(referencia != inicio.getValor()){
                // Crea un nodo temporal para agregarlos a la pila auxiliar.
                Nodo temp = new Nodo();
                // Ingresa el valor al nodo temporal.
                temp.setValor(inicio.getValor());
                // Consulta si la pila auxiliar no a sido inicializada.
                if(pilaAux == null){
                    // Inicializa la pila auxiliar.
                    pilaAux = temp;
                }
                // Caso contrario si la pila auxiliar ya contiene elementos
                // los agrega al inicio.
                else{
                    temp.setSiguiente(pilaAux);
                    pilaAux = temp;
                }
                // Elimina el nodo del tope de la pila hasta llegar al nodo
                // que se desea eliminar.
                retirar();
            }
            // Actualiza el valor del nodo.
            inicio.setValor(valor);
            // Regresa los valores de la pila auxiliar a la pila original
            // mientras la pila auxiliar tenga elementos.
            while(pilaAux != null){
                // Utiliza el metodo apilar para regresar los elementos a 
                // la pila original.
                apilar(pilaAux.getValor());
                // Avansa al siguiente nodo de la pila auxiliar.
                pilaAux = pilaAux.getSiguiente();
            }
            // Libera la memoria utilizada por la pila auxiliar.
            pilaAux = null;
        }
    }
    /**
     * Elimina la pila
     */
    public void eliminar(){
        // Elimina el valor y la referencia a los demas nodos.
        inicio = null;
        // Reinicia el contador a 0.
        tamanio = 0;
    }
    /**
     * Despliega en pantalla los elementos de la pìla.
     */
    public void listar(){
        // Crea una copia de la pila.
        Nodo aux = inicio;
        // Recorre la pila hasta el ultimo nodo.
        while(aux != null){
            System.out.println("|\t" + aux.getValor() + "\t|");
            System.out.println("-----------------");
            aux = aux.getSiguiente();
        }
    }
}
Clase Main
package pilas;
/**
 * Clase principa que implementa los metodos de la clase pila.
 * @author xavier
 */
public class Main {
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Pila pila = new Pila();
        
        System.out.println("<<-- Ejemplo de Pila -->>\n\n");
        
        pila.apilar(4);
        pila.apilar(16);
        pila.apilar(12);
        pila.apilar(8);
        pila.apilar(65);
        
        System.out.println("<<-- Pila -->>");
        pila.listar();
        System.out.println("\n<<-- Tamaño -->");
        System.out.println(pila.getTamanio());
        
        System.out.println("\n<<-- Retirar el elemento del tope de la pila -->>");
        pila.retirar();
        pila.listar();
        System.out.println("Tamaño: " + pila.getTamanio());
        
        System.out.println("\n<<-- Actualizar el valor del nodo con el valor 12 por 24 -->>");
        pila.editar(12, 44);
        pila.listar();
        System.out.println("Tamaño: " + pila.getTamanio());
        
        System.out.println("\n<<-- Eliminar el nodo con el valor 16 -->>");
        pila.remover(16);
        pila.listar();
        System.out.println("Tamaño: " + pila.getTamanio());
        
        System.out.println("\n<<-- Consulta si existe el valor 65 -->>");
        System.out.println(pila.buscar(65));
        
        System.out.println("\n<<-- Elimina la pila -->>");
        pila.eliminar();
        

        System.out.println("\n<<-- Consulta si la pila esta vacia -->>");
        System.out.println(pila.esVacia());
        
        System.out.println("\n\n<<-- Fin de ejemplo pila -->>");
    }
}


Comentarios

Publicar un comentario