亚洲Av无码精品色午夜,亚洲av日韩av无码,在线亚洲人成电影网站色www

AK47 — Wed, 23 Nov 2011 06:33:00 GMT

JAXB 向Xml非根节点��d��一个或多个属性，直接上代码，关于JAXB的相��x��解可查阅JAVA API�?br />
原创文章�Q��{载请注明出处�?/span>http://www.tkk7.com/kangdy/archive/2011/11/23/364635.html

code1: colors�c?nbsp; 根节�?br />

code1

package com.kangdy.test;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement(name = "Colors")
@XmlAccessorType(XmlAccessType.FIELD)
public class Colors {

   @XmlElement(name = "red",nillable=true)
   private Red red;

   @XmlElement(name = "blue",nillable=true)
   private Blue blue;

   public Red getRed() {
       return red;
   }

   public Blue getBlue() {
       return blue;
   }

   public void setRed(Red red) {
       this.red = red;
   }

   public void setBlue(Blue blue) {
       this.blue = blue;
   }
}

code2: Red�c?nbsp; 子节�?br />

code2package com.kangdy.test;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement(name = "red")
@XmlAccessorType(XmlAccessType.FIELD)
public class Red {

   private String value;

   @XmlAttribute(name = "att1")
   private String att;

   public String getValue() {
       return value;
   }

   public void setValue(String value) {
       this.value = value;
   }

   public String getAtt() {
       return att;
   }

   public void setAtt(String att) {
       this.att = att;
   }

}

code3: �c?Blue 子节�?br />

code3

package com.kangdy.test;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement(name = "blue")
@XmlAccessorType(XmlAccessType.FIELD)
public class Blue {
   private String value;

   @XmlAttribute(name = "att2")
   private String att2;

   @XmlAttribute(name = "att1")
   private String att;

   public String getAtt() {
       return att;
   }

   public void setAtt(String att) {
       this.att = att;
   }

   public String getValue() {
       return value;
   }

   public void setValue(String value) {
       this.value = value;
   }

   public String getAtt2() {
       return att2;
   }

   public void setAtt2(String att2) {
       this.att2 = att2;
   }
}

code4: main�c?br />

code4

package com.kangdy.test;

import java.io.StringWriter;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.Marshaller;

public class Jaxbtest {
   public static void main(String[] args) throws Exception {

       StringWriter writer = new StringWriter();
       JAXBContext jc = JAXBContext.newInstance(Colors.class);
       Marshaller ma = jc.createMarshaller();
       ma.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);

       Colors colors = new Colors();
       Red red = new Red();
       red.setAtt("att-red");
       red.setValue("red");
       Blue blue = new Blue();
       blue.setValue("blue");
       blue.setAtt("att-blue");
       blue.setAtt2("blue-att2");
       colors.setRed(red);
       colors.setBlue(blue);

       ma.marshal(colors, writer);
       System.out.println(writer.toString());

   }
}

�q�行�l�果�Q?br />

�l�果

        red


        blue

AK47 2011-11-23 14:33 发表评论

重新认识Java finally

AK47 — Tue, 01 Nov 2011 08:56:00 GMT

关于java finally �|�上�?��文章个��为相当不�?br />以下是�{贴内容：

1 . JAVA finally字句的异�怸�失和�q�回��D��盖解�?/strong>
原帖地址 �Q?br />http://blog.csdn.net/sureyonder/article/details/5560538
转脓(chu��ng)
Java虚拟机在每个try语句块和与其相关的catch子句的结��?处都�?#8220;调用”finally子句的子例程。实际上�Q�finally子句在方法内部的表现很象“微型子例�E?#8221;。finally子句正常�l�束后－指的是finally子句中最后一条语句正常执行完毕，不包括抛出异常，或执行return、continue、break�{�情况，隶属于这个finally子句的微型子例程执行“�q�回”操作。程序在�W�一�ơ调用微型子例程的地方��l�执行后面的语句�?br />
finally“微型子例�E?#8221;不等同于�Ҏ(gu��)��函数的调用，finally子句都是在同一个栈内执行的�Q�微型子例程�?#8220;�q�回”操作也不会涉及到�Ҏ(gu��)��退栈，仅仅是�ɽE�序计数器pc跌��{到同一个方法的一个不同的位置�l�箋执行�?br />一　异常丢失
    public static void exceptionLost()
     {
       try
       {
         try
         {
           throw new Exception( "exception in try" );
         }
         finally
         {
           throw new Exception( "exception in finally" );
         }
       }
       catch( Exception e )
       {
         System.out.println( e );
       }
     }

exceptionLost()的输出结果是“exception in finally”�Q�而不是try块中抛出的异常，�q�是JAVA异常机制的一个瑕疵－异常丢失�?br />
在字节码中，throw语句不是原子性操作。在较老的JDK中，exceptionLost()中try块的throw语句分解为几步操作：
1) 把Exception("exception in try")对象引用存储��C��个局部变量中
　　astore_2 　// pop the reference to the thrown exception, store into local variable 2
2) 调用finally微型子程�?br />3) 把局部变量中的Exception("exception in try")对象引用push到操作数栈顶�Q�然后抛出异�?br />　　aload_2 　// push the reference to the thrown exception from local variable 2

　　athrow 　　// throw the exception

如果finally通过break、return、continue�Q�或者抛出异常而退出，那么上面的第�Q�步��׃��会执行�?br />
在JDK1.6中，通过字节码我们可以看刎ͼ�finally子句作�ؓ一�U�特�D�的catch来实现的�Q�下面是exceptionLost()�Ҏ(gu��)��的异常表�Q?br />
Exception table�Q?br /> from   to 　target 　type
   0    　10    10   　　any
　0    　21    21   　　Class java/lang/Exception

finally可以捕获�?行到9行之间抛出的��M��c�d��(any)的异常，�q��新抛出捕��L��异常�Q�或者抛��Z��个自己构造的新异常，�q�个新异常就会覆盖try语句块中的异常�?br />二　�q�回��D��?br />
    public static int getValue()
     {
       int value = 0;

       try
       {
         value = 100;

         return value;
       }
       finally
       {
         value = 200;
       }
     }

