Fonte: http://www.activeinfo.com.br/curso_programacao/conversao_entre_bases.html

Curso de Lógica da Programação na Prática.

Conversão Entre Bases Numéricas.

Na lição anterior tivemos uma introdução aos números decimais, binários, hexadecimais e octais.

Nesta lição vamos aprender algumas técnicas para transformar números de bases diferentes entre si.

Conversão de Decimal para Binário

Para encontrar o número binário correspondente a um número decimal, são realizadas sucessivas divisões do número decimal por 2.

Em seguida, o resto da divisão de cada operação é coletado de forma invertida, da última para a primeira operação de divisão, como na figura, onde foi obtido o número binário correspondente ao número decimal 25:

Na figura acima vemos que o número decimal foi dividido sucessivamente por 2 e os resultados foram coletados da última para a primeira divisão, formando o número binário.

Conversão de Binário para Decimal

Como vimos na lição anterior, para descobrir o número decimal correspondente a um número binário, basta calcular a soma de cada um dos dígitos do número binário multiplicado por 2 (que é a sua base) elevado à posição colunar do número, que, da direita para a esquerda começa em 0.

Vejamos uma conversão do número binário que obtivemos na conversão acima:

Conversão de Decimal para Hexadecimal

A conversão de números decimais para hexadecimais é idêntica à conversão de decimal para binário, exceto que a divisão deve ser realizada por 16, que é a base dos hexadecimais.

Quando tiver dúvida sobre o valor em hexadecimal de algum resto, verifique na tabela da lição anterior.

Conversão de Hexadecimal em Decimal

A conversão de números hexadecimais em decimais é realizada através da soma dos dígitos hexadecimais multiplicados pela base 16 elevada à posição colunar contando da direita para a esquerda, começando em 0, de forma semelhante à conversão de binários em decimais:

Note que os caracteres que definem os dígitos hexadecimais A, B e C foram substituídos pelos valores equivalentes em decimais 10, 11 e 12 de acordo com a tabela da lição anterior para a realização do cálculo.

Conversão de Decimal em Octal

Assim como nas conversões anteriores, divide-se o decimal pela base para a qual se quer obter o número, no caso, 8:

Vimos que foram coletados os restos de cada divisão da última para a primeira para formar o número octal.

Conversão de Octal em Decimal

A conversão de números octais em decimais é obtida através da soma dos dígitos do número octal multiplicados pela base 8 elevada à posição colunar do dígito, começando em 0 da direita para a esquerda:

Conversão de Binário em Hexadecimal

Para converter um número binário em hexadecimal, separa-se o número binário em grupos de 4 bits, da direita para a esquerda. Em seguida, transforma-se cada grupo de 4 bits em hexadecimal. Ao final, simplesmente une-se os resultados em um só:

Caso o número de dígitos do número binário não seja múltiplo de 4, completa-se os dígitos à esquerda com zeros (0):

Conversão de Binário em Octal

Para converter números binários em octais, separa-se os dígitos do número binário em grupos de 3 bits da direita para a esquerda. Em seguida transforma-se cada grupo individual de 3 bits em octal. Ao final, une-se os resultados:

Caso o número de dígitos do número binário não seja múltiplo de 3, completa-se os dígitos à esquerda com zeros (0):

Conversão de Hexadecimal em Binário

Para converter números hexadecimais em binários, decompõem-se o número hexadecimal diretamente em binários de 4 dígitos. Os zeros mais à esquerda do resultado binário podem ser omitidos:

Conversão de Octal em Binário

Para converter números octais em binários, decompõem-se o número octal diretamente em binários de 3 dígitos. Os zeros mais à esquerda do resultado binário podem ser omitidos:

Conversão de Octal em Hexadecimal

Para converter um número octal em hexadecimal, transforma-se primeiro o octal em binário e em seguida o binário em hexadecimal:

Conversão de Hexadecimal em Octal

Para converter um número hexadecimal em octal, transforma-se primeiro o hexadecimal em binário e em seguida o binário em octal:

Conversões entre Bases em Ruby

Na lição anterior vimos que temos, basicamente:

Números Decimais, de base 10.
Números Binários, de base 2.
Números Hexadecimais, de base 16.
Números Octais, de base 8.

Em Ruby há uma maneira bem simples de converter números entre bases diferentes.

Veja este exemplo no irb:

Vejamos como é feita essa conversão:

Em primeiro lugar, o número em questão está no formato String (observe as aspas). Em seguida, o mesmo é convertido em inteiro com o .to_i, informando a base entre parênteses para a qual o mesmo deve ser convertido, no caso, base 10, para que seja convertido em inteiro decimal.Em seguida o número é convertido em String novamente, informando a base para a qual o número deve ser interpretado, no caso, base 2, para que seja convertido em binário.
Na segunda operação, o processo inverso é realizado. O número binário que está no formato String é convertido em inteiro com o .to_i e é informada a base 2 para o mesmo, que logo em seguida é convertido novamente emString, dessa vez de base 10.

E, é claro que Ruby também facilita a conversão entre outras bases. Nas linhas subsequentes do nosso teste são convetidos diversos exemplos que utilizamos em nossa lição entre diversas bases.

Conversão entre bases em Java

Em Java, também é fácil converter números entre bases diferentes. Veja este programa simples:

/**********************************************************
 * Programa: programa em Java que demonstra a
 *           conversão de números entre bases diferentes
 *
 * Compilação: javac ConversaoEntreBases.java
 * Execução: java ConversaoEntreBases
 *
 * % java ConversaoEntreBases
 * % ---------------------------------
 * % Decimal 211 para Binário: 11010011
 * % Decimal 211 para Octal: 323
 * % Decimal 211 para Hexadecimal: d3
 * % ---------------------------------
 * % Binário: 11101110 para Decimal: 238
 * % Binário: 11101110 para Octal: 356
 * % Binário: 11101110 para Hexadecimal: ee
 * % ---------------------------------
 * % Octal: 77 para Decimal: 63
 * % Octal: 77 para Binário: 111111
 * % Octal: 77 para Hexadecimal: 3f
 * % ---------------------------------
 * % Hexadecimal: 58 para Decimal: 88
 * % Hexadecimal: 58 para Binário: 1011000
 * % Hexadecimal: 58 para Octal: 130
 *
 * @author Marcos Cesar Kossoski
 *
**********************************************************/
public class ConversaoEntreBases {

  public static void main (String[] args) {

    String dec = "211";
    // string para inteiro decimal
    int decimal = Integer.parseInt(dec, 10);
    // decimal para binario
    String binario = Integer.toBinaryString(decimal);
    // decimal para octal
    String octal = Integer.toOctalString(decimal);
    // decimal para hexadecimal
    String hexadecimal = Integer.toHexString(decimal);

    System.out.println("---------------------------------");
    System.out.println("Decimal " + dec + " para Binário: " + binario);
    System.out.println("Decimal " + dec + " para Octal: " + octal);
    System.out.println("Decimal " + dec + " para Hexadecimal: " + hexadecimal);

    // -------------------------------------------------------

    String bin = "11101110";
    // string binario para decimal
    int decBin = Integer.parseInt(bin, 2);
    // binario para octal
    String decOct = Integer.toOctalString(decBin);
    // binario para hexadecimal
    String decHex = Integer.toHexString(decBin);

    System.out.println("---------------------------------");
    System.out.println("Binário: " + bin + " para Decimal: " + decBin);
    System.out.println("Binário: " + bin + " para Octal: " + decOct);
    System.out.println("Binário: " + bin + " para Hexadecimal: " + decHex);

    // -------------------------------------------------------

    String oct = "77";
    // string octal para inteiro decimal
    int octalInt = Integer.parseInt(oct, 8);
    // octal para hexadecimal
    String octHex = Integer.toHexString(octalInt);
    // octal para binário
    String octBin = Integer.toBinaryString(octalInt);

    System.out.println("---------------------------------");
    System.out.println("Octal: " + oct + " para Decimal: " + octalInt);
    System.out.println("Octal: " + oct + " para Binário: " + octBin);
    System.out.println("Octal: " + oct + " para Hexadecimal: " + octHex);

    // -------------------------------------------------------

    String hex = "58";
    // string hexadecimal para inteiro decimal
    int hexInt = Integer.parseInt(hex, 16);
    // hexadecimal para octal
    String hexOct = Integer.toOctalString(hexInt);
    // hexadecimal para binario
    String hexBin = Integer.toBinaryString(hexInt);

    System.out.println("---------------------------------");
    System.out.println("Hexadecimal: " + hex + " para Decimal: " + hexInt);
    System.out.println("Hexadecimal: " + hex + " para Binário: " + hexBin);
    System.out.println("Hexadecimal: " + hex + " para Octal: " + hexOct);
  }

}