java安全编码指南之:Number操作详解
简介
java中可以被称为Number的有byte，short，int，long，float，double和char，我们在使用这些Nubmer的过程中，需要注意些什么内容呢？一起来看看吧。
Number的范围
每种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作为除数
我们在使用变量作为除数的时候，一定要注意先判断是否为0.
兼容C++的无符号整数类型
在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.
NAN和INFINITY
在整型运算中，除数是不能为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
}
不要使用float或者double作为循环的计数器
考虑下面的代码：
for (float x = 0.1f; x <= 1.0f; x += 0.1f) {
System.out.println(x);
}
上面的代码有什么问题呢？
我们都知道java中浮点数是不准确的，但是不一定有人知道为什么不准确。
这里给大家解释一下，计算机中所有与的数都是以二进制存储的，我们以0.6为例。
0.6转成为二进制格式是乘2取整，0.6x2=1.2，取整剩余0.2，继续上面的步骤0.2x2=0.4，0.4x2=0.8,0.8x2=1.6,取整剩余0.6，产生了一个循环。
所以0.6的二进制格式是.1001 1001 1001 1001 1001 1001 1001 … 无限循环下去。
所以，有些小数是无法用二进制精确的表示的，最终导致使用float或者double作为计数器是不准的。
BigDecimal的构建
为了解决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
以上这篇java安全编码指南之:Number操作详解就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持脚本之家。
相关文章
这篇文章主要介绍了Java抽象类和普通类区别、 数组跟List的区别,在这里需要注意List是一个接口,不能直接实例化,需要使用具体的实现类来创建对象,本文结合示例代码介绍的非常详细,需要的朋友参考下吧2023-09-09
本文主要介绍了Java优雅的处理金钱问题(BigDecimal)，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧2023-06-06
Java如何获取resources下的文件路径和创建临时文件
这篇文章主要介绍了Java如何获取resources下的文件路径和创建临时文件，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教2022-12-12
在写程序的过程中,有时候会遇到私服里没有需要的jar包的情况,这时候我们就可以手动导入jar包到本地仓库进行使用,下面这篇文章主要给大家介绍了关于jar包手动添加到本地maven仓库的相关资料,需要的朋友可以参考下2022-08-08
这篇文章主要介绍了java编程中实现调用js方法,结合具体实例形式较为详细的分析了java编程中调用js方法的常用操作技巧与注意事项,需要的朋友可以参考下2017-09-09
下面小编就为大家带来一篇浅谈mybatis中的#和$的区别。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧2016-06-06
这篇文章主要介绍了SpringBoot 返回Json实体类属性大小写的解决，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教2021-10-10
在本篇文章里小编给大家整理的是关于java7 新I/O知识点详解，有需要的朋友们可以学习下。2019-11-11
当数组需要容纳更多元素时，可以通过扩容来增加其容量，本文主要介绍了Java数组扩容的三大小结，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧2023-08-08
这篇文章主要介绍了浅析scala中map与flatMap的区别，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧2019-06-06
最新评论