java精华（1）

1 JAVA SE
1.1 深入JAVA API
1.1.1 Lang包
1.1.1.1 String类和StringBuffer类

位于java.lang包中，这个包中的类使用时不用导入

String类一旦初始化就不可以改变，而stringbuffer则可以。它用于封装内容可变的字符串。它可以使用tostring（）转换成string字符串。

String x=”a”+4+”c”编译时等效于String x=new StringBuffer().append(“a”).append(4).append(“c”).toString();

字符串常量是一种特殊的匿名对象，String s1=”hello”;String s2=”hello”;则s1==s2;因为他们指向同一个匿名对象。

如果String s1=new String(“hello”);String s2=new String(“hello”);则s1!=s2;

/*逐行读取键盘输入，直到输入为“bye”时，结束程序

注：对于回车换行，在windows下面，有'\r'和'\n'两个，而unix下面只有'\n'，但是写程序的时候都要把他区分开*/

public class readline

{

public static void main(String args[])

{

String strInfo=null;

int pos=0;

byte[] buf=new byte[1024];//定义一个数组，存放换行前的各个字符

int ch=0; //存放读入的字符

system.out.println(“Please input a string:”);

while(true)

{

try

{

ch=System.in.read(); //该方法每次读入一个字节的内容到ch变量中。

}

catch(Exception e)

{

}

switch(ch)

{

case '\r': //回车时，不进行处理

break;

case '\n': //换行时，将数组总的内容放进字符串中

strInfo=new String(buf,0,pos); //该方法将数组中从第0个开始，到第pos个结束存入字符串。

if(strInfo.equals("bye"))   //如果该字符串内容为bye，则退出程序。

{

return;

}

else   //如果不为bye，则输出，并且竟pos置为0，准备下次存入。

{

System.out.println(strInfo);

pos=0;

break;

}

default:

buf[pos++]=(byte)ch;  //如果不是回车，换行，则将读取的数据存入数组中。

}

}

}

}

String类的常用成员方法

1、 构造方法：

String(byte[] byte,int offset,int length);这个在上面已经用到。

2、 equalsIgnoreCase:忽略大小写的比较，上例中如果您输入的是BYE,则不会退出，因为大小写不同，但是如果使用这个方法，则会退出。

3、 indexOf(int ch);返回字符ch在字符串中首次出现的位置

4、 substring(int benginIndex);

5、 substring(int beginIndex,int endIndex);

返回字符串的子字符串，4返回从benginindex位置开始到结束的子字符串，5返回beginindex和endindex-1之间的子字符串。

基本数据类型包装类的作用是：将基本的数据类型包装成对象。因为有些方法不可以直接处理基本数据类型，只能处理对象，例如vector的add方法，参数就只能是对象。这时就需要使用他们的包装类将他们包装成对象。

例：在屏幕上打印出一个*组成的矩形，矩形的宽度和高度通过启动程序时传递给main（）方法的参数指定。

public class testInteger

{

public static void main(String[] args)

//main()的参数是string类型的数组，用来做为长，宽时，要转换成整型。

{

int w=new Integer(args[0]).intValue();

int h=Integer.parseInt(args[1]);

//int h=Integer.valueOf(args[1]).intValue();

//以上为三种将字符串转换成整形的方法。

for(int i=0;i<h;i++)

{

StringBuffer sb=new StringBuffer(); //使用stringbuffer，是因为它是可追加的。

for(int j=0;j<w;j++)

{

sb.append('*');

}

System.out.println(sb.toString()); //在打印之前，要将stringbuffer转化为string类型。

}

}

}

比较下面两段代码的执行效率：

（1）String sb=new String();

For(int j=0;j<w;j++)

{

Sb=sb+’*’;

}

(2) StringBuffer sb=new StringBuffer();

For(int j=0;j<w;j++)

{

Sb.append(‘*’);

}

(1) 和（2）在运行结果上相同，但效率相差很多。

（1） 在每一次循环中，都要先将string类型转换为stringbuffer类型，然后将‘*’追加进去，然后再调用tostring（）方法，转换为string类型，效率很低。

（2） 在没次循环中，都只是调用原来的那个stringbuffer对象，没有创建新的对象，所以效率比较高。

1.1.1.2 System类与Runtime类

由于java不支持全局函数和全局变量，所以java设计者将一些与系统相关的重要函数和变量放在system类中。

我们不能直接创建runtime的实例，只能通过runtime.getruntime（）静态方法来获得。

编程实例：在java程序中启动一个windows记事本程序的运行实例，并在该运行实例中打开该运行程序的源文件，启动的记事本程序5秒后关闭。

public class Property

{

public static void main(String[] args)

{

Process p=null; //java虚拟机启动的进程。

try

{

p=Runtime.getRuntime().exec("notepad.exe Property.java"); //启动记事本并且打开源文件。

Thread.sleep(5000); //持续5秒

p.destroy(); //关闭该进程

}

catch(Exception ex)

{

ex.printStackTrace();

}

}

}

1.1.1.3 Java语言中两种异常的差别

Java提供了两类主要的异常:runtime exception和checked exception。所有的checked exception是从java.lang.Exception类衍生出来的，而runtime exception则是从java.lang.RuntimeException或java.lang.Error类衍生出来的。
　　它们的不同之处表现在两方面:机制上和逻辑上。
　　一、机制上
　　它们在机制上的不同表现在两点:1.如何定义方法;2. 如何处理抛出的异常。请看下面CheckedException的定义:
　　public class CheckedException extends Exception
　　{
　　public CheckedException() {}
　　public CheckedException( String message )
　　{
　　super( message );
　　}
　　}
　　以及一个使用exception的例子:
　　public class ExceptionalClass
　　{
　　public void method1()
　　throws CheckedException
　　{
　　　// ... throw new CheckedException( “...出错了“ );
　　}
　　public void method2( String arg )
　　{
　　　if( arg == null )
　　　{
　　　　throw new NullPointerException( “method2的参数arg是null!” );
　　　}
　　}
　　public void method3() throws CheckedException
　　{
　　　method1();
　　}
　　}
　　你可能已经注意到了，两个方法method1()和method2()都会抛出exception，可是只有method1()做了声明。另外，method3()本身并不会抛出exception，可是它却声明会抛出CheckedException。在向你解释之前，让我们先来看看这个类的main()方法:
　　public static void main( String[] args )
　　{
　　ExceptionalClass example = new ExceptionalClass();
　　try
　　{
　　example.method1();
　　example.method3();
　　}
　　catch( CheckedException ex ) { } example.method2( null );
　　}
　　在main()方法中，如果要调用method1()，你必须把这个调用放在try/catch程序块当中，因为它会抛出Checked exception。
　　相比之下，当你调用method2()时，则不需要把它放在try/catch程序块当中，因为它会抛出的exception不是checked exception，而是runtime exception。会抛出runtime exception的方法在定义时不必声明它会抛出exception。
　　现在，让我们再来看看method3()。它调用了method1()却没有把这个调用放在try/catch程序块当中。它是通过声明它会抛出method1()会抛出的exception来避免这样做的。它没有捕获这个exception，而是把它传递下去。实际上main()方法也可以这样做，通过声明它会抛出Checked exception来避免使用try/catch程序块(当然我们反对这种做法)。
　　小结一下:
　　* Runtime exceptions:
　　在定义方法时不需要声明会抛出runtime exception;
　　在调用这个方法时不需要捕获这个runtime exception;
　　runtime exception是从java.lang.RuntimeException或java.lang.Error类衍生出来的。
　　* Checked exceptions:
　　定义方法时必须声明所有可能会抛出的checked exception;
　　在调用这个方法时，必须捕获它的checked exception，不然就得把它的exception传递下去;
　　checked exception是从java.lang.Exception类衍生出来的。
　　二、逻辑上
　　从逻辑的角度来说，checked exceptions和runtime exception是有不同的使用目的的。checked exception用来指示一种调用方能够直接处理的异常情况。而runtime exception则用来指示一种调用方本身无法处理或恢复的程序错误。
　　checked exception迫使你捕获它并处理这种异常情况。以java.net.URL类的构建器(constructor)为例，它的每一个构建器都会抛出MalformedURLException。MalformedURLException就是一种checked exception。设想一下，你有一个简单的程序，用来提示用户输入一个URL，然后通过这个URL去下载一个网页。如果用户输入的URL有错误，构建器就会抛出一个exception。既然这个exception是checked exception，你的程序就可以捕获它并正确处理:比如说提示用户重新输入。
　　再看下面这个例子:
　　public void method()
　　{
　　int [] numbers = { 1, 2, 3 };
　　int sum = numbers[0] numbers[3];
　　}
　　在运行方法method()时会遇到ArrayIndexOutOfBoundsException(因为数组numbers的成员是从0到2)。对于这个异常，调用方无法处理/纠正。这个方法method()和上面的method2()一样，都是runtime exception的情形。上面我已经提到，runtime exception用来指示一种调用方本身无法处理/恢复的程序错误。而程序错误通常是无法在运行过程中处理的，必须改正程序代码。
　　总而言之，在程序的运行过程中一个checked exception被抛出的时候，只有能够适当处理这个异常的调用方才应该用try/catch来捕获它。而对于runtime exception，则不应当在程序中捕获它。如果你要捕获它的话，你就会冒这样一个风险:程序代码的错误(bug)被掩盖在运行当中无法被察觉。因为在程序测试过程中，系统打印出来的调用堆栈路径(StackTrace)往往使你更快找到并修改代码中的错误。有些程序员建议捕获runtime exception并纪录在log中，我反对这样做。这样做的坏处是你必须通过浏览log来找出问题，而用来测试程序的测试系统(比如Unit Test)却无法直接捕获问题并报告出来。
　　在程序中捕获runtime exception还会带来更多的问题:要捕获哪些runtime exception?什么时候捕获?runtime exception是不需要声明的，你怎样知道有没有runtime exception要捕获?你想看到在程序中每一次调用方法时，都使用try/catch程序块吗?

