java基础复习1之八大基本类型及其包装类型，128陷阱

0，前言

前段时间开始准备春招，复习一些知识点，时间也不算太短，记录了一些笔记什么的，接下来会陆陆续续整理发上来，不过也不会很快，毕竟笔记记的不是很规范，得稍微整理整理，内容也会简略很多，尽量一天至少一篇吧，内容还是很多的，所以发的不会很快，接下来还会发些jvm，并发，计网等整理知识点。嘻嘻嘻。
先发个我做的关于java语法复习的思维导图吧，相信做的还是比较完善的。如有缺陷，欢迎指出。
这个是我做流程图的一个网址，点击这个链接注册可以为我扩容，欢迎点击，蟹蟹。
https://www.processon.com/i/5f734507f346fb06e1bd03e7

对于一些基础语法，我没有做太多的介绍，和其他的语言基本上没有太多的区别。这里推荐一本书，可以说是java必读的一本经典书籍吧《java核心技术 卷1》里面有详细的java语法。我也是根据这本书的流程来复习的。
对于相对时间比较紧迫的同学们，可以利用目录复习（我也是这样的），大致根据目录来回忆知识点，关于模糊的，可以认真查阅。不过有的时候未免遗忘一些细节（自己可能不知道），可以大致将章节浏览一遍，然后再复习。关于基础部分还是很重要的。多敲代码，很多细节要避免想当然。
链接：https://pan.baidu.com/s/1KBHJGm7gA3tdtHyj0N6Jyg
提取码：a1b1
这里贴出《java核心卷1》的pdf版，有需要的可以下载。
注：博客中的内容可能会有疏漏，错误，希望同学们带着批评思维来看待。

一，java的简单基础语法

1，自增，自减。也就是i++，和–i的区别。
2，&&和& 的区别，||和|的区别。
3，还有c，c++和java一个挺大的区别，java中if判断必须是boolean类型。
4，还有什么for什么的。
这里不做过多描述。

二，八大基本类型

数据类型

• 基本数据类型

  • 整型

    • byte：1字节 -128———127 （ 10000000==-128）
    • short：2字节 -2^{15—————2}15-1
    • int：4字节 -2^{31—————2}31-1
    • long：8字节 -2^{63—————2}63-1

  • 浮点型：阶位用移码表示

    • float：4字节 符号 阶位 值 （1 8 23 ）

    • double：8字节 符号 阶位 值 （1 11 52 ）

    • 精度丢失的原因：

      1，阶位不够表示

      2，尾数不够表示

  • boolean：默认值：flase

  • char：默认值：空（\u0000）
    以上其实底层会涉及到一些原码，补码的问题，有兴趣的同学可以去了解，这里不做太多描述。不过这些底层的结构也就是为什么java对于一些类型转换需要显示声明的原因，因为可能丢失精度。

二，类型转换

1，自动类型转换
自动类型转换简单理解，就是小转大的时候，是不需要显示声明的。例如：

int a=10;
double b=a;

这里是没有问题的，因为是小（32位）转大（64位）。int转double不需要强制类型转换。ps：这里的64位其实是不严谨的。

long a=100000l;
int c=a;

这样的类型转换是不行的，需要显式声明，因为属于大转小，
注:long变成double可能存在精度丢失问题。
因为其实double的结构上只有52位来表示小数位。所以说其实能精确表示的范围没有long类型大，也就是有精度丢失问题的。所以不能类型转换也会有精度丢失问题，同理int->float，也是会有精度丢失问题。

三，包装类型

类型	大小	对应包装类
int	4字节	Integer
long	8字节	Long
short	2字节	Short
byte	1字节	Byte
浮点型
float	4字节	Float
double	8字节	Double
其他
char	2字节	Character
boolean	1字节	Boolean

为什么会有包装类型呢，我的理解就是在很多情况下，我们需要利用一个对象来传参，而八大基本类型是不属于对象的，那么我们就需要一些类，能代替八大基本类型来实现这个需求的。也就是包装类型的。

1，自动装箱

int a=1;
Integer b=a;

这里会发现一个问题，a不属于Integer，却能直接给赋值成Integer，其实这里就算是自动装箱了。

2，自动拆箱

Integer a=new Integer(1);
int i=a;

这里就是自动拆箱机制。

3，128陷阱

这里贴出一段源码

    private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];

        static {
            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            high = h;

            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);

            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }

这是关于128陷阱的来源，为什么是128（-128到127），不是其他的数字，其实我们可以修改上显得范围。

 public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

这是利用==比较两个Integer对象的代码。可以看出在cache范围内的数字其实是比较数组中的数值，而对于所有Integer其实就是同一个数组，地址一致，所以结果会是true。
贴一段比较代码吧，大家可以试一试，结果会是怎么样的

        Integer a1=1;
        Integer a2=1;
        int b=1000;
        Integer b1=1000;
        Integer b2=1000;
        System.out.println(a1==1);
        System.out.println(a1==a);
        System.out.println(a1==a2);
        System.out.println(a1.equals(a2));

        System.out.println(b1==1000);
        System.out.println(b1==b);
        System.out.println(b1==b2);
        System.out.println(b1.equals(b2));

涉及到自动拆装箱和128陷阱，大家可以试一试，理解一下。
结果：是 T T T T T T F T。大家可以结合源码理解一波。

留个挺有意思的小问题

     	long c=1000l;
        Long c1=1000l;
        Long c2=1000l;
        System.out.println(c1==c);
        System.out.println(c1==1000);
        System.out.println(c1==c2);
        System.out.println(c1.equals(1000));


		Long c3=100l;
        Long c4=100l;
        System.out.println(c3==c4);
        System.out.println(c1.equals(100));

这样的结果会是怎么样的呢，猜一猜，执行一波，看看结果是否在预料之中。
注：涉及到自动装箱机制。