Java básico 068. Uso de la interfaz Deque para trabajar con registros.

Utilizando la Interfaz Java Deque.

La interfaz Java Deque java.util.Deque, representa una cola de doble extremo, lo que significa una cola donde puede agregar y eliminar elementos de ambos extremos de la cola. El nombre Deque es una abreviatura de Double Ended Queue.

Para implementar un Deque podemos utilizar dos interfaces, por una parte java.util.LinkedList el más estándar y java.util.ArrayDeque.

La interfaz Java Deque contiene los siguientes métodos para agregarle elementos:

• add(): Agregar elemento al principio de la cola.
• addLast (): Agrega un elemento al final de la cola.
• addFirst (): Agrega un elemento al principio de la cola.

Para eliminar elementos de un Java Deque, puede usarse uno de los siguientes métodos:

• remove(): Elimina el primer elemento.
• removeFirst(): Remueve el primer elemento.
• removeLast(): Remueve el ultimo elemento.

Como ejemplo utilizamos la clase “Usuario” que nos sirve para almacenar como registro, una clase “UsuarioApp” con el método main para la ejecución.

Clase Usuario.

/**
 *
 * @author carlos
 */
public class Usuario {
    //Atributos
    private int id;
    private String nombre;
    private String password;
    
    //Constructores
    public Usuario() {
        
    }

    public Usuario(int id, String nombre, String password) {
        this.id = id;
        this.nombre = nombre;
        this.password = password;
    }

    //Getters y Setters

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
    
}

Clase UsuarioApp

import java.util.Deque;
import java.util.LinkedList;

/**
 *
 * @author carlos
 */
public class DequeApp {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        //Métodos creados más abajo
        Deque<Usuario> usuario = cargar();
        print(usuario);
        eliminar(usuario);
        print(usuario);
    }
    
    static Deque<Usuario> cargar(){
        //Forma de instanciar un Deque utilizando LinkedList
        Deque<Usuario> us = new LinkedList<>();
        //add() agrega elementos al princio. En orden en que llega.
        us.add(new Usuario(1, "Angel", "sng1236"));
        us.add(new Usuario(2, "Perla", "per20145")); 
        //addFirst() agrega justo al principio de la lista
        us.addFirst(new Usuario(3, "Manuela", "mnd23145"));
        //addLast() agrega elemento al final de la lista
        us.addLast(new Usuario(4, "Luis", "lu2345"));
        return us;
    }
    
    static void eliminar(Deque<Usuario> usuario){
        System.out.println("----------------------");
        System.out.println("Removiendo elementos");
        //Remueve el primer elemento
        usuario.removeFirst();
        //Remueve el último elemento.
        usuario.removeLast();
        
    }
    
    static void print(Deque<Usuario> usuario){
        System.out.println("Imprimiendo Datos.");
        for(Usuario us : usuario){
            System.out.println("______________________________");
            System.out.println("ID: " + us.getId());
            System.out.println("Nombre: " + us.getNombre());
            System.out.println("Password: " + us.getPassword());
        }
    }
    
}

Resultado.

Java básico 067. Uso de Pila -Stack- para trabajar con registros

Utilización de la clase Stack. Estructura de datos tipo pila.

La clase Java Stackjava.util.Stack , es una estructura de datos de pila clásica. Puede insertar elementos en la parte superior de una pila de Java y volver a abrirlos, lo que significa leer y eliminar los elementos de la parte superior de la pila.

Un Stack posee varios método propios, que le permiten gestionar los elementos agregados de una forma diferente a una interfaz List.

Como ejemplo utilizaremos una clase “Usuario”, de la cual crearemos instancias que se irán agregando a la cola. Necesitaremos una clase main para crear los métodos y ejecutarlos.

Clase Usuario.

/**
 *
 * @author carlos
 */
public class Usuario {
    //Atributos
    private int id;
    private String nombre;
    private String password;
    
    //Constructores
    public Usuario() {
        
    }

    public Usuario(int id, String nombre, String password) {
        this.id = id;
        this.nombre = nombre;
        this.password = password;
    }

    //Getters y Setters

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
    
}

Clase main “StackApp” que será el ejecutable.

import java.util.Stack;

/**
 *
 * @author carlos
 */
