3.那些Java程序中的小细节

没有第二章啦，第二章就是简单的安装下环境，比较简单就不写了。

1.基本数据类型你不知道的点

Java提供了8种数据类型，首先说说整型。

byte，short，int，long，各占1，2，4，8字节，这个没什么好说的。

感觉short是用的最少的，一般int用的最多。

1.1 进制

再来说说进制问题。

在Java中，表示十六进制使用前缀0x，八进制使用前缀0，二进制使用前缀0b，字面量之间可以用下划线来区分如10000和1_0000是一样的，看起来更舒服一些。

1.2 特殊值

浮点类型重点讲讲溢出的情况。

如下代码

public class Demo1 {
    public static void main(String[] args) {
        System.out.println(1.0 / 0);
        System.out.println(-1.0 / 0);
        System.out.println(0.0 / 0);

    }
}
//Infinity
//-Infinity
//NaN

我们知道，一般情况下，是不能以0为除数的，否则就抛异常，但对于浮点运算，分母0其实也变成了double类型，这就导致结果打印是正无穷，负无穷，NaN值，这三个都是比较特殊的值，虽然基本用不到，但这里还是说明一下。

1.3 浮点运算

如果我们拿System.out.println(2.0 - 1.1);代码做运算，那么结果不是我们想象的0.9，而是0.8999999999999999，这里涉及到了浮点数的精度问题，如果一定要用浮点计算，这里给的建议是，使用BigDecimal，下面给出示例代码。

public class Demo1 {
    public static void main(String[] args) {
        BigDecimal a = new BigDecimal("2.0");
        BigDecimal b = new BigDecimal("1.1");
        BigDecimal decimal = a.subtract(b);
        System.out.println(decimal.toString());
        //打印 0.9
    }
}

1.4 char类型坑人的 \u

char类型用来表示单个或双个字符，使用\u符号的时候，一般是以十六进制来表示，比如\u03C0
表示的就是π，另外用到\u的就是一些转义字符了，如回车换行什么的，那我为什么说有坑呢？

比如在注释的时候，意外使用到了\u，即便看起来是一行注释，结果却运行报错了。
因为第一行\u后面需要跟上16进制，而第二行的\u000A其实代表的是回车，后面的语句就不再是注释了。

// look inside c:\users  //提示  java: 非法的 Unicode 转义
// \u000A is a newline   //提示  java: 需要';'

1.5 类型转换

类型转换分为两种，一种是小类型转大类型，一种是大类型转小类型，后一种被称为类型强转。

小转大

首先看图。

可以把大类型想象成箱子，小类型是小盒子，那么只需要直接装入即可，不需要额外的操作。

        byte a = 10;
        short b = a;
        int c = b;
        long d = c;

这几步赋值是完全没有问题的，但如果大小类型之间的计算，只需要记住是最终的结果是按大类型为准即可，如下所示。

 		int a = 10;
        double b = 20.34;
        double c = b - a;

大转小

这时候就要注意，可能会有精度或者数据溢出的风险了。

        double b = 20.34;
        int a = (int) b;//得到的a为20

        long c = 1242121414124124241L;
        int d = (int) c;//因为超过了整型范围 所以两者肯定不相等

强转其实也很简单，相当于把大箱子塞进小盒子，折叠下可能能塞进去，那就不会损失什么，但上面的情况都属于折叠了都不能塞进去，所以只能保留部分数据了。

2. 局部变量必须初始化

看下面代码

public class Demo1 {
    static int b;
    public static void main(String[] args) {
        int a;
        String s;
        System.out.println(a);//编译报错
        System.out.println(b);//正常
        System.out.println(s);//编译报错
    }
}

可以看到，只要是局部变量，必须赋初始值，否则就会导致报错，而对于那些全局变量，编译期间就会赋默认的初始值，所以不需要我们担心，不过好在编译器会给我们提示，不会出现运行时期的错误。

3. 中断控制

那些if，else什么的就不讲了，知道goto关键字吧，在Java中我们可能会遇到多层嵌套的循环，但在内层循环中就要跳到最外层，这不是单单一个break就能解决的，所以有了这个名为：带标签的break

我们想要在获取特定结果后直接跳出，如下程序所示。

public class Demo1 {
    public static void main(String[] args) {
        //很独特的命名 想象成是一个标签即可 名称+冒号
        look:
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 100; j++) {
                System.out.print(j);
                if (j > 5) {
                    break look;
                }
            }
        }
    }
}
//打印 0123456

在特定的时候用即可，一般情况下不太用的到。

4. 数组小方法

对于数组，简单的概念就不讲了，特别需要注意的是，如果是基本类型的数组，初始化过后，内部一般是某个类型的初始值，如int[] arr1=new int[10];，byte[] arr2=new byte[10]; 内部元素都是0，而如果是引用类型，那就都是null，注意null不代表没有，内部也是占了空间的。

下面介绍几个小方法，方便我们更好的使用数组。

public class Demo1 {
    public static void main(String[] args) {
        //1.使用Arrays.toString(数组)
        int[] arr = {1, 6, 3, 4, 5};
        System.out.println(Arrays.toString(arr));
        //2.使用Arrays.copyOf(数组，长度)
        int[] arr2 = Arrays.copyOf(arr, arr.length);
        System.out.println(Arrays.toString(arr2));
        //3.使用Arrays.sort(数组)排序
        Arrays.sort(arr2);
        //验证下是不是深拷贝
        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.toString(arr2));
        //[1, 6, 3, 4, 5]
        //[1, 6, 3, 4, 5]
        //[1, 6, 3, 4, 5]
        //[1, 3, 4, 5, 6]
    }
}

简单讲解下，虽然注释都有。
1.Arrays.toString() 可以输出数组.
2.Arrays.copyOf() 对数组进行深拷贝。
3.Arrays.sort() 对数组进行排序，内部是变种的快排。

到了一定年龄，便要学会寡言，每一句话都要有用，有重量。喜怒不形于色，大事淡然，有自己的底线。 寡言底线，是我们要学习的。