Java – Conversor de bases numéricas

1 comentario / Algoritmos, java, Matemáticas discretas / Por

En este post te mostraré un pequeño conversor de números en Java. Es un programa que convierte de binario a decimal, de decimal a binario, de hexadecimal a octal, etcétera. Soporta las siguientes bases:

  • Binario
  • Octal
  • Decimal
  • Hexadecimal

Soportando la conversión entre cualquiera de estas bases. Al inicio el programa pregunta cómo se quiere convertir el número y luego se muestra el resultado.

Conversor de números en Java – Binario, octal, decimal y hexadecimal

Algoritmo general

En total son 12 conversiones ya que vamos a convertir de Binario a octal, decimal y hexadecimal. De Octal a binario, decimal y hexadecimal. Así por cada base numérica.

Para evitar hacer todos esos métodos, vamos a usar una base común. Solo vamos a hacer la conversión de Decimal a todas las bases, y a la inversa.

Así, por ejemplo, para convertir de binario a octal simplemente convertimos de binario a decimal, y una vez que tenemos el decimal, de decimal a octal.

De este modo nos evitamos por ejemplo el método de convertir directamente binario a octal. Así haremos para todos los métodos.

Métodos de conversión

Las siguientes funciones nos van a ayudar a transformar entre números usando Java. Tenemos los métodos que convierten de decimal a otras bases, y más tarde de otras bases a decimal.

//De Decimal a otras bases
public static String decimalABinario(int decimal) {
    String binario = "";
    while (decimal > 0) {
        binario = decimal % 2 + binario;
        decimal = decimal / 2;
    }
    return binario;
}

public static String decimalAOctal(int decimal) {
    int residuo;
    String octal = "";
    char[] caracteresOctales = {'0', '1', '2', '3', '4', '5', '6', '7'};
    while (decimal > 0) {
        residuo = decimal % 8;
        char caracter = caracteresOctales[residuo];
        octal = caracter + octal;
        decimal = decimal / 8;
    }
    return octal;
}

public static String decimalAHexadecimal(int decimal) {
    int residuo;
    String hexadecimal = "";
    char[] caracteresHexadecimales = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
    while (decimal > 0) {
        residuo = decimal % 16;
        char caracterHexadecimal = caracteresHexadecimales[residuo];
        hexadecimal = caracterHexadecimal + hexadecimal;
        decimal = decimal / 16;
    }
    return hexadecimal;
}

// Conversiones de otras bases a decimal
public static int binarioADecimal(int binario) {
    int decimal = 0;
    int potencia = 0;
    // Ciclo infinito hasta que binario sea 0
    while (true) {
        if (binario == 0) {
            break;
        } else {
            int temp = binario % 10;
            decimal += temp * Math.pow(2, potencia);
            binario = binario / 10;
            potencia++;
        }
    }
    return decimal;
}

public static int octalADecimal(int octal) {
    int decimal = 0;
    int potencia = 0;
    // Ciclo infinito que se rompe cuando octal es 0
    while (true) {
        if (octal == 0) {
            break;
        } else {
            int temp = octal % 10;
            decimal += temp * Math.pow(8, potencia);
            octal = octal / 10;
            potencia++;
        }
    }
    return decimal;
}

public static int hexadecimalADecimal(String hexadecimal) {
    String caracteresHexadecimales = "0123456789ABCDEF";
    hexadecimal = hexadecimal.toUpperCase();
    int decimal = 0;
    for (int i = 0; i < hexadecimal.length(); i++) {
        char caracter = hexadecimal.charAt(i);
        int posicionEnCaracteres = caracteresHexadecimales.indexOf(caracter);
        decimal = 16 * decimal + posicionEnCaracteres;
    }
    return decimal;
}

Validación de números

Adicional a la conversión de números, tenemos que crear algunos métodos en Java para validar los datos. Los mismos quedan como se ve a continuación:

// Validadores
public static boolean validarDecimal(int decimal) {
    // Decimal pasa la validación con el hecho de que sea entero
    return true;
}

public static boolean validarBinario(int binario) {
    // Comprobar si solo se compone de unos y ceros
    String binarioComoCadena = String.valueOf(binario);
    for (int i = 0; i < binarioComoCadena.length(); i++) {
        char caracter = binarioComoCadena.charAt(i);
        if (caracter != '0' && caracter != '1') {
            return false;
        }
    }
    return true;
}

