起因:
面试的时候被问到能否现场写一个进制转换的方法,比如10进制转16进制等.
内心戏:
卧槽,16进制是啥东西?满16进1位,但是怎么表示16呢?1,2,3,4,5,6,7,8,9,10,11,12,13,14,15?然后大于15就进一位?

我特么的连16进制是啥都不知道,写个鸡儿转16进制啊.

面试官说,那你随便写个进制吧,10转2也行.
内心戏02:
10转2怎么转来着?然后开始快速回忆初中高中大学老师怎么是怎么讲10转2的.
10进制转2进制:
功夫不负有心人,我连蒙带猜知道了10转2的过程了.

10÷2=5余0

5÷2=2余1

2÷2=1余0

1÷2=0余1,

余数从下到上连在一起便是结果:1010.
核心代码如下:
public String transJinZhi01(String str, int jinZhi) {

        assert str != null && str.length() > 0;
        assert jinZhi % 2 == 0 && jinZhi > 0;
        Stack<Object> objects = new Stack<>();
        //将字符串转成数字
        int num = Integer.valueOf(str);
        //第一次取余数
        int yuShu = num % jinZhi;
        //第一次的商,下面判断是否需要遍历
        int shang = num / jinZhi;
        objects.push(yuShu);
        do {
            yuShu = shang % jinZhi;
            shang = shang / jinZhi;
            objects.push(yuShu);
        } while (shang != 0);

        StringBuffer stringBuffer = new StringBuffer();
        while (!objects.empty()) {
            Object pop = objects.pop();
            stringBuffer.append(pop);
        }
        String s1 = stringBuffer.toString();
        System.out.println("数字" + str + "转化为" + jinZhi + "进制后为 = " + s1);
        return null;
    }


测试代码如下:
    @Test
    public void test01() {

        //报错
//        this.transJinZhi01(null, 10);
        //报错
//        this.transJinZhi01("10", 1);
        //报错
//        this.transJinZhi01("10", 0);
        //报错
//        this.transJinZhi01("", 10);
        //正常
        this.transJinZhi01("1000", 2);
        this.transJinZhi01("1000", 8);
        this.transJinZhi01("1000", 10);
        //看源码怎么写的
//        String s = Integer.toBinaryString(10);
//        System.out.println("s = " + s);
    }

运行结果是:
数字1000转化为2进制后为 = 1111101000
数字1000转化为8进制后为 = 1750
数字1000转化为10进制后为 = 1000


结束语:
面试时粗略写的,想着趁着这个机会把这个完善下记录下来,也是自己的短板.

此方法是10进制转2、4、8进制的方法,抛开效率讲是可行的,欢迎各位伙伴指正.

我为啥不写任意进制转换呢?

因为我没搞懂超过10进制后怎么表示呢…

尴尬尴尬

二进制怎么转化成其他进制（详细过程） 

计算机中常用的数的进制主要有：二进制、八进制、十六进制，学习计算机要对其有所了解。

2进制，用两个阿拉伯数字：0、1；

8进制，用八个阿拉伯数字：0、1、2、3、4、5、6、7；

10进制，用十个阿拉伯数字：0到9；

16进制就是逢16进1，但我们只有0~9这十个数字，所以我们用A，B，C，D，E，F这五个字母来分别表示10，11，12，13，14，15。字母不区分大小写。

以下简介各种进制之间的转换方法：

一、二进制转换十进制

例：二进制 “1101100”

1101100 ←二进制数

6543210 ←排位方法

例如二进制换算十进制的算法:

1*26 + 1*25 + 0*24 + 1*23 + 1* 22 + 0*21 + 0*20

↑ ↑

说明：2代表进制，后面的数是次方e69da5e887aae799bee5baa6e79fa5e9819331333332633639（从右往左数，以0开始）

=64+32+0+8+4+0+0

=108

二、二进制换算八进制

例：二进制的“10110111011”

换八进制时，从右到左，三位一组，不够补0，即成了：

010 110 111 011

然后每组中的3个数分别对应4、2、1的状态，然后将为状态为1的相加，如：

010 = 2

110 = 4+2 = 6

111 = 4+2+1 = 7

011 = 2+1 = 3

结果为：2673

三、二进制转换十六进制

十六进制换二进制的方法也类似，只要每组4位，分别对应8、4、2、1就行了，如分解为：

0101 1011 1011

运算为：

0101 = 4+1 = 5

1011 = 8+2+1 = 11（由于10为A，所以11即B）

1011 = 8+2+1 = 11（由于10为A，所以11即B）

结果为：5BB

四、二进制数转换为十进制数

二进制数第0位的权值是2的0次方，第1位的权值是2的1次方……

所以，设有一个二进制数：0110 0100，转换为10进制为：

计算： 0 * 20 + 0 * 21 + 1 * 22 + 1 * 23 + 0 * 24 + 1 * 25 + 1 * 26 + 0 * 27 = 100

五、八进制数转换为十进制数

八进制就是逢8进1。

八进制数采用 0～7这八数来表达一个数。

八进制数第0位的权值为8的0次方，第1位权值为8的1次方，第2位权值为8的2次方……

所以，设有一个八进制数：1507，转换为十进制为：

计算： 7 * 80 + 0 * 81 + 5 * 82 + 1 * 83 = 839

结果是，八进制数 1507 转换成十进制数为 839

六、十六进制转换十进制

例：2AF5换算成10进制

直接计算就是： 5 * 160 + F * 161 + A * 162 + 2 * 163 = 10997

(别忘了，在上面的计算中，A表示10，而F表示15)、

现在可以看出，所有进制换算成10进制，关键在于各自的权值不同。