�q�个�Ҏ(gu��)��的返回值是100�q�是200?�l�果�?00�?br />在字节码中，return语句不是原子性操作，它会把getValue()中的return语句分解为几步操作：
1) 把value值存储到一个局部变�?�q�里命名为temp)中：
　　 iload_0　　 // push local variable 0 - the 100
　　 istore_2　 // pop an int (the 100), store into local varaible 2
2) 调用finally微型子程�?br />3) 把局部变�?指temp)的值push到操作数栈顶�Q�然后返回到调用�Ҏ(gu��)��
　   iload_2　　// push local varaible 2 - the 100
　　ireturn      // return int on top of the stack - the 100: return 100

�׃��return语句在返回之前会把返回��g��存到一个��时的局部变量中�Q�所以在finally子句内对value重新赋��g��会媄响返回倹{�?br />
了解finally子句内在的一些知识，我们能够了解finally能够做什么和不能够做什么，�q�样会帮助我们正��用finally子句�?/div>

2 . 关于 Java �?finally 语句块的深度辨析
原帖地址 �Q?a href=" http://www.ibm.com/developerworks/cn/java/j-lo-finally/index.html?ca=drs-">
http://www.ibm.com/developerworks/cn/java/j-lo-finally/index.html?ca=drs-
转脓(chu��ng)
关于 Java 虚拟机是如何�~�译 finally 语句块的问题�Q�有兴趣的读者可以参�?span style="color: #008000;">�?The JavaTM Virtual Machine Specification, Second Edition 》中 7.13 �?Compiling finally。那里详�l�介�l�了 Java 虚拟机是如何�~�译 finally 语句块。实际上�Q�Java 虚拟��Z��?finally 语句块作�?subroutine�Q�对于这�?subroutine 不知该如何翻译�ؓ好，�q�脆��׃��译了，免得产生歧义和误解。）直接插入�?try 语句块或�?catch 语句块的控制转移语句之前。但是，�q�有另外一个不可忽视的因素�Q�那��是在执�?subroutine�Q�也��是 finally 语句块）之前�Q�try 或�?catch 语句块会保留其返回值到本地变量表（Local Variable Table�Q�中。待 subroutine 执行完毕之后�Q�再恢复保留的返回值到操作数栈中，然后通过 return 或�?throw 语句��其�q�回�l�该�Ҏ(gu��)��的调用者（invoker�Q��?/span>��h��意，前文中我们曾�l�提到过 return、throw �?break、continue 的区别，对于�q�条规则�Q�保留返回��|��Q�只适用�?return �?throw 语句�Q�不适用�?break �?continue 语句�Q�因为它们根本就没有�q�回倹{�?/span>

AK47 2011-11-01 16:56 发表评论

(转脓(chu��ng))BigInteger �?BigDecimal

AK47 — Fri, 10 Dec 2010 06:16:00 GMT

高精度数�?/strong>
Java 提供了两个类专门用于�q�行高精度运��BigInteger �?BigDecimal �Q�尽��它们可大致划分��C��装器相同的�c�d��里，但两者都没有对应的主�c�d��Q�这两个�c�都有自��q��一�p�d��Ҏ(gu��)��Q�类��g��我们针对�ȝ��型执行的操作�Q�也��是说能�?int 或float 做的事情�Q�用BigInteger和BigDecimal 一样可以做�Q�只是必��L��用方法调用，而不是��用运��符。此外由于牵涉更多，所以运��速度会慢一�Ҏ(gu��)��M��我们牺牲了速度�Q�但换来了精度�?/p>
高精度��Q�Ҏ(gu��)��BigDecimal

一些非整数��|��如几��元和几��分�q�样的小敎ͼ�需要很�_��。��Q�Ҏ(gu��)��不是�_��|��所以��用它们会��D��舍入误差。因此，使用��点数来试图表示象货币量�q�样的精��数量不是一个好的想法。��用��Q�Ҏ(gu��)��来进行美元和��分计算会得到灾难性的后果。��Q�Ҏ(gu��)��最好用来表�C��量��D��c�L��|��q�类��g��一开始就不怎么�_��?br />     �?JDK 1.3 ��P��Java 开发�h员就有了另一�U�数��D��C�法来表�C�非整数�Q�BigDecimal。BigDecimal 是标准的�c�，在编译器中不需要特�D�支持，它可以表�C�Z�Q意精度的��数�Q��ƈ对它们进行计��。在内部�Q�可以用��L��_�ֺ��M��范围的值和一个换��因子来表示 BigDecimal�Q�换��因子表�C�左�U�d��数点多少位，从而得到所期望范围内的倹{��因此，�?BigDecimal 表示的数的�Ş式�ؓ unscaledValue*10-scale�?br /> 用于加、减、乘和除的方法给  BigDecimal 值提供了��术�q�算。由�?BigDecimal 对象是不可变的，�q�些�Ҏ(gu��)��中的每一个都会��生新�?BigDecimal 对象。因此，因�ؓ创徏对象的开销�Q�BigDecimal 不适合于大量的数学计算�Q�但设计它的目的是用来精��地表示��数。如果�?zh��n)�正在��L��一�U�能�_��表示如货币量�q�样的数��|��?BigDecimal 可以很好地胜任该��d��?br /> 如��Q点类型一��P��BigDecimal 也有一些��o人奇怪的行�ؓ。尤其在使用 equals() �Ҏ(gu��)��来检��数��g��间是否相�{�时要小心。equals() �Ҏ(gu��)��认�ؓ�Q�两个表�C�同一个数但换��g��同（例如�Q?00.00 �?nbsp; 100.000�Q�的 BigDecimal 值是不相�{�的。然而，compareTo() �Ҏ(gu��)��会认��两个数是相等的，所以在从数��g��比较两个  BigDecimal 值时�Q�应该��?compareTo() 而不�?equals()�?br /> 另外�q�有一些情形，��L��_�ֺ�的小数运��仍不能表示�_��l�果。例如，1 除以 9 会��生无限��@环的��数 .111111...。出于这个原因，在进行除法运��时�Q�BigDecimal 可以让�?zh��n)�昑ּ�地控制舍入。movePointLeft() �Ҏ(gu��)��支持 10 的幂�ơ方的精��除法�?br /> 对于 BigDecimal�Q�有几个可用的构造函数。其中一个构造函��C��双精度��Q�Ҏ(gu��)��作�ؓ输入�Q�另一个以整数和换��因子作��入，�q�有一个以��数�?String 表示作�ؓ输入。要��心使用  BigDecimal(double) 构造函敎ͼ� 因�ؓ如果不了解它�Q�会在计��过�E�中产生舍入误差。请使用��Z��整数�?String 的构造函数�?br /> 如果使用 BigDecimal(double) 构造函��C��恰当�Q�在传递给 JDBC setBigDecimal() �Ҏ(gu��)��Ӟ��会造成��g��很奇怪的 JDBC 驱动�E�序中的异常。例如，考虑以下 JDBC 代码�Q�该代码希望��数�?0.01 存储到小数字�D�：
  PreparedStatement ps =connection.prepareStatement("INSERT INTO Foo SET name=?, value=?");
  ps.setString(1, "penny");
  ps.setBigDecimal(2, new BigDecimal(0.01));
  ps.executeUpdate();
     在执行这�D�似乎无害的代码时会抛出一些��o��惑不解的异常�Q�这取决于具体的 JDBC 驱动�E�序�Q�，因�ؓ 0.01 的双�_�ֺ��q�似��g��D��大的换算��|��q�可能会�?JDBC 驱动�E�序或数据库感到�q�h��。JDBC 驱动�E�序会��生异常，但可能不会说明代码实际上错在哪里�Q�除非意识到二进制��Q�Ҏ(gu��)��的局限性。相反，使用 BigDecimal("0.01") �?BigDecimal(1, 2) 构�?BigDecimal 来避免这�c�问题，因�ؓ�q�两�U�方法都可以�_��地表�C�小数�?br />

code :
import java.math.BigDecimal;
/** * *
*
Title: 开�?开�?lt;/p>
* *
Description: opeansource

* *
Copyright: Copyright (c) 2004

* *
Company: ?��h��

* * @author HaiTang Ming
* * @version 1.0 */
public class BigDecimalUtil {
//默认除法�q�算�_�ֺ�,及即保留��数点多��位
private static final int DEF_DIV_SCALE = 2;
//�q�个�c�M��能实例化
private BigDecimalUtil (){   }
/**
* * 提供�_��的加法运��?nbsp;
* * @param v1 被加�?nbsp;
* * @param v2 加数
* * @return 两个参数的和
* */
public static double add(double v1,double v2){
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return (b1.add(b2)).doubleValue();
}

/**

*提供�_��的减法运��?nbsp;
* * @param v1 被减�?nbsp;
* * @param v2 减数
* * @return 两个参数的差
**/
public static double sub(double v1,double v2){
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return (b1.subtract(b2)).doubleValue();
}
/**
* * 提供�_��的乘法运��?nbsp;
* * @param v1 被乘�?nbsp;
* * @param v2 乘数
* * @return 两个参数的积
* */
public static double mul(double v1,double v2){
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return (b1.multiply(b2)).doubleValue();
}
/**
* * 提供�Q�相对）�_��的除法运��，当发生除不尽的情冉|��Q�精��到
* * ��数点以后多��位�Q�以后的数字四舍五入�?nbsp;
* * @param v1 被除�?nbsp;
* * @param v2 除数
* * @return 两个参数的商
* */
public static double div(double v1,double v2){
return div(v1,v2,DEF_DIV_SCALE);
}
/**
* * 提供�Q�相对）�_��的除法运��。当发生除不��的情况�Ӟ��由scale参数�?nbsp;
* * 定精度，以后的数字四舍五入�?nbsp;
* * @param v1 被除�?nbsp;
* @param v2 除数
* * @param scale 表示表示需要精��到��数点以后几位�?nbsp;
* * @return 两个参数的商
* */
public static double div(double v1,double v2,int scale){
if(scale<0){
   throw new IllegalArgumentException("The scale must be a positive integer or zero");
}
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return (b1.divide(b2,scale,BigDecimal.ROUND_HALF_UP)).doubleValue();
}
/**
* * 提供�_��的小��C��四舍五入处理�?nbsp;
* * @param v 需要四舍五入的数字
* * @param scale ��数点后保留几位
* * @return 四舍五入后的�l�果
* */
public static double round(double v,int scale){
if(scale<0){
   throw new IllegalArgumentException("The scale must be a positive integer or zero");
}
BigDecimal b = new BigDecimal(Double.toString(v));
BigDecimal one = new BigDecimal("1");
return (b.divide(one,scale,BigDecimal.ROUND_HALF_UP)).doubleValue();
}
public static void main(String[] args){
System.out.println(add(234.44,534.90));

double a = 123.345678;
double d = round(a,2);
System.out.println("round("+a+",2)--->"+d);
}
}

高精度整数BigInteger

BigInteger支持��L��_�ֺ�的整敎ͼ�也就是说我们可精��表�C�Z�Q意大��的整数��|��同时在运��过�E�中不会丢失��M��信息;
在BigInteger�c�M��有所有的基本��术�q�算�Ҏ(gu��)��Q�如加、减、乘、除�Q�以及可能会用到的位�q�算如或、异或、非、左�U�R��右�Uȝ��。下面是一些方法的例子�Q�当�Ӟ��如果要有更多的��用方法，可以查阅java api �?/p>
code :public class BigIntegerTest {
public BigIntegerTest() {   }
/**
* * ��试BigInteger
* */
public static void testBigInteger() {
BigInteger bi = new BigInteger("888");
//multiply :乘法
BigInteger result = bi.multiply(new BigInteger("2"));
System.out.println(result);
//divide : 除法
result = bi.divide(new BigInteger("2"));
System.out.println(result);
//add : 加法
result = bi.add(new BigInteger("232"));
System.out.println(result);
//subtract :减法
result = bi.subtract(new BigInteger("23122"));
System.out.println(result);
result = bi.shiftRight(2);
System.out.println(result);
}
public static void main(String[] args) {
testBigInteger();
}
}
原脓(chu��ng)地址�Q?/font>http://dev.firnow.com/course/3_program/java/javaxl/2008914 /142796_2.html

AK47 2010-12-10 14:16 发表评论

(转脓(chu��ng)) ��大整数相加�Q�超�q�了long的范��_��你要怎么做！

AK47 — Fri, 10 Dec 2010 06:06:00 GMT

引用�Q?/legend>
�q�个只能够用字符串的形式来处理了�Q�因��机能够处理的最大是long型，本文以字�W�串的�Ş式来�q�行��大数据的相加，理论上只要你的内存允许，相加多大的数都可以�?/p>
/**

* ��大整数相加�Q?/p>
* 题目要求�Q�如果系�l�要使用��大整数�Q�超�q�long的范��_��Q�请你设计一个数据结构来存储�q�种

* ��大型数字以及设计一�U�算法来实现��大整数的加法运��?/p>
* @author Administrator

*

*/

public class VeryBigNumAdd {

    /**

     * @param args

     */

    public static void main(String[] args) {

       // TODO Auto-generated method stub

       /*

       String a="1223232";

       for(int i=a.length()-1;i>=0;i--)

       {

           System.out.print(a.charAt(i));

       }

       */

       VeryBigNumAdd vbn=new VeryBigNumAdd();

       String a="123453243455535634535252345234677576252241234123523453664563634";

       String b="123453243455535634535252345234677576252241234123523453664563634";

       String result=vbn.doAdd(a,b);

       System.out.println("result:"+result);

    }

    /**

     *

     * @param a 加数字符�?

     * @param b 加数字符�?

     * @return �l�果字符�?/p>
     * 分析�Q?/span>

     * 1、取得两个字�W�串的长�?/span>

     * 2、把两个的长度做比较�Q��ƈ得出较长的长度，及较短的长度

     * 3、把长度较短的加数字�W�串�Q�在左面�?�Q��之与较长的字�W�串一样长

     * 4、从最高位�Q�一个个数的取出来相加，当然首先得�{换�ؓ整型

     * 5、设�|�进位，如果两个数相加及加上�q�位大于�{�于10�Q��ƈ且这不是最左边一个字�W�相加，相加�l�果�{�于

     *    �Q�取�?�Q�取�?�Q�进位）�Q?0�Q��ƈ把进位设�?�Q�如果没有大�?0�Q�就把进位设�?�Q�如些��@环，�?/span>

     *    相加的结果以字符串的形式�l�合��h��Q�就得到最后的�l�果

     */

    String doAdd(String a,String b)

    {

       String str="";

       int lenA=a.length();

       int lenB=b.length();

       int maxLen=(lenA>lenB) ? lenA : lenB;

       int minLen=(lenA
       String strTmp="";

       for(int i=maxLen-minLen;i>0;i--)

       {

           strTmp+="0";

       }

       //把长度调整到相同

       if(maxLen==lenA)

       {

           b=strTmp+b;

       }else

           a=strTmp+a;

       int JW=0;//�q�位

       for(int i=maxLen-1;i>=0;i--)

       {

           int tempA=Integer.parseInt(String.valueOf(a.charAt(i)));

           int tempB=Integer.parseInt(String.valueOf(b.charAt(i)));

           int temp;

           if(tempA+tempB+JW>=10 && i!=0)

           {

              temp=tempA+tempB+JW-10;

              JW=1;

           }

           else

           {

              temp=tempA+tempB+JW;

              JW=0;

           }

           str=String.valueOf(temp)+str;

       }

       return str;

    }

}

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


    其实java 本��n也提供了api ,java.math.BigInteger;import java.math.BigDecimal; 也可以实现�?/p>
code :
package com.kangdy.test;

import java.math.BigInteger;
import java.math.BigDecimal;

public class NumberTest {
public static void main(String args[]){
  BigInteger b1= new BigInteger("2222222222222222222222222");
  BigInteger b2= new BigInteger("8888888888888888888888888");
  BigDecimal b3 = new BigDecimal("66666666666666666666666666");
  BigDecimal b4 = new BigDecimal("9999999999999999999999999999");
  System.out.println(b1.add(b2).toString());
  System.out.println(b3.add(b4).toString());
}
}

�q�里只是�l�出��单的例子�?br />

AK47 2010-12-10 14:06 发表评论

数字金额的中文大��写转化

AK47 — Tue, 02 Nov 2010 06:59:00 GMT
曄��去过一家公叔R��试。笔试题的最后一题是一个数字金额大��写转化的问题�?br /> 当时没想那么多，仅仅惛_��应该把数拆开然后��d��单位的一个大致的设计思�\�?br /> 而那个面试官一个劲儿的问我用啥��法。那个题最后也没答上，回来后比较郁��P��
在网上搜了一下。这个答案还真不��。不�q�觉得有一�U�设计还比较靠谱�?br /> 大概是这��P��
* 先将整数与小数部分分开�Q�计��小数部分，角分�q�保�?br /> * 整数部分长度不��12位，前面�?补��?br /> * ��整数部分分�?部分。高4位代表亿�Q�中间的是万�Q�其余分别代表千�Q�百�Q�十�Q�个
* 定一个方法拼出每一部分丌Ӏ?br /> * 最后整��C��数部分合成�?/span>
自己实现了一下，以下是代码�?br />
code :
package com.kangdy.test;
/**
* 数字金额转化成大�?br /> * 先将整数与小数部分分开�Q�计��小数部分，角分�q�保�?br /> * 整数部分长度不��12位，前面�?补��?br /> * ��整数部分分�?部分。高4位代表亿�Q�中间的是万�Q�其余分别代表千�Q�百�Q�十�Q�个
* 定一个方法拼出每一部分丌Ӏ?br /> * 最后整��C��数部分合成�?br /> * @author dkang
*
*/
public class NumberToString {

String numberStr;

public static final String unit[] = { "", "�?, "�?, "�?, "�?, "�? };

public static final String unit2[] = { "�?, "�?, "�? };

public static final String numStr[] = { "�?, "�?, "�?, "�?, "�?, "�?, "�?,
   "�?, "�?, "�? };

/**
* 字符串长度不��?2位用0补��
*
* @param str
* @return
*/
private String additionalZero(String str) {
  StringBuffer strb = new StringBuffer();
  if (str.length() < 12) {
   int size = 12 - str.length();
   for (int i = 0; i < size; i++) {
    strb.append("0");
   }
  }
  return strb.append(str).toString();
}

/**
* 递归拆分数字成字�W�串
*
* @param value
* @param strBuffer
* @return
*/
private String decomposeNumberToString(int value, StringBuffer strBuffer) {
  int quotient = 0;
  quotient = value / 10;
  if (quotient != 0) {
   decomposeNumberToString(quotient, strBuffer);
  }
  int remaider = value % 10;
  strBuffer.append(remaider + ",");
  return strBuffer.toString().substring(0,
    strBuffer.toString().length() - 1);
}

/**
* 使用循环拆分数字成字�W�串
*
* @param value
* @return
*/
private String decomposeNumberToString2(int value) {
  StringBuilder strBuilder = new StringBuilder();
  int quotient = value;
  int remaider = 0;
  while (quotient != 0) {
   remaider = quotient % 10;
   strBuilder.append(remaider + ",");
   quotient = quotient / 10;
  }
  strBuilder.deleteCharAt(strBuilder.lastIndexOf(","));
  return strBuilder.reverse().toString();
}

/**
* ��d��单位
*
* @param temp
* @return
*/
private String addUnits(String temp) {
  StringBuffer sb = new StringBuffer();
  String str[] = temp.split(",");
  String tempStr = temp.replace(",", "");
  if (tempStr.contains("000")) {
   return sb.append(resplaceNumToStr(str[0]) + unit[3]).toString();
  } else if (tempStr.contains("00")) {
   if (tempStr.charAt(3) == '0') {
    return sb.append(resplaceNumToStr(str[0]) + unit[3]).append(
      resplaceNumToStr(str[1]) + unit[2]).toString();
   } else {
    return sb.append(resplaceNumToStr(str[0]) + unit[3]).append(
      numStr[0]).append(resplaceNumToStr(str[3])).toString();
   }
  } else {
   for (int i = 0; i < str.length; i++) {
    sb.append(resplaceNumToStr(str[i]));
    if (!str[i].equals("0")) {
     sb.append(unit[str.length - (i + 1)]);
    }
   }
  }
  return sb.toString();
}

/**
* 数字替换
*
* @param str
* @return
*/
private String resplaceNumToStr(String str) {
  try {
   int num = Integer.parseInt(str);
   return numStr[num];
  } catch (Exception e) {
   e.printStackTrace();
  }
  return "";
}

/**
* �?位长度的数字转化成字�W�串
*
* @param number
* @param i
* @return
*/
private String transformNumberToString(String number, int i) {
  StringBuffer strBuffer = new StringBuffer();
  StringBuilder strBuilder = new StringBuilder();
  try {
   int num = Integer.parseInt(number);
   if (num != 0) {
    String s1 = decomposeNumberToString(num, strBuffer);
    strBuilder.append(addUnits(s1));
    if (i == 1) {
     strBuilder.append(unit[5]);
    } else if (i == 2)
     strBuilder.append(unit[4]);
   }
  } catch (Exception e) {
   e.printStackTrace();
  }
  return strBuilder.toString();
}

/**
* 得到最�l�结�?br /> *
* @param str
* @return
*/
public String IntegrationResultString(String str) {
  StringBuffer strBuffer = new StringBuffer();
  String numStr[] = null;
  if (str.indexOf(".") != -1) {
   numStr = str.split("\\.");
  } else {
   return strBuffer.append(createIntegerPartsResult(str)).toString();
  }
  String fractionalStr = createFractionalPartsResult(numStr[1]);
  String integerStr = createIntegerPartsResult(numStr[0]);
  return strBuffer.append(integerStr).append(fractionalStr).toString();
}

private String createIntegerPartsResult(String integer) {
  StringBuffer strBuffer = new StringBuffer();
  String temp = additionalZero(integer);
  String str1 = temp.substring(0, 4);
  strBuffer.append(transformNumberToString(str1, 1));
  String str2 = temp.substring(4, 8);
  strBuffer.append(transformNumberToString(str2, 2));
  String str3 = temp.substring(8, temp.length());
  strBuffer.append(transformNumberToString(str3, 3) + unit2[0]);
  return strBuffer.toString();
}

private String createFractionalPartsResult(String fractionalStr) {
  StringBuilder strB = new StringBuilder();
  String s1 = fractionalStr.substring(0, 1);
  String s2 = fractionalStr.substring(1, fractionalStr.length());
  if (!s1.equals("0")) {
   strB.append(resplaceNumToStr(s1) + unit2[1]);
  }
  if (!s2.equals("0")) {
   strB.append(resplaceNumToStr(s2) + unit2[2]);
  }
  return strB.toString();
}

public static void main(String args[]) {
  NumberToString test = new NumberToString();
  String str = "200123004054.11";
  System.out.println(test.IntegrationResultString(str));
}
}

AK47 2010-11-02 14:59 发表评论

�c�d��对象的初始化

AK47 — Wed, 14 Jul 2010 08:18:00 GMT
�cȝ��生命周期�Q�分��载，链接�Q�初始化
如图�Q?br />

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

      随着Java虚拟��载了一个类�Q��ƈ执行了一些它选择�q�行的验证之后，�c�d��可以�q�入准备�?br /> �D�了。在准备阶段�Q�Java虚拟��Zؓ�c�d��量分配内存，讄��默认初始��|��但在到达初始化阶�D�之前，
�c�d��量都没有被初始化为真正的初始倹{�?在准备阶�D�|��不会执行Java代码的�?在准备阶�D�，�?br /> 拟机把给�c�d��量新分配的内存根据类型设�|��ؓ默认倹{�?/p>
��Z��准备让一个类或者接口被"首次��d��"使用�Q�最后一个步骤就是初始化�Q�也��是为类变量
赋予正确的初始倹{��这里的”正确”初始值指的是�E�序员希望这个类变量所具备的�v始倹{��正
��的初始值是和在准备阶段赋予的默认初始值对比而言的。前面说�q�，�Ҏ(gu��)��c�d��的不同，�c�d��
量已�l�被赋予了默认初始倹{��而正��的初始值是�Ҏ(gu��)��E�序员制定的主观计划面生成的�?/p>

在Java代码中，一个正��的初始值是通过�c�d��量初始化语句或者静态初始化语句�l�出的�?br /> 1�Q�一个类变量初始化语句是变量声明后面的等号和表达式：
2�Q�静态初始化语句是一个以static开头的�E�序�?br /> example :
    public class Example1 {

     // �c�d��量初始化语句
     static int value = (int) (Math.random()*6.0);

     // 静态初始化语句
     static{
      System.out.println("this is example");
     }
    }
所有的�c�d��量初始化语句和类型的静态初始化器都被Java�~�译器收集在—�v�Q�放到——个�Ҏ(gu��)��
的方法中。对于类来说�Q�这个方法被�U�C��c�d��始化�Ҏ(gu��)��Q�对于接口来��_��它被�U�Cؓ接口初始�?br /> �Ҏ(gu��)��。在�c�d��接口的Javaclass文�g中，�q�个�Ҏ(gu��)��被称�?#8221;”。通常的Java�E�序�Ҏ(gu��)��是无�?br /> 调用�q�个�Ҏ(gu��)��的。这�U�方法只能被Java虚拟��?/p>
clinit>()�Ҏ(gu��)��
    前面说过�Q�Java�~�译器把�c�d��量初始化语句和静态初始化��句的代码都攑ֈ�class文�g�?br /> ()�Ҏ(gu��)��中，��序��按照它们在�c�L��者接门声明中出现的顺序�?br /> example:
  public class Example1 {
    static int width;
    static int height = (int) (Math.random()*6.0);

    static{
     width = (int) (Math.random()*3.0);
    }
}
java �~�译器生成下�?lt;clinit>�Ҏ(gu��)��Q?br /> 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 �Ҏ(gu��)��首先执行唯一的类变量初始化语句初始化heght,然后在静态初始化语句�?br /> 初始化width(虽然它声明在height之前�Q�但那仅仅是声明了类变量而不是类变量初始化语�?.

除接口以外，初始化一个类之前必须保证其直接超�c�d��被初始化�Q��ƈ且该初始化过�E�是�?Jvm 保证�U�程安全的�?br /> 另外�Q��ƈ非所有的�c�都会拥有一�?() �Ҏ(gu��)��?br /> 1�Q�如果类没有声明��M��c�d��量，也没有静态初始化语句�Q�那么它不会�?lt;clinit>()�Ҏ(gu��)��?br /> 2�Q�如果声明了�c�d��量但是没有��用类变量初始化语句或者静态初始化语句初始它们�Q�那么类不会�?lt;clinit>()�Ҏ(gu��)��?nbsp;
   example:
      public class example{
      static int val;
      }

3�Q�如果类仅包含静�?final 变量的类变量初始化语句，�q�且�c�d��量初始化语句是编译时帔R��表达式，�c�M��会有()�Ҏ(gu��)��?br />     example�Q?br />     public class Example {
     static final String str ="abc";
     static final int value = 100;
    }
�q�种情况java�~�译器把 str �?value 被看做是帔R��Q�jvm会直接��用该�cȝ��帔R��池或者在字节码中直接存放帔R��倹{��该�c�M��会被加蝲�?br />
如果接口不包含在�~�译时解析成帔R��的字�D�初始化语句�Q�接口中��包含一�?lt;clinit>()�Ҏ(gu��)��?br /> example:
interface Example{
  int i =5;
  int hoursOfSleep = (int) (Math.random()*3.0);

}
字段hoursOfSleep会被攑֜�()�Ҏ(gu��)��中（比较诡异�Q�？�Q�它被看作类变量�?/span>�Q�，而字�D�i被看作是�~�译时常量特�D�处�?JAVA语法规定�Q�接口中的变量默认自动隐含是public static final)�?br /> java �~�译器生成下�?lt;clinit>�Ҏ(gu��)��Q?br /> 0 invokestatic java.lang.Math.random
3 ldc2_w 3.0 (double)
6 dmul
7 d2i
8 putstatic Example.hoursOfSleep
11 return

��d��使用和被动��?br />     在前面讲�q�，Java虚拟机在首次��d��使用�c�d��时初始化它们。只�?�U�活动被认�ؓ是主动��
用：
1)创徏�cȝ��新实例，
2)调用�c�M��声明的静态方法，
3)操作�c�L��者接口中声明的非帔R��静态字�D�，
4)调用JavaAPI中特定的反射�Ҏ(gu��)��
5)初始化一个类的子�c?
6)以及指定一个类作�ؓJava虚拟机启动时的初始化�c�R�?br />
   使用一个非帔R��的静态字�D�只有当�c�L��者接口的��声明了�q�个字段时才是主动��用、比如，
�c�M��声明的字�D�可能会被子�c�d��用；接口中声明的字段可能会被子接口或者实��C��q�个接口�?br /> �c�d��用。对于子�c�R��子接口和实现接口的�c�L��_��q�就是被动��?使用它们�q�不会触�?br /> 它们的初始化)。下面的例子说明了这个原理：

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.");
}

}
�q�行�l�果�Q?
example1 is initialized.
new parement is initialized.
0
NewbornBaby 没有被初始化�Q�也没有被加载�?br />

对象的生命周�?br />
        当java虚拟机创��Z��个新的类实例时不��明��的�q�是隐含的，首先要在堆中��Z��存对象的实例变量分配内存�Q�包含所有在对象�c�M��和它��类�?br /> 声明的变量（包括隐藏的实例变量）都要分配内存。其�ơ赋默认初��|��最后赋予正��的初始倹{�?/p>
java�~�译器�ؓ每个�c�都臛_��生成一个实例初始化�Ҏ(gu��)�� "()"与构造方法相对应�?/p>
如果构造方法调用同一个类中的另一个构造方�?构造方法重�?�Q�它对应的init<>():
1)一个同�c�init<>()调用�?br /> 2)对应构造方法体代码的调用�?br /> 如果构造方法不是通过this()调用开始，且对象不是Object 它对应的init<>():
1)一个超�c�init<>()调用�?br /> 2)��L��实例变量初始化代码调用�?br /> 3)对应构造方法体代码的调用�?br /> 如果上述对象是Object�Q�则��L��W�一条。如果构造方法明��用super()首先调用对应��类init<>()其余不变�?br /> 下面的例子详�l�说明了实例变量初始�?摘自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);
}
}
首先�Q��ؓ新的ColoredPoint实例分配内存�I�间�Q�以存储实例变量x,y和color�Q�然后将�q�些变量初始化成默认�?br /> 在这个例子中都是0�?br /> 接下来调用无参数的ColoredPoint(),�׃��ColorPoint没有声明构造方法，java�~�译器会自动提供如下的构造方
法：ColoredPoint(){super();}�?br /> 该构造方法然后调用无参数的Point(),而Point()没有昄��的超�c�，�~�译器会提供一个对其无参数的构造方法的
隐式调用�Q�Point(){super();x=1;y=1}�?br /> 因此��会调用到Object();Object�c�L��有超�c�，��x��递归调用会终止。接下来会调用Object��M��实例初始化语�?br /> 及�Q何实例变量初始化语句�?br /> 接着执行Object()�׃��Object�c�M��未声明这��L��构造方法。因此编译器会提供默认的构造方法object(){}�?br /> 但是执行该构造方法不会��生�Q何媄响，然后�q�回�?br /> 接下来执行Point�c�d��例变量初始化语句。当�q�个�q�程发生�Ӟ��x,y的声明没有提供�Q何初始化表达式，因此�q�个
步骤未采取�Q何动�?x,y 仍�ؓ0)�Q?br /> 接下来执行Point构造方法体�Q�将x,y赋��gؓ1�?br /> 接下来会执行�c�ColoredPoint的实例变量初始化语句。把color赋�?xFF00FF�Q�最后执行ColoredPoint构造方法体
余下的部�?super()调用之后的部�?�Q�碰巧没有�Q何语句，因此不需要进一步的动作�Q�初始化完成�?/p>
与C++不同的是�Q�在创徏新的�c�d��例期��_��java�~�程语言不会为方法分�z�来指定变更的规则。如果调用的�Ҏ(gu��)��在被
初始化对象的子类中重写，那么��是用重写的�Ҏ(gu��)��。甚��x��对象被完全初始化前也是如此。编译和�q�行下面的例�?br /> 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);}
}
输出�Q?br /> 0
3
�q�表明Super�c�M��的printThree()没有被执行。而是调用的Test中的printThree()�?br />