1.1.1.4 类加载器（ClassLoader）
1.1.1.4.1 基础知识

静态库、动态连接库

程序编制一般需经编辑、编译、连接、加载和运行几个步骤。在我们的应用中，有一些公共代码是需要反复使用，就把这些代码编译为“库”文件；在连接步骤中，连接器将从库文件取得所需的代码，复制到生成的可执行文件中。这种库称为静态库，其特点是可执行文件中包含了库代码的一份完整拷贝；缺点就是被多次使用就会有多份冗余拷贝。

为了克服这个缺点可以采用动态连接库。这个时候连接器仅仅是在可执行文件中打上标志，说明需要使用哪些动态连接库；当运行程序时，加载器根据这些标志把所需的动态连接库加载到内存。

另外在当前的编程环境中，一般都提供方法让程序在运行的时候把某个特定的动态连接库加载并运行，也可以将其卸载（例如Win32的LoadLibrary()&FreeLibrary()和Posix的dlopen()&dlclose()）。这个功能被广泛地用于在程序运行时刻更新某些功能模块或者是程序外观。

What is ClassLoader?

与普通程序不同的是，Java程序（class文件）并不是本地的可执行程序。当运行Java程序时，首先运行JVM（Java虚拟机），然后再把Java class加载到JVM里头运行，负责加载Java class的这部分就叫做Class Loader。

JVM本身包含了一个ClassLoader称为Bootstrap ClassLoader，和JVM一样，Bootstrap ClassLoader是用本地代码实现的，它负责加载核心Java Class（即所有java.*开头的类）。另外JVM还会提供两个ClassLoader，它们都是用Java语言编写的，由Bootstrap ClassLoader加载；其中Extension ClassLoader负责加载扩展的Java class（例如所有javax.*开头的类和存放在JRE的ext目录下的类），Application ClassLoader负责加载应用程序自身的类。

When to load the class?

什么时候JVM会使用ClassLoader加载一个类呢？当你使用java去执行一个类，JVM使用Application ClassLoader加载这个类；然后如果类A引用了类B，不管是直接引用还是用Class.forName()引用，JVM就会找到加载类A的ClassLoader，并用这个ClassLoader来加载类B。

Why use your own ClassLoader?

似乎JVM自身的ClassLoader已经足够了，为什么我们还需要创建自己的ClassLoader呢？

因为JVM自带的ClassLoader只是懂得从本地文件系统加载标准的java class文件，如果编写你自己的ClassLoader，你可以做到：
1）在执行非置信代码之前，自动验证数字签名
2）动态地创建符合用户特定需要的定制化构建类
3）从特定的场所取得java class，例如数据库中
4) 等等

事实上当使用Applet的时候，就用到了特定的ClassLoader，因为这时需要从网络上加载java class，并且要检查相关的安全信息。

目前的应用服务器大都使用了ClassLoader技术，即使你不需要创建自己的ClassLoader，了解其原理也有助于更好地部署自己的应用。

ClassLoader Tree & Delegation Model

当你决定创建你自己的ClassLoader时，需要继承java.lang.ClassLoader或者它的子类。在实例化每个ClassLoader对象时，需要指定一个父对象；如果没有指定的话，系统自动指定ClassLoader.getSystemClassLoader()为父对象。如下图：

java精华（1） - java world - Java World

在Java 1.2后，java class的加载采用所谓的委托模式（Delegation Modle），当调用一个ClassLoader.loadClass()加载一个类的时候，将遵循以下的步骤：
1）检查这个类是否已经被加载进来了？
2）如果还没有加载，调用父对象加载该类
3）如果父对象无法加载，调用本对象的findClass()取得这个类。

所以当创建自己的Class Loader时，只需要重载findClass()这个方法。

Unloading? Reloading?

当一个java class被加载到JVM之后，它有没有可能被卸载呢？我们知道Win32有FreeLibrary()函数，Posix有dlclose()函数可以被调用来卸载指定的动态连接库，但是Java并没有提供一个UnloadClass()的方法来卸载指定的类。

在Java中，java class的卸载仅仅是一种对系统的优化，有助于减少应用对内存的占用。既然是一种优化方法，那么就完全是JVM自行决定如何实现，对Java开发人员来说是完全透明的。

在什么时候一个java class/interface会被卸载呢？Sun公司的原话是这么说的："class or interface may be unloaded if and only if its class loader is unreachable. Classes loaded by the bootstrap loader may not be unloaded."

事实上我们关心的不是如何卸载类的，我们关心的是如何更新已经被加载了的类从而更新应用的功能。JSP则是一个非常典型的例子，如果一个JSP文件被更改了，应用服务器则需要把更改后的JSP重新编译，然后加载新生成的类来响应后继的请求。

其实一个已经加载的类是无法被更新的，如果你试图用同一个ClassLoader再次加载同一个类，就会得到异常（java.lang.LinkageError: duplicate class definition），我们只能够重新创建一个新的ClassLoader实例来再次加载新类。至于原来已经加载的类，开发人员不必去管它，因为它可能还有实例正在被使用，只要相关的实例都被内存回收了，那么JVM就会在适当的时候把不会再使用的类卸载。

1.1.1.4.2 类加载的表现形式

java中的类是动态加载的，我们先看一下我们常用的类加载方式，先有一个感性的认识，才能进一步
深入讨论,类加载无非就是下面三种方式。
class A{}
class B{}
class C{}
public class Loader{
    public static void main(String[] args) throws Exception{
       Class aa=A.class; 
       Class bb=Class.forName("B");
       Class cc=ClassLoader.getSystemClassLoader().loadClass("C");
    }
}
我们先看.class字面量方式，很多人可能不知道这种方式，因为这种用法不是一般java语法。
通过javap我们可以发现，这种方式的大致等价于定义了一个静态成员变量
    static Class class$0;(后面的编号是增长的)
