进制

2023-09-18 08:05:10 浏览数 (1)

进制

简介

  1. 二进制：0、1，满2进1，以0b或0B开头
  2. 八进制：0～7，满8进1，以数字0开头表示
  3. 十进制：0～9，满10进1
  4. 十六进制：0～9及A（10）～F（15），满16进1，以0x或0X开头表示。此处A～F不区分大小写

进制转换（Java）

java.lang.Integer

代码语言：java复制
final int tenNum = 123456789;
// 转二进制
System.out.println(Integer.toBinaryString(tenNum));
// 转八进制转
System.out.println(Integer.toOctalString(tenNum));
// 转十进制
System.out.println(Integer.toUnsignedString(tenNum));
// 转十六进制
System.out.println(Integer.toHexString(tenNum));

自写

代码语言：java复制
    public static void main(String[] args) {
        final int tenNum = 123456789;
        // 转十进制
        System.out.print("n转10进制："   twoToTen(Integer.toBinaryString(tenNum)));
        System.out.print("t"   eightToTen(Integer.toOctalString(tenNum)));
        System.out.println("t"   sixteenToTen(Integer.toHexString(tenNum)));

        // 十进制转
        System.out.print("十进制转："   tenToTwo(tenNum));
        System.out.print("t"   tenToEight(tenNum));
        System.out.println("t"   tenToSixTeen(tenNum));

        // 二进制转
        System.out.print("二进制转："   twoToEight(Integer.toBinaryString(tenNum)));
        System.out.println("t"   twoToSixteen(Integer.toBinaryString(tenNum)));

        // 转二进制
        System.out.print("转二进制："   eightToTwo(Integer.toOctalString(tenNum)));
        System.out.println("t"   sixteenToTwo(Integer.toHexString(tenNum)));
    }

    /**
     * 二进制转十进制
     */
    public static int twoToTen(String num) {
        int result = 0;
        int i = 0;
        while (!num.isEmpty()) {
            // 个位 * 2^i
            result  = (int) (Integer.parseInt(num.substring(num.length() - 1)) * Math.pow(2, i));
            num = num.substring(0, num.length() - 1);
            i  ;
        }
        return result;
    }

    /**
     * 八进制转十进制
     */
    public static int eightToTen(String num) {
        int result = 0;
        int i = 0;
        while (!num.isEmpty()) {
            // 个位 * 8^i
            result  = (int) (Integer.parseInt(num.substring(num.length() - 1)) * Math.pow(8, i));
            num = num.substring(0, num.length() - 1);
            i  ;
        }
        return result;
    }

    /**
     * 十六进制转十进制
     */
    public static int sixteenToTen(String num) {
        int result = 0;
        int i = 0;
        String str;
        int number;
        while (!num.isEmpty()) {
            str = num.substring(num.length() - 1);
            switch (str) {
                case "A":
                case "a":
                    number = 10;
                    break;
                case "B":
                case "b":
                    number = 11;
                    break;
                case "C":
                case "c":
                    number = 12;
                    break;
                case "D":
                case "d":
                    number = 13;
                    break;
                case "E":
                case "e":
                    number = 14;
                    break;
                case "F":
                case "f":
                    number = 15;
                    break;
                default:
                    number = Integer.parseInt(str);
                    break;
            }
            // 个位 * 16^i
            result  = (int) (number * Math.pow(16, i));
            num = num.substring(0, num.length() - 1);
            i  ;
        }
        return result;
    }

    /**
     * 十进制转二进制
     */
    public static String tenToTwo(int num) {
        StringBuilder result = new StringBuilder();
        while (num != 0) {
            // 个位
            result.append(num % 2);
            num /= 2;
        }
        return result.reverse().toString();
    }

    /**
     * 十进制转八进制
     */
    public static String tenToEight(int num) {
        StringBuilder result = new StringBuilder();
        while (num != 0) {
            // 个位
            result.append(num % 8);
            num /= 8;
        }
        return result.reverse().toString();
    }

    /**
     * 十进制转十六进制
     */
    public static String tenToSixTeen(int num) {
        StringBuilder result = new StringBuilder();
        while (num != 0) {
            // 个位
            switch (num % 16) {
                case 10:
                    result.append("A");
                    break;
                case 11:
                    result.append("B");
                    break;
                case 12:
                    result.append("C");
                    break;
                case 13:
                    result.append("D");
                    break;
                case 14:
                    result.append("E");
                    break;
                case 15:
                    result.append("F");
                    break;
                default:
                    result.append(num % 16);
                    break;
            }
            num /= 16;
        }
        return result.reverse().toString();
    }

    /**
     * 二进制转八进制
     */
    public static String twoToEight(String num) {
        StringBuilder result = new StringBuilder();
        while (num.length() >= 3) {
            result.append(twoToTen(num.substring(num.length() - 3)));
            num = num.substring(0, num.length() - 3);
        }
        if (!num.isEmpty()) {
            result.append(twoToTen(num));
        }
        return result.reverse().toString();
    }

    /**
     * 二进制转十六进制
     */
    public static String twoToSixteen(String num) {
        StringBuilder result = new StringBuilder();
        while (num.length() >= 4) {
            result.append(tenToSixTeen(twoToTen(num.substring(num.length() - 4))));
            num = num.substring(0, num.length() - 4);
        }
        if (!num.isEmpty()) {
            result.append(tenToSixTeen(twoToTen(num)));
        }
        return result.reverse().toString();
    }

    /**
     * 八进制转二进制
     */
    public static String eightToTwo(String num) {
        StringBuilder result = new StringBuilder();
        StringBuilder str;
        while (!num.isEmpty()) {
            str = new StringBuilder(tenToTwo(Integer.parseInt(String.valueOf(num.charAt(0)))));
            while (str.length() < 3) {
                str.insert(0, "0");
            }
            result.append(str);
            num = num.substring(1);
        }
        return result.toString();
    }

    /**
     * 十六进制转二进制
     */
    private static String sixteenToTwo(String num) {
        StringBuilder result = new StringBuilder();
        StringBuilder str;
        while (!num.isEmpty()) {
            str = new StringBuilder(tenToTwo(sixteenToTen(String.valueOf(num.charAt(0)))));
            while (str.length() < 4) {
                str.insert(0, "0");
            }
            result.append(str);
            num = num.substring(1);
        }
        return result.toString();
    }

