三十六進制之間隨便轉換

本文介绍了一个实用的Java程序,能够实现任意进制(最高36进制)之间的相互转换,包括从任意进制到十进制的转换,以及从十进制到任意进制的转换。文章详细展示了具体的实现思路与核心代码。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

去年在網上給一家公司投簡歷的時候,對方要求寫一個任意進制轉換的函數,當時沒有回過神來,也不知道JAVA中有這樣的函數,呵呵。于是就自己操刀,寫了這個三十六進制之音隨便轉的函數。不過,權當練習吧,如果你不會,倒真的可以看看,學學二進制到十進制、十進制到二進制之音是如何轉何的。

/*
 程序说明:
 理论上是一个任意进制的程序,但是由于字母的有限,所有只能转换最多36进制,即0-9,a-z
 思路是:
 先将任意进制转换为10进制,再将10进制转换到任意进制
 1、任意进制转换为10进制的转换
 分别对整数和小数部分进行转换,再将分别转换后的结果进行拼合,利用相乘相加的原则
 整数部分:(如111的二进制到十进制就是:1*pow(2,2)+1*pow(2,1)+1*pow(2,1))
 小数部分:利用相乘相加的原则
 2、10进制转换到任意进制的转换
 分别对整数和小数部分进行转换,再将分别转换后的结果进行拼合
 整数部分:利用相除取余的原则
  
 小数部分:利用相乘取整的原则
  如:原数为0.9876,转换为二进制,即每次乘2(当然这个便没有举好,有错误,能理解就行了)
  现数 余数  
  0.9752 1
  0.9504 1
  0.9008 1
  0.8016 1
  0.6032 1
  0.2064 1
  0.4128 0
*/
import java.io.*;

import java.util.*;

public class JZZH
{
  //*****************************任意进制到十进制的转换*****************************
  //任意进制到十进制的转换

  String anySystemToTen(double longNum)
    throws Exception
  {
    String strNum = String.valueOf(longNum);
    //将取得的整数部份和小数部份的进制结合在一起,并将其还原为浮点数
    //strNum=intToTenSystem(strInt,JZ)+"."+lessToTenSystem(strLess,JZ);
    return strNum;
  }
  //保证输入的数与进制相配

  boolean checkInputNumIsOK(int Num, int JZ)
  {
    if (Num <= JZ - 1)
      return true;
    else
      return false;
  }
  //由取最得的字符返回相应的数字

  String letterToInteger(String tChar)
  {
    int gotNum = 0;
    int kg = 0; //确定前面该字符是不是已经赋值,这就是使用if语句所留下的后症
    String S;
    if (tChar.equals("A"))
    {
      gotNum = 10;
      kg = 1;
    }
    else if (tChar.equals("B"))
    {
      gotNum = 11;
      kg = 1;
    }
    else if (tChar.equals("C"))
    {
      gotNum = 12;
      kg = 1;
    }
    else if (tChar.equals("D"))
    {
      gotNum = 13;
      kg = 1;
    }
    else if (tChar.equals("E"))
    {
      gotNum = 14;
      kg = 1;
    }
    else if (tChar.equals("F"))
    {
      gotNum = 15;
      kg = 1;
    }
    else if (tChar.equals("G"))
    {
      gotNum = 16;
      kg = 1;
    }
    else if (tChar.equals("H"))
    {
      gotNum = 17;
      kg = 1;
    }
    else if (tChar.equals("I"))
    {
      gotNum = 18;
      kg = 1;
    }
    else if (tChar.equals("J"))
    {
      gotNum = 19;
      kg = 1;
    }
    else if (tChar.equals("K"))
    {
      gotNum = 20;
      kg = 1;
    }
    else if (tChar.equals("L"))
    {
      gotNum = 21;
      kg = 1;
    }
    else if (tChar.equals("M"))
    {
      gotNum = 22;
      kg = 1;
    }
    else if (tChar.equals("O"))
    {
      gotNum = 23;
      kg = 1;
    }
    else if (tChar.equals("P"))
    {
      gotNum = 24;
      kg = 1;
    }
    else if (tChar.equals("Q"))
    {
      gotNum = 25;
      kg = 1;
    }
    else if (tChar.equals("R"))
    {
      gotNum = 26;
      kg = 1;
    }
    else if (tChar.equals("S"))
    {
      gotNum = 27;
      kg = 1;
    }
    else if (tChar.equals("T"))
    {
      gotNum = 28;
      kg = 1;
    }
    else if (tChar.equals("U"))
    {
      gotNum = 29;
      kg = 1;
    }
    else if (tChar.equals("V"))
    {
      gotNum = 30;
      kg = 1;
    }
    else if (tChar.equals("W"))
    {
      gotNum = 31;
      kg = 1;
    }
    else if (tChar.equals("X"))
    {
      gotNum = 32;
      kg = 1;
    }
    else if (tChar.equals("Y"))
    {
      gotNum = 33;
      kg = 1;
    }
    else if (tChar.equals("Z"))
    {
      gotNum = 34;
      kg = 1;
    }
    else if (kg == 0)
    {
      gotNum = Integer.parseInt(tChar);
    }
    S = String.valueOf(gotNum);
    return S;
  }

