如：自动装箱，它可以直接把基本类型赋值给封装类型

Integer num = 10 ;

Double d = 2d ;

自动拆箱，它可以把封装类型赋值给基本类型

int num = new Integer(10);

double d = new Double(2d);

自动装箱与拆箱的功能事实上是编译器来帮您的忙，编译器在编译时期依您所编写的语法，决定是否进行装箱或拆箱动作。在自动装箱时对于值从-128到127之间的值，它们被装箱为Integer对象后，会存在内存中被重用，所以范例4.6中使用==进行比较时，i1 与 i2实际上参考至同一个对象。如果超过了从-128到127之间的值，被装箱后的Integer对象并不会被重用，即相当于每次装箱时都新建一个Integer对象，所以范例4.7使用==进行比较时，i1与i2参考的是不同的对象。所以不要过分依赖自动装箱与拆箱，您还是必须知道基本数据类型与对象的差异。

    public void testBoxingUnboxing() {

        int i = 10;

        Integer inta = i;

        inta++;

        inta += 1;

        int j = inta;

        assertTrue(j == inta);结果是：true//junit里面的方法

        assertTrue(j == new Integer(j)); 结果是：true

        assertTrue(10000 == new Integer(10000)); 结果是：true

    }

Integer i = 100.相当于编译器自动为您作以下的语法编译：

Integer i = new Integer(100).所以自动装箱与拆箱的功能是所谓的“编译器蜜糖”(Compiler Sugar)，虽然使用这个功能很方便，但在程序运行阶段您得了解Java的语义。例如下面的程序是可以通过编译的：

Integer i = null.int j = i.这样的语法在编译时期是合法的，但是在运行时期会有错误，因为这种写法相当于：

Integer i = null.int j = i.intValue().null表示i没有参考至任何的对象实体，它可以合法地指定给对象参考名称。由于实际上i并没有参考至任何的对象，所以也就不可能操作intValue()方法，这样上面的写法在运行时会出现NullPointerException错误。

自动装箱、拆箱的功能提供了方便性，但隐藏了一些细节，所以必须小心。再来看范例4.6，您认为结果是什么呢？

Ü. 范例4.6 AutoBoxDemo2.java

public class AutoBoxDemo2 {

public static void main(String[] args) {
Integer i1 = 100;

Integer i2 = 100;

if (i1 == i2)

System.out.println("i1 == i2");

else

System.out.println("i1 != i2").

}

}

从自动装箱与拆箱的机制来看，可能会觉得结果是显示i1 == i2，您是对的。那么范例4.7的这个程序，您觉得结果是什么？

Ü. 范例4.7 AutoBoxDemo3.java

public class AutoBoxDemo3 {

public static void main(String[] args) {

Integer i1 = 200;

Integer i2 = 200;

if (i1 == i2)

System.out.println("i1 == i2");

else

System.out.println("i1 != i2");

}

}

结果是显示i1 != i2，这有些令人惊讶，两个范例语法完全一样，只不过改个数值而已，结果却相反。

其实这与==运算符的比较有关，在第3章中介绍过==是用来比较两个基本数据类型的变量值是否相等，事实上==也用于判断两个对象引用名称是否参考至同一个对象。

在自动装箱时对于值从–128到127之间的值，它们被装箱为Integer对象后，会存在内存中被重用，所以范例4.6中使用==进行比较时，i1 与 i2实际上参考至同一个对象。如果超过了从–128到127之间的值，被装箱后的Integer对象并不会被重用，即相当于每次装箱时都新建一个Integer对象，所以范例4.7使用==进行比较时，i1与i2参考的是不同的对象。

所以不要过分依赖自动装箱与拆箱，您还是必须知道基本数据类型与对象的差异。范例4.7最好还是依正规的方式来写，而不是依赖编译器蜜糖(Compiler Sugar)。例如范例4.7必须改写为范例4.8才是正确的。

Ü. 范例4.8 AutoBoxDemo4.java