AK47 2010-07-14 16:18 发表评论

AK47 — Tue, 06 Jul 2010 05:47:00 GMT

Java虚拟��Z��pȝ��?br />

�Ҏ(gu��)��?/strong>
         在Java虚拟��Z��Q�被装蝲�c�d��的信息存储在一个逻辑上被�U�Cؓ�Ҏ(gu��)��区的内存中�?br /> 当虚拟机装蝲某个�c�d��Ӟ��它��用类装蝲器定位相应的class文�g�Q?->��d��q�个class文�g�Q�一个线性的二进制流�Q?>��它传入虚拟�?->
虚拟机提取类型信息，�q�将信息存入�Ҏ(gu��)��区，�c�d��中的�c�（静态）变量也存储在�Ҏ(gu��)��?/span>.
�Ҏ(gu��)��区特点：
1)所有线�E�共享方法区。它是线�E�安全的�?br /> 2)�Ҏ(gu��)��区大��不是固定的。虚拟机�Ҏ(gu��)��需要自行调整�?br /> 3)�Ҏ(gu��)��区可以被垃圾回收�?br /> 对于每个被装载的�c�d��Q�虚拟机会在�Ҏ(gu��)��Z��存储以下信息�?br />
1)�c�d��的基本信�?
    a)�c�d��的全限定�?br />      b)�c�d��的直接超�c�d��限定�?除非�q�个�c�d��是java.lang.Objet,它没��类)�?br />     c)�c�d��是类�c�d��q�是接口�c�d��(��是说是一个类�q�是一个接�?�?br />     d)�c�d��的访问修饰符(public ,abstract或final的某个子�c?
    e)��M��直接��接口的全限定名的有序列表�?br />
