Fatal编程技术网
  • java/
  • Java中的十进制到十六进制转换器

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

java

Java中的十进制到十六进制转换器,java,hex,decimal,converter,Java,Hex,Decimal,Converter,我有一个家庭作业，我需要做十进制、二进制和十六进制之间的三向转换。我需要帮助的函数是将十进制转换为十六进制。我几乎不了解十六进制，但是如何将十进制转换为十六进制。我需要一个函数，它接受一个int dec并返回一个字符串hex。不幸的是，我没有这个函数的任何草稿，我完全迷路了。我只有这个 public static String decToHex(int dec) { String hex = ""; return hex; } 此外，我不能使用Integer.t

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

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


    return hex;
  }
此外，我不能使用Integer.toHexString（）等预制函数，我需要实际制作算法，否则我不会学到任何东西。

一种可能的解决方案：

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);       
  }
}

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;
}
输出：

1234BABE
无论如何，这里有一个库方法：

String hex = Integer.toHexString(dec);
以下是任意数字的代码：

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;
}

}
我需要一个函数，它接受int-dec并返回字符串十六进制

我从中找到了一个更优雅的解决方案 . 我对原稿做了一些修改（参见编辑）

//前提条件：d是非负整数
公共静态字符串小数2Hex（int d）{
字符串数字=“0123456789ABCDEF”；
如果（d0）{
int digit=d%base；//最右边的数字
十六进制=数字。字符（数字）+十六进制；//字符串连接
d=d/基；
}
返回十六进制；
}
免责声明：我在我的编码面试中问这个问题。我希望这个解决方案不要太受欢迎：）

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

编辑2015年9月4日：我发现了一个更优雅的解决方案

考虑下面的dec2m方法，将dec转换为十六进制、oct或bin

样本输出为

28十二月==11100箱
12月28日=10月34日
28十二月==1C十六进制

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;
    }
}

公共类转换{
公共静态void main（字符串[]argv）{
int x=28；//样本号
如果（argv.length>0）
x=Integer.parseInt（argv[0]）；//来自命令行的数字
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））；
}
静态字符串dec2m（整数N，整数m）{
字符串s=“”；
对于（int n=n；n>0；n/=m）{
int r=n%m；
s=r<10？r+s：（char）（'A'-10+r）+s；
}
返回s；
}
}
另一种可能的解决方案：

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);       
  }
}

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;
}
我会用

Long a = Long.parseLong(cadenaFinal, 16 );
因为有一些十六进制可能比intenger更大，它会抛出一个异常

代码来将十进制转换为->二进制、八进制、十六进制

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)); 


    }
}

公共类ConvertBase10Sex{
枚举基{
/**
*在32/64位计算机中，整数以32位表示。
*在那里，我们可以将这个整数位数拆分为1,2,4,8,16位的倍数
*/
BASE2（1,1,32），BASE4（3,2,16），BASE8（7,3,11）/*八进制*/，/*BASE10（3,2），*/
BASE16（15，4，8）{
公共字符串getFormattedValue（int val）{
开关（val）{
案例10：
返回“A”；
案例11：
返回“B”；
案例12：
返回“C”；
案例13：
返回“D”；
案例14：
返回“E”；
案例15：
返回“F”；
违约：
返回“”+val；
}
}
}，/*BASE32（31,5,1），*/BASE256（255,8,4），/*BASE512（511,9），*/Base65536（65535,16,2）；
私有整数级0掩码；
私用整数级(1)轮换;；
私有int MAX_旋转；
基本（int-levelZeroMask、int-levelOneRotation、int-maxPossibleRotation）{
this.LEVEL_0_MASK=levelzerosmask；
此.LEVEL_1_旋转=levelOneRotation；
this.MAX_ROTATION=maxPossibleRotation；
}
int getLevelZeroMask（）{
返回级别0屏蔽；
}
int getLevelOneRotation（）{
返回级_1_旋转；
}
int getMaxRotation（）{
返回最大旋转；
}
字符串getFormattedValue（int val）{
返回“”+val；
}
}
public void getBaseXValueOn（Base-Base，int-on）{
转发打印（基于、基于）；
}
私有void forwardPrint（基本，int on）{
int rotation=base.getLevelOneRotation（）；
int mask=base.getLevelZeroMask（）；
int maxRotation=base.getMaxRotation（）；
布尔值found=false；
对于（int-level=maxRotation；level>=2；level--）{
整数旋转1=（1级）*旋转；
int mask1=掩码0）{
valueFound=true；
}
如果（找到值）
系统输出打印（base.getFormattedValue（（on&mask1）>>>rotation1））；
}
System.out.println（base.getFormattedValue（（on&mask））；
}
public int getbasexvalueonalevel（Base-Base、int-on、int-level）{
if（level>base.getMaxRotation（）| | level<1）{
返回0；//输入无效
}
int rotation=base.getLevelOneRotation（）；
int mask=base.getLevelZeroMask（）；
如果（级别>1）{
轮换=（1级）*轮换；
遮罩=遮罩>>旋转；
}
公共静态void main（字符串[]args）{
ConvertBase10ToBaseX obj=新ConvertBase10ToBaseX（）；
对象getBaseXValueOn（Base.base1612456）；
//对象getBaseXValueOn（Base.base16300）；
//对象getBaseXValueOn（Base.BASE16,7）；
//对象getBaseXValueOn（Base.BASE16,7）；
对象getBaseXValueOn（Base.base212456）；
对象getBaseXValueOn（Base.base812456）；

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



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);
    }
}        



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();
   }
}



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();
}



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