这里就是这样的世界，这里的1 + 1 = 10 --二进制物语

儒仁慈世安家业，墨守规矩自方圆。
兵戈铁马平天下，法理束欲定千秋。
佛释恶业普渡生，道化万物共长存。   
诸子百家何为首? 且问君心何所求。
                ---- 张风捷特烈《求》 2019.2.15

零、前言

关于数字化个人认为是计算机世界对现实世界的映射(或称采样或模拟)。
现实世界包括客观存在和人类文明衍生物（自然科学和广义文学）。
数字化就是将这些映射为二进制数据。本文观点为个人体悟总结,仅供参考

本文包括

1.散扯引入一些概念和个人体悟
2.进制及其转化的相关问题
3.逻辑运算
4.字符的编解码
5.java中的基本数据类型

一、先天八卦与烽火狼烟

先声明我不是尊学崇术的人，百家于我如一。
道家认为万物皆有阴阳，这跟计算机世界一切皆有0，1一样。

比如现在我用的笔记软件，你能想象出它是由一群0和1排列组合形成的吗?
然而这些0和1可以根据操作而产交互，就像可以"活"一样。
我曾经很多次将一个应用（手机也好，web也好，电脑也好）想象成一个独立生命体  
与一些简单的生物而言，它们也有生命体征,下面类比一下:

对比类别	生物	应用程序
生存空间	地球	计算机系统(手机、电脑及智能终端)
资源	地球提供	计算机系统提供
食物	可消化的能量体	可处理的数据体
消化	原生食物-->可用能量	原生数据-->可用数据
废物	shi(化验看健康状况)	log (分析看健康状况)
行为	唱歌，做作业，看小说...	播放音乐，放视屏，显示小说...
外观	化妆，换发型，换衣服...	美化UI,齐刘海?,换肤...
收藏品	古董，金钱，武器...	缓存文件cache
诞生	父母	Coder
家族优势	富二代?(金钱支持)	大佬公司的新产品(技术支持)
生态群	娱乐圈, 教育界,学生党...	播放相关，教育相关,游戏类...
最广阔存在	无限空间(宇宙)	无限内存(不可描述)
最底层表现形式	不可描述(元素/分子?)	0 和 1

1、先天八卦 (-`吹牛的绝佳资本`-)

道有言:易生太极，太极生两仪，两仪生四象，四象生八卦。
先天八卦还是蛮好玩的，至于洛书和河图的九宫和后天八卦...

当把阴(断横)看做0，阳(连横)看做 1,自下而上来表示
看过侠岚的应该比较熟悉(我都忍不住说绝招了...)

两仪:一组阴阳变化
阳      1
阴      0 

四象：在两仪之上添加阴阳变化
太阳    11      阳
少阳    10      阳
太阴    00      阴
少阴    01      阴

八卦：在四象之上添加阴阳变化
天  乾  111 南      三连   一   金  太阳
泽  兑  110 东南    上缺   二   金  太阳
火  离  101 东      中虚   三   火  少阳
雷  震  100 东北    仰盂   四   木  少阳
风  巽  011 西南    下断   五   木  少阴
水  坎  010 西      中满   六   水  少阴
山  艮  001 西北    覆碗   七   土  太阴
地  坤  000 北      六断   八   土  太阴

在八卦之上再添加阴阳变化，就形成64卦，如果万物都由阴阳生成
那么我们的世界也是二进制的变化?细思恐极...
这里并不是故弄玄虚，只是想说明一下二进制的变化力

2.烽火狼烟

小学的那道题印象深刻(具体数据当然记不清了):

一个城池边防有六座烽火台，通过狼烟来通知军队敌军人数，
以二进制表示：点烟的代表1，没点的代表0 ，化成十进制后的1000倍即是敌军人数
下面敌军来了多少人?

110010 = 2^5+2^4+2^1=32+16+2=50 答：来了50000人