2)该类型的帔R��?br />    虚拟机必��Mؓ每个被装载的�c�d��l�护一个常量池。常量池��是该类型所用常量的一个有序集合，
   包括直接帔R��(string�Q�integer,floating point帔R��)和对其他�c�d��、字�D�和�Ҏ(gu��)��的符号引用�?br />    池中的数据项��像数组一��h��通过索引讉K��的。因为常量池存储了相应类型所用到的所有类型�?br />    字段和方法的�W�号引用�Q�所以它在Java�E�序的动态连接中��L��核心的作用�?br />
3)字段信息
   �c�d��中声明的每一个字�D�，�Ҏ(gu��)��Z��必须保存下面的信息，字段在类或接口中声明的顺序也必须保存�?br />    字段名，字段�c�d��Q�字�D�修饰符(public private protected static final �{?

4)�Ҏ(gu��)��信息
   �c�d��中声明的每一个方法，�Ҏ(gu��)��Z��必须保存下面的信息，�Ҏ(gu��)��在类或接口中声明的顺序也必须保存�?br />    �Ҏ(gu��)��名，�q�回值类型，参数数量和类�?按声明顺�?�Q�方法修饰符(public private protected static final �{?
   如果�Ҏ(gu��)��不是抽象的或本地的还必须保存�Q�方法字节码�Q�操作数栈和该方法在栈针中局部变量的大小�Q�异常表�?br />
5)除了帔R��以外的所有类(静�?变量
   �q�里主要说下�~�译时常量：��是那些用final声明以及�~�译时已知的值初始化的类变量(例如�Q�static final int val =5)
   每个�~�译时常量的�c�d��都会复制它所有常量到它自��q��帔R��池中或者它的字节码��中(通常情况下编译时直接替换字节�?�?/span>

6)一个到�c�classLoader的引�?br />    指向ClassLoader�cȝ��引用每个�c�d��被装载的时候，虚拟机必��跟�t�它是由启动�c�装载器
   �q�是��q��戯��定义�c�装载器装蝲的。如果是用户自定义类装蝲器装载的�Q�那么虚拟机必须在类
   型信息中存储对该装蝲器的引用�Q�这是作为方法表中的�c�d��数据的一部分保存的�?br />    虚拟��Z��在动态连按期间��用这个信息。当某个�c�d��引用另一个类型的时候，虚拟��Z��h��装蝲
   发�v引用�c�d��的类装蝲器来装蝲被引用的�c�d��。这个动态连接的�q�程�Q�对于虚拟机分离命名�I�间
   的方式也是至关重要的。�ؓ了能够正��地执行动态连接以及维护多个命名空��_��虚拟机需要在�?br />    法表中得知每个类都是由哪个类装蝲器装载的�?br />
7)一个到Class�cȝ��引用
    指向Class�cȝ��引用对于每一个被装蝲的类�?不管是类�q�是接口)�Q�虚拟机都会相应��Cؓ
   它创��Z��个java.lang�Q�Class�cȝ��实例�Q�Class实例攑֜�内存中的堆区�Q�，而且虚拟��必须以某�U�方式把�q�个实例的引用存储在�Ҏ(gu��)��?br />
       ��Z��可能提高访问效率，设计者必��M��l�设计存储在�Ҏ(gu��)��Z��的类型信息的数据�l�构�Q�因此，
除了以上时论的原始类型信息，实现中还可能包括其他数据�l�构以加快访问原始数据的速度�Q�比如方法表�?br /> 虚拟机对每个装蝲的非抽象�c�，都生成一个方法表�Q�把它作为类信息的一部分保存在方法区。方法表是一个数�l�，
它的元素是所有它的实例可能被调用的实例方法的直接引用�Q�包括那些从��类�l�承�q�来的实例方法：(对于抽象�c�d��接口�Q�方法表没有什么帮
助，因�ؓ�E�序决不会生成它们的实例�?�q�行时可以通过�Ҏ(gu��)��表快速搜��d��对象中调用的实例�Ҏ(gu��)��?br />
�Ҏ(gu��)��Z��用的例子

class Lava{
  private int speed = 5;

  void flow(){

  }

}

public class Volcano {

  public static void main(String args[]){

   Lava lava = new Lava();

   lava.flow();
  }
}

1)虚拟机在�Ҏ(gu��)��区查找Volcano�q�个名字�Q�未果，载入volcano.class文�g�Q��ƈ提取相应信息
存入�Ҏ(gu��)��区�?br /> 2)虚拟机开始执行Volcano�c�M��main()�Ҏ(gu��)��的字节码的时候，��管Lava�c�还没被装蝲�Q?br />   但是和大多数(也许所�?虚拟机实��C��P��它不会等到把�E�序中用到的所有类都装载后才开
  始运行程序。恰好相反，它只在需要时才装载相应的�c�R�?br /> 3)main()的第一条指令告知虚拟机为列在常量池�W�一��的�c�d��配��够的内存。所以虚拟机
  使用指向Volcano帔R��池的指针扑ֈ��W�一��，发现它是一个对Lava�cȝ��W�号引用�Q�然后它?y��u)��检�?br />   �Ҏ(gu��)��区，看Lava�c�L��否已�l�被装蝲了�?br /> 4)当虚拟机发现�q�没有装载过名�ؓ"Lava"的类�Ӟ��它就开始查扑�ƈ装蝲文�g“Lava.class”�Q?br />   �q�把从读入的二进制数据中提取的类型信息放在方法区中�?br /> 5)虚拟��Z��一个直接指向方法区Lava�c�L��据的指针来替换常量池�W�—项(��是那个
  字符�?#8220;Lava”)——以后就可以用这个指针来快速地讉K��Lava�c�M��。这个替换过�E�称为常量池
  解析�Q�即把常量池中的�W�号引用替换为直接引用：�q�是通过在方法区中搜索被引用的元素实�?br />   的，在这期间可能又需要装载其他类。在�q�里�Q�我们替换掉�W�号引用�?#8220;直接引用”是一个本
  地指针�?br /> 6)虚拟机准备�ؓ一个新的Lava对象分配内存。此�Ӟ��它又需要方法区中的信息。还�?br />   得刚刚放到Volcano�c�d��量池�W�——项的指针吗?现在虚拟机用它来讉K��Lava�c�d��信息(此前刚放
  到方法区中的)�Q�找出其中记录的�q�样一个信息：一个Lava对象需要分配多��堆�I�间�?
