高精度浮点数BigDecimal

一些非整数值（如几美元和几美分这样的小数）需要很精确。浮点数不是精确值，所以使用它们会导致舍入误差。因此，使用浮点数来试图表示象货币量这样的精确数量不是一个好的想法。使用浮点数来进行美元和美分计算会得到灾难性的后果。浮点数最好用来表示象测量值这类数值，这类值从一开始就不怎么精确。
    从 JDK 1.3 起，Java 开发人员就有了另一种数值表示法来表示非整数：BigDecimal。BigDecimal 是标准的类，在编译器中不需要特殊支持，它可以表示任意精度的小数，并对它们进行计算。在内部，可以用任意精度任何范围的值和一个换算因子来表示 BigDecimal，换算因子表示左移小数点多少位，从而得到所期望范围内的值。因此，用 BigDecimal 表示的数的形式为 unscaledValue*10-scale。
用于加、减、乘和除的方法给  BigDecimal 值提供了算术运算。由于 BigDecimal 对象是不可变的，这些方法中的每一个都会产生新的 BigDecimal 对象。因此，因为创建对象的开销，BigDecimal 不适合于大量的数学计算，但设计它的目的是用来精确地表示小数。如果您正在寻找一种能精确表示如货币量这样的数值，则 BigDecimal 可以很好地胜任该任务。
如浮点类型一样，BigDecimal 也有一些令人奇怪的行为。尤其在使用 equals() 方法来检测数值之间是否相等时要小心。equals() 方法认为，两个表示同一个数但换算值不同（例如，100.00 和  100.000）的 BigDecimal 值是不相等的。然而，compareTo() 方法会认为这两个数是相等的，所以在从数值上比较两个  BigDecimal 值时，应该使用 compareTo() 而不是 equals()。
另外还有一些情形，任意精度的小数运算仍不能表示精确结果。例如，1 除以 9 会产生无限循环的小数 .111111...。出于这个原因，在进行除法运算时，BigDecimal 可以让您显式地控制舍入。movePointLeft() 方法支持 10 的幂次方的精确除法。
对于 BigDecimal，有几个可用的构造函数。其中一个构造函数以双精度浮点数作为输入，另一个以整数和换算因子作为输入，还有一个以小数的 String 表示作为输入。要小心使用  BigDecimal(double) 构造函数， 因为如果不了解它，会在计算过程中产生舍入误差。请使用基于整数或 String 的构造函数。
如果使用 BigDecimal(double) 构造函数不恰当，在传递给 JDBC setBigDecimal() 方法时，会造成似乎很奇怪的 JDBC 驱动程序中的异常。例如，考虑以下 JDBC 代码，该代码希望将数字 0.01 存储到小数字段：
  PreparedStatement ps =connection.prepareStatement("INSERT INTO Foo SET name=?, value=?");
  ps.setString(1, "penny");
  ps.setBigDecimal(2, new BigDecimal(0.01));
  ps.executeUpdate();
     在执行这段似乎无害的代码时会抛出一些令人迷惑不解的异常（这取决于具体的 JDBC 驱动程序），因为 0.01 的双精度近似值会导致大的换算值，这可能会使 JDBC 驱动程序或数据库感到迷惑。JDBC 驱动程序会产生异常，但可能不会说明代码实际上错在哪里，除非意识到二进制浮点数的局限性。相反，使用 BigDecimal("0.01") 或 BigDecimal(1, 2) 构造 BigDecimal 来避免这类问题， 因为这两种方法都可以精确地表示小数。
 

高精度整数BigInteger

BigInteger支持任意精度的整数，也就是说我们可精确表示任意大小的整数值；同时在运算过程中不会丢失任何信息;
在BigInteger类中有所有的基本算术运算方法，如加、减、乘、除，以及可能会用到的位运算如或、异或、非、左移、右移等。下面是一些方法的例子：当然，如果要有更多的使用方法，可以查阅java api 。

原帖地址： http://blog.csdn.net/fenglibing/archive/2007/08/23/1756773.aspx

    
    其实java 本身也提供了api ,java.math.BigInteger;import java.math.BigDecimal; 也可以实现。

这里只是给出简单的例子。

