Java中的十进制到十六进制转换器答案

【问题标题】：Decimal to Hexadecimal Converter in JavaJava中的十进制到十六进制转换器
【发布时间】：2012-11-08 01:00:08
【问题描述】：

我有一个家庭作业，我需要在十进制、二进制和十六进制之间进行三向转换。我需要帮助的功能是将十进制转换为十六进制。我几乎不了解十六进制，但是如何将十进制转换为十六进制。我需要一个接收int dec 并返回String hex 的函数。不幸的是，我没有这个功能的任何草稿，我完全迷路了。我只有这个。

  public static String decToHex(int dec)
  {
    String hex = "";


    return hex;
  }

我也不能使用像 Integer.toHexString() 这样的预制函数或任何东西，我需要实际制作算法，否则我什么都学不到。

【问题讨论】：

“我需要真正制作算法，否则我什么都学不到”——很好。但是我会更进一步说，如果你想学习一些东西，你必须自己弄清楚算法（而不是别人给你）。如果你想成为一名软件程序员，你需要（或变得）擅长解谜。这是一个很好的练习。
您可以在互联网上找到算法。他们很容易。 :-)
是的，我明白了。然而，我一直坐在这里挠头工作。如果我不是完全没有想法并且仍然知道该怎么做，我就不会来 StackOverflow。
你了解十六进制计数吗？与二进制计数一样，除了使用 2 组数字之外，您使用 16。0 = 0x0 1 = 0x1 ... 9 = 0x9 10 = 0xA 11 = 0xB ... 15 = 0XF 16 = 0X11 ...
我想通了！你刚才所说的对我来说非常适合转换为任何基数，我将它与 kol 在这里的一系列可能的数字结合起来，它起作用了！我真的明白了！非常感谢！

标签： java hex decimal converter

【解决方案1】：

一种可能的解决方案：

import java.lang.StringBuilder;

class Test {
  private static final int sizeOfIntInHalfBytes = 8;
  private static final int numberOfBitsInAHalfByte = 4;
  private static final int halfByte = 0x0F;
  private static final char[] hexDigits = { 
    '0', '1', '2', '3', '4', '5', '6', '7', 
    '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
  };

  public static String decToHex(int dec) {
    StringBuilder hexBuilder = new StringBuilder(sizeOfIntInHalfBytes);
    hexBuilder.setLength(sizeOfIntInHalfBytes);
    for (int i = sizeOfIntInHalfBytes - 1; i >= 0; --i)
    {
      int j = dec & halfByte;
      hexBuilder.setCharAt(i, hexDigits[j]);
      dec >>= numberOfBitsInAHalfByte;
    }
    return hexBuilder.toString(); 
  }

  public static void main(String[] args) {
     int dec = 305445566;
     String hex = decToHex(dec);
     System.out.println(hex);       
  }
}

输出：

1234BABE

无论如何，有一个库方法：

String hex = Integer.toHexString(dec);

【讨论】：

相信你也可以使用Integer.parseInt
现在 OP 不会从“做”他的作业中学到很多东西。干得好……不是！！
@StephenC 你是对的，但是这个网站是干什么用的？帮助人们做功课是不好的，但帮助专业程序员做他们真正的工作不是吗？每个人都可以为他们的编程问题搜索低质量的解决方案。 SO 通过收集和选择优质的解决方案，让世界变得更美好。无论如何，我相信 OP 可以从我的解决方案中学到很多东西 :)
@kol - 没有专业人士会永远忽略Integer.toHexString()并亲自实施。 “无论如何，我确实相信 OP 可以从我的解决方案中学到很多东西” - 我相信如果他/她不阅读，OP 会学到更重要的东西。 OP的功课的重点是学习如何编程。您通过编写自己的（开始）丑陋的解决方案来学习如何编程，而不是通过阅读其他人的优雅解决方案。
@AnkitSingla 然后使用long 代替int :) 或者使用java.math.BigInteger，以及它的bitLength、and 和rightShift 方法。 BigInteger还有一个内置的转换方法：public String toString(int radix)，只需调用16作为radix即可。

【解决方案2】：

简单：

  public static String decToHex(int dec)
  {
        return Integer.toHexString(dec);
  }

这里提到：Java Convert integer to hex integer