  //浮点数的整数部份转换为十进制

  String intToTenSystem(String strNum, int JZ)
    throws Exception
  {
    strNum = strNum.toUpperCase(); //全部转换为大写,方便字符到数字的转换  
    double longNum = 0;
    int len = strNum.length(); //取得字符串的长度
    int tInt = 0; //初使化数组位置为0
    int gotNum = 0; //一个一个字符取出所对应的数字
    while (len > 0)
    { //如果没有将字符串的字符转换完,就继续   
      String tChar = strNum.substring(tInt, tInt + 1); //一个一个字符的取
      gotNum = Integer.parseInt(letterToInteger(tChar));
      if (!checkInputNumIsOK(gotNum, JZ))
      {
        System.out.println("你的输入与转换的进制不符,请检查!");
        System.exit(-1);
      }

      longNum = longNum + gotNum * (Math.pow(JZ, len - 1));
      tInt++;
      len--;

    }
    return String.valueOf(longNum);
  }
  //浮点数小数部份转换为十进制

  String lessToTenSystem(String strNum, int JZ)
    throws Exception
  {
    strNum = strNum.toUpperCase();
    double longNum = 0;
    int len = strNum.length(); //取得字符的长度
    int tInt = 0; //取第tInt个字符
    int gotNum = 0; //取出的字符转换为数字
    int cfInt = -1; //多少次次方
    while (len > 0)
    {
      String tChar = strNum.substring(tInt, tInt + 1); //一个一个字符的取
      gotNum = Integer.parseInt(letterToInteger(tChar));
      if (!checkInputNumIsOK(gotNum, JZ))
      {
        System.out.println("你的输入与转换的进制不符,请检查!");
        System.exit(-1);
      }
      //保存出小数部份从对应的进制到十进制的总值
      longNum = longNum + gotNum * (Math.pow(JZ, cfInt)); //关键算法
      tInt++; //字符串中位置加一
      len--; //字符串总长度减一
      cfInt--;
    }
    return String.valueOf(longNum);
  }
  //返回一个浮点数的整数或者是小数部份

  String returnWantPart(String doubleNum, String whichPart)
    throws Exception
  {
    String strNum = doubleNum;
    String leftStr;
    String rightStr;
    //如果输入的是一个浮点数
    if (strNum.indexOf(".") != -1)
    {
      StringTokenizer fenxi = new StringTokenizer(strNum, ".");
      leftStr = fenxi.nextToken();
      rightStr = fenxi.nextToken();
    }
    else
    { //如果输入的是一个整数
      leftStr = strNum;
      rightStr = "0";
    }
    String returnStr = "";
    if (whichPart.equals("left"))
      returnStr = leftStr;
    else if (whichPart.equals("right"))
      returnStr = rightStr;
    return returnStr;
  }
  //*****************************任意进制到十进制的转换*****************************
  //*****************************十进制到任意进制的转换***************************** 

  String tenToAnySystem_Int(String strInt, int JZ)
  { //因为由任意进制到十进制的转换结果为"整数部分.小数部份"
    //也就是分成整数和小数部份分别转换
    //此函数完成的功能是十进制的整数部分到任意进制的转换  
    try
    {
      //取出整数部份 
      strInt = returnWantPart(strInt, "left");
    }
    catch (Exception e)
    {
      e.printStackTrace();
    }
    long intStr = Long.parseLong(strInt);
    long[] result = new long[50]; //用50个数组来保存相除的余数
    long T;
    String resultStr = "";
    int i = 0; //数组的下标
    while (intStr != 0)
    {
      result[i] = intStr % JZ; //取出余数
      intStr = intStr - result[i]; //现数为减去余数的数
      intStr = intStr / JZ;
      i++; //数组下标增加一
    }
    //将数组全部反序排列,并返回结果
    for (int j1 = 0, j2 = i - 1; j1 < (i / 2); j1++, j2--)
    {
      T = result[j1];
      result[j1] = result[j2];
      result[j2] = T;
    }
    for (int j = 0; j < i; j++)
    {
      resultStr = resultStr + intToLetter(result[j]);

    }
    return resultStr;

  }
  //此函数完成的功能是十进制的小数部分到任意进制的转换

  String temToAnySystem_Less(String strLess, int JZ)
  {
    double T = 0;
    T = Double.parseDouble(strLess);
    String resultStr = "";
    String strInt = "";
    //精度取到小数点后面6位为止
    int JinDu = 0;
    int i = 0; //数组下标  
    int[] result = new int[50];
    for (int j = 0; j < 50; j++) //将数组初使化
      result[j] = 0;
    try
    {
      while (JinDu <= 6 && T > 0.000001)
      {
        double tNum = 0;
        tNum = T * JZ;
        if (tNum > 1)
        { //取出整数部份
          try
          {
            strInt = returnWantPart(String.valueOf(tNum), "left");
          }
          catch (Exception e)
          {
            e.printStackTrace();
          }
          result[i] = Integer.parseInt(strInt);
          T = tNum - result[i]; //将当前数减去取出来的数
        }
        else
        {
          //如果整数小于零,那么整数部分就是0
          result[i] = 0;
        }
        JinDu++;
        i++;

      }
    }
    catch (Exception e)
    {
      e.printStackTrace();
    }
    for (int j = 0; j < i; j++)
      resultStr = resultStr + String.valueOf(result[j]);
    if (i == 0)
      return "0";
    else
      return resultStr;

  }
  //将取得的数字转换为相应的字母

  String intToLetter(long num)
  {
    String result = "";
    String S = "";
    if (0 <= num && num <= 9)
      result = String.valueOf(num);
    else if (num > 9)
    {
      S = String.valueOf(num); //将长整型转换为字符串型
      switch (Integer.parseInt(S)) //将字符串型转换为整型
      {
        case 10:
          result = "A";
          break;
        case 11:
          result = "B";
          break;
        case 12:
          result = "C";
          break;
        case 13:
          result = "D";
          break;
        case 14:
          result = "E";
          break;
        case 15:
          result = "F";
          break;
        case 16:
          result = "G";
          break;
        case 17:
          result = "H";
          break;
        case 18:
          result = "I";
          break;
        case 19:
          result = "G";
          break;
        case 20:
          result = "K";
          break;
        case 21:
          result = "L";
          break;
        case 22:
          result = "M";
          break;
        case 23:
          result = "N";
          break;
        case 24:
          result = "O";
          break;
        case 25:
          result = "P";
          break;
        case 26:
          result = "Q";
          break;
        case 27:
          result = "R";
          break;
        case 28:
          result = "S";
          break;
        case 29:
          result = "T";
          break;
        case 30:
          result = "U";
          break;
        case 31:
          result = "V";
          break;
        case 32:
          result = "W";
          break;
        case 33:
          result = "X";
          break;
        case 34:
          result = "Y";
          break;
        case 35:
          result = "Z";
          break;
      }
    }
    return result;
  }
  //*****************************十进制到任意进制的转换*****************************