public class AutoBoxDemo4 {
public static void main(String[] args) {

Integer i1 = 200;

Integer i2 = 200;

if (i1.equals(i2))

System.out.println("i1 == i2");

else

System.out.println("i1 != i2");

}

}

结果这次是显示i1 == i2。使用这样的写法，相信也会比较放心一些，对于这些方便但隐藏细节的功能到底要不要用呢？基本上只有一个原则：如果您不确定就不要用。

 脏读取(TRANSACTION_READ_UNCOMMITTE):
（允许的操作       读-读  读-写 写-读     （脏数据，不可重复读，虚读） ）
   表示,这个事务级别
  允许读取脏数据,什么是脏数据?就是指还没有提交的数据.
  因为这个级别,是允许一个事务(A)读取另一个事务(B)
  还没有提交的数据.一旦事务B发生异常退出.而修改了的数据
  却还没提交,或者新插入的数据和删除了的数据都还没有
  提交,导致事务A拿到了一些脏数据,或者错误数据;
  因此在这个事务级别里是会发生脏读,重复读,错误读取;

 禁止脏读(TRANSACTION_READ_COMMITTED):
（允许的操作       读-读  读-写 （不可重复读，虚读））
  在这个级别中,事务A
  只能读取一些提交的数据,如事务B添加了一条记录,但是
  如果事务B没有提交,那么事务A是读不到的,所以该事务级别,
  把脏读给屏蔽掉了.---却允许重复读取,和错误读取.

  什么是重复读取呢?譬如,事务A读取了一个数据,这个数据
  的值为"helloworld",事务A准备利用这个数据来更新一下
  其他数据,但这个时候事务B开始对这个数据进行修改,并且
  提交---"hello 无名氏",由于是已经提交了,所以事务A是可以
  看到这个数据的,当事务A在没提交事务之前,它想看下数据
  是否正确,这个时候它发现,新读出的数据已经和原来的数据
  不一样了(这就是重复读取);

 允许重复读取(TRANSACTION_REPEATABLE_READ):
（允许的操作       读-读  读-写（仅允许插入，不允许删除和修改）（虚读））
  在这个级别中,
  是禁止了脏读,和取消了不可重复读取,但是没有禁止错误读取;
  这个级别的事务比较严格,当一个事务A在读取一个值的时候
  是不允许另一个事务对该值进行修改的;
  为了允许重复读取,可以选用该级别,因为TRANSACTION_READ_
  COMMITED这个事务级别,是允许重复读取提交的数据的,如果
  事务A在读取一个数值的时候,值为"Hello World!",但这个时
  候事务B对"Hello World"值进行修改了,改为"Hello EveryOne"
  然后提交,当事务A再次去读取这个值的时候,去发现原来读到
  的值改变了,变成了"Hello EveryOne",为了防止出现这种情况
  可以禁止重复提交,目的是为了重复读取不会出错!那么这个
  时候就可以选择
TRANSACTION_REPEATABLE_READ这个级别,
  这个级别就是用来禁止重复提交的.
（实际上是加了行锁，锁定了选中的数据，不允许修改，但是允许插入新的数据）
  虽然这个时候是禁止了重复提交,但却可以添加删除,
  比如事务A,作了个查询语句"select * from 无名氏 "; 这个时候是允许事务B做这样的操作的:
  "insert into 无名氏 values(2,'aaa')"; 这个时候,
  事务A再次做读取操作的时候,却发现数据莫名其妙的
  多了一条,这就是所谓的---幻影读取;

 禁止幻读(TRANSACTION_SERIALIZABLE):
 事务的最高级别(串行化  操作)事务级别最高,所耗费的性能也越多.
  禁止幻读禁止了脏读,禁止了重复提交和幻读.
  也就是当事务A在按条件查询的时候,事务A一旦没有提
  交,任何事务都不能对事务A的资源进行操作--- 保证
  事务A的操作真正的原子性!

 注意:在Oracle中只支持两种级别:

  TRANSACTION_READ_COMMITTED(默认的级别)(只有提交后
     才可以读取)而每一个终端进行自己的DML操作 都自动开启了一个事务

  TRANSACTION_SERIALIZABLE(窜行化操作)