【讨论】：

最佳解决方案。

【解决方案3】：

我需要一个接受 int dec 并返回 String hex 的函数。

我找到了一个更优雅的解决方案 http://introcs.cs.princeton.edu/java/31datatype/Hex2Decimal.java.html 。我对原作做了一些改动（见编辑）

// precondition:  d is a nonnegative integer
public static String decimal2hex(int d) {
    String digits = "0123456789ABCDEF";
    if (d <= 0) return "0";
    int base = 16;   // flexible to change in any base under 16
    String hex = "";
    while (d > 0) {
        int digit = d % base;              // rightmost digit
        hex = digits.charAt(digit) + hex;  // string concatenation
        d = d / base;
    }
    return hex;
}

免责声明：我在编码面试中提出了这个问题。我希望这个解决方案不会太受欢迎:)

2016 年 6 月 17 日编辑：我添加了 base 变量，以便灵活地更改为任何基数：二进制、八进制、7 的基数 ...
根据 cmets，这个解决方案是最优雅的，所以我删除了 Integer.toHexString() 的实现。

2015 年 9 月 4 日编辑：我找到了一个更优雅的解决方案 http://introcs.cs.princeton.edu/java/31datatype/Hex2Decimal.java.html

【讨论】：

您可以删除所有第一部分并保留第二个解决方案，这很优雅
这是我的首选答案，因为它是您实际手动操作的最佳代表。非常优雅。
如果 d 可以为负数会怎样

【解决方案4】：

考虑下面的 dec2m 方法，将 dec 转换为 hex、oct 或 bin。

样本输出是

28 dec == 11100 bin 28 dec == 34 oct 28 dec == 1C hex

public class Conversion {
    public static void main(String[] argv) {
        int x = 28;                           // sample number
        if (argv.length > 0)
            x = Integer.parseInt(argv[0]);    // number from command line

        System.out.printf("%d dec == %s bin\n", i, dec2m(x, 2));
        System.out.printf("%d dec == %s oct\n", i, dec2m(x, 8));
        System.out.printf("%d dec == %s hex\n", i, dec2m(x, 16));
    }

    static String dec2m(int N, int m) {
        String s = "";
        for (int n = N; n > 0; n /= m) {
            int r = n % m;
            s = r < 10 ? r + s : (char) ('A' - 10 + r) + s;
        }
        return s;
    }
}

【讨论】：

【解决方案5】：

这是任意号码的代码：

import java.math.BigInteger;

public class Testing {

/**
 * @param args
 */
static String arr[] ={"0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F"}; 
public static void main(String[] args) {
    String value = "214";
    System.out.println(value + " : " + getHex(value));
}


public static String getHex(String value) {
    String output= "";
    try {
        Integer.parseInt(value);
        Integer number = new Integer(value);
        while(number >= 16){
            output = arr[number%16] + output;
            number = number/16;
        }
        output = arr[number]+output;

    } catch (Exception e) {
        BigInteger number = null;
        try{
            number = new BigInteger(value);
        }catch (Exception e1) {
            return "Not a valid numebr";
        }
        BigInteger hex = new BigInteger("16");
        BigInteger[] val = {};

        while(number.compareTo(hex) == 1 || number.compareTo(hex) == 0){
            val = number.divideAndRemainder(hex);
            output = arr[val[1].intValue()] + output;
            number = val[0];
        }
        output = arr[number.intValue()] + output;
    }

    return output;
}

}

【讨论】：

【解决方案6】：

另一种可能的解决方案：

public String DecToHex(int dec){
  char[] hexDigits = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
              'A', 'B', 'C', 'D', 'E', 'F'};
  String hex = "";
  while (dec != 0) {
      int rem = dec % 16;
      hex = hexDigits[rem] + hex;
      dec = dec / 16;
  }
  return hex;
}

【讨论】：

只有代码的答案不多说了。请添加一些解释，说明您为什么认为您的代码是一个解决方案。
你有实现从 HEX STRING 转换回 Integer 吗？或者想象一下，我希望更改数字并创建不同的 base ，例如 base 20 ？

【解决方案7】：

最简单的方法是：

String hexadecimalString = String.format("%x", integerValue);

【讨论】：

【解决方案8】：