public class StackApp {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        //Rellenando Pila.
        Stack<Usuario> usuarios = usuarios();
        //Método propio de una pila, obtener el último elemento agregado
        System.out.println("Último elemento: " + usuarios.peek().getNombre());
        //Llamando al método para imprimir        
        print(usuarios);
        //Llamando al método para vaciar.
        vaciar(usuarios);
    }
    
    //Utilizamos un método para cargar los elementos en la pila
    //El método retorna una pila de "Usuarios"
    public static Stack<Usuario> usuarios(){
        //Se instancia utilizando new Stack<>()
        Stack<Usuario> usuarios = new Stack<>();
        //Se agregan registros de usuario a la pila.
        //Hay diferentes formas de agregar elementos a la pila
        //Utilizando add
        usuarios.add(new Usuario(1, "Jorge", "jorge2019"));
        //Utilizando push, método propia de una pila
        usuarios.push(new Usuario(2, "Anibal", "pass123"));
        usuarios.push(new Usuario(3, "Miguel", "mg2020"));
        usuarios.push(new Usuario(4, "Ariel", "arl2220"));  
        usuarios.push(new Usuario(5, "Sonia", "sn1980"));
        //Retornamos una pila de usuario.
        return usuarios;
    }
    
    public static void vaciar(Stack<Usuario> usuarios){
        System.out.println("Vaciando pila");
        System.out.println("_____________");
        //Se utiliza el método pop() para vaciar la pila
        //Se recorre la pila hasta que quede vacío
        while(!usuarios.isEmpty()){
            usuarios.pop();
        }
        System.out.println("Pila vacía.");
    }
    
    //Método para imprimir
    public static void print(Stack<Usuario> usuarios){
        System.out.println("Imprimiendo datos de Usuarios");
        System.out.println("_____________________________");
        //Utilizamos foreach para acceder a cada registro usuario y mostrarlo
        for(Usuario u: usuarios){
            System.out.println("Id: " + u.getId());
            System.out.println("Nombre: " + u.getNombre());
            System.out.println("Password: " + u.getPassword());
            System.out.println("_________________________________");
        }
    }
    
}

Resultado del ejemplo.

Java básico 065. Factorial de Números de 1 al 10.

Ejercicio: Realizar el factorial de números de 1 al 10.

/**
 *
 * @author carlos
 */
public class Factoriales {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        System.out.println("Factorial de números de 1 al 10");
        System.out.println("_______________________________");
        long factorial = 1;
        for (int num = 1; num <= 10; num++) {
            for (int i = num; i > 0; i--) {
                factorial = factorial * i;
            }
            System.out.println("El factorial de " + num + " es: " + factorial);
            factorial = 1;//Reiniciar el valor del factorial por cada vuelta
        }
    }
    
}

Resultado.

Java básico 064. Función, calculando números primos.

Función para realizar cálculos de números primos en Java.

Ejercicio: Realizar una función que permita calcular números primos en un rango específico.

Con esta primera clase calculamos si el número ingresado por el usuario es primo o no.

import java.util.Scanner;

/**
 *
 * @author ECS
 */
public class NumerosPrimos {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        //Scanner para obtener datos de la consola.
        Scanner s = new Scanner(System.in);
        System.out.print("Ingresa un número para ver si es primo: ");
        //Guardamos en una variable el número ingresado
        int n = s.nextInt();
        //ejecutamos nuestra función
        boolean esPrimo = esPrimo(n);
        //Si devuelve True no es primo, por tanto ! negamos para ajustar al código
        if(!esPrimo){
            System.out.println("El número " + n + " es Primo."); 
        }
        else{
            System.out.println("El número " + n + " no es Primo."); 
        }
    }
    //La función recibe un entero como argumento
    static boolean esPrimo(int n){
        //inicializamos una variable boolean
        boolean b = false;
        //Los número negativo no entran como primos
        if(n < 0){
            b = true;
        }
        //El 1,2,3,5 son primos conocidos por tanto las obviamos
        else if(n != 1 && n != 2 && n != 3 && n != 5){
            //Con un for recorremos los números intermedios en 1 y n
            //Comprobamos que el módulo con alguno de ellos de 0-cero
            for (int i = 2; i < n; i++) {
               //Si b es true, demuestra que n no es primo
               if(b){
                   break;
               }
               b = (n%i == 0);
            }            
        }
        //Si n es 1,2,3 o 5 se false, que es primo.
        else{
            b = false;
        }
        return b;
    }
    
}

Con la segunda clase podremos especificar un rango de números, en esta caso listamos los numero primos del 1 al 1000. Abajo anexamos una imagen con los primos del 1 al 1000; sirve para comprobar la funcionalidad del código.

/**
 *
 * @author ECS
 */
public class NumerosPrimosDos {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        //Utilizamos un for para comprobar los números primos del 1 al 1000
        int total = 0;
        for (int i = 0; i < 1000; i++) {
            boolean esPrimo = esPrimo(i);
            if(!esPrimo){
                System.out.println("- " + i);
                total++;
            }
        }
        System.out.println("Hay un total de " + total + " números primos.");
    }
    //La función recibe un entero como argumento
    static boolean esPrimo(int n){
        //inicializamos una variable boolean
        boolean b = false;
        //Los números negativos no entran como primos, el 1-uno tampoco
        if(n <= 0 || n == 1){
            b = true;
        }
        //El 2,3,5 son primos conocidos por tanto las obviamos
        else if(n != 2 && n != 3 && n != 5){
            //Con un for recorremos los números intermedios en 1 y n
            //Comprobamos que el módulo con alguno de ellos de 0-cero
            for (int i = 2; i < n; i++) {
               //Si b es true, demuestra que n no es primo y salimos del bucle
               if(b){
                   break;
               }
               b = (n%i == 0);
            }            
        }
        //2,3 y 5 son los primeros primos conocidos
        else{
            b = false;
        }
        return b;
    }
    
}