1）装载：查找并装载类型的二进制数据
2）连接：执行验证，准备，和解析（可选）
         a) 验证：确保导入类型正确
         b) 准备：为类变量分配内存，并将其初始化为默认值
         c) 解析：把类型中的符号引用转换成直接引用
3）初始化：把类变量初始化为默认初值


      随着Java虚拟机装载了一个类，并执行了一些它选择进行的验证之后，类就可以进入准备阶
段了。在准备阶段，Java虚拟机为类变量分配内存，设置默认初始值：但在到达初始化阶段之前，
类变量都没有被初始化为真正的初始值。(在准备阶段是不会执行Java代码的。)在准备阶段，虚
拟机把给类变量新分配的内存根据类型设置为默认值。

 为了准备让一个类或者接口被"首次主动"使用，最后一个步骤就是初始化，也就是为类变量      
赋予正确的初始值。这里的”正确”初始值指的是程序员希望这个类变量所具备的起始值。正
确的初始值是和在准备阶段赋予的默认初始值对比而言的。前面说过，根据类型的不同，类变
量已经被赋予了默认初始值。而正确的初始值是根据程序员制定的主观计划面生成的。

在Java代码中，一个正确的初始值是通过类变量初始化语句或者静态初始化语句给出的。
 1）一个类变量初始化语句是变量声明后面的等号和表达式：
 2）静态初始化语句是一个以static开头的程序块
 example : 
    public class Example1 {
     
     // 类变量初始化语句
     static int value = (int) (Math.random()*6.0);
     
     // 静态初始化语句
     static{
      System.out.println("this is example");
     }
    }
所有的类变量初始化语句和类型的静态初始化器都被Java编译器收集在—起，放到——个特殊
的方法中。对于类来说，这个方法被称作类初始化方法；对于接口来说，它被称为接口初始化
方法。在类和接口的Javaclass文件中，这个方法被称为”<clinit>”。通常的Java程序方法是无法
调用这个<clinit>方法的。这种方法只能被Java虚拟机调用

clinit>()方法
    前面说过，Java编译器把类变量初始化语句和静态初始化浯句的代码都放到class文件的
<clinit>()方法中，顺序就按照它们在类或者接门声明中出现的顺序。
 example:
  public class Example1 {
    static int width;
    static int height = (int) (Math.random()*6.0);

    static{
     width = (int) (Math.random()*3.0);
    }
 }
java 编译器生成下面<clinit>方法：
0 invokestatic java.lang.Math.random
3 ldc2_w 6.0 (double)
6 dmul
7 d2i
8 putstatic Example1.height
11 invokestatic java.lang.Math.random
14 ldc2_w 3.0 (double) 17 dmul
18 d2i
19 putstatic Example1.width
22 return

clinit 方法首先执行唯一的类变量初始化语句初始化heght,然后在静态初始化语句中
初始化width(虽然它声明在height之前，但那仅仅是声明了类变量而不是类变量初始化语句).

除接口以外，初始化一个类之前必须保证其直接超类已被初始化，并且该初始化过程是由 Jvm 保证线程安全的。
另外，并非所有的类都会拥有一个 <clinit>() 方法。
1）如果类没有声明任何类变量，也没有静态初始化语句，那么它不会有<clinit>()方法。
2）如果声明了类变量但是没有使用类变量初始化语句或者静态初始化语句初始它们，那么类不会有<clinit>()方法。 
   example:
      public class example{
       static int val;
      }
    
3）如果类仅包含静态 final 变量的类变量初始化语句，并且类变量初始化语句是编译时常量表达式，类不会有<clinit>()方法。
    example：
    public class Example {
     static final String str ="abc";
     static final int value = 100;
    }
这种情况java编译器把 str 和 value 被看做是常量，jvm会直接使用该类的常量池或者在字节码中直接存放常量值。该类不会被加载。
 
如果接口不包含在编译时解析成常量的字段初始化语句，接口中就包含一个<clinit>()方法。
example:
 interface Example{
  int i =5;
  int hoursOfSleep = (int) (Math.random()*3.0);
  
 }
字段hoursOfSleep会被放在<clinit>()方法中（比较诡异？？？它被看作类变量了），而字段i被看作是编译时常量特殊处理(JAVA语法规定，接口中的变量默认自动隐含是public static final)。
 java 编译器生成下面<clinit>方法：
0 invokestatic java.lang.Math.random
3 ldc2_w 3.0 (double)
6 dmul
7 d2i
8 putstatic Example.hoursOfSleep
11 return

主动使用和被动使用
    在前面讲过，Java虚拟机在首次主动使用类型时初始化它们。只有6种活动被认为是主动使
用：
 1)创建类的新实例，
 2)调用类中声明的静态方法，
 3)操作类或者接口中声明的非常量静态字段，
 4)调用JavaAPI中特定的反射方法
 5)初始化一个类的子类;
 6)以及指定一个类作为Java虚拟机启动时的初始化类。
 
   使用一个非常量的静态字段只有当类或者接口的确声明了这个字段时才是主动使用、比如，
类中声明的字段可能会被子类引用；接口中声明的字段可能会被子接口或者实现了这个接口的
类引用。对于子类、子接口和实现接口的类来说．这就是被动使用(使用它们并不会触发
它们的初始化)。下面的例子说明了这个原理：

class NewParement{
 static int hoursOfSleep = (int) (Math.random()*3.0);
 
 static{
  System.out.println("new parement is initialized.");
 }
}

class NewbornBaby extends NewParement{
 static int hoursOfCry = (int) (Math.random()*2.0);
 
 static{
  System.out.println("new bornBaby is initialized.");
 }
}

public class Example1 {
 
 public static void main(String[] args){
  int hours = NewbornBaby.hoursOfSleep;
  System.out.println(hours);
 }
 static{
  System.out.println("example1 is initialized.");
 }
 
}
运行结果：
example1 is initialized.
new parement is initialized.
0
NewbornBaby 没有被初始化，也没有被加载。

对象的生命周期

        当java虚拟机创建一个新的类实例时不管明确的还是隐含的，首先要在堆中为保存对象的实例变量分配内存，包含所有在对象类中和它超类中
声明的变量（包括隐藏的实例变量）都要分配内存。其次赋默认初值，最后赋予正确的初始值。

java编译器为每个类都至少生成一个实例初始化方法 "<init>()"与构造方法相对应。

如果构造方法调用同一个类中的另一个构造方法(构造方法重载)，它对应的init<>():
1)一个同类init<>()调用。
2)对应构造方法体代码的调用。
如果构造方法不是通过this()调用开始，且对象不是Object 它对应的init<>():
1)一个超类init<>()调用。
2)任意实例变量初始化代码调用。
3)对应构造方法体代码的调用。
如果上述对象是Object，则去掉第一条。如果构造方法明确使用super()首先调用对应超类init<>()其余不变。
下面的例子详细说明了实例变量初始化(摘自Java Language Specification)
class Point{
 int x,y;
 Point(){x=1;y=1;}
}
class ColoredPoint extends Point{
 int color = OxFF00FF;
}
class Test{
 public static void main(String[] args){
  ColoredPoint cp = new ColoredPoint();
  System.out.println(cp.color);
 }
}
首先，为新的ColoredPoint实例分配内存空间，以存储实例变量x,y和color；然后将这些变量初始化成默认值
在这个例子中都是0。
接下来调用无参数的ColoredPoint(),由于ColorPoint没有声明构造方法，java编译器会自动提供如下的构造方
法：ColoredPoint(){super();}。
该构造方法然后调用无参数的Point(),而Point()没有显示的超类，编译器会提供一个对其无参数的构造方法的
隐式调用：Point(){super();x=1;y=1}。
因此将会调用到Object();Object类没有超类，至此递归调用会终止。接下来会调用Object任何实例初始化语句
及任何实例变量初始化语句。
接着执行Object()由于Object类中未声明这样的构造方法。因此编译器会提供默认的构造方法object(){}。
但是执行该构造方法不会产生任何影响，然后返回。
接下来执行Point类实例变量初始化语句。当这个过程发生时，x,y的声明没有提供任何初始化表达式，因此这个
步骤未采取任何动作(x,y 仍为0)；
接下来执行Point构造方法体，将x,y赋值为1。
接下来会执行类ColoredPoint的实例变量初始化语句。把color赋值0xFF00FF，最后执行ColoredPoint构造方法体
余下的部分(super()调用之后的部分)，碰巧没有任何语句，因此不需要进一步的动作，初始化完成。

与C++不同的是，在创建新的类实例期间，java编程语言不会为方法分派来指定变更的规则。如果调用的方法在被
初始化对象的子类中重写，那么就是用重写的方法。甚至新对象被完全初始化前也是如此。编译和运行下面的例子
class Super{
 Super(){printThree();}
 void printThree{System.out.println("Three");}
}
class Test extends Super{
 int three = (int)Math.PI; // That is 3
 public static void main(String args[]){
  Test t = new Test();
  t.printThree();
 }
 void printThree(){System.out.println(three);}
}
输出：
0
3
这表明Super类中的printThree()没有被执行。而是调用的Test中的printThree()。

方法区
         在Java虚拟机中，被装载类型的信息存储在一个逻辑上被称为方法区的内存中。
 当虚拟机装载某个类型时，它使用类装载器定位相应的class文件，-->读入这个class文件（一个线性的二进制流）->将它传入虚拟机-->
 虚拟机提取类型信息，并将信息存入方法区，类型中的类（静态）变量也存储在方法区.
 方法区特点：
 1)所有线程共享方法区。它是线程安全的。
 2)方法区大小不是固定的。虚拟机根据需要自行调整。
 3)方法区可以被垃圾回收。
 对于每个被装载的类型，虚拟机会在方法区中存储以下信息。
 
 1)类型的基本信息;
     a)类型的全限定名
     b)类型的直接超类全限定名(除非这个类型是java.lang.Objet,它没超类)。
     c)类型是类类型还是接口类型(就是说是一个类还是一个接口)。
     d)类型的访问修饰符(public ,abstract或final的某个子类)
     e)任何直接超接口的全限定名的有序列表。
     
 2)该类型的常量池
   虚拟机必须为每个被装载的类型维护一个常量池。常量池就是该类型所用常量的一个有序集合，
   包括直接常量(string，integer,floating point常量)和对其他类型、字段和方法的符号引用。
   池中的数据项就像数组一样是通过索引访问的。因为常量池存储了相应类型所用到的所有类型、
   字段和方法的符号引用，所以它在Java程序的动态连接中起着核心的作用。
   
 3)字段信息
   类型中声明的每一个字段，方法区中必须保存下面的信息，字段在类或接口中声明的顺序也必须保存。
   字段名，字段类型，字段修饰符(public private protected static final 等)
   
 4)方法信息
   类型中声明的每一个方法，方法区中必须保存下面的信息，方法在类或接口中声明的顺序也必须保存。
   方法名，返回值类型，参数数量和类型(按声明顺序)，方法修饰符(public private protected static final 等)
   如果方法不是抽象的或本地的还必须保存：方法字节码，操作数栈和该方法在栈针中局部变量的大小，异常表。
   
 5)除了常量以外的所有类(静态)变量
   这里主要说下编译时常量：就是那些用final声明以及编译时已知的值初始化的类变量(例如：static final int val =5)
   每个编译时常量的类型都会复制它所有常量到它自己的常量池中或者它的字节码流中(通常情况下编译时直接替换字节码)。
   
 6)一个到类classLoader的引用
   指向ClassLoader类的引用  每个类型被装载的时候，虚拟机必须跟踪它是由启动类装载器
   还是由用户自定义类装载器装载的。如果是用户自定义类装载器装载的，那么虚拟机必须在类
   型信息中存储对该装载器的引用：这是作为方法表中的类型数据的一部分保存的。
   虚拟机会在动态连按期间使用这个信息。当某个类型引用另一个类型的时候，虚拟机会请求装载
   发起引用类型的类装载器来装载被引用的类型。这个动态连接的过程，对于虚拟机分离命名空间
   的方式也是至关重要的。为了能够正确地执行动态连接以及维护多个命名空间，虚拟机需要在方
   法表中得知每个类都是由哪个类装载器装载的。
   
 7)一个到Class类的引用
    指向Class类的引用  对于每一个被装载的类型(不管是类还是接口)，虚拟机都会相应地为
    它创建一个java.lang．Class类的实例（Class实例放在内存中的堆区），而且虚拟机还必须以某种方式把这个实例的引用存储在方法区
    
       为了尽可能提高访问效率，设计者必须仔细设计存储在方法区中的类型信息的数据结构，因此，