你可以试图再定义一个  static Class class$0,应该会收到一个编译错误(重复定义)。
Class aa=A.class;
就相当于
    if(class$0==null){
try{ 
           Class.forName("A");
}
cacth(ClassNotFoundException e){
    throw new NoClassDefFoundError(e);
}
    }
    Class aa=class$0;
可以很清楚的看到，这种类的字面量定义其实不是加载类的方式，而是被编译器处理了，实质
上是使用了Class.forName方法，但是使用这种方式有一个很大的好处就是不用处理异常，因为
编译器处理的时候如果找不到类会抛出一个NoClassDefFoundError。也许你觉得需要处理
ClassNotFoundException这种异常，事实上99%的情况下我们可以把这种异常认为是一个错误。
所以大部分情况我们使用这种方式会更简洁。
最常用的方式就是Class.forName方式了，这也是一个通用的上层调用。这个方法有两个重载，
可能很多人都忽略了第二个方法。
public static Class forName(String name) throws ClassNotFoundException
public static Class forName(String name, boolean initialize,ClassLoader loader) throws ClassNotFoundException
第二个方法后面多了两个参数，第二个参数表示是否初始化，第三个参数为指定的类加载器。
在上面的例子中：
Class bb=Class.forName("B");等价于
Class bb=Class.forName("B",true,Loader.class.getClassLoader());
这里要详细说一下这个类的初始化这个参数,如果这个参数为false的话，
类中的static成员不会被初始化，static语句块也不会被执行。
也就是类虽然被加载了，但是没有被初始化，不过在第一次使用时仍然会初始化。
所以我们有时候会看到Class.forName("XXX").newInstance()这样的语句，为什么这里要创建一个
不用的实例呢?不过是为了保证类被初始化(兼容以前的系统)。
其实第二个方法是比较难用的，需要指定类加载器，如果不指定而且又没有安装安全管理器的化，
是无法加载类的，只要看一下具体的实现就明白了。
最本质的方式当然是直接使用ClassLoader加载了，所有的类最终都是通过ClassLoader加载的，
Class cc=ClassLoader.getSystemClassLoader().loadClass("C");
这里通过使用系统类加载器来加载某个类，很直接的方式，但是很遗憾的是通过这种方式加载类，
类是没有被初始化的(也就是初始化被延迟到真正使用的时候).不过我们也可以借鉴上面的经验，加载
后实例化一个对象Class cc=ClassLoader.getSystemClassLoader().loadClass("C").newInstance()。
这里使用了系统类加载器，也是最常用的类加载器，从classpath中寻找要加载的类。
java中默认有三种类加载器：引导类加载器，扩展类加载器，系统类加载器。
java中的类加载有着规范的层次结构，如果我们要了解类加载的过程，需要明确知道哪个类被谁
加载，某个类加载器加载了哪些类等等，就需要深入理解ClassLoader的本质。
以上只是类加载的表面的东西，我们还将讨论深层次的东西。

2 集合类JAVA SE
2.1 深入JAVA API
2.1.1 Lang包
2.1.1.1 String类和StringBuffer类

位于java.lang包中，这个包中的类使用时不用导入

String类一旦初始化就不可以改变，而stringbuffer则可以。它用于封装内容可变的字符串。它可以使用tostring（）转换成string字符串。

String x=”a”+4+”c”编译时等效于String x=new StringBuffer().append(“a”).append(4).append(“c”).toString();

字符串常量是一种特殊的匿名对象，String s1=”hello”;String s2=”hello”;则s1==s2;因为他们指向同一个匿名对象。

如果String s1=new String(“hello”);String s2=new String(“hello”);则s1!=s2;

/*逐行读取键盘输入，直到输入为“bye”时，结束程序

注：对于回车换行，在windows下面，有'\r'和'\n'两个，而unix下面只有'\n'，但是写程序的时候都要把他区分开*/

public class readline

{

public static void main(String args[])

{

String strInfo=null;

int pos=0;

byte[] buf=new byte[1024];//定义一个数组，存放换行前的各个字符

int ch=0; //存放读入的字符

system.out.println(“Please input a string:”);

while(true)

{

try

{

ch=System.in.read(); //该方法每次读入一个字节的内容到ch变量中。

}

catch(Exception e)

{

}

switch(ch)

{

case '\r': //回车时，不进行处理

break;

case '\n': //换行时，将数组总的内容放进字符串中

strInfo=new String(buf,0,pos); //该方法将数组中从第0个开始，到第pos个结束存入字符串。

if(strInfo.equals("bye"))   //如果该字符串内容为bye，则退出程序。

{

return;

}

else   //如果不为bye，则输出，并且竟pos置为0，准备下次存入。

{

System.out.println(strInfo);

pos=0;

break;

}

default:

buf[pos++]=(byte)ch;  //如果不是回车，换行，则将读取的数据存入数组中。

}

}

}

}

String类的常用成员方法

6、 构造方法：

String(byte[] byte,int offset,int length);这个在上面已经用到。

7、 equalsIgnoreCase:忽略大小写的比较，上例中如果您输入的是BYE,则不会退出，因为大小写不同，但是如果使用这个方法，则会退出。

8、 indexOf(int ch);返回字符ch在字符串中首次出现的位置

9、 substring(int benginIndex);

10、 substring(int beginIndex,int endIndex);

返回字符串的子字符串，4返回从benginindex位置开始到结束的子字符串，5返回beginindex和endindex-1之间的子字符串。

基本数据类型包装类的作用是：将基本的数据类型包装成对象。因为有些方法不可以直接处理基本数据类型，只能处理对象，例如vector的add方法，参数就只能是对象。这时就需要使用他们的包装类将他们包装成对象。

例：在屏幕上打印出一个*组成的矩形，矩形的宽度和高度通过启动程序时传递给main（）方法的参数指定。

public class testInteger

{

public static void main(String[] args)

//main()的参数是string类型的数组，用来做为长，宽时，要转换成整型。

{

int w=new Integer(args[0]).intValue();

int h=Integer.parseInt(args[1]);

//int h=Integer.valueOf(args[1]).intValue();

//以上为三种将字符串转换成整形的方法。

for(int i=0;i<h;i++)

{

StringBuffer sb=new StringBuffer(); //使用stringbuffer，是因为它是可追加的。

for(int j=0;j<w;j++)

{

sb.append('*');

}

System.out.println(sb.toString()); //在打印之前，要将stringbuffer转化为string类型。

}

}

}

比较下面两段代码的执行效率：

（1）String sb=new String();

For(int j=0;j<w;j++)

{

Sb=sb+’*’;

}

(2) StringBuffer sb=new StringBuffer();

For(int j=0;j<w;j++)

{

Sb.append(‘*’);

}

(2) 和（2）在运行结果上相同，但效率相差很多。

（3） 在每一次循环中，都要先将string类型转换为stringbuffer类型，然后将‘*’追加进去，然后再调用tostring（）方法，转换为string类型，效率很低。

（4） 在没次循环中，都只是调用原来的那个stringbuffer对象，没有创建新的对象，所以效率比较高。

2.1.1.2 System类与Runtime类

由于java不支持全局函数和全局变量，所以java设计者将一些与系统相关的重要函数和变量放在system类中。

我们不能直接创建runtime的实例，只能通过runtime.getruntime（）静态方法来获得。

编程实例：在java程序中启动一个windows记事本程序的运行实例，并在该运行实例中打开该运行程序的源文件，启动的记事本程序5秒后关闭。

public class Property