Java básico 063. Función, calcular área de un triángulo utilizando fórmula de Herón

Ejercicio: Calcular área de un triángulo utilizando fórmula de Herón.

public class AreaTriangulo{
    public static void main( String[] args ){
        /*
        Calcular área de un triángulo utilizando fórmula de Herón
        Lados a, b y c.
        Semiperímetro fórmula: s = ((a+b+c)/2);
        El Area: area = raiz(s * ((s-a)*(s-b)*(s-c)))
        */
            double a;

            a = area(5, 4, 4);
            System.out.println("El área de un triangulo con los lados 5,4,4 es: " + a);

            a = area(4, 4, 4);
            System.out.println("El área de un triangulo con los lados 4,4,4 es: " + a);

            a = area(5, 3, 4);
            System.out.println("El área de un triangulo con los lados 5,3,4 es: " + a );

            a = area(3, 3, 3);
            System.out.println("El área de un triangulo con los lados 3,3,3 es: " + a );
 }
    public static double area( double a, double b, double c ){
        double s = ((a+b+c)/2);
        double area = (Math.sqrt(s * ((s-a)*(s-b)*(s-c))));
        return area;    
    }
}

Java básico 062. Función, utilizando StringTokenizer.

Ejercicio: Desarrollar una función aplicando el objeto StringTokenizer.

import java.util.StringTokenizer;

/**
 *
 * @author Ariel
 */
public class TokenUso {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        //Creamos una variable tipo String, la declaramos de forma que,
        //cada sección este dividida por un caracter especial.
        String cuentas="1@ACTIVO.*1$no#"+
        "11@ACTIVO CORRIENTE.*1$no#"+
        "111@EFECTIVO Y OTROS MEDIOS LÍQUIDOS.*1$no#"+
        "1111@Disponibles.*1$no#"+
        "111101@Caja.*1$si#"+
        "111102@Fondo Fijo.*1$si#"+
        "111103@Caja moneda extranjera.*1$si#"+
        "111104@Valores por depositar.*1$si#"+
        "1112@Bancos.*1$no#"+
        "111201@Banco Regional Cta. Cte.*1$si#"+
        "111202@Banco Regional Caja de ahorro.*1$si#"+
        "111203@Banco Fomento Cta. Cte.*1$si#"+
        "111204@Banco Fomento Caja de ahorro.*1$si#"+
        "111205@Banco Continental Cta. Cte.*1$si#"+
        "111206@Banco Continental Caja de ahorro.*1$si#"+
        "111207@Banco Itapúa Cta. Cte.*1$si#"+
        "111208@Banco Itapúa Caja de ahorro.*1$si#"+
        "1113@Otros equivalentes al efectivo.*1$no#"+
        "111301@Banco Regional plazo fijo.*1$si#"+
        "111302@Banco Regional certificado de depósito de ahorro.*1$si#"+
        "111303@Banco Fomento plazo fijo.*1$si#"+
        "111304@Banco Fomento certificado de depósito de ahorro.*1$si#";
        //Llamamos a nuestra función y le pasamos nuestra variable como argumento.
        usoToken(cuentas);
    }
    
    static void usoToken(String info){
        //Creamos un objeto tipo StringTokenizer, como primer argumento le pasamos
        //una variable tipo String especialmente creada, el segundo argumento entre comillas
        //corresponde a los caracteres que servirán para indicar cada token,
        //en este caso utilizamos "@*$#", lo cual indica que tendremos cuatro tokens.
        StringTokenizer token = new StringTokenizer(info,"@*$#");
        //Utilizamos un "while" para recorrer el String, y extraer los tokens
        while (token.hasMoreTokens()) {
            //Cada variable String almacena un token.
            String cuenta = token.nextToken();
            String nombre = token.nextToken();
            String grupo = token.nextToken();
            String imputable = token.nextToken();
            //Podemos imprimir el resultado o almacenar en una lista.
            System.out.println(cuenta + " - " + nombre + " - " + grupo + " - " + imputable );            
        }
        //Todo esto es útil para crear plantillas.
    }
}

Java básico 061. Función, imprimir un rombo hueco utilizando asteriscos “*”.

Ejercicio: Diseñe una función que lea un número entero del teclado y escriba un rombo (hueco) con asteriscos (*), según el siguiente ejemplo para un número leído con valor 5:

    *
   * *
  *   *
 *     *
*       *
 *     *
  *   *
   * *
    *

import java.util.Scanner;

/**
 *
 * @author Ariel
 */
public class FuncionDibujOcho {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        //Declaramos un entero, cantidad de elementos.
        int n;
        //Utilizamos Scanner para capturar datos del teclado.
        Scanner num = new Scanner(System.in);  
        //El try sirve para capturar las excepciones de entrada de datos.
        try {
            System.out.print("Ingresa una cantidad entera: ");
            //Forma de capturar datos de teclado con Scanner.
            n = num.nextInt();
            //Llamamos la función pasando el entero capturado como argumento.
            asterisco(n);
        } catch (Exception e) {
            //En caso que el dato ingresado no sea de tipo entero, se indica el error.
            System.out.println("ERROR: se espera dato entero.");
        }
    }
    //Creamos la función al cual le pasamos un entero como argumento.
    static void asterisco(int n){
        //Creamos una variable tipo constante para utilizarla.
        final char simbolo = '*';
        //Creamos el primer for.
        //Se hace con un preincremento ++j.
        for (int i = 0; i < n; ++i) {
            //Cada primer for, se hace un salto de línea.
            System.out.println();
            //Utilizamos dos "for" para lograr la forma.
            for (int j = 0; j < n-i-1; ++j) {                      
                System.out.print(" ");           
            }
            for (int j = 0; j < 2*i+1; ++j){
                //Condición para imprimir solo los bordes.
                if ((i==0)||(j==0)||(j==2*i)) {
                    System.out.print(simbolo);
                } else {
                    System.out.print(" ");
                }                
            }            
        }
        //Se utiliza otro grupo de for para lograr la forma de "rombo"
        for (int j = n-2; j >= 0; --j) {
            System.out.println();
            //Utilizamos dos "for" para lograr la forma.
            for (int i = 0; i < n-j-1; ++i) {                
                System.out.print(" ");
            }
            for (int i = 0; i < 2*j+1; ++i) {
                //Condición para imprimir solo los bordes.
                if ((j==0)||(i==0)||(i==2*j)) {
                    System.out.print(simbolo);
                } else {
                    System.out.print(" ");
                }                
            }
        }
        System.out.println();
    }
}

Java básico 060. Función, imprimir un rombo relleno utilizando asteriscos “*”.

Ejercicio: Diseñe una función que lea un número entero del teclado y escriba un rombo (relleno) con asteriscos (*), según el siguiente ejemplo para un número leído con valor 5:

    *
   ***
  *****
 *******
*********
 *******
  *****
   ***
    *

import java.util.Scanner;

/**
 *
 * @author Ariel
 */
public class FuncionDibujSiete {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        //Declaramos un entero, cantidad de elementos.
        int n;
        //Utilizamos Scanner para capturar datos del teclado.
        Scanner num = new Scanner(System.in);  
        //El try sirve para capturar las excepciones de entrada de datos.
        try {
            System.out.print("Ingresa una cantidad entera: ");
            //Forma de capturar datos de teclado con Scanner.
            n = num.nextInt();
            //Llamamos la función pasando el entero capturado como argumento.
            asterisco(n);
        } catch (Exception e) {
            //En caso que el dato ingresado no sea de tipo entero, se indica el error.
            System.out.println("ERROR: se espera dato entero.");
        }
    }
    //Creamos la función al cual le pasamos un entero como argumento.
    static void asterisco(int n){
        //Creamos una variable tipo constante para utilizarla.
        final char simbolo = '*';
        //Creamos el primer for.
        //Se hace con un preincremento ++j.
        for (int i = 0; i < n; ++i) {
            //Cada primer for, se hace un salto de línea.
            System.out.println();
            //Utilizamos dos "for" para lograr la forma.
            for (int j = 0; j < n-i-1; ++j) {                      
                System.out.print(" ");           
            }
            for (int j = 0; j < 2*i+1; ++j){
                System.out.print(simbolo);
            }            
        }
        //Se utiliza otro grupo de for para lograr la forma de "rombo"
        for (int j = n-2; j >= 0; --j) {
            System.out.println();
            //Utilizamos dos "for" para lograr la forma.
            for (int i = 0; i < n-j-1; ++i) {
                System.out.print(" ");
            }
            for (int i = 0; i < 2*j+1; ++i) {
                System.out.print(simbolo);
            }
        }
        System.out.println();
    }
}

Java básico 059. Función, imprimir un triángulo hueco utilizando asteriscos “*”.

Ejercicio: Diseñe una función que lea un número entero del teclado y escriba un triángulo (hueco) con tantos asteriscos (*) de altura como indique el número leído.

Por ejemplo, para un número leído con valor 5, escribirá:

    *
   * *
  *   *
 *     *
*********

import java.util.Scanner;

/**
 *
 * @author Ariel
 */
public class FuncionDibujSeis {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        //Declaramos un entero, cantidad de elementos.
        int n;
        //Utilizamos Scanner para capturar datos del teclado.
        Scanner num = new Scanner(System.in);  
        //El try sirve para capturar las excepciones de entrada de datos.
        try {
            System.out.print("Ingresa una cantidad entera: ");
            //Forma de capturar datos de teclado con Scanner.
            n = num.nextInt();
            //Llamamos la función pasando el entero capturado como argumento.
            asterisco(n);
        } catch (Exception e) {
            //En caso que el dato ingresado no sea de tipo entero, se indica el error.
            System.out.println("ERROR: se espera dato entero.");
        }
    }
    //Creamos la función al cual le pasamos un entero como argumento.
    static void asterisco(int n){
        //Creamos una variable tipo constante para utilizarla.
        final char simbolo = '*';
        //Creamos el primer for.
        //Se hace con un preincremento ++j.
        for (int i = 0; i < n; ++i) {
            //Cada primer for, se hace un salto de línea.
            System.out.println();
            //Utilizamos dos for para lograr la forma.
            for (int j = 0; j < n-i-1; ++j) {                      
                System.out.print(" ");           
            }
            for (int j = 0; j < 2*i+1; ++j){
                //Condición para imprimir solo los bordes.
                if ((i==0)||(i==n-1)||(j==0)||(j==2*i)) {
                    System.out.print(simbolo);
                }
                else{
                   System.out.print(" ");  
                }
                
            }
        }
        System.out.println();
    }
}

Java básico 058. Función, imprimir un triángulo relleno utilizando asteriscos “*”.

Ejercicio: Diseñe una función que lea un número entero del teclado y escriba un triángulo (relleno) con tantos asteriscos (*) de altura como indique el número leído.

Por ejemplo, para un número leído con valor 5, escribirá:

    *
   ***
  *****
 *******
*********

import java.util.Scanner;

/**
 *
 * @author Ariel
 */
public class FuncionDibujCinco {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        //Declaramos un entero, cantidad de elementos.
        int n;
        //Utilizamos Scanner para capturar datos del teclado.
        Scanner num = new Scanner(System.in);  
        //El try sirve para capturar las excepciones de entrada de datos.
        try {
            System.out.print("Ingresa una cantidad entera: ");
            //Forma de capturar datos de teclado con Scanner.
            n = num.nextInt();
            //Llamamos la función pasando el entero capturado como argumento.
            asterisco(n);
        } catch (Exception e) {
            //En caso que el dato ingresado no sea de tipo entero, se indica el error.
            System.out.println("ERROR: se espera dato entero.");
        }
    }
    //Creamos la función al cual le pasamos un entero como argumento.
    static void asterisco(int n){
        //Creamos una variable tipo constante para utilizarla.
        final char simbolo = '*';
        //Creamos el primer for.
        //Se hace con un preincremento ++j.
        for (int i = 0; i < n; ++i) {
            //Cada primer for, se hace un salto de línea.
            System.out.println();
            //Utilizamos dos for para lograr la forma.
            for (int j = 0; j < n-i-1; ++j) {                      
                System.out.print(" ");           
            }
            for (int j = 0; j < 2*i+1; ++j){
                System.out.print(simbolo);
            }
        }
        System.out.println();
    }
}

Java básico 057. Función, imprimir un triángulo rectángulo hueco utilizando asteriscos “*”.

Ejercicio: Diseñe una función que lea un numero entero del teclado y escriba un triángulo rectángulo (hueco) con tantos asteriscos (*) de base y altura como indique el número leído.

Por ejemplo, para un número leído con valor 5, escribirá:

*
**
* *
*  *
*****

import java.util.Scanner;

/**
 *
 * @author Ariel
 */
public class FuncionDibujCuatro {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        //Declaramos un entero, cantidad de elementos.
        int n;
        //Utilizamos Scanner para capturar datos del teclado.
        Scanner num = new Scanner(System.in);  
        //El try sirve para capturar las excepciones de entrada de datos.
        try {
            System.out.print("Ingresa una cantidad entera: ");
            //Forma de capturar datos de teclado con Scanner.
            n = num.nextInt();
            //Llamamos la función pasando el entero capturado como argumento.
            asterisco(n);
        } catch (Exception e) {
            //En caso que el dato ingresado no sea de tipo entero, se indica el error.
            System.out.println("ERROR: se espera dato entero.");
        }
    }
    //Creamos la función al cual le pasamos un entero como argumento.
    static void asterisco(int n){
        //Creamos una variable tipo constante para utilizarla.
        final char simbolo = '*';
        //Creamos el primer for.
        //Se hace con un preincremento ++j.
        for (int i = 0; i < n; ++i) {
            //Cada primer for, se hace un salto de línea.
            System.out.println();
            //Anidamos otro for con el mismo proceso.
            for (int j = 0; j <= i; ++j) {
                //Establecemos una condición para que se imprima el "*".
                if(((i==0)||(i==n-1)||(j==0)||(j==i))){                    
                    System.out.print(simbolo);
                }
                else{
                    System.out.print(" ");
                }
            }            
        }
        System.out.println();
    }
}

Java básico 056. Función, imprimir un triángulo rectángulo lleno utilizando asteriscos “*”.

Ejercicio: Diseñe una función que lea un número entero del teclado y escriba un triángulo rectángulo (relleno) con tantos asteriscos (*) de base y altura como indique el número leído.

Por ejemplo, para un número leído con valor 5, escribirá:

*
**
***
****
*****

import java.util.Scanner;

/**
 *
 * @author Ariel
 */
public class FuncionDibujTres {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        //Declaramos un entero, cantidad de elementos.
        int n;
        //Utilizamos Scanner para capturar datos del teclado.
        Scanner num = new Scanner(System.in);  
        //El try sirve para capturar las excepciones de entrada de datos.
        try {
            System.out.print("Ingresa una cantidad entera.");
            //Forma de capturar datos de teclado con Scanner.
            n = num.nextInt();
            //Llamamos la función pasando el entero capturado como argumento.
            asterisco(n);
        } catch (Exception e) {
            //En caso que el dato ingresado no sea de tipo entero, se indica el error.
            System.out.println("ERROR: se espera dato entero.");
        }
    }
    //Creamos la función al cual le pasamos un entero como argumento.
    static void asterisco(int n){
        //Creamos una variable tipo constante para utilizarla.
        final char simbolo = '*';
        //Creamos el primer for.
        //Se hace con un preincremento ++i al igual que ++j.
        for (int i = 0; i < n; ++i) {
            //Cada primer for, se hace un salto de línea.
            System.out.println();
            //Anidamos otro for con el mismo proceso.            
            //Mientra "j" sea menor o igual a "i" se imprime, esto dará forma al
            //Triángulo Rectángulo..
            for (int j = 0; j <= i; ++j) {                
                    System.out.print(simbolo);                
            }            
        }
        System.out.println();
    }
}

Java básico 055. Función, imprimir un cuadrado lleno utilizando asteriscos “*”.

Ejercicio: Diseñe una función que lea un número entero del teclado y escriba un cuadrado (relleno) con tantos asteriscos (*) de lado como indique el número leído. Por ejemplo, para un número leído con valor 5, escribirá:

*****
*****
*****
*****
*****

import java.util.Scanner;

/**
 *
 * @author Ariel
 */
public class FuncionDibujDos {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        //Declaramos un entero, cantidad de elementos.
        int n;
        //Utilizamos Scanner para capturar datos del teclado.
        Scanner num = new Scanner(System.in);  
        //El try sirve para capturar las excepciones de entrada de datos.
        try {
            System.out.print("Ingresa una cantidad entera.");
            //Forma de capturar datos de teclado con Scanner.
            n = num.nextInt();
            //Llamamos la función pasando el entero capturado como argumento.
            asterisco(n);
        } catch (Exception e) {
            //En caso que el dato ingresado no sea de tipo entero, se indica el error.
            System.out.println("ERROR: se espera dato entero.");
        }
    }
    //Creamos la función al cual le pasamos un entero como argumento.
    static void asterisco(int n){
        //Creamos una variable tipo constante para utilizarla.
        final char simbolo = '*';
        //Creamos el primer for.
        //Se hace con un preincremento ++j.
        for (int i = 0; i < n; ++i) {
            //Cada primer for, se hace un salto de línea.
            System.out.println();
            //Anidamos otro for con el mismo proceso.
            for (int j = 0; j < n; ++j) {                
                    System.out.print(simbolo);                
            }            
        }
        System.out.println();
    }
}

Java básico 054. Función, cálculo de x^y utilizando multiplicación sucesiva.

Ejercicio: Diseñe un programa que lea de teclado dos números enteros (x e y) y escriba en pantalla el resultado de calcular la potencia de x elevado a y (x^y), mediante multiplicaciones sucesivas. Por ejemplo, 2^3 = 2x2x2.

import java.util.Scanner;

/**
 *
 * @author Ariel
 */
public class MultiSuce {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        //Declaramos dos variable enteras.
        int x, y;
        //Utilizamos Scanner para capturar datos.
        Scanner num = new Scanner(System.in);
        //Solicitamos los datos necesarios.
        System.out.println("Ingresa la base y el exponenete.");
        System.out.print("Base: ");
        x = num.nextInt();
        System.out.print("Exponente: ");
        y = num.nextInt();
        //Ejecutamos la función pasándole los argumentos necesarios.
        long multSus = multSuc(x, y);
        System.out.println("Resultado " + x + "^" + y + " = " + multSus);
    }
    //Creamos una función con retorno tipo long y dos argumentos tipo enteros.
    static long multSuc(int x, int y){
        long exp = 1;
        //Comprobamos que los datos ingresados no sean ceros.
        if(x != 0 && y != 0){
            //Utilizamos un bucle for para la multiplicación sucesiva.
            //Se hará la multiplicación tantas veces como el exponente ingresado.
            for (int i = 1; i <= y; i++) {
                //Esto representa exp = exp * x;
                exp *= x;
            }
 
        }
        //Retornamos el resultado.
        return exp;
    }
}

Java básico 053. Función, obtener multiplicación de (m * n) utilizando ciclo.