这就有意思，来了50000人我总不能在天上写个50000吧，
两种状态和六个变化点，再结合状态获取的途径，烽火狼烟确实实现了信息的传递
但功劳是烽火狼烟吗，是二进制吗? 烽火狼烟只是途径，而二进制只是规则。

其是本质:编码和解码,曾经我一度不解为什么要编解码?
看起来编解码似乎是一个很愚蠢的事：
可识别信息转了一大圈又变成了可识别信息，还要额外定制编码的规则   
就像把一个图片拆成拼图，再花费时间拼出来一样，有什么意义呢?

第一优势：加密 
不可直接识别信息其中隐含着[有人可以识别的意思] 
传递信息的过程中保证了信息的相对安全[避免不知道规则的人读取或修改] 

第二优势：可操作
这个优势可以说改变了一个时代，便是我们当今时代    
人类定制了[编译规则]与[操作系统]来当翻译官，这两者是人类不能及的  
但我们有聪明才智:
程序员--->写代码-->编译成二进制-->操作系统读取二进制指令--->操作系统执行
关键就在[编译成的二进制]可以在[操作系统]执行，让使用方感受科技的时代

说了那么多，想表达一点：变化可以附加信息

二、进制相关

1.我与二进制

小学看二进制，不是1就是0呗，我蒙一下还有一半概率!
中学看二进制，觉得有点意思，不是1就是0，谁想出来的,这么无聊!
高学看二进制，面无表情...二进制就二进制呗，管我甚事，反正我会算!
大学看二进制，不听不听，王八念经...!
现在看二进制，擦，哲学啊!

2.状态与变化点

一种机制的变化总和=状态的变化点次方

道家：
状态：阴阳
变化点：爻  如八卦是阴阳的三种变化，称为三爻 , 两仪即 二爻

计算机：
状态：0 , 1 (高电平1和低电平0)
变化点：位 如一个int是0,1的32种变化，称为32位，boolean即 1位(真假)

|--为什么状态和变化这么重要? 拿烽火狼烟来说,能用十进制吗?
答案：能 ! 只要规则定制完善即可，比如九种颜色的烟代表1~9，0代表不点
这样就能形成10种状态，也就是十进制，6座烽火台可以表示0~999999中的任意一个  
但是成本太高，可行性也很低；点与不点是两种天然的状态，干嘛非要瞎折腾  
111111 最大表示 63(即2^6-1) 这和 999999(即10^6-1),两者的信息量差距还是非常大的

3.为什么计算机非要用二进制

天时-地利-人和

天时：电气时代的来临，人类掌握了电的使用，机械和电力结合的历史洪流
地利：二进制的物理可实现(高低电平)、逻辑运算能力、结构与运算规则简单
人和：人才辈出，各个学科都诞生出一批大师，学术氛围...

二进制加法：0+0=0  1+0=1 0+1=1 1+1=10  天然与
二进制乘法：0*0=0  1*0=0 0*1=0 1*1=1   天然或

4、进制转化

这里我提个问题，来想一下：
是不是所有的十进制实数都能转化成二进制?
是不是所有的其他进制实数都能转化成十进制?

4.1.其他进制转化为10进制

一气化三清，公式走起

R：基数(进制) 
i：数字的位置
权：R的i次方 
n：整数位数-1
m：小数位数

------------------345.6 十进制 ---------------------------
   3        4       5       6
   ↓        ↓       ↓       ↓
3*10^2 + 4*10^1 + 5*10^0 + 6*10^-1
300    + 40     + 5      + 0.6     = 345.6

基数 R=10; n=2; m=1
对于3而言：i=2     权：10^2    K=3  
对于4而言：i=1     权：10^1    K=4
对于5而言：i=0     权：10^0    K=5
对于5而言：i=-1    权：10^-1   K=6

------------------345.6八进制转10进制 ---------------------------
  3       4       5       6
  ↓       ↓       ↓       ↓