public static boolean validarOctal(int octal) {
    // comprobar si solo tiene números del 0 al 7
    String octalComoCadena = String.valueOf(octal);
    String caracteresOctales = "01234567";
    for (int i = 0; i < octalComoCadena.length(); i++) {
        char caracter = octalComoCadena.charAt(i);
        // Si no se encuentra dentro de los caracteres válidos, regresamos false
        if (caracteresOctales.indexOf(caracter) == -1) {
            return false;
        }
    }
    return true;
}

// Nota: se debe enviar la cadena hexadecimal convertida a mayúsculas
public static boolean validarHexadecimal(String hexadecimal) {
    // Comprobar si solo tiene números del 0 al 9 y letras de la A a la F
    String caracteresHexadecimales = "0123456789ABCDEF";
    for (int i = 0; i < hexadecimal.length(); i++) {
        char caracter = hexadecimal.charAt(i);
        // Si no se encuentra dentro de los caracteres válidos, regresamos false
        if (caracteresHexadecimales.indexOf(caracter) == -1) {
            return false;
        }
    }
    return true;
}

En resumen lo que se hace es validar el hexadecimal, octal, decimal o binario analizando que cada uno de sus caracteres sea válido o esté comprendido entre los caracteres que conforman a la base.

Menú de opciones

Ya tenemos la forma de convertir y de validar números. Ahora vamos a crear un menú en Java para poder solicitar al usuario cómo desea realizar la conversión. Queda así:


System.out.println("1. Binario a octal\n" +
        "2. Binario a decimal\n" +
        "3. Binario a hexadecimal\n" +
        "4. Octal a binario\n" +
        "5. Octal a decimal\n" +
        "6. Octal a hexadecimal\n" +
        "7. Decimal a binario\n" +
        "8. Decimal a octal\n" +
        "9. Decimal a hexadecimal\n" +
        "10. Hexadecimal a binario\n" +
        "11. Hexadecimal a octal\n" +
        "12. Hexadecimal a decimal\n" +
        "Seleccione: ");
Scanner sc = new Scanner(System.in);
int eleccion = sc.nextInt();
if (eleccion < 1 || eleccion > 12) {
    System.out.println("Elección no válida");
    return;
}
Scanner scanner = new Scanner(System.in);
switch (eleccion) {
    case 1:
        System.out.println("Ingrese número binario:");
        int binario = scanner.nextInt();
        if (!validarBinario(binario)) {
            System.out.println("Número no válido");
            return;
        }
        int decimal = binarioADecimal(binario);
        String octalResultante = decimalAOctal(decimal);
        System.out.println("El octal es " + octalResultante);
        break;
    case 2:
        System.out.println("Ingrese número binario:");
        binario = scanner.nextInt();
        if (!validarBinario(binario)) {
            System.out.println("Número no válido");
            return;
        }
        decimal = binarioADecimal(binario);
        System.out.println("El decimal es " + decimal);
        break;

    case 3:
        System.out.println("Ingrese número binario:");
        binario = scanner.nextInt();
        if (!validarBinario(binario)) {
            System.out.println("Número no válido");
            return;
        }
        decimal = binarioADecimal(binario);
        String hexadecimal = decimalAHexadecimal(decimal);
        System.out.println("El hexadecimal es " + hexadecimal);
        break;
    case 4:
        System.out.println("Ingrese número octal:");
        int octal = scanner.nextInt();
        if (!validarOctal(octal)) {
            System.out.println("Número no válido");
            return;
        }
        decimal = octalADecimal(octal);
        String binarioResultante = decimalABinario(decimal);
        System.out.println("El binario es " + binarioResultante);
        break;
    case 5:
        System.out.println("Ingrese número octal:");
        octal = scanner.nextInt();
        if (!validarOctal(octal)) {
            System.out.println("Número no válido");
            return;
        }
        decimal = octalADecimal(octal);
        System.out.println("El decimal es " + decimal);
        break;
    case 6:
        System.out.println("Ingrese número octal:");
        octal = scanner.nextInt();
        if (!validarOctal(octal)) {
            System.out.println("Número no válido");
            return;
        }
        decimal = octalADecimal(octal);
        String hexadecimalResultante = decimalAHexadecimal(decimal);
        System.out.println("El hexadecimal es " + hexadecimalResultante);
        break;
    case 7:
        System.out.println("Ingrese número decimal:");
        decimal = scanner.nextInt();
        if (!validarDecimal(decimal)) {
            System.out.println("Número no válido");
            return;
        }
        binarioResultante = decimalABinario(decimal);
        System.out.println("El binario es " + binarioResultante);
        break;
    case 8:
        System.out.println("Ingrese número decimal:");
        decimal = scanner.nextInt();
        if (!validarDecimal(decimal)) {
            System.out.println("Número no válido");
            return;
        }
        octalResultante = decimalAOctal(decimal);
        System.out.println("El octal es " + octalResultante);
        break;
    case 9:
        System.out.println("Ingrese número decimal:");
        decimal = scanner.nextInt();
        if (!validarDecimal(decimal)) {
            System.out.println("Número no válido");
            return;
        }
        hexadecimalResultante = decimalAHexadecimal(decimal);
        System.out.println("El hexadecimal es " + hexadecimalResultante);
        break;
    case 10:
        System.out.println("Ingrese número hexadecimal:");
        hexadecimal = scanner.nextLine().toUpperCase();
        if (!validarHexadecimal(hexadecimal)) {
            System.out.println("Número no válido");
            return;
        }
        decimal = hexadecimalADecimal(hexadecimal);
        binarioResultante = decimalABinario(decimal);
        System.out.println("El binario es " + binarioResultante);
        break;
    case 11:
        System.out.println("Ingrese número hexadecimal:");
        hexadecimal = scanner.nextLine().toUpperCase();
        if (!validarHexadecimal(hexadecimal)) {
            System.out.println("Número no válido");
            return;
        }
        decimal = hexadecimalADecimal(hexadecimal);
        octalResultante = decimalAOctal(decimal);
        System.out.println("El octal es " + octalResultante);
        break;
    case 12:
        System.out.println("Ingrese número hexadecimal:");
        hexadecimal = scanner.nextLine().toUpperCase();
        if (!validarHexadecimal(hexadecimal)) {
            System.out.println("Número no válido");
            return;
        }
        decimal = hexadecimalADecimal(hexadecimal);
        System.out.println("El decimal es " + decimal);
        break;
}