{

public static void main(String[] args)

{

Process p=null; //java虚拟机启动的进程。

try

{

p=Runtime.getRuntime().exec("notepad.exe Property.java"); //启动记事本并且打开源文件。

Thread.sleep(5000); //持续5秒

p.destroy(); //关闭该进程

}

catch(Exception ex)

{

ex.printStackTrace();

}

}

}

2.1.1.3 Java语言中两种异常的差别

Java提供了两类主要的异常:runtime exception和checked exception。所有的checked exception是从java.lang.Exception类衍生出来的，而runtime exception则是从java.lang.RuntimeException或java.lang.Error类衍生出来的。
　　它们的不同之处表现在两方面:机制上和逻辑上。
　　一、机制上
　　它们在机制上的不同表现在两点:1.如何定义方法;2. 如何处理抛出的异常。请看下面CheckedException的定义:
　　public class CheckedException extends Exception
　　{
　　public CheckedException() {}
　　public CheckedException( String message )
　　{
　　super( message );
　　}
　　}
　　以及一个使用exception的例子:
　　public class ExceptionalClass
　　{
　　public void method1()
　　throws CheckedException
　　{
　　　// ... throw new CheckedException( “...出错了“ );
　　}
　　public void method2( String arg )
　　{
　　　if( arg == null )
　　　{
　　　　throw new NullPointerException( “method2的参数arg是null!” );
　　　}
　　}
　　public void method3() throws CheckedException
　　{
　　　method1();
　　}
　　}
　　你可能已经注意到了，两个方法method1()和method2()都会抛出exception，可是只有method1()做了声明。另外，method3()本身并不会抛出exception，可是它却声明会抛出CheckedException。在向你解释之前，让我们先来看看这个类的main()方法:
　　public static void main( String[] args )
　　{
　　ExceptionalClass example = new ExceptionalClass();
　　try
　　{
　　example.method1();
　　example.method3();
　　}
　　catch( CheckedException ex ) { } example.method2( null );
　　}
　　在main()方法中，如果要调用method1()，你必须把这个调用放在try/catch程序块当中，因为它会抛出Checked exception。
　　相比之下，当你调用method2()时，则不需要把它放在try/catch程序块当中，因为它会抛出的exception不是checked exception，而是runtime exception。会抛出runtime exception的方法在定义时不必声明它会抛出exception。
　　现在，让我们再来看看method3()。它调用了method1()却没有把这个调用放在try/catch程序块当中。它是通过声明它会抛出method1()会抛出的exception来避免这样做的。它没有捕获这个exception，而是把它传递下去。实际上main()方法也可以这样做，通过声明它会抛出Checked exception来避免使用try/catch程序块(当然我们反对这种做法)。
　　小结一下:
　　* Runtime exceptions:
　　在定义方法时不需要声明会抛出runtime exception;
　　在调用这个方法时不需要捕获这个runtime exception;
　　runtime exception是从java.lang.RuntimeException或java.lang.Error类衍生出来的。
　　* Checked exceptions:
　　定义方法时必须声明所有可能会抛出的checked exception;
　　在调用这个方法时，必须捕获它的checked exception，不然就得把它的exception传递下去;
　　checked exception是从java.lang.Exception类衍生出来的。
　　二、逻辑上
　　从逻辑的角度来说，checked exceptions和runtime exception是有不同的使用目的的。checked exception用来指示一种调用方能够直接处理的异常情况。而runtime exception则用来指示一种调用方本身无法处理或恢复的程序错误。
　　checked exception迫使你捕获它并处理这种异常情况。以java.net.URL类的构建器(constructor)为例，它的每一个构建器都会抛出MalformedURLException。MalformedURLException就是一种checked exception。设想一下，你有一个简单的程序，用来提示用户输入一个URL，然后通过这个URL去下载一个网页。如果用户输入的URL有错误，构建器就会抛出一个exception。既然这个exception是checked exception，你的程序就可以捕获它并正确处理:比如说提示用户重新输入。
　　再看下面这个例子:
　　public void method()
　　{
　　int [] numbers = { 1, 2, 3 };
　　int sum = numbers[0] numbers[3];
　　}
　　在运行方法method()时会遇到ArrayIndexOutOfBoundsException(因为数组numbers的成员是从0到2)。对于这个异常，调用方无法处理/纠正。这个方法method()和上面的method2()一样，都是runtime exception的情形。上面我已经提到，runtime exception用来指示一种调用方本身无法处理/恢复的程序错误。而程序错误通常是无法在运行过程中处理的，必须改正程序代码。
　　总而言之，在程序的运行过程中一个checked exception被抛出的时候，只有能够适当处理这个异常的调用方才应该用try/catch来捕获它。而对于runtime exception，则不应当在程序中捕获它。如果你要捕获它的话，你就会冒这样一个风险:程序代码的错误(bug)被掩盖在运行当中无法被察觉。因为在程序测试过程中，系统打印出来的调用堆栈路径(StackTrace)往往使你更快找到并修改代码中的错误。有些程序员建议捕获runtime exception并纪录在log中，我反对这样做。这样做的坏处是你必须通过浏览log来找出问题，而用来测试程序的测试系统(比如Unit Test)却无法直接捕获问题并报告出来。
　　在程序中捕获runtime exception还会带来更多的问题:要捕获哪些runtime exception?什么时候捕获?runtime exception是不需要声明的，你怎样知道有没有runtime exception要捕获?你想看到在程序中每一次调用方法时，都使用try/catch程序块吗?

2.1.1.4 类加载器（ClassLoader）
2.1.1.4.1 基础知识

静态库、动态连接库

程序编制一般需经编辑、编译、连接、加载和运行几个步骤。在我们的应用中，有一些公共代码是需要反复使用，就把这些代码编译为“库”文件；在连接步骤中，连接器将从库文件取得所需的代码，复制到生成的可执行文件中。这种库称为静态库，其特点是可执行文件中包含了库代码的一份完整拷贝；缺点就是被多次使用就会有多份冗余拷贝。

为了克服这个缺点可以采用动态连接库。这个时候连接器仅仅是在可执行文件中打上标志，说明需要使用哪些动态连接库；当运行程序时，加载器根据这些标志把所需的动态连接库加载到内存。

另外在当前的编程环境中，一般都提供方法让程序在运行的时候把某个特定的动态连接库加载并运行，也可以将其卸载（例如Win32的LoadLibrary()&FreeLibrary()和Posix的dlopen()&dlclose()）。这个功能被广泛地用于在程序运行时刻更新某些功能模块或者是程序外观。

What is ClassLoader?

与普通程序不同的是，Java程序（class文件）并不是本地的可执行程序。当运行Java程序时，首先运行JVM（Java虚拟机），然后再把Java class加载到JVM里头运行，负责加载Java class的这部分就叫做Class Loader。

JVM本身包含了一个ClassLoader称为Bootstrap ClassLoader，和JVM一样，Bootstrap ClassLoader是用本地代码实现的，它负责加载核心Java Class（即所有java.*开头的类）。另外JVM还会提供两个ClassLoader，它们都是用Java语言编写的，由Bootstrap ClassLoader加载；其中Extension ClassLoader负责加载扩展的Java class（例如所有javax.*开头的类和存放在JRE的ext目录下的类），Application ClassLoader负责加载应用程序自身的类。

When to load the class?

什么时候JVM会使用ClassLoader加载一个类呢？当你使用java去执行一个类，JVM使用Application ClassLoader加载这个类；然后如果类A引用了类B，不管是直接引用还是用Class.forName()引用，JVM就会找到加载类A的ClassLoader，并用这个ClassLoader来加载类B。

Why use your own ClassLoader?

似乎JVM自身的ClassLoader已经足够了，为什么我们还需要创建自己的ClassLoader呢？