3*8^2 + 4*8^1 + 5*8^0 + 6*8^-1
192   + 32    + 5     + 0.75     = 229.75

基数 R=8; n=2; m=1
对于3而言：i=2     权：8^2    K=3  
对于4而言：i=1     权：8^1    K=4
对于5而言：i=0     权：8^1    K=5
对于5而言：i=-1    权：8^-1   K=6

---------------11001.1二进制转10进制 --------------------------
  1       1       0       0       1       1      
  ↓       ↓       ↓       ↓       ↓       ↓      
1*2^4 + 1*2^3 + 0*2^2 + 0*2^1 + 1*2^0 + 1*2^-1 
16    + 8     + 0     + 0     + 1     + 0.5     = 25.5

基数 R=2; n=4; m=1 自左到右
对于1而言：i=4     权：2^4    K=1  
对于1而言：i=3     权：2^3    K=1  
对于0而言：i=2     权：2^2    K=0  
对于0而言：i=1     权：2^1    K=0
对于1而言：i=0     权：2^1    K=1
对于1而言：i=-1    权：2^-1   K=1

二进制--->十进制：权值相加

4.2.十进制转换成二进制

--------------十进制49转换二进制-----------------------
--------------------- 权值
49 / 2 = 24 ······1   2^0 = 1
24 / 2 = 12 ······0   ---
12 / 2 = 6  ······0   ---
6 / 2 = 3   ······0   ---
3 / 2 = 1   ······1   2^4 = 16
1 / 2 = 0   ······1   2^5 = 32 
--倒取-->110001  ：小学老师告诉我这样转化，到现在我也不明白why?
十进制整数可以和二进制整数一一对应，那小数呢?

--------------十进制0.8125转换二进制-----------------------
---------------------------- 权值
0.8125 * 2 =  1.625     1    2^-1=0.5
0.625  * 2 =  1.25      1    2^-2=0.25
0.25   * 2 =  0.5       0    ---
0.5    * 2 =  1         1    2^-4=0.0625
0      * 2 =  0         0    --- over
0.5+0.25+0.0625 = 0.8125 ---准确无误，这老师可没教过

--------------十进制0.6531转换二进制-----------------------
---------------------------- 权值
0.6531 * 2 =  1.3062    1    2^-1=0.5
0.3062 * 2 =  0.6124    0    ---
0.6124 * 2 =  1.2248    1    2^-3=0.125
0.2248 * 2 =  0.4496    0    ---
0.4496 * 2 =  0.8992    0    ---
0.8992 * 2 =  1.7984    1    2^-6=0.03125
.... 无穷尽
0.5+0.125+0.03125 = 0.65625 ≈ 0.6531
这就更玄乎了...竟然无穷尽，所以这便是计算机中小数的瑕疵

4.3.二进制与八进制十六进制间的转化

小数对二进制来说是个无法磨灭的瑕疵，也许有什么二进制的无限不循环(循环)小数也说不定
我认为数是美的，瑕疵只是我们还无法忍识的另一种美的存在形式，2,8,16完美转化

每一个八进制数可以由三个二进制数表示
二进制  1010111011.1101  
形象化  001 010 111 011 . 110 100  
八进制  1   2   7   3   . 6   4  

形象化    0010 1011 1011.1101  
十六进制  2    11   11   13------>2BB.D

四、计算机中数的表示

1.无符号

结合烽火狼烟，相当于有八个烽火台，每个烽火台有2个状态(0,1)
能够表示 0~ 2^8-1 个正整数

2.加入符号

对于整数而言要有符号,java中的byte是带有符号(+或-)的，于是要扣除一位
就像烽火狼烟无法表示友方来军多少人，可以扣除一个作为友方来军体还是敌方来军
所以就7个烽火台有数字价值，好处是效用增加，坏处是表示的数范围减小
能够表示-2^7 ~ 2^7-1 即(-128 ~ 127)个正整数

3.减法： byte 为例

计算机无法直接做减法，但是加法也可以变成减法
今天刚好发生了一件事来表述:

早上我做公交车，看文章太专注，TM做过了两站，

假如公交车到终点时会从时空虫洞回到起点（就当是3019年的公交吧……）。
公交车一共19站，我当时在18站，目的地在16站
有两个选择，
--->下来往回走两站，18-2=16
--->目的地也可以看做在第16+19=35 站
    18+ ? = 35，也就是再坐17站
    
即-2和+17有同样的效果，就称17是-2的补码。这就是计算机减法的思想支持。
显而易见:在这个运算体系中:
原码 -2
补码  17
18-2 = 18+17 都能到第16站
具有这样周期性的有很多，即到头重新数，时钟，星期，日期，简谐运动的振幅等

byte a = 17;
byte b = -5;
System.out.println(a + b);//12

4.小数的表示：float为例

7.25(十进制) = 111.01(二进制 )
111.01(二进制)=1.1101*2^2(二进制)  类比科学计数法

符号位：0
阶码：2 + 127 ---二进制---> 10000001
尾数：1101

|---在java中可用以下代码验证：记得补满32位
float a = 7.25f;
int b=Float.floatToIntBits(a);
String string = Integer.toBinaryString(b);
System.out.println(string);
//0100 0000 1110 1000 0000 0000 0000 0000

四、逻辑控制

1、四个位运算符

随便写了几个值，眼都瞅花了...

位与:&     两个都是1为1
位或:|     只要有1就是1
位非:~     全取反
位异或：^  两个都不一样为1

例子：c = a & b 
    0000 0000 0000 0000 0000 0110 1010 1001  [a]   0x000006a9  1705
 &  0000 0000 0000 0000 0100 0100 1011 0101  [b]   0x000044b5  17589
---------------------------    
    0000 0000 0000 0000 0000 0100 1010 0001  [c]   0x000004a1  1185
    
例子：d = a | b
    0000 0000 0000 0000 0000 0110 1010 1001  [a]   0x000006a9  1705
 |  0000 0000 0000 0000 0100 0100 1011 0101  [b]   0x000044b5  17589
---------------------------
    0000 0000 0000 0000 0100 0110 1011 1101  [d]   0x000046bd  18109
    
例子：e = ~a    
    0000 0000 0000 0000 0000 0110 1010 1001  [a]   0x000006a9  1705
  ~  
    1111 1111 1111 1111 1111 1001 0101 0110  [e]   0xfffff956  -1706

例子：f = a ^ b
    0000 0000 0000 0000 0000 0110 1010 1001  [a]   0x000006a9  1705
 ^  0000 0000 0000 0000 0100 0100 1011 0101  [b]   0x000044b5  17589
---------------------------
    0000 0000 0000 0000 0100 0010 0001 1100  [f]   0x0000421c  16924

2.java中校验上面位运算的例子

public static void main(String[] args) {
    int a = 0x000006a9;//0000 0000 0000 0000 0000 0110 1010 1001
    int b = 0x000044b5;//0000 0000 0000 0000 0100 0100 1011 0101
    int c = 0x000004a1;//0000 0000 0000 0000 0000 0100 1010 0001
    int d = 0x000046bd;//0000 0000 0000 0000 0100 0110 1011 1101
    int e = 0xfffff956;//1111 1111 1111 1111 1111 1001 0101 0110
    int f = 0x0000421c;//1111 1111 1111 1111 1111 1001 0101 0110
    System.out.println(a);//1705
    System.out.println(b);//17589
    //位与
    System.out.println(a & b);//1185
    System.out.println(c);//1185
    //位或
    System.out.println(a | b);//18109
    System.out.println(d);//18109
    //位非
    System.out.println(e);//-1706
    System.out.println(~a);//-1706
    //位异或
    System.out.println(f);//-1706
    System.out.println(a ^ b);//-1706
}

3.移位操作

左移n位相当于乘以2的n次方 a<<n
右移n位:a>>n