Sé que el código está algo “sucio” pues se repiten varias cosas, además de que todo se podría encerrar en otras funciones para hacer algo más limpio, pero recuerda que puedes modificar el código si no es de tu agrado 😉

Poniendo todo junto

El código completo para hacer un conversor de bases numéricas en Java se ve a continuación. Recuerda que eres libre de copiarlo y modificarlo:

/*
  ____          _____               _ _           _       
 |  _ \        |  __ \             (_) |         | |      
 | |_) |_   _  | |__) |_ _ _ __ _____| |__  _   _| |_ ___ 
 |  _ <| | | | |  ___/ _` | '__|_  / | '_ \| | | | __/ _ \
 | |_) | |_| | | |  | (_| | |   / /| | |_) | |_| | ||  __/
 |____/ \__, | |_|   \__,_|_|  /___|_|_.__/ \__, |\__\___|
         __/ |                               __/ |        
        |___/                               |___/         
    
____________________________________
/ Si necesitas ayuda, contáctame en \
\ https://parzibyte.me               /
 ------------------------------------
        \   ^__^
         \  (oo)\_______
            (__)\       )\/\
                ||----w |
                ||     ||
Creado por Parzibyte (https://parzibyte.me). Este encabezado debe mantenerse intacto,
excepto si este es un proyecto de un estudiante.
*/
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        System.out.println("1. Binario a octal\n" +
                "2. Binario a decimal\n" +
                "3. Binario a hexadecimal\n" +
                "4. Octal a binario\n" +
                "5. Octal a decimal\n" +
                "6. Octal a hexadecimal\n" +
                "7. Decimal a binario\n" +
                "8. Decimal a octal\n" +
                "9. Decimal a hexadecimal\n" +
                "10. Hexadecimal a binario\n" +
                "11. Hexadecimal a octal\n" +
                "12. Hexadecimal a decimal\n" +
                "Seleccione: ");
        Scanner sc = new Scanner(System.in);
        int eleccion = sc.nextInt();
        if (eleccion < 1 || eleccion > 12) {
            System.out.println("Elección no válida");
            return;
        }
        Scanner scanner = new Scanner(System.in);
        switch (eleccion) {
            case 1:
                System.out.println("Ingrese número binario:");
                int binario = scanner.nextInt();
                if (!validarBinario(binario)) {
                    System.out.println("Número no válido");
                    return;
                }
                int decimal = binarioADecimal(binario);
                String octalResultante = decimalAOctal(decimal);
                System.out.println("El octal es " + octalResultante);
                break;
            case 2:
                System.out.println("Ingrese número binario:");
                binario = scanner.nextInt();
                if (!validarBinario(binario)) {
                    System.out.println("Número no válido");
                    return;
                }
                decimal = binarioADecimal(binario);
                System.out.println("El decimal es " + decimal);
                break;

            case 3:
                System.out.println("Ingrese número binario:");
                binario = scanner.nextInt();
                if (!validarBinario(binario)) {
                    System.out.println("Número no válido");
                    return;
                }
                decimal = binarioADecimal(binario);
                String hexadecimal = decimalAHexadecimal(decimal);
                System.out.println("El hexadecimal es " + hexadecimal);
                break;
            case 4:
                System.out.println("Ingrese número octal:");
                int octal = scanner.nextInt();
                if (!validarOctal(octal)) {
                    System.out.println("Número no válido");
                    return;
                }
                decimal = octalADecimal(octal);
                String binarioResultante = decimalABinario(decimal);
                System.out.println("El binario es " + binarioResultante);
                break;
            case 5:
                System.out.println("Ingrese número octal:");
                octal = scanner.nextInt();
                if (!validarOctal(octal)) {
                    System.out.println("Número no válido");
                    return;
                }
                decimal = octalADecimal(octal);
                System.out.println("El decimal es " + decimal);
                break;
            case 6:
                System.out.println("Ingrese número octal:");
                octal = scanner.nextInt();
                if (!validarOctal(octal)) {
                    System.out.println("Número no válido");
                    return;
                }
                decimal = octalADecimal(octal);
                String hexadecimalResultante = decimalAHexadecimal(decimal);
                System.out.println("El hexadecimal es " + hexadecimalResultante);
                break;
            case 7:
                System.out.println("Ingrese número decimal:");
                decimal = scanner.nextInt();
                if (!validarDecimal(decimal)) {
                    System.out.println("Número no válido");
                    return;
                }
                binarioResultante = decimalABinario(decimal);
                System.out.println("El binario es " + binarioResultante);
                break;
            case 8:
                System.out.println("Ingrese número decimal:");
                decimal = scanner.nextInt();
                if (!validarDecimal(decimal)) {
                    System.out.println("Número no válido");
                    return;
                }
                octalResultante = decimalAOctal(decimal);
                System.out.println("El octal es " + octalResultante);
                break;
            case 9:
                System.out.println("Ingrese número decimal:");
                decimal = scanner.nextInt();
                if (!validarDecimal(decimal)) {
                    System.out.println("Número no válido");
                    return;
                }
                hexadecimalResultante = decimalAHexadecimal(decimal);
                System.out.println("El hexadecimal es " + hexadecimalResultante);
                break;
            case 10:
                System.out.println("Ingrese número hexadecimal:");
                hexadecimal = scanner.nextLine().toUpperCase();
                if (!validarHexadecimal(hexadecimal)) {
                    System.out.println("Número no válido");
                    return;
                }
                decimal = hexadecimalADecimal(hexadecimal);
                binarioResultante = decimalABinario(decimal);
                System.out.println("El binario es " + binarioResultante);
                break;
            case 11:
                System.out.println("Ingrese número hexadecimal:");
                hexadecimal = scanner.nextLine().toUpperCase();
                if (!validarHexadecimal(hexadecimal)) {
                    System.out.println("Número no válido");
                    return;
                }
                decimal = hexadecimalADecimal(hexadecimal);
                octalResultante = decimalAOctal(decimal);
                System.out.println("El octal es " + octalResultante);
                break;
            case 12:
                System.out.println("Ingrese número hexadecimal:");
                hexadecimal = scanner.nextLine().toUpperCase();
                if (!validarHexadecimal(hexadecimal)) {
                    System.out.println("Número no válido");
                    return;
                }
                decimal = hexadecimalADecimal(hexadecimal);
                System.out.println("El decimal es " + decimal);
                break;
        }
    }

    // Validadores
    public static boolean validarDecimal(int decimal) {
        // Decimal pasa la validación con el hecho de que sea entero
        return true;
    }

    public static boolean validarBinario(int binario) {
        // Comprobar si solo se compone de unos y ceros
        String binarioComoCadena = String.valueOf(binario);
        for (int i = 0; i < binarioComoCadena.length(); i++) {
            char caracter = binarioComoCadena.charAt(i);
            if (caracter != '0' && caracter != '1') {
                return false;
            }
        }
        return true;
    }

    public static boolean validarOctal(int octal) {
        // comprobar si solo tiene números del 0 al 7
        String octalComoCadena = String.valueOf(octal);
        String caracteresOctales = "01234567";
        for (int i = 0; i < octalComoCadena.length(); i++) {
            char caracter = octalComoCadena.charAt(i);
            // Si no se encuentra dentro de los caracteres válidos, regresamos false
            if (caracteresOctales.indexOf(caracter) == -1) {
                return false;
            }
        }
        return true;
    }

    // Nota: se debe enviar la cadena hexadecimal convertida a mayúsculas
    public static boolean validarHexadecimal(String hexadecimal) {
        // Comprobar si solo tiene números del 0 al 9 y letras de la A a la F
        String caracteresHexadecimales = "0123456789ABCDEF";
        for (int i = 0; i < hexadecimal.length(); i++) {
            char caracter = hexadecimal.charAt(i);
            // Si no se encuentra dentro de los caracteres válidos, regresamos false
            if (caracteresHexadecimales.indexOf(caracter) == -1) {
                return false;
            }
        }
        return true;
    }

    //De Decimal a otras bases
    public static String decimalABinario(int decimal) {
        String binario = "";
        while (decimal > 0) {
            binario = decimal % 2 + binario;
            decimal = decimal / 2;
        }
        return binario;
    }

    public static String decimalAOctal(int decimal) {
        int residuo;
        String octal = "";
        char[] caracteresOctales = {'0', '1', '2', '3', '4', '5', '6', '7'};
        while (decimal > 0) {
            residuo = decimal % 8;
            char caracter = caracteresOctales[residuo];
            octal = caracter + octal;
            decimal = decimal / 8;
        }
        return octal;
    }

    public static String decimalAHexadecimal(int decimal) {
        int residuo;
        String hexadecimal = "";
        char[] caracteresHexadecimales = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
        while (decimal > 0) {
            residuo = decimal % 16;
            char caracterHexadecimal = caracteresHexadecimales[residuo];
            hexadecimal = caracterHexadecimal + hexadecimal;
            decimal = decimal / 16;
        }
        return hexadecimal;
    }

    // Conversiones de otras bases a decimal
    public static int binarioADecimal(int binario) {
        int decimal = 0;
        int potencia = 0;
        // Ciclo infinito hasta que binario sea 0
        while (true) {
            if (binario == 0) {
                break;
            } else {
                int temp = binario % 10;
                decimal += temp * Math.pow(2, potencia);
                binario = binario / 10;
                potencia++;
            }
        }
        return decimal;
    }

    public static int octalADecimal(int octal) {
        int decimal = 0;
        int potencia = 0;
        // Ciclo infinito que se rompe cuando octal es 0
        while (true) {
            if (octal == 0) {
                break;
            } else {
                int temp = octal % 10;
                decimal += temp * Math.pow(8, potencia);
                octal = octal / 10;
                potencia++;
            }
        }
        return decimal;
    }

    public static int hexadecimalADecimal(String hexadecimal) {
        String caracteresHexadecimales = "0123456789ABCDEF";
        hexadecimal = hexadecimal.toUpperCase();
        int decimal = 0;
        for (int i = 0; i < hexadecimal.length(); i++) {
            char caracter = hexadecimal.charAt(i);
            int posicionEnCaracteres = caracteresHexadecimales.indexOf(caracter);
            decimal = 16 * decimal + posicionEnCaracteres;
        }
        return decimal;
    }

}

Te invito a aprender más sobre Java en mi blog.

He grabado un vídeo en YouTube en caso de no comprender de manera clara con el texto:

Estoy aquí para ayudarte 🤝💻

Estoy aquí para ayudarte en todo lo que necesites. Si requieres alguna modificación en lo presentado en este post, deseas asistencia con tu tarea, proyecto o precisas desarrollar un software a medida, no dudes en contactarme. Estoy comprometido a brindarte el apoyo necesario para que logres tus objetivos. Mi correo es parzibyte(arroba)gmail.com, estoy como@parzibyte en Telegram o en mi página de contacto

No te pierdas ninguno de mis posts 🚀🔔

Suscríbete a mi canal de Telegram para recibir una notificación cuando escriba un nuevo tutorial de programación.

1 comentario en “Java – Conversor de bases numéricas”

Dejar un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *