关于java:java安全编码指南之Number操作

java 中能够被称为 Number 的有 byte，short，int，long，float，double 和 char，咱们在应用这些 Nubmer 的过程中，须要留神些什么内容呢？一起来看看吧。

每种 Number 类型都有它的范畴，咱们看下 java 中 Number 类型的范畴：

思考到咱们最罕用的 int 操作，尽管 int 的范畴够大，然而如果咱们在做一些 int 操作的时候还是可能超出 int 的范畴。

超出了 int 范畴会发送什么事件呢？看上面的例子：

    public void testIntegerOverflow(){System.out.println(Integer.MAX_VALUE+1000);
    }

运行后果：-2147482649。

很显著 Integer.MAX_VALUE+1000 将会超出 Integer 的最大值范畴，然而咱们没有失去异样揭示，反而失去了一个谬误的后果。

正确的操作是如果咱们遇到了 Overflow 的问题，须要抛出异样：ArithmeticException。

怎么避免这种 IntegerOverflow 的问题呢？一般来讲，咱们有上面几种形式。

第一种形式：在做 Integer 操作之前，进行预判断是否超出范围：

举个例子：

    static final int safeAdd(int left, int right) {
        if (right > 0 ? left > Integer.MAX_VALUE - right
                : left < Integer.MIN_VALUE - right) {throw new ArithmeticException("Integer overflow");
        }
        return left + right;
    }

下面的例子中，咱们须要进行两个整数相加操作，在相加之前，咱们须要进行范畴的判断，从而保障计算的安全性。

第二种形式：应用 Math 的 addExact 和 multiplyExact 办法：

Math 的 addExact 和 multiplyExact 办法曾经提供了 Overflow 的判断，咱们看下 addExact 的实现：

    public static int addExact(int x, int y) {
        int r = x + y;
        // HD 2-12 Overflow iff both arguments have the opposite sign of the result
        if (((x ^ r) & (y ^ r)) < 0) {throw new ArithmeticException("integer overflow");
        }
        return r;
    }

看下怎么应用：

    public int addUseMath(int a, int b){return Math.addExact(a,b);
    }

第三种形式：向上转型

既然超出了 Integer 的范畴，那么咱们能够用范畴更大的 long 来存储数据。

    public static long intRangeCheck(long value) {if ((value < Integer.MIN_VALUE) || (value > Integer.MAX_VALUE)) {throw new ArithmeticException("Integer overflow");
        }
        return value;
    }

    public int addUseUpcasting(int a, int b){return (int)intRangeCheck((long)a+(long)b);
    }

下面的例子中，咱们将 a + b 转换成了两个 long 相加，从而保障不溢出范畴。

而后进行一次范畴比拟，从而判断相加之后的后果是否依然在整数范畴内。

第四种形式：应用 BigInteger

咱们能够应用 BigInteger.valueOf(a) 将 int 转换成为 BigInteger，再进行后续操作：

    public int useBigInteger(int a, int b){return BigInteger.valueOf(a).add(BigInteger.valueOf(b)).intValue();}

咱们通常会对 Integer 进行位运算或者算数运算。尽管能够进行两种运算，然而最好不要将两种运算同时进行，这样会造成混同。

比方上面的例子：

x += (x << 1) + 1;

下面的例子是想做什么呢？其实它是想将 3x+ 1 的值赋给 x。

然而这样写进去让人很难了解，所以咱们须要防止这样实现。

再看上面的一个例子：

    public void testBitwiseOperation(){
        int i = -10;
        System.out.println(i>>>2);
        System.out.println(i>>2);
        System.out.println(i/4);
    }

原本咱们想做的是将 i 除以 4，后果发现只有最初一个才是咱们要的后果。

咱们来解释一下，第一个 i >>>2 是逻辑右移，将会把最右边的填充成 0, 所以得出的后果是一个正值 1073741821。

第二个 i >>2 是算数右移，最右边的还是会填充成 1，然而会向下取整，所以得出后果是 -3.

间接应用 i /4，咱们是向上取整，所以得出后果是 -2.

咱们在应用变量作为除数的时候，肯定要留神先判断是否为 0.

在 java 中只有 16 位的 char 示意的是无符号整数，而 int 实际上示意的是带符号的整数。

而在 C 或者 C ++ 中是能够间接示意无符号的整数的，那么，如果咱们有一个 32 位的无符号整数，该怎么用 java 来解决呢？

    public int readIntWrong(DataInputStream is) throws IOException {return is.readInt();
    }

看下面的例子，咱们从 Stream 中读取一个 int 值，如果是一个 32 位的无符号整数，那么读出来 int 就变成了有符号的负整数，这和咱们的冀望是相符的。

考虑一下，long 是 64 位的，咱们是不是能够应用 long 来示意 32 位的无符号整数呢？

    public long readIntRight(DataInputStream is) throws IOException{return is.readInt() & 0xFFFFFFFFL; // Mask with 32 one-bits
    }

看下面的例子，咱们返回的是 long，如果将 32 位的 int 转换成为 64 位的 long，会主动依据符号位进行补全。

所以这时候咱们须要和 0xFFFFFFFFL 进行 mask 操作，将高 32 位重置为 0.

在整型运算中，除数是不能为 0 的，否则间接运行异样。然而在浮点数运算中，引入了 NAN 和 INFINITY 的概念，咱们来看一下 Double 和 Float 中的定义。

public static final double POSITIVE_INFINITY = 1.0 / 0.0;
public static final double NEGATIVE_INFINITY = -1.0 / 0.0;
public static final double NaN = 0.0d / 0.0;

public static final float POSITIVE_INFINITY = 1.0f / 0.0f;
public static final float NEGATIVE_INFINITY = -1.0f / 0.0f;
public static final float NaN = 0.0f / 0.0f;

1 除以 0 就是 INFINITY，而 0 除以 0 就是 NaN。

接下来，咱们看一下 NAN 和 INFINITY 的比拟：

public void compareInfinity(){System.out.println(Double.POSITIVE_INFINITY == Double.POSITIVE_INFINITY);
    }

运行后果是 true。

    public void compareNaN(){System.out.println(Double.NaN == Double.NaN);
    }

运行后果是 false。

能够看到 NaN 和 NaN 相比是 false。

那么咱们怎么比拟 NaN 呢？

别急，Double 提供了一个 isNaN 办法，咱们能够这样应用：

System.out.println(Double.isNaN(Double.NaN));

接下来咱们看一个在代码中常常会用到的一个 Double 解析：

    public void incorrectParse(String userInput){
        double val = 0;
        try {val = Double.valueOf(userInput);
        } catch (NumberFormatException e) { }
        //do something for val
    }

这段代码有没有问题？咋看下如同没有问题，然而，如果咱们的 userInput 是 NaN，Infinity，或者 -Infinity，Double.valueOf 是能够解析失去后果的。

    public void testNaN(){System.out.println(Double.valueOf("NaN"));
        System.out.println(Double.valueOf("Infinity"));
        System.out.println(Double.valueOf("-Infinity"));
    }

运行输入：

NaN
Infinity
-Infinity

所以，咱们还须要额定去判断 NaN 和 Infinity：

public void correctParse(String userInput){
        double val = 0;
        try {val = Double.valueOf(userInput);
        } catch (NumberFormatException e) { }
        if (Double.isInfinite(val)){// Handle infinity error}

        if (Double.isNaN(val)) {// Handle NaN error}
        //do something for val
    }

思考上面的代码：

for (float x = 0.1f; x <= 1.0f; x += 0.1f) {System.out.println(x);
}

下面的代码有什么问题呢？

咱们都晓得 java 中浮点数是不精确的，然而不肯定有人晓得为什么不精确。

这里给大家解释一下，计算机中所有与的数都是以二进制存储的，咱们以 0.6 为例。

0.6 转成为二进制格局是乘 2 取整，0.6×2=1.2，取整残余 0.2，持续下面的步骤 0.2×2=0.4，0.4×2=0.8,0.8×2=1.6, 取整残余 0.6，产生了一个循环。

所以 0.6 的二进制格局是.1001 1001 1001 1001 1001 1001 1001 … 有限循环上来。

所以，有些小数是无奈用二进制准确的示意的，最终导致应用 float 或者 double 作为计数器是不准的。

为了解决 float 或者 Double 计算中精度缺失的问题，咱们通常会应用 BigDecimal。

那么在应用 BigDecimal 的时候，请留神肯定不要从 float 构建 BigDecimal，否则可能呈现意想不到的问题。

    public void getFromFloat(){System.out.println(new BigDecimal(0.1));
    }

下面的代码，咱们失去的后果是：0.1000000000000000055511151231257827021181583404541015625。

这是因为二进制无奈完满的展现所有的小数。

所以，咱们须要从 String 来构建 BigDecimal：

    public void getFromString(){System.out.println(new BigDecimal("0.1"));
    }

在 java 中各种类型的 Number 能够相互进行转换：

比方：

short to byte or char
char to byte or short
int to byte, short, or char
long to byte, short, char, or int
float to byte, short, char, int, or long
double to byte, short, char, int, long, or float

或者反向：

byte to short, int, long, float, or double
short to int, long, float, or double
char to int, long, float, or double
int to long, float, or double
long to float or double
float to double

从大范畴的类型转向小范畴的类型时，咱们要思考是否超出转换类型范畴的状况：

    public void intToByte(int i){if ((i < Byte.MIN_VALUE) || (i > Byte.MAX_VALUE)) {throw new ArithmeticException("Value is out of range");
        }
        byte b = (byte) i;
    }

比方下面的例子中，咱们将 int 转换成为 byte，那么在转换之前，须要先判断 int 是否超出了 byte 的范畴。

同时咱们还须要思考到精度的切换，看上面的例子：

    public void intToFloat(){System.out.println(subtraction(1111111111,1111111111));
    }

    public int subtraction(int i , float j){return i - (int)j;
    }

后果是多少呢？

答案不是 0，而是 -57。

为什么呢？

因为这里咱们做了两次转换，第一次从 1111111111 转换到 float，float 尽管有 32 位，然而只有 23 位是寄存真正的数值的，1 位是符号位，剩下的 8 位是指数位。

所以从 1111111111 转换到 float 发送了精度失落。

咱们能够把 subtraction 办法批改一下，首先判断 float 的范畴，如果超出了 23bit 的示意范畴，则阐明发送了精度失落，咱们须要抛出异样：

    public int subtraction(int i , float j){System.out.println(j);
        if ((j > 0x007fffff) || (j < -0x800000)) {throw new ArithmeticException("Insufficient precision");
        }
        return i - (int)j;
    }

当然还有一种方法，咱们能够用精度更高的 double 来做转换，double 有 52 位来寄存真正的数据，所以足够了。

    public int subtractionWithDouble(int i , double j){System.out.println(j);
        return i - (int)j;
    }

本文的代码：

learn-java-base-9-to-20/tree/master/security

本文已收录于 http://www.flydean.com/java-security-code-line-number/

最艰深的解读，最粗浅的干货，最简洁的教程，泛滥你不晓得的小技巧等你来发现！

欢送关注我的公众号:「程序那些事」, 懂技术，更懂你！

关于java:java安全编码指南之Number操作

简介

Number 的范畴

辨别位运算和算数运算

留神不要应用 0 作为除数

兼容 C ++ 的无符号整数类型

NAN 和 INFINITY

不要应用 float 或者 double 作为循环的计数器

BigDecimal 的构建

类型转换问题

Just My Socks（注册教程内含优惠码）

关于java:java安全编码指南之Number操作

简介

Number 的范畴

辨别位运算和算数运算

留神不要应用 0 作为除数

兼容 C ++ 的无符号整数类型

NAN 和 INFINITY

不要应用 float 或者 double 作为循环的计数器

BigDecimal 的构建

类型转换问题

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）