public String intern()

返回字符串对象的规范化表示形式。

一个初始为空的字符串池，它由类 String 私有地维护。

当调用 intern 方法时，如果池已经包含一个等于此 String 对象的字符串（用 equals(Object) 方法确定），则返回池中的字符串。否则，将此 String 对象添加到池中，并返回此 String 对象的引用。

它遵循以下规则：对于任意两个字符串 s 和 t，当且仅当 s.equals(t) 为 true 时，s.intern() == t.intern() 才为 true。

  String.intern();
再补充介绍一点：存在于.class文件中的常量池，在运行期间被jvm装载，并且可以扩充。String的intern()方法就是扩充常量池的一个方法；当一个String实例str调用intern()方法时，java查找常量池中是否有相同unicode的字符串常量，如果有，则返回其引用，如果没有，则在常量池中增加一个unicode等于str的字符串并返回它的引用。
例3：
String   s0=”kvill”;
String   s1=new   String(“kvill”);
String   s2=new   String(“kvill”);
System.out.println(s0==s1);
S1.intern();
S2=s2.intern();
System.out.println(s0==s1);
System.out.prntln(s0==s1.intern());
System.out.println(s0==s2);
结果为：
False
False   //虽然执行了s1.intern()，但它的返回值没有赋给s1
True
True
最后再破除一个错误的理解：
有人说，“使用String.intern()方法可以将一个String类保存到一个全局的String表中，如果具有相同值的unicode字符串已经在这个表中，那么该方法返回表中已有字符串的地址，如果在表中没有相同值的字符串，则将自己的地址注册到表中”如果把这个全局的String表理解为常量吃的话，最后一句话“如果在表中没有相同值的字符串，则将自己的地址注册到表中”是错的。
例4：
String   s1=new   String(“kvill”);
String   s2=s1.intern();
System.out.println(s1==s1.intern());
System.out.println(s1+”   ”+s2);
System.out.println(s2==s1.intern());
结果是：
False
Kvill   kvill
True
我们没有声明一个”kvill”常量，所以常量池中一开始没有”kvill”的，当我们调用s1.intern()后就在常量池中新添加了一个”kvill”常量，原来的不在常量池中的”kvill”仍然存在，也就不是“把自己的地址注册到常量池中”了。
例5：
String   str1=”java”;
String   str2=”blog”;
String   s=str1+str2;
System.out.println(s==”javablog”);
结果是false。Jvm确实对型如String   str1=”java”;的String对象放在常量池里，但是它是在编译时那么做的，而String   s=str1+str2;是在运行时刻才能知道，也就是说str1+str2是在堆里创建的，所以结果为false了。


比较两个已经存在于字符串池中字符串对象可以用"=="进行，拥有比equals操作符更快的速度

1String readData() throws EOFException {
2   while () {
3      if(!in.hasNext()) {
4          if(n<len)
5            throw new EOFException();
6     }  
7  }
8}

这是抛出已存在标准的异常，步骤为：
1.找到一个合适的异常类
2.创建该类的对象
3.将异常抛出
一旦抛出异常，该方法就不可能返回到调用者，这就意味着不必为返回的默认值或错误代码担忧了。

在程序中可能会遇到任何标准异常都无法正确描述清楚的问题，这时候就需要定义自己的异常类，定义自己的异常类需要继承自Exception 或者其子类，如继承自IOException  一般要为自定义的Exception定义两个构造函数，一个是默认的无参的构造函数，另一个是带一个描述详细错误信息String的构造函数（超类的toString（）方法会打印出这些详细信息。

1public class MyException extends IOException {
2
3    MyException () {}
4    
5    MyException (String info) {
6       super(info);
7   }
8}

现在就可以像使用标准Exception类一样使用自定义的Exception类了