例子：g = a << 4  
         0000 0000 0000 0000 0000 0110 1010 1001  [a]   0x000006a9  1705
    0000 0000 0000 0000 0000 0110 1010 1001  <---移位
         0000 0000 0000 0000 0110 1010 1001 0000  [g]   0x00006a90  27280=1705*2^4
         
例子：h = a >> 4  
         0000 0000 0000 0000 0000 0110 1010 1001  [a]   0x000006a9  1705
              0000 0000 0000 0000 0000 0110 1010 1001  <---移位
         0000 0000 0000 0000 0000 0000 0110 1010  [g]   0x0000006a  27280=106

---->[代码验证]---------------
int g = 0x00006a90;//0000 0000 0000 0000 0110 1010 1001 0000
int h = 0x0000006a;//0000 0000 0000 0000 0110 1010 1001 0000
System.out.println(g);//27280
System.out.println(a << 4);//27280
System.out.println(h);//106
System.out.println(a >> 4);//106

4.需要注意的几种套路：

1.将两个int值得低八位(最后一个字节)拼成一个short

取低8位: int 值 & 0x000000FF ----看一下挺好理解的
    0000 0000 0000 0000 0000 0110 1010 1001  [a]   0x000006a9  1705
&   0000 0000 0000 0000 0000 0000 1111 1111     
-------------------------------------------------
    0000 0000 0000 0000 0000 0000 1010 1001  [i]   0x000000a9

取低8位后左移8位: int 值 & 0x000000FF
     0000 0000 0000 0000 0100 0100 1011 0101  [b]   0x000044b5  17589
&    0000 0000 0000 0000 0000 0000 1111 1111 
-------------------------------------------------
     0000 0000 0000 0000 0000 0000 1011 0101  [j]  0x000000b5
     0000 0000 0000 0000 1011 0101 0000 0000  [j]  左移8位  0x0000b500
     
    0000 0000 0000 0000 0000 0000 1010 1001  [i]   0x000000a9
 +  0000 0000 0000 0000 1011 0101 0000 0000  [j]   0x0000b500
 -------------------------------------------------
    0000 0000 0000 0000 1011 0101 1010 1001        0x0000b5a9

强转成short完成任务:1011 0101 1010 1001  

2.当 n = 2^i 时，x % n = (n - 1) & x (这是看HashMap源码学到的),例如：
至于原理没研究过，但位运算要比%运算要快，所以后者有优势，HashMap里便是后者
int x = 67444;
int i1 = 255 & x;//===>67444 % 255
int i2 = x % 256;//===>67444 % 256
System.out.println(i1);//166
System.out.println(i2);//166

五、字符编码

你有没有想过这样一个问题?
计算机文件存储的基础是字节，为什么一个字节(byte)是8位

1.ASCII码

这是我能找到最清楚的ASCII码表了，以后有时间自己画一幅(已加入TODO事项)
ASCII码中字符和控制字符一共有128种，即2^7，用7个二进制便可以映射
类比烽火狼烟，由变化映射出数字。这里映射出字符，理念是一致的，即用变化承载信息

上面的高三位(b6,b5,b4)和左边的低四位(b3,b2,b1,b0)形成坐标点，
确定了一个字符的唯一存在:如, 101 0100 --映射--> T  

public static void main(String[] args) {
    char T = 'T';
    System.out.println((int)T);//84
    System.out.println(Integer.toBinaryString(T));//1010100
}

1010100你能记住吗? 二进制和16进制是一一对应的，所以0x54 就等于0b1010100  
记住：字符0：0x30   字符A:0x41  字符a:0x61  常用的也就差不多了

标准ASCII码使用了七位，但会预留一位作为校验位
IBM对ASCII码进行了扩充，攻256个字符，属于扩展ASCII码(非标准)

2.汉字(及其他语言字符)的编码