Ejercicio: Desarrollar una función que lea del teclado dos números enteros y escriba en pantalla el resultado de multiplicar ambos números, teniendo en cuenta que no se permite utilizar la operación de multiplicar (*), por lo que se deberá realizar mediante sumas sucesivas. Por ejemplo, 2 x 3 = 2 + 2 + 2.

import java.util.Scanner;

/**
 *
 * @author Ariel
 */
public class MultiFor {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        //Declaramos dos variables tipo entero.
        int m, n;
        //Utilizamos Scanner para capturar datos del teclado.
        Scanner num = new Scanner(System.in);
        //Solicitamos los datos.
        System.out.println("Introduce dos número enteros (m*n).");
        System.out.print("Introduce m: ");
        m = num.nextInt();
        System.out.print("Introduce n: ");
        n = num.nextInt();
        //Llamamos a la función que creamos, pasandole los dos parámetros.
        int multi = multi(m, n);
        //Imprimimos datos.
        System.out.println("La multiplicación ("+m+"*"+n+")= "+multi);
    }
    //Creamos la función con retorno tipo entero y dos parámetros.
    static int multi(int m, int n){
        int mul = 0;
        //Establecemos condición de que (m y n) no sean cero.
        if((m != 0) && (n != 0)){
            //Utilizamos un for para ejecutar el ciclo de sumas.
            for (int i = 0; i < n; i++) {
                // += representa (mul = mul + m), solo acorta lo anterior.
                mul += m;
            }
        }
        //Retornamos el resultado.
        //Si m o n es cero, retornará cero.
        return mul;
    }
}

Java básico 052. Función, obtener cociente y resto sin utilizar operaciones de división.

Ejercicio: Diseñe un programa que lea del teclado dos números enteros y escriba en pantalla el cociente y resto de la división de ambos números, teniendo en cuenta que no se permite utilizar las operaciones de división y resto (/, %), por lo que se deberá realizar mediante restas sucesivas.

Ejemplo: 7 / 2 = (7 -2 = 5; 5 -2 = 3 ; 3 -2 = 1 =) Cociente = 3 ; Resto = 1.

import java.util.Scanner;

/**
 *
 * @author Ariel
 */
public class JavaCal {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        //Declaramos dos variables enteras.
        int dividendo;
        int divisor;
        //Utilizamos Scanner para capturar valores desde el teclado.
        Scanner num = new Scanner(System.in);
        //Utilizamos "try" para controlar posibles errores de entrada de datos.
        try {
            //Procedemos a capturar los valores.
            System.out.print("Ingresa el dividendo: ");
            dividendo = num.nextInt();
            System.out.print("Ingresa el divisor: ");
            divisor = num.nextInt();
            //Después de obtener los datos llamamos nuestra función.
            calculo(dividendo, divisor);
        } catch (Exception e) {
            System.out.println("Error de datos: " + e);
        }
    }
    //Creamos nuestra función sin retorno.
    //La función requerirá 2 parámetros.
    static void calculo(int dividendo, int divisor){
        int resto;
        int cociente = 0;
        //Condición en caso que número sea negativo o cero.
        if(divisor <= 0){
            System.out.println("No se puede realizar operación.");
        }
        else{
            //Arreglos para mejorar el formato de impresión.
            int y = dividendo - divisor;
            System.out.println("(" + dividendo + "/" + divisor + ")" );
            System.out.print("(" + dividendo + "-" + divisor + "=" + y + ")" );
            resto = dividendo;
            //Un bucle para realizar los cálculos necesarios.
            while (resto >= divisor) {
                resto -= divisor;
                int var = resto - divisor;
                ++cociente;
                //Por cada ciclo imprimimos los valores intermedios.
                if(resto > divisor){
                    System.out.print("("+ resto + "-" + divisor + "=" + var + ")");
                }
                
            }
            //Al termina el ciclo nos retorna los valores finales.
            System.out.println("\nCociente: " + cociente + " ; " + "Resto: " + resto);
        }
    }
}

Java básico 051. Función, imprimir un cuadrado hueco utilizando asteriscos “*”.

Ejercicio: Desarrollar una función que lea un número entero de teclado y escriba un cuadrado (hueco) con tantos asteriscos (*) de lado como indique el número leído. Por ejemplo, para un número leído con valor 5, escribirá:

*****
*   *
*   *
*   *
*****

import java.util.Scanner;

/**
 *
 * @author Ariel
 */
