JAVA的枚举基本操作，对原码反码补码的理解及为运算的深入理解，浮点数计算的误差分析
①深入浅出的了解枚举类型
先看一段代码：
enum Size{SMALL,MEDIUM,LARGE}; public class EnumTest { public static void main(String[] args) { Size s=Size.SMALL; Size t=Size.LARGE; //s和t引用同一个对象？ System.out.println(s==t); //false //是原始数据类型吗？ System.out.println(s.getClass().isPrimitive());//false //从字符串中转换 Size u=Size.valueOf("SMALL"); System.out.println(s==u); //true //列出它的所有值 for(Size value:Size.values()){ System.out.println(value);//顺序输出枚举类的值 } } }
首先我们定义了一个枚举类Size，在主函数中定义了两个对象，分别赋值为SMALL和LARGE
首先判断的是他们是否为同一个对象？结果：FALSE
第二个输出的是他是原始的数据类型吗？结果：FALSE
第三个通过将一个普通的字符串转换成一个枚举对象，然后在判断他是否与初始定义的枚举对象相同？结果：TRUE
第四个通过一个foreach语句，和枚举的一个方法values()实现将枚举类型成员以数组的形式返回，然后按顺序输出枚举成员的值。
通过以上的程序事例，让我们了解到，枚举类型属于引用类型，每个具体的值都引用特定的对象，相同的值引用的是同一个对象，就像s==u一样。
枚举类型还有个方法：ordinal()用来得到枚举成员的索引，例如上个代码中的：System.out.println(t.ordinal());结果为：2
还可以比较两个枚举对象在定义时的顺序：compareTo()，例如：Size q=Size.MEDIUM; System.out.println(q.compareTo(t)); 结果为：-1，因为q对象的值要小于t对象的值，用它两下标相减。
除此之外：还可以在枚举类型中添加新的方法
enum Color { RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4); // 成员变量 private String name; private int index; // 构造方法 private Color(String name, int index) { this.name = name; this.index = index; } // 寻找下标对应的名字 public static String getName(int index) { for (Color c : Color.values()) { if (c.getIndex() == index) { return c.name; } } return null; } // get set 方法 public String getName() { return name; } public void setName(String name) { this.name = name; } public int getIndex() { return index; } public void setIndex(int index) { this.index = index; } } public class Enum { public static void main(String[] args) { // TODO Auto-generated method stub Color a=Color.RED; System.out.println(Color.getName(2)); System.out.println(a.getName()+" "+a.getIndex()); } }
在枚举类型中添加私有数据：index和name还添加了寻找下标所对应的名字的方法，在主函数中调用枚举类，实现新方法。
输出为：
绿色
红色 1
②原码，反码，补码
原码：是最简单的机器数表示法。用最高位表示符号位，‘1’表示负号，‘0’表示正号。其他位存放该数的二进制的绝对值。
举个简单的栗子：
0101，其最高位为‘0’，证明他首先是正数，其次再用二进制的方法来计算它 sum=1*22+0*21+1*20=6，因此该二进制数代表的就是6
1111，其最高位为‘1’，证明他首先是负数，其次再用同样的方式来计算 sum=-(1*22+1*21+1*20）=-7,因此该二进制数代表的就是-7
该表可以帮助你进一步的理解原码
反码：正数的反码还是等于原码，负数的反码就是他的原码除符号位外，其他位取反（例如：如果原先是1->0,原先是0->1）
例如：-5所对应的二进制数是：1101 他的反码就是：1010
给一些数的反码来进行观察
补码：正数的补码等于他的原码，负数的补码等于他的反码+1，符号位不变
例如：-5的二进制数是：1101 反码：1010 补码：1011
说完基本的概念后，我们来看一下一些数，位运算是如何计算的：按位与&，按位或|，按位取反~，按位异或^
按位&：如果两个数的对应位都为1，结果才为1.
public class ma { public static void main(String[] args) { // TODO Auto-generated method stub int a=4,b=5; System.out.println(a&b); } }
猜一猜结果为多少：4.
如果两个数为一正一负呢？
public class ma { public static void main(String[] args) { // TODO Auto-generated method stub int a=2,b=-5; System.out.println(a&b); } }
你的答案是不是：0，恭喜你答错了，实际输出的是：2.
为什么呢？因为在计算机中正数的原码，反码，补码都是一样的，而负数的却是不一样的，为了能够实现减法的运算，在JAVA中所有的数都是用补码来存储的。
不信，咱们可以算算。
2 补码：0010
-5 原码：1101 反码：1010 补码：1011
0010&1011=0010 该结果为2，答案正确。
按位或：两个操作数中对应位都是0，结果才是0，否则为1.
public class ma { public static void main(String[] args) { // TODO Auto-generated method stub int a=2,b=-5; System.out.println(a|b); } }
大家想一想这个数是多少？
答案是：-5
2 补码：0010
-5 原码：1101 反码：1010 补码：1011
0010|1011=1011 1011看符号位是‘1’，证明他是个负数，而负数都是以补码的形式来存放的，因此，我们要给他还原回去
1011 ->1010 ->1101 结果为：-5 答案正确
按位取反：~就是将操作数二进制的1修改为0，0修改为1
按位异或：^当两个操作数的二进制位表示相同时为0，否则为1
③字符串连接的小常识
public class Test { public static void main(String[] args) { int X=100; int Y=200; System.out.println("X+Y="+X+Y); System.out.println(X+Y+"=X+Y"); } }
输出：
X+Y=100200
300=X+Y
字符串与变量相+时，就会形成一个新的字符串
先进行变量的相+时，则会先进行数值相加，然后再连接字符串
④同名变量的屏蔽原则
每个变量都有一个“有效的”区域，出了该区域，变量就不再有效。
例如：
package com.大数计算; public class xiaoce { static int a=10; public static void main(String[] args) { // TODO Auto-generated method stub int a=5; System.out.println(a); } }
输出：5
package com.大数计算; public class xiaoce { static int a=10; static void f() { int a=0; System.out.println(a); } public static void main(String[] args) { // TODO Auto-generated method stub int a=5; f(); System.out.println(a); } }
输出：0 5
在f（）方法里，a的有效范围就是f（）方法，故输出0
⑤double类型的运算精确吗？
package com.大数计算; public class TestDouble { public static void main(String args[]) { System.out.println("0.05 + 0.01 = " + (0.05 + 0.01));//尾数不一样 System.out.println("1.0 - 0.42 = " + (1.0 - 0.42)); System.out.println("4.015 * 100 = " + (4.015 * 100)); System.out.println("123.3 / 100 = " + (123.3 / 100));//.3 System.out.println(12.3/100); } }
0.05 + 0.01 = 0.060000000000000005
1.0 - 0.42 = 0.5800000000000001
4.015 * 100 = 401.49999999999994
123.3 / 100 = 1.2329999999999999
0.12300000000000001
为什么会出现这样的误差？
其根本原因是计算机所使用二进制01代码无法准确表示某些带小数位的十进制数据。
那我们应该如何解决这样的误差问题呢？
于是，引入math.BigDecimal;
package com.大数计算; import java.math.BigDecimal; //浮点数是不精确的 public class TestBigDecimal { public static void main(String[] args) { BigDecimal f1 = new BigDecimal("0.05"); BigDecimal f2 = BigDecimal.valueOf(0.01); BigDecimal f3 = new BigDecimal(0.05); System.out.println("下面使用String作为BigDecimal构造器参数的计算结果："); System.out.println("0.05 + 0.01 = " + f1.add(f2)); System.out.println("0.05 - 0.01 = " + f1.subtract(f2)); System.out.println("0.05 * 0.01 = " + f1.multiply(f2)); System.out.println("0.05 / 0.01 = " + f1.divide(f2)); System.out.println("下面使用double作为BigDecimal构造器参数的计算结果："); System.out.println("0.05 + 0.01 = " + f3.add(f2)); System.out.println("0.05 - 0.01 = " + f3.subtract(f2)); System.out.println("0.05 * 0.01 = " + f3.multiply(f2)); System.out.println("0.05 / 0.01 = " + f3.divide(f2)); } }
下面使用String作为BigDecimal构造器参数的计算结果：
0.05 + 0.01 = 0.06
0.05 - 0.01 = 0.04
0.05 * 0.01 = 0.0005
0.05 / 0.01 = 5
下面使用double作为BigDecimal构造器参数的计算结果：
0.05 + 0.01 = 0.06000000000000000277555756156289135105907917022705078125
0.05 - 0.01 = 0.04000000000000000277555756156289135105907917022705078125
0.05 * 0.01 = 0.0005000000000000000277555756156289135105907917022705078125
0.05 / 0.01 = 5.000000000000000277555756156289135105907917022705078125
将double类型转换成String类型，在进行运算就可以保证数值的精确,切记不要使用double类型去初始化BigDecimal对象，会产生误差。