1String readData() throws MyException {
2   while () {
3      if(!in.hasNext()) {
4          if(n<len)
5            throw new MyException();
6    }  
7 }
8}

可以用超类Throwable类的getMessage方法得到详细的错误描述信息。或者toString()方法打印该信息。

捕获异常：
如果语句exp1有可能抛出一个异常，或者说是调用了能够抛出一个异常的方法，那么我们可以在程序中捕获该异常

1try {
2 exp1;
3 exp2;
4 .
5
6} catch(Exception e) {
7   e.
8}
9

或者是并不捕获，再次抛出该异常

再次抛出异常，异常链：
可以在catch块中再次抛出新的异常，这样可以隐藏原始的错误细节

1} catch(SQLException sqle) {
2    throw new ServletException("caused by SQLException "+e.getMessage());
3}

另一种更好的方法
既抛出高级的异常，又不会丢失原始的异常信息。

1}catch(SQLException sqle) { 
2    Throwable ta=new ServletException("caused by SQLException");
3    ta.setCause(e);
4    throw ta;
5}
6当捕获抛出的异常ta时，可以用ta.getCause(),得到原始的异常

finally子句，发生三种情况时，会执行finally子句
1.try代码正常执行
2.try代码抛出一个在catch子句中捕获的异常
3.try代码抛出一个未在catch子句中捕获的异常
就是说无论异常如何，finally子句中的代码都会执行
一般把一些资源回收的工作交给finally子句

最好把try-catch块和try-finally块分开，这样可以提高代码的清晰度

 1try {
 2   try {
 3      //可能抛出IOException的语句
 4    } finally {
 5    is.close();
 6 }
 7} catch(IOExceotion e) {
 8   
 9}
10

这样的另外一个好处是，可以catch到finally子句中抛出的异常。这也就引发了另外一个问题，如果在try和finally中都抛出了异常，而且是不同类型的，那么最后返回的是那一个呢？答案是finally中抛出的异常会覆盖try中抛出的异常。从而丢失了try当中抛出的异常信息，让抛出该方法的使用者不能跟踪异常信息。所以，在finally中执行的语句最好是不要抛出异常，但是不幸的是我们有时候不得不在finally中执行一些清楚操作如：关闭输入流InputStream,但是InputStream类的设计者并没有这么设计（将会抛出异常）。

由于finally子句总是会执行，所以在finally中包含return值时，是很危险的。假设我们利用return语句从try中返回，在方法返回之前finally子句的内容将会被执行。如果finally子句当中也包含一个return 语句，那么这个return语句所返回的值，将会覆盖原先return的值。

1public int f(int n) {
2  try {
3      return n*n;
4    } finally {
5     if(n==2)
6       return 2;
7  }
8}

在这里如果调用i=f(2);那么i的值将会是2而不是期望的2*2=4


最后最重要的一点，关于一个方法是捕获一个异常还是抛出给调用他的方法
有一点规则   
                                早抛出，晚捕获，尽量把异常抛出给调用它的函数

1Charset charset=Charset.forName("GBK");

Set<String> aliases=charset.aliases();

1 Map<String,Charset> map=Charset.availableCharsets();
2            for(String setname:map.keySet()) {
3                System.out.println(setname);
4            }

1String str=new String("晓宇");
2            ByteBuffer  buff = charset.encode(str);
3            byte[] bytes=buff.array();

1ByteBuffer by=ByteBuffer.wrap(bytes, 0, bytes.length);
2      CharBuffer cb=charset.decode(by);//返回一个CharBuffer对象，已经将字节数组转化为字符数组
3      System.out.println("  "+cb.toString());

实际上String类中集成了Charset对象的使用，String类有两个用于编码和解码的函数

1byte[] bytes = str.getBytes("CharsetName");  //将字符串str按照指定名称的Charset进行编码成字节数组
2            String str2=new String(bytes,"CharsetName"); //将字节数组按照指定名称的Charset解码为字符串