符号型的文字，如汉字、日文、韩文这就复杂了:一多，二杂,三歧义
7个字节128个空间肯定不够用，那就增加变化呗，再来8个字节
Unicode使用两个字节即16位来映射字符，一共2^16种，即65 536

然后发现还是不怎么够用，再扩充? 然后UTF-32
这下肯定够了容量 4 294 967 296 个，但是也太浪费了吧!
我要装个a，用128的篮字就行了,你给我个能装42亿的篮子?受宠若惊...

于是UTF-8闪亮登场

ASCII 码表：美国标准信息交换码      1字节--使用：7位
ISO8859-1：拉丁码表。欧洲码表       1字节--使用：8位
GB2312：中国的中文编码表。          2字节--使用：16位
GBK：GB2312升级版，增加中文         2字节--使用：16位                   
Unicode：国际标准码                 2字节--使用：16位
UTF-8：Unicode升级版 能用1个字符表示用1个字符，不然用2个，要还是不够用，使用3个字节

3.指定编码表写出文件

public class 编码表测试 {
    public static void main(String[] args) throws IOException {
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("UTF-8.txt"),"utf-8");
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("GBK.txt"),"gbk");
        osw.write("张风toly");
        osw.close();
    }
}

4.计算机怎么识别`张`字的

将张这个字符串用utf-8编码转化为字节数组，可看到是[-27, -68, -96]三个数
这三个数又代表什么?

String str = "张";
System.out.println(Arrays.toString(str.getBytes("utf-8")));
//[-27, -68, -96]

用计算器查看十进制数的字节型的二进制，可以看到：

5.使用不同码表读取测试

InputStreamReader isr_GBK_gbk = new InputStreamReader(new FileInputStream("GBK.txt"),"gbk");
char[] buf = new char[10];
int len = isr_GBK_gbk.read(buf);
System.out.println(new String(buf, 0, len));//张风toly

InputStreamReader isr_GBK_utf8 = new InputStreamReader(new FileInputStream("GBK.txt"),"utf-8");
char[] buf2 = new char[10];
int len2 = isr_GBK_utf8.read(buf2);
System.out.println(new String(buf2, 0, len2));//�ŷ�toly

InputStreamReader isr_UTF8_utf8 = new InputStreamReader(new FileInputStream("UTF-8.txt"),"utf-8");
char[] buf4 = new char[10];
int len4 = isr_UTF8_utf8.read(buf4);
System.out.println(new String(buf4, 0, len4));//张风toly

InputStreamReader isr_UTF8_gbk = new InputStreamReader(new FileInputStream("UTF-8.txt"),"gbk");
char[] buf3 = new char[10];
int len3 = isr_UTF8_gbk.read(buf3);
System.out.println(new String(buf3, 0, len3));//寮犻toly

6.`位bit与字节byte`

位是计算机的基石，字节是文件的基石
如果说位是0,1的阴阳变化?, 字节便是256卦象,而这256卦象便是文件的最小单元
256卦象是多少爻呢 ? 8 ，也就是 8 个位来记录这256种变化
所有文件都是以字节为单位的，你见过哪里有10000.5字节吗?

字节的进制转化：
1 B = 8 bit       1 KB = 1024 B = 8192 bit
1 MB = 1024 KB    1 GB = 1024 MB    1TB = 1024 GB

7.形象体感一下字节的存在

就拿我头像来看看吧，1,153,744 字节 115万多字节?! 也就是920万多位
也就是说要近一亿个烽火台才能表达出这张图片的信息?

现在类比一下：(宏观来看，半斤八两的就不计较了)
人共约有40万亿-60万亿个细胞组成，容纳了大约13个数量级的细胞

如果把位类比细胞：
13个数量级的位(bit)大概是12个数量级的字节(byte)---
12个数量级的字节(byte)大概是 1T 四阶12级：B-->KB-->MB-->GB-->T
于是乎:一个字节在1T的硬盘里的感觉就像一个细胞之于人体的感觉  