假设有人问你，十进数 1234 为什么是 一千二百三十四？你尽可以给他这么一个算式： 1234 = 1 * 103 + 2 * 102 + 3 * 101 + 4 * 100

计算机原本是就一堆 01010二进制的表达式，如何将这一堆二进制数映射为我们实际生活中的真值，比如+11,+22，-3，-4…… 这些叫做有符号数
为了用这些二进制数字表达出我们现实生活中的数字，人们设计三种不一样的编码
1。 第一种叫原码，
最高位的符号如果是0，表达这个数是一个正数，
如果最高位是1，表达这个数是一个负数
这种表达方式在做运算的时候是会出问题的，因为符号位的参与，导致得不到正确的结果。
在字长位4位的时候
4 = 0 1 0 0    
-2 = 1 0 1 0
4 - 2 = 4 + （-2）= 0100+1010 = 1110  ==》 表示的是 -6
2。 第二种是反码。
反码符号位不变，各位取反。
至于反码所解决的问题，还没有弄清楚
3。第三种就是补码了。
补码的概念很多知乎上的答案写的很清楚了。
先说结论 -2 的补码是 1 110  
0100+1110 = 1 0 010 ，这里1溢出了，舍去取0作为符号位，得到正确答案2
溢出舍去意味着走完一个周期，舍去的操作也可以理解成减去10000
溢出要从头开始，从头开始表达的状态和我们最终要求得的状态是一致的。
可以联想下时钟，时钟4点到2点，我可以选择逆时针拨动(2+12n)个格子
(2+12n)这个数字是无限的，不适用于现实中计算机的运算
计算机的运算通常有位数限制的！
时钟是一个很好理解补码的例子，时钟上的12个状态。 
4-2表示4点拨到2点需要逆时针拨动2个格子
为了到达到2点，也可以顺时针拨动10个格子
如果规定顺时针是正方向，那么 状态等价 ==》 4 - 2 = 4 + （10）
补码给我的感觉，就是在有限的状态数中，达到相同状态的另外一个表达方式。
这里也可以联想一个数轴，往数轴上的一个方向一直跑，跑到一个值后，又得从头开始
也可以理解成一种周期的概念，周而复始
计算机可以如果是8位，可以保存2^8 = 256种状态。
但是 如果用原码 来表示有符号的数， 只能保存255个
因为 -0 = 1000 0000 , +0 = 0000 0000
这样我们现实中的数 0 （0是没有正负的），但是在原码中，我们这样说，
1000 0000表示的是0， 0000 0000也表示的是0 ，0占据了两种表达
但是如果是使用补码来存储的， -0和+0的补码都是 0000 0000 
我们就可以说，0000 0000 表达的是0 （包括+0 -0），这个时候多出来一个1000 0000
人们就将这个1000 0000 表示成 -128，为了不浪费吧？
关于计算时候的溢出
溢出意味着这次计算越界了，需要从头开始。
他的表现是最高位的符号位发生了改变，变0变1都有可能
再次声明一下补码的概念，表示有限状态的一对数，注意是一对！
这个时候将溢出的数加上一个周期，或者减去一个周期，让他回到有限状态中
这个概念的实质就是求余，也叫做减去一个模，或者加上一个模。
来自CSAPP：
补码中的权重：第一位 i *  (-2)^(n-1)，针对整数
如果第一位i取0，那么他就没有这个负数的权重，表达一个正数，
如果取1，表示有负数的权重，那么他表达就 是一个负数
如果一个数的补码是1000 0000 ，那么他的真值就是 (-2)^7 = -128
还是挺自然的
-128是不能用原码表示的，8位原码的表示有符号数范围是 [-127, 127]
在定点小数的表示中，-1是不能用原码表示的，
因为8位原码的范围是-1+2^(-7) 到 1-2^(-7)，就是不可能到达到1和-1
反过来想如果到达1和-1，那他就不是小数了嘛
但是如果我们想用补码来表示有符号的小数，
那就把1000 0000 拿过去表示 -1 就好了嘛
总结下：
1。将加减法运算当做一种达到状态的方式，在一个有限数中，是有两种办法达到同一个状态的，就是减法的运算本质上，在有限数中，是可以用加法得到的，可能会有溢出的情况，求余求回去就好了。
2。补码的表示的数字在左边的半轴延长了一位，整数是-2^n，小数是-1，就变成256个了，造成了原点的对称，原码和反码都是255个，关于原点对称
以上就是一些关于补码的思考，如果有错请大家指出哦！

最近在给学生讲课的时候，学生问到，对于一个c语言编写的程序，一个int类型的数据，在内存中是如何存储的。
例如：int类型的1在内存中占用4个字节，那这4个字节具体怎么存储呢？
目前市面上大部分书籍说的都是数字的字节表示形式，按照二进制的方式进行存储。学生就理所当然的认为是按照下面方式进行存储的。
第1字节                 第2字节                  第3字节               第4字节
00000000            00000000             00000000           00000001
但是我告诉他们实际上并不是这样存储的，而是低位在前，高位在后的方式存储的，也就是按照下面的方式
第1字节                 第2字节                  第3字节               第4字节
00000001            00000000             00000000           00000000
学生们就觉得有点不太好理解，于是就写了一段小程序来检验一下，看看是否是我说的这种方式进行存储。

[cpp] view plain copy
#include <stdio.h>  
  
  
int main(){  
    int i = 1;  
    unsigned char * p = (unsigned char *)(&i);  
    printf("第1字节：%d,第2字节：%d,第3字节：%d,第4字节：%d\n",*p,*(p+1),*(p+2),*(p+3));  
}  

于是他们按照我的这个思路，对所有的基本数据类型都做了一个检测，并且对结构体等复杂类型的内存存储方式都做了一个检验，对数据类型在内存中的存储方式的理解又深入了一步。