因为JVM自带的ClassLoader只是懂得从本地文件系统加载标准的java class文件，如果编写你自己的ClassLoader，你可以做到：
1）在执行非置信代码之前，自动验证数字签名
2）动态地创建符合用户特定需要的定制化构建类
3）从特定的场所取得java class，例如数据库中
4) 等等

事实上当使用Applet的时候，就用到了特定的ClassLoader，因为这时需要从网络上加载java class，并且要检查相关的安全信息。

目前的应用服务器大都使用了ClassLoader技术，即使你不需要创建自己的ClassLoader，了解其原理也有助于更好地部署自己的应用。

ClassLoader Tree & Delegation Model

当你决定创建你自己的ClassLoader时，需要继承java.lang.ClassLoader或者它的子类。在实例化每个ClassLoader对象时，需要指定一个父对象；如果没有指定的话，系统自动指定ClassLoader.getSystemClassLoader()为父对象。如下图：

java精华（1） - java world - Java World

在Java 1.2后，java class的加载采用所谓的委托模式（Delegation Modle），当调用一个ClassLoader.loadClass()加载一个类的时候，将遵循以下的步骤：
1）检查这个类是否已经被加载进来了？
2）如果还没有加载，调用父对象加载该类
3）如果父对象无法加载，调用本对象的findClass()取得这个类。

所以当创建自己的Class Loader时，只需要重载findClass()这个方法。

Unloading? Reloading?

当一个java class被加载到JVM之后，它有没有可能被卸载呢？我们知道Win32有FreeLibrary()函数，Posix有dlclose()函数可以被调用来卸载指定的动态连接库，但是Java并没有提供一个UnloadClass()的方法来卸载指定的类。

在Java中，java class的卸载仅仅是一种对系统的优化，有助于减少应用对内存的占用。既然是一种优化方法，那么就完全是JVM自行决定如何实现，对Java开发人员来说是完全透明的。

在什么时候一个java class/interface会被卸载呢？Sun公司的原话是这么说的："class or interface may be unloaded if and only if its class loader is unreachable. Classes loaded by the bootstrap loader may not be unloaded."

事实上我们关心的不是如何卸载类的，我们关心的是如何更新已经被加载了的类从而更新应用的功能。JSP则是一个非常典型的例子，如果一个JSP文件被更改了，应用服务器则需要把更改后的JSP重新编译，然后加载新生成的类来响应后继的请求。

其实一个已经加载的类是无法被更新的，如果你试图用同一个ClassLoader再次加载同一个类，就会得到异常（java.lang.LinkageError: duplicate class definition），我们只能够重新创建一个新的ClassLoader实例来再次加载新类。至于原来已经加载的类，开发人员不必去管它，因为它可能还有实例正在被使用，只要相关的实例都被内存回收了，那么JVM就会在适当的时候把不会再使用的类卸载。

2.1.1.4.2 类加载的表现形式

java中的类是动态加载的，我们先看一下我们常用的类加载方式，先有一个感性的认识，才能进一步
深入讨论,类加载无非就是下面三种方式。
class A{}
class B{}
class C{}
public class Loader{
    public static void main(String[] args) throws Exception{
       Class aa=A.class; 
       Class bb=Class.forName("B");
       Class cc=ClassLoader.getSystemClassLoader().loadClass("C");
    }
}
我们先看.class字面量方式，很多人可能不知道这种方式，因为这种用法不是一般java语法。
通过javap我们可以发现，这种方式的大致等价于定义了一个静态成员变量
    static Class class$0;(后面的编号是增长的)
你可以试图再定义一个  static Class class$0,应该会收到一个编译错误(重复定义)。
Class aa=A.class;
就相当于
    if(class$0==null){
try{ 
           Class.forName("A");
}
cacth(ClassNotFoundException e){
    throw new NoClassDefFoundError(e);
}
    }
    Class aa=class$0;
可以很清楚的看到，这种类的字面量定义其实不是加载类的方式，而是被编译器处理了，实质
上是使用了Class.forName方法，但是使用这种方式有一个很大的好处就是不用处理异常，因为
编译器处理的时候如果找不到类会抛出一个NoClassDefFoundError。也许你觉得需要处理
ClassNotFoundException这种异常，事实上99%的情况下我们可以把这种异常认为是一个错误。
所以大部分情况我们使用这种方式会更简洁。
最常用的方式就是Class.forName方式了，这也是一个通用的上层调用。这个方法有两个重载，
可能很多人都忽略了第二个方法。
public static Class forName(String name) throws ClassNotFoundException
public static Class forName(String name, boolean initialize,ClassLoader loader) throws ClassNotFoundException
第二个方法后面多了两个参数，第二个参数表示是否初始化，第三个参数为指定的类加载器。
在上面的例子中：
Class bb=Class.forName("B");等价于
Class bb=Class.forName("B",true,Loader.class.getClassLoader());
这里要详细说一下这个类的初始化这个参数,如果这个参数为false的话，
类中的static成员不会被初始化，static语句块也不会被执行。
也就是类虽然被加载了，但是没有被初始化，不过在第一次使用时仍然会初始化。
所以我们有时候会看到Class.forName("XXX").newInstance()这样的语句，为什么这里要创建一个
不用的实例呢?不过是为了保证类被初始化(兼容以前的系统)。
其实第二个方法是比较难用的，需要指定类加载器，如果不指定而且又没有安装安全管理器的化，
是无法加载类的，只要看一下具体的实现就明白了。
最本质的方式当然是直接使用ClassLoader加载了，所有的类最终都是通过ClassLoader加载的，
Class cc=ClassLoader.getSystemClassLoader().loadClass("C");
这里通过使用系统类加载器来加载某个类，很直接的方式，但是很遗憾的是通过这种方式加载类，
类是没有被初始化的(也就是初始化被延迟到真正使用的时候).不过我们也可以借鉴上面的经验，加载
后实例化一个对象Class cc=ClassLoader.getSystemClassLoader().loadClass("C").newInstance()。
这里使用了系统类加载器，也是最常用的类加载器，从classpath中寻找要加载的类。
java中默认有三种类加载器：引导类加载器，扩展类加载器，系统类加载器。
java中的类加载有着规范的层次结构，如果我们要了解类加载的过程，需要明确知道哪个类被谁
加载，某个类加载器加载了哪些类等等，就需要深入理解ClassLoader的本质。
以上只是类加载的表面的东西，我们还将讨论深层次的东西。

2.1.2

集合类用于存储一组对象。

2.1.2.1 Java Util 包使用详解

本章介绍Java的实用工具类库java.util包。在这个包中，Java提供了一些实用的方法和数据结构。例如，Java提供日期(Data)类、日历(Calendar)类来产生和获取日期及时间，提供随机数(Random)类产生各种类型的随机数，还提供了堆栈(Stack)、向量(Vector) 、位集合(Bitset)以及哈希表(Hashtable)等类来表示相应的数据结构。
　　图1.1给出了java.util包的基本层次结构图。下面我们将具体介绍其中几个重要的类。
　　　　　　　　　　　┌java.util.BitSet
　　　　　　　　　　　│java.util.Calendar
　　　　　　　　　　　│　　　　　　└java.util.GregorianCalendar
　　　　　　　　　　　│java.util.Date
　　　　　　　　　　　│java.util.Dictionary
　　　　　　　　　　　│　　　　　　└java.util.Hashtable
　　　　　　　　　　　│　　　　　　　　　　　　　└java.util.Properties
　　　　　　　　　　　│java.util.EventObject
　　　　　　　　　　　│java.util.ResourceBundle
　　　　　　　┌普通类┤　　　　　　├java.util.ListResourceBundle
　　　　　　　│　　　│　　　　　　└java.util.PropertyResourceBundle
　　　　　　　│　　　│java.util.Local
　　　　　　　│　　　│java.util.Observable
　　　　　　　│　　　│java.util.Random
　　　　　　　│　　　│java.util.StringTokenizer
　　　　　　　│　　　│java.util.Vector
　　　　　　　│　　　│　　　　　　└java.util.Stack
　　Java.util┤　　　  └java.util.TimeZone
　　　　　　　│　　　　　　　　　　└java.util.SimpleTimeZone
　　　　　　　│　　　┌java.util.Enumeration
　　　　　　　├接　口┤java.util.EventListener
　　　　　　　│　　　└java.util.Observer
　　　　　　　│　　　┌java.util.EmptyStackException
　　　　　　　└异常类┤java.util.MissingResourceException
　　　　　　　　　　　│java.util.NoSuchElementException
　　　　　　　　　　　└java.util.TooManyListenersException
　　　　　　　图1.1 java.util包的基本层次结构