---->[下面的表述仅代表个人观点]-----------------------------
注意：一个字节内只有八位(256种变化)，但细胞的内部变化种类... 
一般分子直径数量级在-10 将一个分子看成立方，体积大概数量级-30 
普通细胞直径大概在：10～20μm 大概在数量级-5，将一个细胞看成立方
体积数量级大概在 -15 ，也就是一个细胞大概有15个数量级的分子 

如果一个程序要形成一个独立运行的人类系统，
在不考虑分子的变化的情况下，如果(256种变化)可以表示分子
需要至少15个数量级的 T 空间即1千万亿T，才能容纳一个人的总体变化，
且不说1千万亿T的硬盘如何制造，能够编写出这么大的程序吗?

可以说人类的存在是宇宙的一个完美的bug!
                                    --------张风捷特烈(杂谈)

六、再来看java的几种数据类型

1.八仙一览

经过上面走一遭，是不是感觉更熟悉了?

boolean     布尔类型    1字节
byte        字节        1字节、有符号
char        字符型      2个字节、无符号、Unicode字符兼整数
short       短整型      2个字节、有符号、整数 
int         整型        4个字节、有符号、整数   
long        长整型      8个字节、有符号、整数   
float       浮点型      4个字节、有符号、小数   符号位：1bit,阶码:8bit, 尾数：23bit
double      双精度浮点  8个字节、有符号、小数   符号位：1bit,阶码:11bit,尾数：52bit

2.抛张表

类型	字节数	位数	范围	初始值
boolean	1	8	true/false	false
byte	1	8	-2^7 ~ 2^7-1 (-128 ~ 127)	0
char	2	16	0 ~ 2^16-1(0 ~ 65535)	null
short	2	16	-2^15 ~ 2^15-1 (-32768~32717)	0
int	4	32	-2^31 ~ 2^31-1 (-2147483648~2147483647)	0
long	8	64	-2^63 ~ 2^63-1	0L
float	4	32	`±1.4E-45 ~ ±3.4028235E38`	0.0f
double	8	64	`±4.9E-324 ~ ±1.7976931348623157E308`	0.0d

3.上面给出的是用JAVA的API获取的

难道就没有人疑问，float的最小值? 我看到有点蒙，Are you sure?

|---我不淡定了  测试一下
float f = -1.5f;
System.out.println(Float.MIN_VALUE > f);//true

|---Float获取最小值可能比一个float大?

---->[Float.java]------------------
 # 看来是直接定义的常量 这就有意了---代码注释是最小非零整数
 public static final float MIN_VALUE = 0x0.000002P-126f; // 1.4e-45f

|---所以严格说取值范围应该加上±号，否则不严谨，网上基本上都是正的

4.咱就是喜欢校验的人

毕竟实践是检验真理的唯一标准

float f = 0.0 00000 00000 00000 00000 00000 00000 00000 00000 00001f;//Error 
果然第46个0的时候报错了,double就没事

double d = 0.000000000000000000000000000000000000000000000000000000000000000000000000000001;

好了，本篇没人挺多的，如果你认真看完，一定受益颇多
而我作为作者，受益就更加丰富了，总结一下，有些东西算是理清了

后记：捷文规范

1.本文成长记录及勘误表

项目源码	日期	附录
V0.1--	2018-2-15	无

发布名：计算机的世界：[－bit之魂－]
捷文链接：https://www.jianshu.com/p/ee74ea7255f5

2.更多关于我

笔名	QQ	微信
张风捷特烈	1981462002	zdl1994328

我的github：https://github.com/toly1994328
我的简书：https://www.jianshu.com/u/e4e52c116681
我的掘金：https://juejin.cn/user/149189281194766
个人网站：http://www.toly1994.com

3.声明

1----本文由张风捷特烈原创,转载请注明
2----欢迎广大编程爱好者共同交流
3----个人能力有限，如有不正之处欢迎大家批评指证，必定虚心改正
4----看到这里，我在此感谢你的喜欢与支持