在输入输出流中有两个用于将字节流转化为指定编码格式的字符流的类  InputStreamReader/OutputStreamReader
这两个类是读写流和读写器的桥梁 用法如下

1InputStreamReader isr = new InputStreamReader(in, "charsetname");
2            BufferedReader br = new BufferedReader(isr);//加入一个BufferedReader，可以用到该类的readLine()

该用法在我的另外一篇socket备忘的里面体现了，可将网络传过来的utf-8格式编码的字节流正确的解码，以至于显示的时候不会出现乱码

//整数到字节数组的转换 软件测试专业网站:51Testing软件测试网 h$_g8Lbx g s
   public byte[] intToByte(int intValue) {
O R-v0OS&{;u0    byte[] result = new byte[4];
e!sm#DN0    result[0] = (byte) ( (intValue & 0xFF000000) >> 24);软件测试专业网站:51Testing软件测试网3e Ou-l*l
    result[1] = (byte) ( (intValue & 0x00FF0000) >> 16);软件测试专业网站:51Testing软件测试网%F3hN!XoC
    result[2] = (byte) ( (intValue & 0x0000FF00) >> 8);
d"TS)ro;L`;A:eI0    result[3] = (byte) ( (intValue & 0x000000FF));软件测试专业网站:51Testing软件测试网t1^O{;_,S"e `
    return result;软件测试专业网站:51Testing软件测试网q*~[? n M"i
  }

  //字节数组到整数的转换 软件测试专业网站:51Testing软件测试网i f9`
`3@0LZK&R
  public static int byteToInt(byte[] b) { 软件测试专业网站:51Testing软件测试网Rb~,W
s"u1m
public static int byteToInt(byte[] byteVal) {
2X/cH bIM0      int result = 0;软件测试专业网站:51Testing软件测试网7e5~3p"J r\ _
      for (int i = 0; i < byteVal.length; i++) {
1i {T q a2eT V_.^!Q0        int tmpVal = (byteVal[i] << (8 * (3 - i)));
&?x%pQ4_9T7k0        switch (i) {软件测试专业网站:51Testing软件测试网A P/u[ C,J&FA#f
          case 0:软件测试专业网站:51Testing软件测试网B,}\z`]8UU
            tmpVal = tmpVal & 0xFF000000;软件测试专业网站:51Testing软件测试网*yS6X$y9n*md~
            break;
piL/jY)lkZ?0          case 1:软件测试专业网站:51Testing软件测试网5D#YS%w3f X|g
            tmpVal = tmpVal & 0x00FF0000;软件测试专业网站:51Testing软件测试网c?Iu I w
            break;软件测试专业网站:51Testing软件测试网~&E3Vmp0_;}@
          case 2:
6j3t1F;iX+K4{0            tmpVal = tmpVal & 0x0000FF00;软件测试专业网站:51Testing软件测试网5fD7H.i y R a/q
            break;
]5b:h MMa!K0          case 3:
)^~_.\A0            tmpVal = tmpVal & 0x000000FF;

t2}8J f7A E~eH2[0            break;软件测试专业网站:51Testing软件测试网\? d:MN#D#iN
        }
MJ:c.rxWE0X"e"^*@0        result = result | tmpVal;软件测试专业网站:51Testing软件测试网9R lE\Q(g&SAJ
      }软件测试专业网站:51Testing软件测试网1ixe#~9]lyF},T
      return result;软件测试专业网站:51Testing软件测试网d,d"L^/fC?*upX
    }

  //字符到字节转换