2.1.2.1.1 日期类Date

Java在日期类中封装了有关日期和时间的信息，用户可以通过调用相应的方法来获取系统时间或设置日期和时间。Date类中有很多方法在JDK1.0公布后已经过时了，在8.3中我们将介绍JDK1.0中新加的用于替代Date的功能的其它类。
　　在日期类中共定义了六种构造函数。
　　(1)public Date()
　　创建的日期类对象的日期时间被设置成创建时刻相对应的日期时间。
　　例 Date today=new Date()；//today被设置成创建时刻相对应的日期时间。
　　(2)public Date (long date)
　　long 型的参数date可以通过调用Date类中的static方法parse(String s)来获得。
　　例 long l=Date.parse("Mon 6 Jan 1997 13:3:00");
　　　　Date day=new Date(l);
　　//day中时间为1997年 1月6号星期一，13:3:00。
　　(3)public Date(String s)
　　按字符串s产生一日期对象。s的格式与方法parse中字符串参数的模式相同。
　　例 Date day=new Date("Mon 6 Jan 1997 13:3:00");
　　//day 中时间为1997年1月6号星期一，13:3:00.
　　(4)public Date(int year,int month,int date)
　　(5)public Date(int year,int month,int date,int hrs,int min)
　　(6)public Date(int year,int month,int date,int hrs,int min,int sec)
　　按给定的参数创建一日期对象。
　　参数说明：
　　year的值为：需设定的年份-1900。例如需设定的年份是1997则year的值应为97，即1997-1900的结果。所以Date中可设定的年份最小为1900；
　　month的值域为0～11，0代表1月，11表代表12月；
　　date的值域在1～31之间；
　　hrs的值域在0～23之间。从午夜到次日凌晨1点间hrs=0，从中午到下午1点间hrs=12；
　　min和sec的值域在0～59之间。
　　例 Date day=new Date(11,3,4);
　　//day中的时间为：04-Apr-11 12:00:00 AM
另外，还可以给出不正确的参数。
　　例　设定时间为1910年2月30日，它将被解释成3月2日。
　　Date day=new Date(10,1,30,10,12,34);
　　System.out.println("Day's date is:"+day);
　　//打印结果为：Day's date is:Web Mar 02 10:13:34 GMT+08:00 1910
　　下面我们给出一些Date类中常用方法。
　　(1)public static long UTC(int year,int month,int date,int hrs. int min,int sec)
　　该方法将利用给定参数计算UTC值。UTC是一种计时体制，与GMT(格林威治时间)的计时体系略有差别。UTC计时体系是基于原子时钟的，而GTMT计时体系是基于天文学观测的。计算中使用的一般为GMT计时体系。
　　(2)public static long parse(String s)
　　该方法将字符串s转换成一个long型的日期。在介绍构造方法Date(long date)时曾使用过这个方法。
　　字符串s有一定的格式，一般为：
　　(星期 日 年 时间GMT+时区)
　　若不注明时区，则为本地时区。
　　(3)public void setMonth(int month)
　　(4)public int getMonth()
　　这两个方法分别为设定和获取月份值。
　　获取的月份的值域为0～11，0代表1月，11代表12月。
　　(5)public String toString()
　　(6)public String toLocalString()
　　(7)public String toGMTString()
　　将给定日期对象转换成不同格式的字符串。它们对应的具体的格式可参看例子8.1。
　　(8)public int getTimezoneOffset()
　　该方法用于获取日期对象的时区偏移量。
　　例8.1中对上面介绍的Date类中的基本方法进行了具体的应用，并打印了相应的结果。由于使用了一些过时的方法，所以编译时会有警告信息。另外，由于本例中的时间表示与平台有关，不同的JDK版本对此处理不完全相同，因此不同版本的JDK执行本例的结果可能有细微差异。
　　例1.1 DateApp.java
　　import java.lang.System;
　　import java.util.Date;
　　public class DateApp{
　　　public static void main(String args[]){
　　　　Date today=new Date();
　　　　//today中的日期被设成创建时刻的日期和时间，假设创建时刻为1997年3月
　　　　//23日17时51分54秒。
　　　　System.out.println("Today's date is "+today);
　　　　//返回一般的时间表示法，本例中结果为
　　　　//Today's date is Fri May 23 17:51:54 1997
　　　　System.out.println("Today's date(Internet GMT)is:"
　　　　　+today.toGMTString());
　　　　//返回结果为GMT时间表示法，本例中结果为
　　　　//Today's date(Internet GMT)is: 23 May 1997 09:51:54:GMT
　　　　System.out.println("Today's date(Locale) is:"
　　　　　+today.toLocaleString());
　　　　//返回结果为本地习惯的时间表示法，结果为
　　　　//Today's date(Locale)is:05/23/97 17:51:54
　　　　System.out.println("Today's year is: "+today.getYear());
　　　　System.out.println("Today's month is: "+(today.getMonth()+1));
　　　　System.out.println("Today's date is: "+today.getDate());
　　　　//调用Date类中方法，获取年月日的值。
　　　　//下面调用了不同的构造方法来创建Date类的对象。
　　　　Date day1=new Date(100,1,23,10,12,34);
　　　　System.out.println("Day1's date is: "+day1);
　　　　Date day2=new Date("Sat 12 Aug 1996 13:3:00");
　　　　System.out.println("Day2's date is: "+day2);
　　　　long l= Date.parse("Sat 5 Aug 1996 13:3:00 GMT+0800");
　　　　Date day3= new Date(l);
　　　　System.out.println("Day3's date(GMT)is: "+day3.toGMTString());
　　　　System.out.println("Day3's date(Locale)is: "
　　　　　+day3.toLocaleString());
　　　　System.out.println("Day3's time zone offset is:"
　　　　　+day3.getTimezoneOffset());
　　　}
　　}
　　运行结果(JDK1.3版，与原文不同，原文是JDK1.0版)：
　　E:\java\tutorial\java01>java DateApp
　　Today's date is Thu Dec 27 17:58:16 CST 2001
　　Today's date(Internet GMT)is:27 Dec 2001 09:58:16 GMT
　　Today's date(Locale) is:2001-12-27 17:58:16
　　Today's year is: 101
　　Today's month is: 12
　　Today's date is: 27
　　Day1's date is: Wed Feb 23 10:12:34 CST 2000
　　Day2's date is: Fri Aug 12 13:03:00 CST 1996
　　Day3's date(GMT)is: 5 Aug 1996 05:03:00 GMT
　　Day3's date(Locale)is: 1996-8-5 13:03:00
　　Day3's time zone offset is:-480
　　E:\java\tutorial\java01>

2.1.2.1.2 日历类Calendar