  public static void main(String[] arg)
    throws Exception
  {
    try
    {
      JZZH jzzh = new JZZH();
      BufferedReader br =
        new BufferedReader(new InputStreamReader(System.in));
      String inData = " ";

      while (!inData.toUpperCase().equals("QUIT"))
      {
        System.out.print("请输入一个数(quit退出)(格式:原数,原数进制,要转换到的进制):");
        inData = br.readLine();
        if (inData.equals("") || inData.equals(" "))
          continue;
        if (inData.toUpperCase().equals("QUIT"))
          break;
        StringTokenizer fenxi = new StringTokenizer(inData, ",");
        String tData = fenxi.nextToken(); //取出原数
        //String whichPart=
        //System.out.println("The Result is :"+tData);
        int whichSystem = Integer.parseInt(fenxi.nextToken()); //取出原进制
        int targetSystem = Integer.parseInt(fenxi.nextToken()); //取出要转换的进制
        String returnLeftPart; //输入数的整数部分
        String returnRightPart; //输入数的小数部分
        //分别取出数的左面和右面
        returnLeftPart = jzzh.returnWantPart(tData, "left"); //取出输入数的整数部分
        returnRightPart = jzzh.returnWantPart(tData, "right"); //取出输入数的小数部分

        String anyChangedToIntSystem; //用于接收输入数的整数部分转换后的结果
        String anyChangedToLessSystem; //用于接收输入数的小数部分转换后的结果
        anyChangedToIntSystem =
            jzzh.intToTenSystem(returnLeftPart, whichSystem);
        anyChangedToLessSystem =
            jzzh.lessToTenSystem(returnRightPart, whichSystem);

        double leftNum = Double.parseDouble(anyChangedToIntSystem);
        double rightNum = Double.parseDouble(anyChangedToLessSystem);
        double totalNum = leftNum + rightNum; //拼合结果
        System.out.println(tData + "由" + whichSystem + "到10进制的结果是:" +
                           jzzh.anySystemToTen(totalNum));

        //十进制到任意进制的转换temToAnySystem_Less
        String tenChangedToAnySystemInt = "";
        String tenChangedToAnySystemLess = "";
        tenChangedToAnySystemInt =
            jzzh.tenToAnySystem_Int(anyChangedToIntSystem, targetSystem);
        tenChangedToAnySystemLess =
            jzzh.temToAnySystem_Less(anyChangedToLessSystem, targetSystem);
        System.out.println(tData + "由" + whichSystem + "到" + targetSystem +
                           "进制的结果是:" + tenChangedToAnySystemInt + "." +
                           tenChangedToAnySystemLess);

      }
    }
    catch (IOException e)
    {
      e.printStackTrace();
    }
  }
}

 

