JAVA 强制转换运算导致的精度损失

[houjiaoer]

导致精度损失后，是如何处理的？也就是说，强制转换的时候，精度损失有什么损失规律吗？能否不运行该程序就可以看出来损失后的结果应该是什么？

[zhouzhijun]

用int还是用long这是个问题，
如果数字小，就用int
如果int的范围不够用，就用long

楼主好像既想节约内存，又想表示long那种范围的数字

很遗憾，这个是不可能的，呵呵。






基本数据类型可以分成数字型和布尔型，布尔型与其它基本数据类型之间不能强制相互转换!




如果这2种类型是兼容的，那么Java 将自动地进行转换。例如，把int 类型的值赋给long 类型的变量，总是可行的。然而，不是所有的类型都是兼容的，因此，不是所有的类型转换都是可以隐式实现的。例如，没有将double 型转换为byte 型的定义。幸好，获得不兼容的类型之间的转换仍然是可能的。要达到这个目的，你必须使用一个强制类型转换，它能完成两个不兼容的类型之间的显式变换。让我们看看自动类型转换和强制类型转换。
一．Java 的自动转换
如果下列2个条件都能满足，那么将一种类型的数据赋给另外一种类型变量时，将执行自动类型转换（automatic type conversion）：
1．这2种类型是兼容的。
2．目的类型数的范围比来源类型的大。
当以上2个条件都满足时，拓宽转换（widening conversion ）发生。例如，int 型的范围比所有byte 型的合法范围大，因此不要求显式强制类型转换语句。
对于拓宽转换，数字类型，包括整数（integer ）和浮点（floating-point ）类型都是彼此兼容的，但是，数字类型和字符类型（char）或布尔类型（bollean ）是不兼容的。字符类型（char ）和布尔类型（bollean ）也是互相不兼容的。
二． 不兼容类型的强制转换
尽管自动类型转换是很有帮助的，但并不能满足所有的编程需要。例如，如果你需要将int 型的值赋给一个byte 型的变量，你将怎么办？这种转换不会自动进行，因为byte 型的变化范围比int 型的要小。这种转换有时称为“缩小转换”（），因为你肯定要将源数据类型的值变小才能适合目标数据类型。
为了完成两种不兼容类型之间的转换，你就必须进行强制类型转换。所谓强制类型转换只不过是一种显式的类型变换。它的通用格式如下：
(target-type)value
其中，目标类型（target-type ）指定了要将指定值转换成的类型。例如，下面的程序段将int 型强制转换成byte 型。如果整数的值超出了byte 型的取值范围，它的值将会因为对byte 型值域取模（整数除以byte 得到的余数）而减少。
int a;
byte b;
// ...
b = (byte) a;
当把浮点值赋给整数类型时一种不同的类型转换发生了：截断（truncation ）。你知道整数没有小数部分。这样，当把浮点值赋给整数类型时，它的小数部分会被舍去。例如，如果将值1.23赋给一个整数，其结果值只是1，0.23 被丢弃了。当然，如果浮点值太大而不能适合目标整数类型，那么它的值将会因为对目标类型值域取模而减少。
下面的程序说明了强制类型转换：
// Demonstrate casts.
class Conversion {
public static void main(String args[]) {
byte b;
int i = 257;
double d = 323.142;
System.out.println("\nConversion of int to byte.");
b = (byte) i;
System.out.println("i and b " + i + " " + b);
System.out.println("\nConversion of double to int.");
i = (int) d;
System.out.println("d and i " + d + " " + i);
System.out.println("\nConversion of double to byte.");
b = (byte) d;
System.out.println("d and b " + d + " " + b);
}
}
该程序的输出如下：
Conversion of int to byte.
i and b 257 1
Conversion of double to int.
d and i 323.142 323
Conversion of double to byte.
d and b 323.142 67
让我们看看每一个类型转换。当值257被强制转换为byte 变量时，其结果是257除以256 （256是byte 类型的变化范围）的余数1。当把变量d转换为int 型，它的小数部分被舍弃了。当把变量d转换为byte 型，它的小数部分被舍弃了，而且它的值减少为256 的模，即67。

[tianyidan]

害怕发生这种事情，就用最长的。

[lovingprince]

主要是由大字节的类型向小字节的类型转换时才发生丢失，例如，long是64位，如果你要强制转换成int 32位的，如果超出了Int的表示范围，就会发生丢失，反过来，小字节向大字节转换，这种丢失就不会发生

[yq4427]

损失精度， 比如说 int i= 1/10 结果是i 为0 ; 整型的只能装整型

[dracularking]

这类信息丢失,包括符号丢失,数值大小(magnitude of numeric value),以及精度损失,的强制转换通常是对于基础类型而言的 共有23种
byte to char
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

称为 narrowing primitive conversion 与之相对的就是windening primitive conversion
纷繁的上下类型转换规则中 通常是丢弃所有除了n个目标类型的低位数据，n表示目标类型的数位长度


看一些示例

// A narrowing of int to short loses high bits:
System.out.println("(short)0x12345678==0x" + Integer.toHexString((short)0x12345678));

// A int value not fitting in byte changes sign and magnitude:
System.out.println("(byte)255==" + (byte)255);

// A float value too big to fit gives largest int value:
System.out.println("(int)1e20f==" + (int)1e20f);

// A NaN converted to int yields zero:
System.out.println("(int)NaN==" + (int)Float.NaN);
		
// A double value too large for float yields infinity:
System.out.println("(float)-1e100==" + (float)-1e100);

// A double value too small for float underflows to zero:
System.out.println("(float)1e-50==" + (float)1e-50);

另：除去一些溢出和信息损失外，narrowing primitive consersions不会导致运行时异常

[dracularking]

以上结果：

(short)0x12345678==0x5678
(byte)255==-1
(int)1e20f==2147483647
(int)NaN==0
(float)-1e100==-Infinity
(float)1e-50==0.0

另纠错：windening => widening
由此见，往往不必等结果出来提前可判断

[yuyudabing]

关键就是大转小有损失，扩展转换不存在信息丢失问题，但是窄化转换就有了！