我会用

Long a = Long.parseLong(cadenaFinal, 16 );

因为有一些十六进制可以比整数大，它会抛出异常

【讨论】：

此解决方案读取包含数字的十六进制表示形式的字符串并返回带有该值的 long。换句话说，这不是 OP 要求的。
如果有人遇到和我一样的问题，我就放在那里，以防万一

【解决方案9】：

将 DECIMAL 转换为-> BINARY、OCTAL、HEXADECIMAL 的代码

public class ConvertBase10ToBaseX {
    enum Base {
        /**
         * Integer is represented in 32 bit in 32/64 bit machine.
         * There we can split this integer no of bits into multiples of 1,2,4,8,16 bits
         */
        BASE2(1,1,32), BASE4(3,2,16), BASE8(7,3,11)/* OCTAL*/, /*BASE10(3,2),*/ 
        BASE16(15, 4, 8){       
            public String getFormattedValue(int val){
                switch(val) {
                case 10:
                    return "A";
                case 11:
                    return "B";
                case 12:
                    return "C";
                case 13:
                    return "D";
                case 14:
                    return "E";
                case 15:
                    return "F";
                default:
                    return "" + val;
                }

            }
        }, /*BASE32(31,5,1),*/ BASE256(255, 8, 4), /*BASE512(511,9),*/ Base65536(65535, 16, 2);

        private int LEVEL_0_MASK;
        private int LEVEL_1_ROTATION;
        private int MAX_ROTATION;

        Base(int levelZeroMask, int levelOneRotation, int maxPossibleRotation) {
            this.LEVEL_0_MASK = levelZeroMask;
            this.LEVEL_1_ROTATION = levelOneRotation;
            this.MAX_ROTATION = maxPossibleRotation;
        }

        int getLevelZeroMask(){
            return LEVEL_0_MASK;
        }
        int getLevelOneRotation(){
            return LEVEL_1_ROTATION;
        }
        int getMaxRotation(){
            return MAX_ROTATION;
        }
        String getFormattedValue(int val){
            return "" + val;
        }
    }

    public void getBaseXValueOn(Base base, int on) {
        forwardPrint(base, on);
    }

    private void forwardPrint(Base base, int on) {

        int rotation = base.getLevelOneRotation();
        int mask = base.getLevelZeroMask();
        int maxRotation = base.getMaxRotation();
        boolean valueFound = false;

        for(int level = maxRotation; level >= 2; level--) {
            int rotation1 = (level-1) * rotation;
            int mask1 = mask << rotation1 ;
            if((on & mask1) > 0 ) {
                valueFound = true;
            }
            if(valueFound)
            System.out.print(base.getFormattedValue((on & mask1) >>> rotation1));
        }
        System.out.println(base.getFormattedValue((on & mask)));
    }

    public int getBaseXValueOnAtLevel(Base base, int on, int level) {
        if(level > base.getMaxRotation() || level < 1) {
            return 0; //INVALID Input
        }
        int rotation = base.getLevelOneRotation();
        int mask = base.getLevelZeroMask();

        if(level > 1) {
            rotation = (level-1) * rotation;
            mask = mask << rotation;
        } else {
            rotation = 0;
        }


        return (on & mask) >>> rotation;
    }