<think>好的,用户现在说“我不懂。如果我直接在变量前面加上类型名能直接转换为相应的类型吗”,需要仔细分析他的问题。首先,用户之前询问过关于数据类型转换属于哪个学科的问题,现在可能在实际编程中遇到了类型转换的问题,但不太理解具体的转换机制。 用户可能尝试过在变量前加类型名进行转换,但不确定是否有效或者是否有潜在的问题。比如他可能在写类似(int)variable这样的代码,但不确定这样的转换是否安全或正确。这时候需要解释显式类型转换的不同方式及其适用场景。 首先需要明确不同编程语言的类型转换语法可能不同。比如C/C++使用的是强制转换语法,而C#和Java则有更严格的转换方法。用户可能在使用其中一种语言,但未明确说明,所以需要涵盖常见语言的情况。 接下来,要解释直接加类型名的转换在不同情况下的结果,比如数值类型之间转换可能丢失精度,指针转换可能导致未定义行为,对象类型转换需要继承关系等。同时要强调潜在的风险,比如数据截断、内存错误等,帮助用户意识到不能随意转换。 用户可能对隐式转换和显式转换的区别不太清楚,需要举例说明。例如,float转int会丢失小数部分,而int转float则可能精度不够。还要提到reinterpret_cast这样的底层转换,说明其危险性和特定用途。 最后,需要给出最佳实践,比如使用安全的转换函数、检查范围、利用编译器的类型检查等,帮助用户避免常见错误。同时要提供代码示例,让用户更直观地理解不同转换方法的效果和问题所在。 总结下来,回答需要结构清晰,涵盖不同语言的语法、转换结果、风险以及正确做法,确保用户不仅知道如何转换,还能安全有效地进行操作。</think>好的!这个问题属于**编程语言基础**中的**类型转换**知识。用最简单的方式解释: --- ### 一、直接加类型名的转换(显式类型转换) **可以转换,但结果取决于具体场景**,分三种情况: #### 1. **数值类型转换**(最常见) ```c int a = 10; float b = (float)a; // C/C++中直接加类型名转换 ``` - **安全的情况** 小范围类型 → 大范围类型(如 `int` → `float`) ```c int x = 42; double y = (double)x; // 安全,结果为42.0 ``` - **危险的情况** 大范围类型 → 小范围类型(如 `float` → `int`) ```c float pi = 3.1415; int n = (int)pi; // 直接截断小数部分,n=3(丢失精度) ``` #### 2. **指针类型转换**(高风险操作) ```c int num = 100; char* p = (char*)# // 将int指针强转为char指针 printf("%d", *p); // 输出结果取决于系统字节序(可能得到无意义值) ``` - **典型风险**:内存访问错误、数据错乱 #### 3. **对象类型转换**(面向对象语言) ```java Object obj = "Hello"; String str = (String)obj; // 强制转换,前提是obj确实是String类型 ``` - **错误示范**: ```java Object obj = Integer.valueOf(123); String str = (String)obj; // 运行时抛出ClassCastException ``` --- ### 二、为什么不能随便转换?⚠️ 1. **数据截断** ```c int big = 50000; short s = (short)big; // 范围溢出,s=-15536(二进制高位被截断) ``` 2. **内存解释错误** ```c float f = 3.14; int* p = (int*)&f; printf("%d", *p); // 输出IEEE 754二进制解释的整数形式(非3) ``` 3. **面向对象类型不匹配** ```csharp Animal animal = new Dog(); Cat cat = (Cat)animal; // 运行时崩溃(除非Animal实际是Cat) ``` --- ### 三、正确做法 ✅ #### 1. **使用安全转换函数** - C++: ```cpp std::stoi("123") // 字符串→整数 static_cast<double>(x) // 比C风格转换更安全 ``` - Python: ```python int("42") # 字符串→整数(失败会抛异常) float(3) # 整数→浮点数 ``` #### 2. **检查范围后再转换** ```c float source = 1e20; if (source <= INT_MAX && source >= INT_MIN) { int safe = (int)source; } else { // 处理溢出 } ``` #### 3. **利用语言特性** - C#的`as`关键字: ```csharp object obj = new StringBuilder(); string s = obj as string; // 安全转换,失败返回null ``` - Java的`instanceof`检查: ```java if (obj instanceof String) { String s = (String)obj; } ``` --- ### 四、重点总结表 | **转换类型** | 语法示例 | 风险点 | 安全建议 | |------------------|------------------|-----------------------|-------------------------| | 数值类型强制转换 | `(int)3.14` | 精度丢失/溢出 | 检查目标类型范围 | | 指针强制转换 | `(char*)&intVar` | 内存解释错误 | 避免使用或严格对齐内存 | | 对象向下转型 | `(SubClass)obj` | 类型不匹配异常 | 先用`instanceof`检查 | --- 如果具体到某种语言(比如C/C++/Java/Python),可以再针对性说明,需要的话告诉我你想了解哪种语言的具体情况~
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值