在早期的JDK版本中，日期(Date)类附有两大功能：(1)允许用年、月、日、时、分、秒来解释日期：(2)允许对表示日期的字符串进行格式化和句法分析。在JDK1.1中提供了类Calendar来完成第一种功能，类DateFormat来完成第二项功能。dateFormat是java.text包中的一个类。与Date类有所不同的是，DateFormat类接受用各种语言和不同习惯表示的日期字符串。本节将介绍java.util包中的类Calendar及其它新增加的相关的类。
　　类Calendar是一个抽象类，它完成日期(Date)类和普通日期表示法(即用一组整型域如YEAR，MONTH，DAY，HOUR表示日期)之间的转换。
　　由于所使用的规则不同，不同的日历系统对同一个日期的解释有所不同。在JDK1.1中提供了Calendar类一个子类GregorianCalendar??它实现了世界上普遍使用的公历系统。当然用户也可以通过继承Calendar类，并增加所需规则，以实现不同的日历系统。
　　第GregorianCalendar继承了Calendar类。本节将在介绍类GregorianCalendar的同时顺带介绍Calendar类中的相关方法。
　　类GregorianCalendar提供了七种构造函数：
　　(1)public GregorianCalendar()
　　创建的对象中的相关值被设置成指定时区，缺省地点的当前时间，即程序运行时所处的时区、地点的当前时间。
　　(2)public GregorianCalendar(TimeZone zone)
　　创建的对象中的相关值被设置成指定时区zone，缺省地点的当前时间。
　　(3)public GregorianCalendar(Locale aLocale)
　　创建的对象中的相关值被设置成缺省时区，指定地点aLocale的当前时间。
　　(4)public GregorianCalendar(TimeZone zone,Local aLocale)
　　创建的对象中的相关值被设置成指定时区，指定地点的当前时间。
　　上面使用到的类TimeZone的性质如下：
　　TimeZone是java.util包中的一个类，其中封装了有关时区的信息。每一个时区对应一组ID。类TimeZone提供了一些方法完成时区与对应ID两者之间的转换。
　　(Ⅰ)已知某个特定的ID，可以调用方法
　　public static synchronized TimeZone getTimeZone(String ID)
来获取对应的时区对象。
　　例 太平洋时区的ID为PST，用下面的方法可获取对应于太平洋时区的时区对象：
　　TimeZone tz=TimeZone.getTimeZone("PST");
　　调用方法getDefault()可以获取主机所处时区的对象。
　　TimeZone tz=TimeZone.getDefault();
　　(Ⅱ)调用以下方法可以获取时区的ID
　　■public static synchronized String[] getavailableIDs(int rawOffset)
　　根据给定时区偏移值获取ID数组。同一时区的不同地区的ID可能不同，这是由于不同地区对是否实施夏时制意见不统一而造成的。
　　例String s[]=TimeZone.getAvailableIDs(-7*60*60*1000);
　　打印s，结果为s[0]=PNT，s[1]=MST
　　■public static synchronized String[] getAvailableIDs()
　　获取提供的所有支持的ID。
　　■public String getID()
　　获取特定时区对象的ID。
　　例 TimeZone tz=TimeZone.getDefault();
　　String s=tz.getID();
　　打印s，结果为s=CTT。
　　上面使用类的对象代表了一个特定的地理、政治或文化区域。Locale只是一种机制，它用来标识一类对象，Local本身并不包含此类对象。
　　要获取一个Locale的对象有两种方法：
　　(Ⅰ)调用Locale类的构造方法
　　Locale(String language,String country)
　　Locale(String language,String country,String variant)
　　参数说明：language??在ISO-639中定义的代码，由两个小写字母组成。
　　　　　　　country??在ISO-3166中定义的代码，由两个大写字母组成。
　　　　　　　variant??售货商以及特定浏览器的代码，例如使用WIN代表Windows。
　　(Ⅱ)调用Locale类中定义的常量
　　Local类提供了大量的常量供用户创建Locale对象。
　　例 Locale.CHINA
　　　　为中国创建一个Locale的对象。
　　类TimeZone和类Locale中的其它方法，读者可查阅API。
　　(5)public GregorianCalendar(int year,int month,int date)
　　(6)public GregorianCalendar(int year,int month,int date,int hour,int minute)
　　(7)public GregorianCalendar(int year,int month,int date,int hour,int minute,int second)
　　用给定的日期和时间创建一个GregorianCalendar的对象。
　　参数说明：
　　year-设定日历对象的变量YEAR；month-设定日历对象的变量MONTH；
　　date-设定日历对象的变量DATE；hour-设定日历对象的变量HOUR_OF_DAY；
　　minute-设定日历对象的变量MINUTE；second-设定日历对象的变量SECOND。
　　与Date类中不同的是year的值没有1900这个下限，而且year的值代表实际的年份。month的含义与Date类相同，0代表1月，11代表12月。
　　例 GregorianCalendar cal=new GregorianCalendar(1991,2,4)
　　cal的日期为1991年3月4号。
　　除了与Date中类似的方法外，Calendar类还提供了有关方法对日历进行滚动计算和数学计算。计算规则由给定的日历系统决定。进行日期计算时，有时会遇到信息不足或信息不实等特殊情况。Calendar采取了相应的方法解决这些问题。当信息不足时将采用缺省设置，在GregorianCalendar类中缺省设置一般为YEAR=1970,MONTH=JANUARY,DATE=1。
　　当信息不实时，Calendar将按下面的次序优先选择相应的Calendar的变量组合，并将其它有冲突的信息丢弃。
　　MONTH+DAY_OF_MONTH
　　MONTH+WEEK_OF_MONTH+DAY_OF_WEEK
　　MONTH+DAY_OF_WEEK_OF_MONTH+DAY_OF_WEEK
　　DAY_OF+YEAR
　　DAY_OF_WEEK_WEEK_OF_YEAR
　　HOUR_OF_DAY

2.1.2.1.3 随机数类Random

　Java实用工具类库中的类java.util.Random提供了产生各种类型随机数的方法。它可以产生int、long、float、double以及Goussian等类型的随机数。这也是它与java.lang.Math中的方法Random()最大的不同之处，后者只产生double型的随机数。
　　类Random中的方法十分简单，它只有两个构造方法和六个普通方法。
　　构造方法：
　　(1)public Random()
　　(2)public Random(long seed)
　　Java产生随机数需要有一个基值seed，在第一种方法中基值缺省，则将系统时间作为seed。
　　普通方法：
　　(1)public synonronized void setSeed(long seed)
　　该方法是设定基值seed。
　　(2)public int nextInt()
　　该方法是产生一个整型随机数。
　　(3)public long nextLong()
　　该方法是产生一个long型随机数。
　　(4)public float nextFloat()
　　该方法是产生一个Float型随机数。
　　(5)public double nextDouble()
　　该方法是产生一个Double型随机数。
　　(6)public synchronized double nextGoussian()
　　该方法是产生一个double型的Goussian随机数。
　　例1.2 RandomApp.java。
　　//import java.lang.*;
　　import java.util.Random;
　　public class RandomApp{
　　　public static void main(String args[]){
　　　　Random ran1=new Random();
　　　　Random ran2=new Random(12345);
　　　　//创建了两个类Random的对象。
　　　　System.out.println("The 1st set of random numbers:");
　　　　System.out.println("\t Integer:"+ran1.nextInt());
　　　　System.out.println("\t Long:"+ran1.nextLong());
　　　　System.out.println("\t Float:"+ran1.nextFloat());
　　　　System.out.println("\t Double:"+ran1.nextDouble());
　　　　System.out.println("\t Gaussian:"+ran1.nextGaussian());
　　　　//产生各种类型的随机数
　　　　System.out.print("The 2nd set of random numbers:");
　　　　for(int i=0;i<5;i++){
　　　　　System.out.println(ran2.nextInt()+" ");
　　　　　if(i==2) System.out.println();
　　　　　//产生同种类型的不同的随机数。
　　　　　System.out.println();//原文如此
　　　　}
　　　}
　　}
　　运行结果：
　　E:\java01>java RandomApp
　　The 1st set of random numbers:
　　　　Integer:-173899656
　　　　Long:8056223819738127077
　　　　Float:0.6293638
　　　　Double:0.7888394520265607
　　　　Gaussian:0.5015701094568733
　　The 2nd set of random numbers:1553932502
　　-2090749135
　　-287790814
　　-355989640
　　-716867186
　　E:\java01>