7)虚拟机确定一个Lava对象大小后，��在堆上分配�I�间�Q��ƈ把这个对象实例变量speed初始化�ؓ默认初始�?
  8)当把新生成的Lava对象的引用压到栈中，main()�Ҏ(gu��)��的第一条指令也完成�?指��o通过�q�个引用
  调用Java代码(该代码把speed变量初始化�ؓ正确初始�?).另外用这个引用调用Lava对象引用的flow()�Ҏ(gu��)��?/p>
�?/strong>
        每个java虚拟机实例都有一个方法区以及一个堆�Q�一个java�E�序独占一个java虚拟机实例，而每个java�E�序都有自己的堆�I�间�Q�它们不会彼此干�?但同一个java�E�序的多个线�E�共享一个堆�I�间。这�U�情况下要考虑多线�E�访问同步问题�?br />
Java�?br />         一个新�U�程被创建时�Q�都会得到自��q��PC寄存器和一个java栈，虚拟��Zؓ每个�U�程开辟内存区。这些内存区是私有的�Q��Q何线�E�不能访问其他线�E�的PC寄存器和java栈。java栈��L��存储该线�E�中java�Ҏ(gu��)��的调用状态。包括它的局部变量，被调用时传进来的参数�Q�它的返回��|��以及�q�算的中间结果等。java栈是��p��多栈帧或者说帧组成，一个栈帧包含一个java�Ҏ(gu��)��的调用状态，当线�E�调用java�Ҏ(gu��)��Ӟ��虚拟机压入一个新的栈帧到该线�E�的java栈中。当�Ҏ(gu��)��q�回�Ӟ��q�个栈��被从java栈中弹出�q�抛弃�?br /> .本地�Ҏ(gu��)��?br />          ��M��本地�Ҏ(gu��)��接口都会使用某种本地�Ҏ(gu��)��饯。当�U�程调用Java�Ҏ(gu��)��Ӟ��虚拟��Z��创徏一个新的栈帧井压�hJava栈�?br /> 然而当它调用的是本地方法时�Q�虚拟机会保持Java栈不变，不再在线�E�的Java栈中压�h新的帧，虚拟机只是简单地动态连�?br /> �q�直接调用指定的本地�Ҏ(gu��)��。可以把�q�看做是虚拟机利用本地方法来动态扩展自己�?/p>

AK47 2010-07-06 13:47 发表评论

亚洲Av无码精品色午夜,亚洲av日韩av无码,在线亚洲人成电影网站色www

重新认识Java finally

(转脓(chu��ng))BigInteger �?BigDecimal

(转脓(chu��ng)) ���大整数相加�Q�超�q�了long的范��_��你要怎么做！

数字金额的中文大���写转化

�c�d��对象的初始化

(转脓(chu��ng)) ��大整数相加�Q�超�q�了long的范��_��你要怎么做！

数字金额的中文大��写转化