如题

一道题

某个 POJO 定义了一个 Long 变量 fieldID，api 接收 Json 数据并将其转换成这个 POJO。

  1. 当在 Json 数据里没有 fieldID 的时候，转换得到的 fieldID 值为？
  2. 如果将 fieldID 定义成 long，上面转换得到的 fieldID 的值又是什么？

如果不知道答案，那么请往下看。

Java 的数据类型分两种

  1. 基本类型：long,int,byte,float,double,char
  2. 对象类型（类）： Long,Integer,Byte,Float,Double,Character,String，其它一切java提供的，或者你自己创建的类。

答案

到这里，应该就知道上题的答案了。
上题其实考的是 Long 变量与 long 变量的默认值问题，Long 是对象类型，其默认值是 null，而 long 是基本数据类型，默认值是 0.

Long 叫 long 的包装类。包装类的名字，其首字母是基本类型名首字母的大写形式，后面部分，除 Character,Integer 之外，是一样的。
Integer,Byte,Float,Double,Character 也都是对应基本类型 int,byte,float,double,char 的包装类。

那么问题来了，什么叫包装类呢？

Java 语言是一个面向对象的语言，但是 Java 中的基本数据类型却是不面向对象的，这在实际使用时存在很多的不便，为了解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类 (Wrapper Class)，有些地方也翻译为外覆类或数据类型类。

对象类型转换成基本类型

如果将一个 Long 变量 赋值给 long 变量，当 Long 变量为 null 时，会出错。
为了避免这种错误，需要判断 null 的情况。

结论

POJO 在绝大多数应用场景，用基本类型足矣。

将 Integer 型转化为 Long 型

1
2
Integer a = 10;
Long b = a.longValue();

数据类型长度

long 是长整型，在怎么长本身也是整型，12.10的整形部分是12，当然结果是12，

byte: 八位整数 -128——127，可用来节省内存的使用。
short: 16位整数 -32768——32,767，也比较省内存。
int: 32位整数 -2,147,483,648——2,147,483,647，一般来说整数都够用了
long: 64位整数 -9,223,372,036,854,775,808—— 9,223,372,036,854,775,807，一般不需要用
float: 32位浮点，如果浮点需要节省内存用这个。
Double: 64位浮点，一般非整数浮点可用这个。

浮点数据比较

float 和 double 都不是精确的，如果要储存钱一类的数据必须用精确数据类型：java.math.BigDecimal
本人封装了一个浮点数据比较类，供参考：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
package com.company.doman.common;

import org.apache.commons.lang3.math.NumberUtils;
import java.math.BigDecimal;
/**
 * 带小数的数字类型数据比较
 *
 * @author AndyChen
 * @since 2017-1-18
 */
public class HaveDecimalsNumberCompareTool
{
    static double deviation = 10E-10;

    /**
     * 在给定精度范围内比较两个double类型值是否相等
     */
    public static boolean equals(double a, double b)
    {
        if (Double.isNaN(a) || Double.isNaN(b) || Double.isInfinite(a) || Double.isInfinite(b))
        {
            return false;
        }

        return a == b || Math.abs(a - b) < deviation;
    }

    /**
     * 等于
     * BigDecimal.compareTo
     * -1 小于
     * 0 等于
     * 1 大于
     */
    public static boolean equals(String a, String b)
    {
        return getBigDecimalCompareResult(a, b) == 0;
    }

    /**
     * 介于
     *
     * @param a
     * @param b
     * @return a是否介于b与c
     */
    public static boolean between(String a, String b, String c)
    {
        int resultGreaterThanOrEqualBefore = getBigDecimalCompareResult(a, b);
        int lessGreaterThanOrEqualAfter = getBigDecimalCompareResult(a, c);

        return (resultGreaterThanOrEqualBefore == 0 || resultGreaterThanOrEqualBefore == 1)
               && (lessGreaterThanOrEqualAfter == 0 || lessGreaterThanOrEqualAfter == -1);
    }

    /**
     * 大于
     *
     * @param a
     * @param b
     * @return
     */
    public static boolean greaterThan(String a, String b)
    {
        return getBigDecimalCompareResult(a, b) == 1;
    }

    /**
     * 小于
     *
     * @param a
     * @param b
     * @return
     */
    public static boolean lessThan(String a, String b)
    {
        return getBigDecimalCompareResult(a, b) == -1;
    }

    /**
     * 大于等于
     *
     * @param a
     * @param b
     * @return
     */
    public static boolean greaterThanOrEqual(String a, String b)
    {
        return getBigDecimalCompareResult(a, b) >= 0;
    }

    /**
     * 小于等于
     *
     * @param a
     * @param b
     * @return
     */
    public static boolean lessThanOrEqual(String a, String b)
    {
        int result = getBigDecimalCompareResult(a, b);
        return (result == 0 || result == -1);
    }

    /**
     * 得到两个浮点数的比较结果
     *
     * @param a
     * @param b
     * @return -2: 至少有一个是非数值，0: 相等 -1: 小于 1: 大于
     */
    private static int getBigDecimalCompareResult(String a, String b)
    {
        BigDecimal x = NumberUtils.createBigDecimal(a);
        BigDecimal y = NumberUtils.createBigDecimal(b);

        if (x == null || y == null)
        {
            return -2;
        }

        return x.compareTo(y);
    }
}