2.1.2.1.4 向量类Vector

Java.util.Vector提供了向量(Vector)类以实现类似动态数组的功能。在Java语言中。正如在一开始就提到过，是没有指针概念的，但如果能正确灵活地使用指针又确实可以大大提高程序的质量，比如在C、C++中所谓“动态数组”一般都由指针来实现。为了弥补这点缺陷，Java提供了丰富的类库来方便编程者使用，Vector类便是其中之一。事实上，灵活使用数组也可完成向量类的功能，但向量类中提供的大量方法大大方便了用户的使用。
　　创建了一个向量类的对象后，可以往其中随意地插入不同的类的对象，既不需顾及类型也不需预先选定向量的容量，并可方便地进行查找。对于预先不知或不愿预先定义数组大小，并需频繁进行查找、插入和删除工作的情况，可以考虑使用向量类。
　　向量类提供了三种构造方法：
　　public vector()
　　public vector(int initialcapacity,int capacityIncrement)
　　public vector(int initialcapacity)
　　使用第一种方法，系统会自动对向量对象进行管理。若使用后两种方法，则系统将根据参数initialcapacity设定向量对象的容量(即向量对象可存储数据的大小)，当真正存放的数据个数超过容量时，系统会扩充向量对象的存储容量。参数capacityIncrement给定了每次扩充的扩充值。当capacityIncrement为0时，则每次扩充一倍。利用这个功能可以优化存储。
　　在Vector类中提供了各种方法方便用户使用：
　　■插入功能
　　(1)public final synchronized void addElement(Object obj)
　　将obj插入向量的尾部。obj可以是任何类的对象。对同一个向量对象，可在其中插入不同类的对象。但插入的应是对象而不是数值，所以插入数值时要注意将数值转换成相应的对象。
　　例 要插入一个整数1时，不要直接调用v1.addElement(1)，正确的方法为：
　　Vector v1=new Vector();
　　Integer integer1=new Integer(1);
　　v1.addElement(integer1);
　　(2)public final synchronized void setElementAt(object obj,int index)
　　将index处的对象设成obj，原来的对象将被覆盖。
　　(3)public final synchronized void insertElementAt(Object obj,int index)
　　在index指定的位置插入obj，原来对象以及此后的对象依次往后顺延。
　　■删除功能
　　(1)public final synchronized void removeElement(Object obj)
　　从向量中删除obj。若有多个存在，则从向量头开始试，删除找到的第一个与obj相同的向量成员。
　　(2)public final synchronized void removeAllElement()
　　删除向量中所有的对象。
　　(3)public final synchronized void removeElementlAt(int index)
　　删除index所指的地方的对象。
　　■查询搜索功能
　　(1)public final int indexOf(Object obj)
　　从向量头开始搜索obj ,返回所遇到的第一个obj对应的下标，若不存在此obj，返回-1。
　　(2)public final synchronized int indexOf(Object obj,int index)
　　从index所表示的下标处开始搜索obj。
　　(3)public final int lastIndexOf(Object obj)
　　从向量尾部开始逆向搜索obj。
　　(4)public final synchronized int lastIndexOf(Object obj,int index)
　　从index所表示的下标处由尾至头逆向搜索obj。
　　(5)public final synchronized Object firstElement()
　　获取向量对象中的首个obj。
　　(6)public final synchronized Object lastelement()
　　获取向量对象中的最后一个obj。
　　了解了向量的最基本的方法后，我们来看一下例8.3VectorApp.java。
　　例1.3 VectorApp.java。
　　import java.util.Vector;
　　import java.lang.*;//这一句不应该要，但原文如此
　　import java.util.Enumeration;
　　public class VectorApp{
　　　public static void main(String[] args){
　　　　Vector v1=new Vector();
　　　　Integer integer1=new Integer(1);
　　　　v1.addElement("one");
　　　　//加入的为字符串对象
　　　　v1.addElement(integer1);
　　　　v1.addElement(integer1);
　　　　//加入的为Integer的对象
　　　　v1.addElement("two");
　　　　v1.addElement(new Integer(2));
　　　　v1.addElement(integer1);
　　　　v1.addElement(integer1);
　　　　System.out.println("The vector v1 is:\n\t"+v1);
　　　　//将v1转换成字符串并打印
　　　　v1.insertElementAt("three",2);
　　　　v1.insertElementAt(new Float(3.9),3);
　　　　System.out.println("The vector v1(used method insertElementAt()) is:\n\t "+v1);
　　　　//往指定位置插入新的对象，指定位置后的对象依次往后顺延
　　　　v1.setElementAt("four",2);
　　　　System.out.println("The vector v1(used method setElementAt()) is:\n\t "+v1);
　　　　//将指定位置的对象设置为新的对象
　　　　v1.removeElement(integer1);
　　　　//从向量对象v1中删除对象integer1由于存在多个integer1所以从头开始
　　　　//找，删除找到的第一个integer1
　　　　Enumeration enum=v1.elements();
　　　　System.out.print("The vector v1(used method removeElement())is:");
　　　　while(enum.hasMoreElements())
　　　　System.out.print(enum.nextElement()+" ");
　　　　System.out.println();
　　　　//使用枚举类(Enumeration)的方法来获取向量对象的每个元素
　　　　System.out.println("The position of object 1(top-to-bottom):"
　　　　　+ v1.indexOf(integer1));
　　　　System.out.println("The position of object 1(tottom-to-top):"
　　　　　+v1.lastIndexOf(integer1));
　　　　//按不同的方向查找对象integer1所处的位置
　　　　v1.setSize(4);
　　　　System.out.println("The new vector(resized the vector)is:"+v1);
　　　　//重新设置v1的大小，多余的元素被行弃
　　　}
　　}
　　运行结果：
　　E:\java01>java VectorApp
　　The vector v1 is:
　　　　　[one, 1, 1, two, 2, 1, 1]
　　The vector v1(used method insertElementAt()) is:
　　　　　[one, 1, three, 3.9, 1, two, 2, 1, 1]
　　The vector v1(used method setElementAt()) is:
　　　　　[one, 1, four, 3.9, 1, two, 2, 1, 1]
　　The vector v1(used method removeElement())is:one four 3.9 1 two 2 1 1
　　The position of object 1(top-to-bottom):3
　　The position of object 1(tottom-to-top):7
　　The new vector(resized the vector)is:[one, four, 3.9, 1]
　　E:\java01>
　　从例1.3运行的结果中可以清楚地了解上面各种方法的作用，另外还有几点需解释。
　　(1)类Vector定义了方法
　　public final int size()
　　此方法用于获取向量元素的个数。它的返回值是向是中实际存在的元素个数，而非向量容量。可以调用方法capactly()来获取容量值。
　　方法：
　　public final synchronized void setsize(int newsize)
　　此方法用来定义向量大小。若向量对象现有成员个数已超过了newsize的值，则超过部分的多余元素会丢失。
　　(2)程序中定义了Enumeration类的一个对象
　　Enumeration是java.util中的一个接口类，在Enumeration中封装了有关枚举数据集合的方法。
　　在Enumeration中提供了方法hawMoreElement()来判断集合中是束还有其它元素和方法nextElement()来获取下一个元素。利用这两个方法可以依次获得集合中元素。
　　Vector中提供方法：
　　public final synchronized Enumeration elements()
　　此方法将向量对象对应到一个枚举类型。java.util包中的其它类中也大都有这类方法，以便于用户获取对应的枚举类型。
转发至微博