二进制数

值

长度

0000 0001

1

2^1-1=1

0000 0010

2

2^2-1=3

0000 0100

4

2^3-1=7

0000 1000

8

2^4-1=15

0001 0000

16

2^5-1=31

0010 0000

32

2^6-1=63

0100 0000

64

2^7-1=127

1000 0000

128

2^8-1=255

1字节 = 8bit

1字节最大能存长度为-128～127（-2^7 ~ 2^7-1）的数值

原码、反码、补码

汇总

  1. 二进制的最高位是符号位
    1. 0--表示：N，取值范围：（0,∞），
    2. 1--表示：负数，取值范围：[-∞,0)
  2. N 的原码、反码、补码都一样（三码合一）
  3. 负数的反码 = 它的原码符号位不变，其他位取反
  4. 负数的补码 = 它的反码 1，负数的反码 = 负数的补码 - 1
  5. 在计算机运算的时候，都是以补码的方式来运算的
  6. 当看运算结果的时候，要看他的原码

案例

源数据

十进制数

原码（二进制）

反码

补码

4

0100

0100

0100

2

0010

0010

0010

-2

1010

1101

1110

-5

1101

1010

1011

计算

样例

补码计算

补码结果

反码结果

原码结果

十进制

4 2

0100 0010

0110

0100

6

4 - 2

0100 1110

0010

0010

2

4 - 5

0100 1011

1111

1110

1001

-1

2-2

0010 1110

0000

0000

0

2-5

0010 1011

1101

1100

1011

-3

-2-5

1110 1011

1001

1000

1111

-7

4 - 2 ——> 0100 1110 = 1 0010 -2-5 ——> 1110 1011 = 1 1001 上述出现计算结果溢出，故忽略

位移运算符

名称

符号

介绍

按位与

&

两位全为1，结果为1，否则为0

按位或

|

两位有一个为1，结果为1，否则为0

按位异或

^

两位一个为0，一个为1时，结果为1，否则为0

按位取反

~

0->1,1->0

算数右移

>>

低位溢出，符号位不变，并用符号位补溢出的高位

算数左移

<<

符号位不变，低位补0

逻辑右移

>>>

也叫无符号右移，运算规则是：低位溢出，高位补0

没有 <<< 符号

案例

样例

原码

反码

补码

补码结果

反码结果

原码结果

十进制

2 & 3

0010 & 0011

0010

2

~-2

~1010

~1101

~1110

0001

1

~2

~0010

1101

1100

1011

-3

1 >> 2

0001 >> 2

0000

0

1 << 2

0001 << 2

0100

4

4 << 3

0100 << 3

0010 0000

32

1 >> 2 本质为：1 / 2 / 2 = 0

1 << 2本质为：1 2 2 = 4

4 << 3本质为：4 2 2 * 2 = 32

java 二进制

0 人点赞