Q N"P6tq.b@~0  public static byte[] charToByte(char ch){ 软件测试专业网站:51Testing软件测试网%]|X,~-vb'?$SU
    int temp=(int)ch; 软件测试专业网站:51Testing软件测试网'L9cx"B:` Ak
    byte[] b=new byte[2]; 软件测试专业网站:51Testing软件测试网2C8j1U/i1[ ls
    for (int i=b.length-1;i>-1;i--){
'C3^]_V:qz0      b = new Integer(temp&0xff).byteValue();      //将最高位保存在最低位 软件测试专业网站:51Testing软件测试网 |S`"I h%YQU\(g
      temp = temp >> 8;       //向右移8位 软件测试专业网站:51Testing软件测试网!s/jv'Z2R
    } 软件测试专业网站:51Testing软件测试网R+C:w4LY4Xu!M
    return b; 软件测试专业网站:51Testing软件测试网%n+x/Y ZV`6T\
  }

  //字节到字符转换 软件测试专业网站:51Testing软件测试网n:gg'^!_@NF p*@B
  public static char byteToChar(byte[] b){ 软件测试专业网站:51Testing软件测试网(}xOQ:b
    int s=0;
ZuYw~ac0    if(b[0]>0) 软件测试专业网站:51Testing软件测试网'Tsc(rq
      s+=b[0]; 软件测试专业网站:51Testing软件测试网5G]%j*fg)wk$Z
    else 软件测试专业网站:51Testing软件测试网q#i2kb@
      s+=256+b[0];
#iCo0kd+|i0    s*=256; 软件测试专业网站:51Testing软件测试网X%Zn?-k9h5q
    if(b[1]>0) 软件测试专业网站:51Testing软件测试网(E0v"C(Bv4Q
      s+=b[1];
+{`z$m a R0    else 软件测试专业网站:51Testing软件测试网D^j aODKA3T
      s+=256+b[1]; 软件测试专业网站:51Testing软件测试网\ hv8We}U)b
    char ch=(char)s; 软件测试专业网站:51Testing软件测试网#JLO"h;NH*AHb0LLt!m
    return ch; 软件测试专业网站:51Testing软件测试网$g,Mu0?JT#Ef&xi
  }

  //浮点到字节转换
de4w8L-M
pD8{\0  public static byte[] doubleToByte(double d){ 软件测试专业网站:51Testing软件测试网,~9g3FuQ9q;sMCa
    byte[] b=new byte[8]; 软件测试专业网站:51Testing软件测试网 UY:}1oV:\ {-u
Z7Ed
    long l=Double.doubleToLongBits(d);
ar8f3|"@b(g'L0    for(int i=0;i<b.length;i++){
%t4r
oUTU;zgxI0      b=new Long(l).byteValue(); 软件测试专业网站:51Testing软件测试网*I%@7R#} bb0P
      l=l>>8;
E$^+\"u!h!Y3^0    } 软件测试专业网站:51Testing软件测试网%])x)S)u)i,ul
    return b;
n`(]3K k`0  }

  //字节到浮点转换
KwV!^Kt2q#p j0  public static double byteToDouble(byte[] b){
:C.}9o G
I9r0    long l;

    l=b[0]; 软件测试专业网站:51Testing软件测试网^4_/j4oL\*l b
    l&=0xff; 软件测试专业网站:51Testing软件测试网8x-f
A;H.\
    l|=((long)b[1]<<8); 软件测试专业网站:51Testing软件测试网P\Z9tk
    l&=0xffff;
u;A&Vs3n.p]*K/B0    l|=((long)b[2]<<16);
)_ ^,F\ n3o0    l&=0xffffff;
` z3~*PIe a
MK0    l|=((long)b[3]<<24);
DM!ldb&|U(A*J0    l&=0xffffffffl;
'i)k yh\0    l|=((long)b[4]<<32); 软件测试专业网站:51Testing软件测试网 T$D_Wr:M!_,E^
a
    l&=0xffffffffffl;

    l|=((long)b[5]<<40); 软件测试专业网站:51Testing软件测试网g3m+GN$_)J1h,F.^(u.H d
    l&=0xffffffffffffl;
,gJ&o'u N7\S
p0    l|=((long)b[6]<<48);
:m@s7\WCt+B0    l&=0xffffffffffffffl;
,x)T:eO e2d![0    l|=((long)b[7]<<56);
}^MS.x%_7P0    return Double.longBitsToDouble(l); 软件测试专业网站:51Testing软件测试网Q)at;{k9Tq
  }