    public static void main(String[] args) {
        ConvertBase10ToBaseX obj = new ConvertBase10ToBaseX();

        obj.getBaseXValueOn(Base.BASE16,12456); 
//      obj.getBaseXValueOn(Base.BASE16,300); 
//      obj.getBaseXValueOn(Base.BASE16,7); 
//      obj.getBaseXValueOn(Base.BASE16,7);

        obj.getBaseXValueOn(Base.BASE2,12456);
        obj.getBaseXValueOn(Base.BASE8,12456);
        obj.getBaseXValueOn(Base.BASE2,8);
        obj.getBaseXValueOn(Base.BASE2,9);
        obj.getBaseXValueOn(Base.BASE2,10);
        obj.getBaseXValueOn(Base.BASE2,11);
        obj.getBaseXValueOn(Base.BASE2,12);
        obj.getBaseXValueOn(Base.BASE2,13);
        obj.getBaseXValueOn(Base.BASE2,14);
        obj.getBaseXValueOn(Base.BASE2,15);
        obj.getBaseXValueOn(Base.BASE2,16);
        obj.getBaseXValueOn(Base.BASE2,17);


        System.out.println(obj.getBaseXValueOnAtLevel(Base.BASE2, 4, 1)); 
        System.out.println(obj.getBaseXValueOnAtLevel(Base.BASE2, 4, 2)); 
        System.out.println(obj.getBaseXValueOnAtLevel(Base.BASE2, 4, 3)); 
        System.out.println(obj.getBaseXValueOnAtLevel(Base.BASE2, 4, 4)); 

        System.out.println(obj.getBaseXValueOnAtLevel(Base.BASE16,15, 1)); 
        System.out.println(obj.getBaseXValueOnAtLevel(Base.BASE16,30, 2)); 
        System.out.println(obj.getBaseXValueOnAtLevel(Base.BASE16,7, 1)); 
        System.out.println(obj.getBaseXValueOnAtLevel(Base.BASE16,7, 2)); 

        System.out.println(obj.getBaseXValueOnAtLevel(Base.BASE256, 511, 1)); 
        System.out.println(obj.getBaseXValueOnAtLevel(Base.BASE256, 511, 2)); 
        System.out.println(obj.getBaseXValueOnAtLevel(Base.BASE256, 512, 1));
        System.out.println(obj.getBaseXValueOnAtLevel(Base.BASE256, 512, 2)); 
        System.out.println(obj.getBaseXValueOnAtLevel(Base.BASE256, 513, 2)); 


    }
}

【讨论】：

投反对票时；请让作者和其他人知道原因。因此，可以改进帖子。

【解决方案10】：

这是我的

public static String dec2Hex(int num)
{
    String hex = "";

    while (num != 0)
    {
        if (num % 16 < 10)
            hex = Integer.toString(num % 16) + hex;
        else
            hex = (char)((num % 16)+55) + hex;
        num = num / 16;
    }

    return hex;
}

【讨论】：

【解决方案11】：

一种将十进制转换为十六进制的更好解决方案，这个解决方案不太复杂

import java.util.Scanner;
public class DecimalToHexa
{
    public static void main(String ar[])
    {
        Scanner sc=new Scanner(System.in);
        System.out.println("Enter a Decimal number: ");
        int n=sc.nextInt();
        if(n<0)
        {
            System.out.println("Enter a positive integer");
            return;
        }
        int i=0,d=0;
        String hx="",h="";
        while(n>0)
        {
            d=n%16;`enter code here`
            n/=16;
            if(d==10)h="A";
            else if(d==11)h="B";
            else if(d==12)h="C";
            else if(d==13)h="D";
            else if(d==14)h="E";
            else if(d==15)h="F";
            else h=""+d;            
            hx=""+h+hx;
        }
        System.out.println("Equivalent HEXA: "+hx);
    }
}

【讨论】：

【解决方案12】：

以下将十进制转换为十六进制时间复杂度：O(n) 线性时间，没有任何 java 内置函数

private static String decimalToHexaDecimal(int N) {
    char hexaDecimals[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
    StringBuilder builder = new StringBuilder();
    int base= 16;
    while (N != 0) {
        int reminder = N % base;
        builder.append(hexaDecimals[reminder]);
        N = N / base;
    }

    return builder.reverse().toString();
}

【讨论】：

【解决方案13】：

查看下面的代码进行十进制到十六进制的转换，

import java.util.Scanner;

public class DecimalToHexadecimal
{
   public static void main(String[] args)
   {
      int temp, decimalNumber;
      String hexaDecimal = "";
      char hexa[] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
 
      Scanner sc = new Scanner(System.in);
      System.out.print("Please enter decimal number : ");
      decimalNumber = sc.nextInt();
 
      while(decimalNumber > 0)
      {
         temp = decimalNumber % 16;
         hexaDecimal = hexa[temp] + hexaDecimal;
         decimalNumber = decimalNumber / 16;
      }
 
      System.out.print("The hexadecimal value of " + decimalNumber + " is : " + hexaDecimal);      
      sc.close();
   }
}

您可以在以下链接中了解更多关于将十进制转换为十六进制的不同方法>>java convert decimal to hexadecimal。

【讨论】：