除了以上时论的原始类型信息，实现中还可能包括其他数据结构以加快访问原始数据的速度，比如方法表。
虚拟机对每个装载的非抽象类，都生成一个方法表，把它作为类信息的一部分保存在方法区。方法表是一个数组，
它的元素是所有它的实例可能被调用的实例方法的直接引用，包括那些从超类继承过来的实例方法：(对于抽象类和接口，方法表没有什么帮
助，因为程序决不会生成它们的实例。)运行时可以通过方法表快速搜寻在对象中调用的实例方法。
 
方法区使用的例子

 class Lava{
  private int speed = 5;
 
  void flow(){
  
  }
 
 }

 public class Volcano {
  
  public static void main(String args[]){
   
   Lava lava = new Lava();
   
   lava.flow();
  }
 }

  1)虚拟机在方法区查找Volcano这个名字，未果，载入volcano.class文件，并提取相应信息
   存入方法区。
  2)虚拟机开始执行Volcano类中main()方法的字节码的时候，尽管Lava类还没被装载，
  但是和大多数(也许所有)虚拟机实现一样，它不会等到把程序中用到的所有类都装载后才开
  始运行程序。恰好相反，它只在需要时才装载相应的类。
  3)main()的第一条指令告知虚拟机为列在常量池第一项的类分配足够的内存。所以虚拟机
  使用指向Volcano常量池的指针找到第一项，发现它是一个对Lava类的符号引用，然后它就检查
  方法区，看Lava类是否已经被装载了。
  4)当虚拟机发现还没有装载过名为"Lava"的类时，它就开始查找并装载文件“Lava.class”，
  并把从读入的二进制数据中提取的类型信息放在方法区中。
  5)虚拟机以一个直接指向方法区Lava类数据的指针来替换常量池第—项(就是那个
  字符串“Lava”)——以后就可以用这个指针来快速地访问Lava类了。这个替换过程称为常量池
  解析，即把常量池中的符号引用替换为直接引用：这是通过在方法区中搜索被引用的元素实现
  的，在这期间可能又需要装载其他类。在这里，我们替换掉符号引用的“直接引用”是一个本
  地指针。
  6)虚拟机准备为一个新的Lava对象分配内存。此时，它又需要方法区中的信息。还记
  得刚刚放到Volcano类常量池第——项的指针吗?现在虚拟机用它来访问Lava类型信息(此前刚放
  到方法区中的)，找出其中记录的这样一个信息：一个Lava对象需要分配多少堆空间。
  7)虚拟机确定一个Lava对象大小后，就在堆上分配空间，并把这个对象实例变量speed初始化为默认初始值0
  8)当把新生成的Lava对象的引用压到栈中，main()方法的第一条指令也完成了,指令通过这个引用
  调用Java代码(该代码把speed变量初始化为正确初始值5).另外用这个引用调用Lava对象引用的flow()方法。

堆
        每个java虚拟机实例都有一个方法区以及一个堆，一个java程序独占一个java虚拟机实例，而每个java程序都有自己的堆空间，它们不会彼此干扰,但同一个java程序的多个线程共享一个堆空间。这种情况下要考虑多线程访问同步问题。
 
Java栈
        一个新线程被创建时，都会得到自己的PC寄存器和一个java栈，虚拟机为每个线程开辟内存区。这些内存区是私有的，任何线程不能访问其他线程的PC寄存器和java栈。java栈总是存储该线程中java方法的调用状态。包括它的局部变量，被调用时传进来的参数，它的返回值，以及运算的中间结果等。java栈是由许多栈帧或者说帧组成，一个栈帧包含一个java方法的调用状态，当线程调用java方法时，虚拟机压入一个新的栈帧到该线程的java栈中。当方法返回时，这个栈帧被从java栈中弹出并抛弃。
.本地方法栈
         任何本地方法接口都会使用某种本地方法饯。当线程调用Java方法时，虚拟机会创建一个新的栈帧井压人Java栈。
然而当它调用的是本地方法时，虚拟机会保持Java栈不变，不再在线程的Java栈中压人新的帧，虚拟机只是简单地动态连接
并直接调用指定的本地方法。可以把这看做是虚拟机利用本地方法来动态扩展自己。