public class FuncionDibuj {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        //Declaramos un entero, cantidad de elementos.
        int n;
        //Utilizamos Scanner para capturar datos del teclado.
        Scanner num = new Scanner(System.in);  
        //El try sirve para capturar las excepciones de entrada de datos.
        try {
            System.out.print("Ingresa una cantidad entera.");
            //Forma de capturar datos de teclado con Scanner.
            n = num.nextInt();
            //Llamamos la función pasando el entero capturado como argumento.
            asterisco(n);
        } catch (Exception e) {
            //En caso que el dato ingresado no sea de tipo entero, se indica el error.
            System.out.println("ERROR: se espera dato entero.");
        }
    }
    //Creamos la función al cual le pasamos un entero como argumento.
    static void asterisco(int n){
        //Creamos una variable tipo constante para utilizarla.
        final char simbolo = '*';
        //Creamos el primer for.
        //Se hace con un preincremento ++j.
        for (int i = 0; i < n; ++i) {
            //Cada primer for, se hace un salto de línea.
            System.out.println();
            //Anidamos otro for con el mismo proceso.
            for (int j = 0; j < n; ++j) {
                //Establecemos una condición para que se imprima el "*".
                if((i == 0) || (i == n-1) || (j == 0) || (j == n - 1)){
                    System.out.print(simbolo);
                }
                else{
                    System.out.print(" ");
                }
            }            
        }
        System.out.println();
    }
}

Java básico 050. Función, obtener semanas, días y HH:mm:ss de cierta cantidad de segundos.

Ejercicio: Desarrollar una función que lea de teclado una cierta cantidad de segundos y muestre su equivalente en semanas, días, horas, minutos y segundos.

Ejemplo: 2178585 segundos equivalen a [3] semanas, 4 días, 05:09:45.

import java.util.Scanner;

/**
 *
 * @author Ariel
 */
public class FuncionSeg {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        //Obtenemos los segundos con la función.
        int segundos = segundos();
        //Obtenemos el resultado.
        String calculos = calculos(segundos);
        //Imprimimos el resultado.
        System.out.println(calculos);
        
    }
    static String calculos(int s){
        //Declaramos constantes enteros, representan valores absolutos.
        final int segMin = 60;
        final int minHora = 60;
        final int horaDia = 24;
        final int diaSemana = 7;
        final int segHora = segMin * minHora;
        final int segDia = segHora * horaDia;
        final int segSemana = segDia * diaSemana;
        //Especificamos el valor de cada variable.
        int semana = s / segSemana;
        //Con el resto seguimos el proceso descendiente.
        int resto = s % segSemana;
        int dia = resto / segDia;
        resto = resto % segDia;
        int hora = resto / segHora;
        String horaS = hora + "";
        //Un pequeño arreglo para mostrar formato HH:mm:ss.
        if(hora < 10)horaS = "0" + horaS;
        resto = resto % segHora;
        int minuto = resto / segMin;
        String minutoS = minuto + "";
        if(minuto < 10)minutoS = "0" + minutoS;
        int segundo = resto % segMin;
        String segundoS = segundo + "";
        if(segundo < 10)segundoS = "0" + segundoS;
        //Almacenamos todo el resultado en un String usando concatenación.
        String res = (s + " segundos representan " + "[" + semana + "]" + " semanas "
                + "[" + dia + "]" + " días y " + horaS +":" + minutoS + ":" + segundoS );
        //Retornamos ese valor.
        return res;
    }
    //Utilizamos una función para capturar los segundos del usuario.
    static int segundos(){
        int segundos;
        Scanner seg = new Scanner(System.in);
        //Utilizamos un try para comprobar que los datos sean enteros.
        try {
            System.out.print("Ingresa los segundo para comprobar: ");
            segundos = seg.nextInt();
        } catch (Exception e) {
           //En caso que no sea entero volvemos a lanzar la función.
           System.out.println("ERROR: Ingresar datos numéricos entero.");
           segundos = segundos();
        }
        return segundos;
    }
}

Java básico 049. Función, obtener el máximo de un “Array” utilizando recursividad.

Ejercicio: Desarrollar una función que calcule el valor máximo de una tabla (array) de forma recursiva.

/**
 *
 * @author Ariel
 */
public class TablaMax {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        //Creamos un array con 10 elementos.
        int t[] = new int[10];
        //Cargamos el array con números generados de forma aleatoria.
        for (int i = 0; i < t.length; i++) {
            t[i] = (int) (Math.random() * 1000 + 1);
        }
        //Imprimimos los datos del array
        System.out.println("Imprimiendo tabla.");
        for (int i = 0; i < t.length; i++) {
            int j = t[i];
            System.out.print("[" + j + "]");
        }
        System.out.println("\nObteniendo el máximo.");
        //Usamos la segunda función que retorna el valor del primero.
        int maximo = maximo(t);
        System.out.println("El máximo de la tabla es: " + "[" + maximo + "]");
        
    }
    static int maximo(int t[], int pos){
        //A la función le pasamos 2 argumentos. El array y la posición inicial del índice.
        int res;
        //Si llegamos al final del array significa que el último es el máximo.
        if(pos == t.length - 1){
            res = t[pos];
        }
        else{
            //Vamos iterando el array utilizando recursividad.
            int k = maximo(t, pos + 1);
            if (t[pos] > k){
                res = t[pos];
            }
            else{
                res = k;
            }
        }
        return res;
    }
    //Sobrecargamos la primera función, a esta solo le pasamos un argumento, 
    //que es el array. La función retorna un entero que será el maximo llamando
    //la primera función.
    static int maximo(int t[]){
        return maximo(t, 0);
    }
}