Int32 最大的数值是多少？？？（附十进制十六进制相互转换且包含正负数的java代码）

最新推荐文章于 2025-03-04 12:22:12 发布

原创最新推荐文章于 2025-03-04 12:22:12 发布 · 1w 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#二进制 #16进制

二进制专栏收录该内容

1 篇文章

订阅专栏

本文详细介绍了如何将负数转换为二进制、八进制和十六进制，并解释了计算机内部如何区分正负数及二进制位运算的应用。

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

正数转二进制很简单，转十六进制也很简单。

那么负数的情况下呢？在计算机中无法识别你给的符号“+”,"-"，计算机只认识0和1 那么在二进制中如何表示负数。

先简单介绍一下负数如何转二进制，八进制，十六进制：

比如给的是-4

那么先算出+4的二进制表示：

1 0 0

但是请记住我们需要在前面补0，因为在计算机中一个Int32为的数字是一个长度为32的内存空间，计算机眼里

0000 0000 0000 0000 0000 0000 0000 0100 才是4，这是源码

接下来进行反码，结果是

1111 1111 1111 1111 1111 1111 1011

反码之后，再+1便是4的补码

1111 1111 1111 1111 1111 1111 1100

得到4的补码之后，其实这个补码就是-4的二进制表示，那么-4的八进制就是将每3位换算成数字结果是：

37777777774

那么16进制就是每4位换算成数字

FFFFFFFC

说到这里就有个疑问了，按照上面的规则，-1二进制里表示 1111 1111 1111 1111 1111 1111 1111 1111

那么4294967295 数字转换成二进制也是1111 1111 1111 1111 1111 1111 1111 1111。

那么1111 1111 1111 1111 1111 1111 1111 1111到底表示哪个呢？

其实：

一段内存是连续32个1，你把它按照一个int来解读就是-1，按照unsigned int来解读就是4294967295

我们可以在c++程序中实现一下：

 int aa = 4294967295;
    cout<<aa;

结果是：

当你把int aa 变成 unsigned int aa unsigned表示无符号

那么结果就是4294967295

在c++中：

unsigned int: 4294967295(2^32-1)
signed int: 2^31-1

因为，计算机需要留一个最高位来判断你这个数字是正的还是负的。

所以Int一个数字32位下最大数字是2^31-1 你定义的超过了这数字那么计算机就会把你计算出负数了。

下面附上java写的十进制转十六进制的代码

package com.company;


import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;

import java.util.HashMap;
import java.util.Map;
import java.math.*;
import java.util.*;


public class Main {


    static int Bin[] = new int[1000];
    static char Hex[] = new char[1000];
    static int _pos=0;
    static int Change(char x)
    {
        if(x>='0'&&x<='9')
            return x-'0';
        else if(x=='A')
            return 10;
        else if(x=='B')
            return 11;
        else if(x=='C')
            return 12;
        else if(x=='D')
            return 13;
        else if(x=='E')
            return 14;
        else if(x=='F')
            return 15;
        else
            return 16;

    }
    //十六进制转二进制
    static void HextoBin()
    {
        for(int i=0;i<Hex.length;i++)
        {
            int x= Change(Hex[i]);
            int j=0;
            _pos+=4;
            while(x>0)
            {
                Bin[--_pos]=x%2;
                x/=2;
                j++;
            }
            _pos+=j;

        }
        //是负数要减1再进行反码
        if(Hex.length==8&&Hex[0]>='8')
        {
            int xx =-1;
            for(int i=_pos-1;i>=0;i--)
            {
                Bin[i]+=xx;

                if(Bin[i]==-1)
                {
                    Bin[i]=1;
                    xx =-1;
                }
                else
                    xx=0;

            }
            for(int i=0;i<_pos;i++)
            {
                Bin[i]=(Bin[i]==1?0:1);
            }

        }
    }

    static int BintoDem()
    {
        int x=0;
        for(int i=_pos-1;i>=0;i--)
        {
            x+=(Bin[i]*((int)Math.pow(2.0,_pos-1-i)));
        }
        return x;
    }


    public static void main(String[] args) {
    // write your code here
       // HashMap<String,HashMap<String,String>> m = new HashMap<>();
        System.out.println("**********输入数字，输出16进制数");
    Scanner input = new Scanner(System.in);
    x=input.nextInt();
    DemtoBin(x);
    BintoHex();
    for(int i=pos2-1;i>=0;i--)
        System.out.print(hex[i]);

    System.out.println();

    //16进制为负数，必须是8位，且第一位是大于等于8的
    System.out.println("***********输入16进制数，输入数字");

        Hex=input.next().toCharArray();
        HextoBin();
       int x= BintoDem();
        if(Hex.length==8&&Hex[0]>='8')
        {
            System.out.println("-"+x);
        }
        else
            System.out.println(x);

    }


    static int bin[] = new int[10000];
    static char hex[] = new char [10000];
    static int pos2=0;
    static int pos =32;
    static int pos3 =0;
    static int x;

    static void  DemtoBin(int x) {

        //先转换为二进制
        int y = Math.abs(x);
        pos3=0;
        while(y>0)
        {
            bin[pos3++]=y%2;
            y/=2;
        }



        //如果为负数，要进行反码
        if (x < 0) {
            for (int i = 0; i < pos; i++) {
                bin[i] = (bin[i] == 1 ? 0 : 1);
            }
            //加1
            int xx = 1;
            for (int i = 0; i < pos; i++) {
                bin[i] += xx;
                if (bin[i] == 2) {
                    bin[i] = 0;
                    xx = 1;
                } else
                    xx = 0;
            }
            if(xx==1)
                bin[pos++]=xx;
        }

    }
    static char change(int x)
    {
        if(x>=0&&x<=9)
        {
            return (char)(x+48);
        }
        else if(x==10)
            return 'A';
        else if(x==11)
            return 'B';
        else if(x==12)
            return 'C';
        else if(x==13)
            return 'D';
        else if(x==14)
            return 'E';
        else if(x==15)
           return 'F';
        else
            return 'G';


    }
    //二进制转16进制
    static void BintoHex()
    {
        int len;
        if(x<0)

            len = pos;
        else
            len =pos3;

            int j=0;int res=0;
            for(int i=0;i<len;i++)
            {

                res+=Math.pow(2.0,j)*bin[i];
                j++;
                if(j==4)
                {
                    hex[pos2++]=change(res);
                    res =0;
                    j=0;
                }
            }

            if(j!=0)
            {
                hex[pos2++]=change(res);
                
            }

    }
}

---------------------------------------更新---------------------------------

一个数字给你转换成二进制，其实不用上面那么麻烦，判断符号啥的，无论正数还是负数

都可以用位运算来解决，&1 表示判断这个数字最后一位的是0还是1，<<1 表示左移一位：

public byte[] getIntBit(int b) {
      byte[] array = new byte[32];
      for (int i = 31; i >= 0; i--) {
          array[i] = (byte)(b & 1);
          b = (byte) (b >> 1);
      }
      return array;
  }