国产精品国产亚洲伊人久久,亚洲一区二区三区四区在线观看,国产精品麻豆久久

java中的transient(转蝲)

肖麦 — Sat, 10 Oct 2009 02:03:00 GMT

Java语言的关键字�Q�用来表�C�Z��个域不是该对象串行化的一部分。当一个对象被串行化的时候，transient型变量的��g��包括在串行化的表�C�Z��Q�然而非transient型的变量是被包括�q�去的。还是不大明白�?br />     后来�Q�终于搜到这��文章，写得很详�l�。Be Careful With Transient Data
    怕万一�q�篇文章链接失效�Q�收藏�v来。Be Careful With Transient Data

    �l�于明白了�?br />     当串行化某个对象�Ӟ��如果该对象的某个变量是transient�Q�那么这个变量不会被串行化进厅R��也��是��_��假设某个�cȝ��成员变量是transient�Q�那么当通过ObjectOutputStream把这个类的某个实例保存到��盘上时�Q�实际上transient变量的值是不会保存的。因为当从磁盘中��d��q�个对象的时候，对象的该变量会没有被赋倹{�?br />     另外�q�篇文章�q�提刎ͼ�当从��盘中读出某个类的实例时�Q�实际上�q�不会执行这个类的构造函敎ͼ�而是��d��q�个�cȝ��实例的状态，�q�且把这个状态付�l�这个类的对象。这�Ҏ(gu��)��以前��g��不知道�?br />
Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1064847

Be Careful With Transient Data

(原文来自http://www.devx.com/tips/Tip/13726)

Expertise: Intermediate
Language: Java
January 28, 2000
Be Careful With Transient Data
Java's serialization provides an elegant, and easy to use mechanism for making an object's state persistent. While controlling object serialization, we might have a particular object data member that we do not want the serialization mechanism to save.

To turn off serialization on a certain field of an object, we tag that field of the class of our object with the Java's "transient" keyword. This, to low-level parts of the Java virtual machine, is an indication that the transient variable is not part of the persistent state of an object.

First, let's have some backgrounder code with Java's serialization.
Suppose we define a class as:

public class LoggingInfo implements java.io.Serializable
{
private Date loggingDate = new Date();
private String uid;
private transient String pwd;

LoggingInfo(String user, String password)
{
uid = user;
pwd = password;
}
public String toString()
{
String password=null;
if(pwd == null)
{
password = "NOT SET";
}
else
{
password = pwd;
}
return "logon info: "n " + "user: " + uid +
""n logging date : " + loggingDate.toString() +
""n password: " + password;
}
}
Now we can create an instance of this class and serialize it, and write the serialized object to disk as in:
LoggingInfo logInfo = new LoggingInfo("MIKE", "MECHANICS");
System.out.println(logInfo.toString());
try
{
ObjectOutputStream o = new ObjectOutputStream(
new FileOutputStream("logInfo.out"));
o.writeObject(logInfo);
o.close();
}
catch(Exception e) {//deal with exception}
To read the object back, we can write
try
{
ObjectInputStream in =new ObjectInputStream(
new FileInputStream("logInfo.out"));
LoggingInfo logInfo = (LoggingInfo)in.readObject();
System.out.println(logInfo.toString());
}
catch(Exception e) {//deal with exception}
If we run this code, we notice that the read-back object prints password as "NOT SET". This is exactly the effect we should have expected when we declared the pwd field as transient.

Now, let's see a potential problem that careless treatment of transient fields may cause. Suppose we modify our class definition and provide default values for the transient field, say we write:

public class GuestLoggingInfo implements java.io.Serializable
{
private Date loggingDate = new Date();
private String uid;
private transient String pwd;

GuestLoggingInfo()
{
uid = "guest";
pwd = "guest";
}
public String toString()
{
//same as above
}
}
Now, if we serialize an instance of GuestLoggingInfo, write it to disk, and read it back, we still see that the read-back object prints password as "NOT SET". In effect, the process of reading back (de-serializing) totally ignores the constructor of GuestLoggingInfo. So what happened?

The answer lies in the fact that the initialization code is not called because we are not initializing, in other words, we are not constructing a brand new object, but loading back the persistent state of an object of a class, and assigning that state to another object of the same class. Declaring the pwd field as transient, excludes the data for that

肖麦 2009-10-10 10:03 发表评论

Java中finally关键字的使用

肖麦 — Fri, 28 Mar 2008 08:59:00 GMT

与其他语�a�的模型相比，finally 关键字是�?Java 异常处理模型的最佌��充。finally �l�构使代码��M��执行�Q�而不��有无异常发生。��?finally 可以�l�护对象的内部状态，�q�可以清理非内存资源�?如果没有 finally�Q��?zh��n)�的代码就会很费解。例如，下面的代码说明，在不使用 finally 的情况下�(zh��n)�必��d��何编写代码来释放非内存资源：

　　import java.net.*;
　　import java.io.*;

     class WithoutFinally
　{
　　     public void foo() throws IOException
　　{
　　//在�Q一个空闲的端口上创��Z��个套接字
　　ServerSocket ss = new ServerSocket(0);
　　try
        {
　　      Socket socket = ss.accept();
　　      //此处的其他代�?..
　　}
　　catch (IOException e)
       {
　　      ss.close();                                              //1
　　      throw e;
　　}
　　//...
　　ss.close();                                                //2
　　}
　}

　　�q�段代码创徏了一个套接字�Q��ƈ调用 accept �Ҏ(gu��)��。在退��Ҏ(gu��)��之前�Q��?zh��n)�必须关闭此套接字�Q�以避免资源漏洞。�ؓ了完成这一��d��Q�我们在 //2 处调�?close�Q�它是该�Ҏ(gu��)��的最后一条语句。但是，如果 try 块中发生一个异�怼�怎么样呢�Q�在�q�种情况下，//2 处的 close 调用永远不会发生。因此，�(zh��n)�必��L��莯��个异常，�q�在重新发出�q�个异常之前�?//1 处插入对 close 的另一个调用。这样就可以��保在退��Ҏ(gu��)��之前关闭套接字�?/p>

　　�q�样�~�写代码既麻烦又易于出错�Q�但在没�?finally 的情况下�q�是必不可少的。不�q�的是，在没�?finally 机制的语�a�中，�E�序员就可能忘记以这�U�方式组�l�他们的代码�Q�从而导致资源漏�z�。Java 中的 finally 子句解决了这个问题。有�?finally�Q�前面的代码��可以重写�ؓ以下的�Ş式：

　　import java.net.*;
　　import java.io.*;

class WithFinally
{
　public void foo2() throws IOException
　{
　　//在�Q一个空闲的端口上创��Z��个套接字
　　ServerSocket ss = new ServerSocket(0);
　　try
        {
　　     Socket socket = ss.accept();
　　     //此处的其他代�?..
　　}
　　finally
        {
　　      ss.close();
　　}
　}
}

　　finally 块确�?close �Ҏ(gu��)��总被执行�Q�而不��?try 块内是否发出异常。因此，可以��保在退��Ҏ(gu��)��之前��M��调用 close �Ҏ(gu��)��。这��h��可以确信套接字被关闭�ƈ且�?zh��n)�没有泄漏资源。在此方法中不需要再有一�?catch 块。在�W�一个示例中提供 catch 块只是�ؓ了关闭套接字�Q�现在这是通过 finally 关闭的。如果�?zh��n)��实提供了一�?catch 块，�?finally 块中的代码在 catch 块完成以后执行�?/p>

　　finally 块必��M�� try �?try/catch 块配合��用。此外，不可能退�?try 块而不执行�?finally 块。如�?finally 块存在，则它��M��执行。（无论从那点看�Q�这个陈�q�都是正��的。有一�U�方法可以退�?try 块而不执行 finally 块。如果代码在 try 内部执行一�?System.exit(0); 语句�Q�则应用�E�序�l�止而不会执�?finally 执行。另一斚w��Q�如果�?zh��n)��?try 块执行期间拨掉电(sh��)源，finally 也不会执行。）

肖麦 2008-03-28 16:59 发表评论

Java�?异常机制"的深入研�I?

肖麦 — Thu, 27 Mar 2008 01:31:00 GMT

　Java�?异常机制"的深入研�I?转蝲)

　　作者：陈健�?发文旉��Q?004.03.10

　　�׃��本文旨在探讨Java"异常机制"的深层原理，因此关于"异常"的��用方法都不做详细说明。首先看一�D�非常熟�(zh��n)�的用于打开一个文件的C�E�序�D�：

　　FILE *fp;

　　fp=fopen(filename,"rw");

　　if(fp==NULL){

　　printf("cannot open file\n");

　　exit(0);

　　}

　　在这�D늨�序中�Q�if条�g语句中的一�D는�来处理没有找到指定文�Ӟ��或者其它原因无法正��打开指定文�g。可是如果遇��C��个责��d��不强的程序员�Q�他可能认�ؓ出现找不到文件的可能性很��，或者由于思�\集中在程序功能的实现上而忘��C��处理�q�种情况。这时程序同样可以正��编译，而且一般情况下也不会出现问题。但此时�q�段�E�序可以肯定说是不够健壮的，而且一旦这�D늨�序发生了错误也会让程序员很难发现错误出在哪里。在C语言以及其它大多数高�U�语�a�中都可以丑և�很多�q�种例子�?/p>

　　也就是一个函数在使用的时候，可能会出现�ƈ没有辑ֈ��q�个函数的��用目的的情况�Q�哪怕在�q�段�E�序的特定��用环境下发生�q�种异常情况的可能性只有万分之一。常用处理的�Ҏ(gu��)��是�Q�程序员在需要��用某个函数时必须充分了解可能会有什么原因导致该函数不能正确执行�Q�然后加入相应的条�g判断语句来进行处理。后面将有一个例子说明这个问题�?/p>

　　而Java�?异常机制"��是在处理上�q�问题中�l�了�E�序员非常简单而灵�zȝ��方式。一般来��_��其它高��语言主要是让函数使用者来��x��该函数可能会出现的异常情况，而java则是把这件事情交�l�方�?和函数对应的概念�Q�在Java中称�Ҏ(gu��)��)的设计者来做。这对于�Ҏ(gu��)��的��用者来说带来的方便是不会因��d��不强�Q�或者办事丢三那四，会忘了在使用�Ҏ(gu��)��时处理可能发生的异常情况。而麻烦就是，在��用一个可能会发生异常的方法时�Q�绝对不能视而不见，而必��d��出相应的处理。也��是说象上述C�E�序�D�中�Q�如果忘了if�E�序块，�q�个�E�序甚至�q�能蒙过一个外行上司，但当使用Java来完成这个功能时�Q�只要用到的�Ҏ(gu��)��使用�?异常"机制�Q�如果不对可能��?异常"的方法进行相应处理，java�~�译器是不会让其通过的�?/p>

　　一�?异常�c?的组�l��Ş�?/strong>

　　Java�pȝ��c�M��的方法��生的异常都被�l�织�?异常�c?�Q�还有Error�c�，不在本文讨论范围�Q�，此方法和它相关的"异常�c?通过throws关键字关联在一��P��q�且�q�些�c�都必须是Exception�cȝ��子类。�Q何一个自己开发的�cȝ��Ҏ(gu��)��中如果可能会产生某种异常�Q�也可以��这�U�异常组�l�成一�?异常�c?�Q�但�q�个"异常�c?同样必须是Exception的子�c�，或孙子类�{�等�?/p>
　　�?�Q?/p>
　　/*isLegal于检查数据是否合法，�?gt;0时视为合法，�q�回合法��|��

　　*否则视�ؓ不合法，抛出"异常"�?/

　　int isLegal(int dt) throws LowZeroException//�q�种定义本文中均�U�Cؓ�Ҏ(gu��)��?异常"�?/p>
　　{　 //�q�throws建立了关�?/p>
　　 if(dt>=0){

　　 return data;

　　 }

　　 else

　　 throw new LowZeroException();

　　}

　　/*自已写的异常�c�，�l�承自Exception*/

　　class LowZeroException extends Exception

　　{

　　 public LowZeroException(){

　　 super();

　　 }

　　}

　　仔细观察�Ҏ(gu��)��isLegal()�Q�它体现出的最值得注意的特色是�Q�它有两�U�方式的函数出口�Q�一�U�是通过return语句�Q�返回的是方法本�w�定义的�c�d��的实例，另一�U�是通过throw�Q�返回的�?异常�c?的对象实例，Java中称之�ؓ抛出"异常"。对比一下C中如何处理同��L��问题的：

　　int isLegal(int dt) {

　　 if(dt>=0){

　　 return data;

　　 }

　　 else

　　 return -1;//通过一个特定值来表明出错

　　}

　　�׃��C只能通过return�q�回函数��|��所以在处理异常情况时则可能通过以上方式来处理。当然这��p��求isLegal()函数的��用者必��ȝ��道函��C��使用�q�回�?1来表明出��C��合法数据的情��c�?/p>
　　�Ҏ(gu��)��q�两�U�处理方法，可以知道java�?异常机制"把处理异�怺�件的职能和方法本�w�的职能通过两个不同出口分离开来�?/p>
　　所有这�?异常�c?独立于它具体服务的方法被�l�一�l�织成一个类树�?异常机制"��好比高校的后勤�C�会化一��P��通过后勤�C�会化将学校的教学职能和学校的后勤保障分��d��来，�q�且后勤集团的组�l��Ş式也是独立于学校��M��的。事实证明，�q�种�l�织方式不仅提高了服务效率，也提高了服务质量。整个Java体系中的"异常�c?�l�织形式如图1所�C�：

　　

　　在例1中的isLegal()�Ҏ(gu��)��如果在调用过�E�中没有能正常返回整形数�Q�而是�?异常"产生点��生了"异常"对象�Q�那么这�?异常"对象��p��来接�Ӟ��q�处理它呢？以下��来解答�q�个问题�?/p>
　　二�?异常"的处理过�E?/strong>

　　Java中由try…catch语法来处�?异常"�Q�将兌��?异常�c?的方法包含在try{}�E�序块中�Q�catch(){}关键字可以��用�Ş参，用于和方法��生的"异常"对象�l�合。当调用某个�Ҏ(gu��)��Ӟ��引�v异常事�g发生的条件成立，便会抛出"异常"�Q�原来的�E�序��程��会在此�Ҏ(gu��)��处中断，然后try模块后紧跟的catch中的"形参"和此异常对象完成了结合，�l�而进入了catch模块中运行。具体过�E��D例说明：

　　�?�Q?/p>
　　/*��关联有异常的方法包含在try模块�?/

　　int myMethod(int dt){

　　int data = 0;

　　try{

　　 int data = isLegal(dt);

　　}catch(LowZeroException e){

　　 System.out.println("发生数据错误�Q?);

　　}

　　 return data;

　　 }

　　三�?异常"的处理方�?/strong>

　　有两�U�方法处�?异常"�Q�第一�U�如�?�Q�将含有"异常"出口的方法直接放到try块中�Q�然后由紧随其后的catch块捕捉。第二种是不直接监听捕捉被引用方法的"异常"�Q�而是��这�?异常"兌��传递给引用�Ҏ(gu��)��Q�同时监听捕捉工作也相应向上传递�?/p>
　　�?�Q?/p>
　　int myMethod2(int dt)

　　{

　　 int data = 0;

　　try{

　　 data = myMethod(dt)

　　 }catch(LowZeroException e){

　　 System.out.println("发生数据错误�Q?);

　　 e.printStackTrace();

　　 }

　　 return data;

　　}

　　int myMethod(int dt) throws LowZeroException

　　{

　　 int data = isLegal(dt); //此处引用isLegal()�Ҏ(gu��)��Q�但�q�没有捕捉它�?异常"

　　return data;

　　}

　　从上例中可以看到�Ҏ(gu��)��myMethod()与它引用的方法isLegal()产生�?异常"LowZeroException建立了关联，也就是完成了��?异常"兌��的向上传递，此时的myMethod()�Ҏ(gu��)��体中虽然只有一个return�q�回语句�Q�但它事实上同样有两�U�方式的函数出口�Q�一�U�是由return�q�回的整形��|��另一�U�则是返回方法名中的throws关键字所指的"异常�c?的实例对象。相应的�Q�监听捕捉的工作交给了上一层方法myMethod2()。同��L��道理�Q�myMethod2()也可以将"异常"通过throws的关联��l�向上传递。这��L��话，一旦一�?异常"被捕捉到�Ӟ��q�个"异常"必有一个传递�\径，而如果我们在捕捉点的catch�E�序块中加入printStackTrace()�Ҏ(gu��)��Q�便能清楚的看到�q�个"异常"是怎样传递过来的。例如在�?如果�?异常"被捕捉到�Q�e.printStackTrace()打印出来的结果将是：

　　LowZeroException:

　　at Example.isLegal

　　at Example myMethod

　　at Example.myMethod2

　　at Example main

　　从上�l�果中我们可以看刎ͼ�从LowZeroException"异常"产生点，卛_��含throw new LowZeroException();子句的方法开始，然后一直追溯到产生当前�U�程的方法（注意�Q�printStackTrace()�q�不是追溯到捕捉点结束，而是��C�生当前线�E�的�Ҏ(gu��)��l�束�Q��?异常"产生点��生的LowZeroException"异常"对象�Q�首先被赋给了isLegal()兌��的LowZeroException�cȝ��无名引用�Q�然后��l�赋�l�myMethod()兌��的LowZeroException�cȝ��无名引用�Q�再�l�箋赋给myMethod2()中的catch块中的�Ş参e�Q�最后在�q�里被处理掉�Q�这�?异常"对象随即消失。可以说�Q�catch(){}��是"异常"对象的生命终�l�点�?/p>
　　另外�q�要注意一点，�Ҏ(gu��)��?异常"的关联可以一直向上传递，当传递到与main�Ҏ(gu��)��兌��后，卛_��main()�Ҏ(gu��)��的定义中使用了throws Exception�Q�这旉��了虚拟机没有其它�Ҏ(gu��)��能够引用main()�Ҏ(gu��)��Q�且在程序中可能看不到try…catch�E�序块，但�ƈ不会产生错误�Q�因为此时虚拟机会捕�?异常"�Q��ƈ且会默认的调用printStackTrace()�Ҏ(gu��)��打印�?异常"路径。��M��只要一个方法关联了"异常"�Q�可以将�q�个"异常"兌��向上传递，但是最�l�必��M��用catch来终�?异常"�Q�或者一直传递到main()�Ҏ(gu��)��交给Java虚拟机来�l�束"异常"对象的生命，否则是通不�q�编译的�?/p>
　　四、��?异常机制"的需要注意的几点

　　1.一个方法中可能会��生多�U�不同的异常�Q�你可以讄��多个"异常"抛出�Ҏ(gu��)��解决�q�个问题�?/p>
　　2."异常"对象从��生点产生后，到被捕捉后终止生命的全过�E�中�Q�实际上是一个传��D��E�，所以你可以�Ҏ(gu��)��需要，来合理的控制��到"异常"的粒度。例如在�?中，如果你�ƈ不需要知道具体��生的是LowZeroException"异常"�Q�那么你可以使用"异常"的公��q��c�Exception来结�?异常"对象�Q�即catch(Exception e){…}。同样在"异常"与方法关联的传递过�E�中�Q�也可以�Ҏ(gu��)��需要控制关�?异常"的粒度，即throws后面跟上异常对象的父�c�d��?/p>
　　3."异常机制"中还有一�U�特�D�情况――RuntimeException"异常�c?�Q�见�?�Q�，�q�个"异常�c?和它的所有子�c�都有一个特性，��是"异常"对象一产生��p��Java虚拟机直接处理掉�Q�即在方法中出现throw 子句的地方便被虚拟机捕捉了。因此凡是抛��U?�q�行时异�?的方法在被引用时�Q�不需要有try…catch语句来处�?异常"�?/p>

肖麦 2008-03-27 09:31 发表评论

java 日期格式�?转蝲)

肖麦 — Wed, 06 Jun 2007 08:47:00 GMT

java 日期格式�?br>import java.util.Date;
import java.text.DateFormat;

/**
* 格式化时间类
* DateFormat.FULL = 0
* DateFormat.DEFAULT = 2
* DateFormat.LONG = 1
* DateFormat.MEDIUM = 2
* DateFormat.SHORT = 3
* @author    Michael
* @version   1.0�Q?2007/03/09
*/

public class Test{
    public static void main(String []args){
        Date d = new Date();
        String s;

        /** Date�cȝ��格式: Sat Apr 16 13:17:29 CST 2006 */
        System.out.println(d);

        System.out.println("******************************************");

        /** getDateInstance() */
        /** 输出格式: 2006-4-16 */
        s = DateFormat.getDateInstance().format(d);
        System.out.println(s);

        /** 输出格式: 2006-4-16 */
        s = DateFormat.getDateInstance(DateFormat.DEFAULT).format(d);
        System.out.println(s);

        /** 输出格式: 2006�q?�?6�?星期�?*/
        s = DateFormat.getDateInstance(DateFormat.FULL).format(d);
        System.out.println(s);

        /** 输出格式: 2006-4-16 */
        s = DateFormat.getDateInstance(DateFormat.MEDIUM).format(d);
        System.out.println(s);

        /** 输出格式: 06-4-16 */
        s = DateFormat.getDateInstance(DateFormat.SHORT).format(d);
        System.out.println(s);

        /** 输出格式: 2006-01-01 00:00:00 */
        java.text.DateFormat format1 = new java.text.SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        s = format1.format(new Date());
        System.out.println(s);

        /** 输出格式: 2006-01-01 00:00:00 */
        System.out.println((new java.text.SimpleDateFormat("yyyy-MM-dd hh:mm:ss")).format(new Date()));

        /** 输出格式: 20060101000000***/
        java.text.DateFormat format2 = new java.text.SimpleDateFormat("yyyyMMddhhmmss");
        s = format2.format(new Date());
        System.out.println(s);
    }
}

肖麦 2007-06-06 16:47 发表评论

java文�g操作(一)

肖麦 — Thu, 05 Apr 2007 03:16:00 GMT
��、文件及��Z��文本的应�?
1、流式输入与输出

��行数据的输入、输出操作，Java中把不同的输入、输出源�Q�键盘、文件、网�l�连接等�Q�抽象�ؓ“��?#8221;�Q�Stream�Q�，有两�U�基本的��：输入��和输出��?/p>
�Q?�Q�输入流�Q�只能从中读取数据，而不能向其写出数据�?/p>
�Q?�Q�输出流�Q�只能向其写出数据，而不能从中读取数据�?/p>
��实际上指在计算机的输入与输��Z��间运动的数据的序列，��序列中的数据既可以是未�l�加工的原始二进制数据，也可以是�l�一定编码处理后�W�合某种格式规定的特定数据，如字�W�流序列、数字流序列�{��?/p>
1.1、字节流与字�W�流

按处理数据的�c�d��Q�流可以分�ؓ字节��和字符��，它们处理的信息的基本单位分别是字节（byte�Q�与字符�Q�char�Q��?/p>
输入字节��的�c�MؓInputStream

输出字节��的�c�MؓOutputStream

输入字符��的�c�MؓReader

输出字符��的�c�MؓWriter

如下表，�q�四个类是抽象类�Q�其他的输入输出��类都是它们的子�c�R�?/p>
字节��与字符��?/p>

字节��?/p>

字符��?/p>

输入

InputStream

Reader

输出

OutputStream

Writer

InputStream�c?br>

�Ҏ(gu��)��摘要

int available()
          �q�回此输入流�Ҏ(gu��)��的下一个调用方可以不受��d��C��此输入流��d��Q�或跌��Q�的字节数�?/td>

void close()
          关闭此输入流�q��放与该流兌��的所有系�l�资源�?/td>

void mark(int readlimit)
          在此输入��中标记当前的位�|��?/td>

boolean markSupported()
          ��试此输入流是否支持 mark �?reset �Ҏ(gu��)��?/td>

abstract int read()
          从输入流��d��下一个数据字节�?/td>

int read(byte[] b)
          从输入流中读取一定数量的字节�q�将其存储在�~�冲区数�l?b 中，以整数�Ş式返回实际读取的字节数�?/td>

int read(byte[] b, int off, int len)
          ��输入流中最�?len 个数据字节读入字节数�l�，��读取的�W�一个字节存储在元素 b[off] 中，下一个存储在 b[off+1] 中，依次�c�L��。读取的字节数最多等�?len�?/td>

void reset()
          ��此��重新定位到�Ҏ(gu��)��输入��最后调�?mark �Ҏ(gu��)��时的位置�?/td>

long skip(long n)
          跌��和放弃此输入��中�?n 个数据字节�?/td>

�W�一个read�Q�）�Ҏ(gu��)��从输入流的当前位�|�处��d��一个字节（8位）的二�q�制数据�Q�然后以此数据�ؓ低位字节�Q�配上一个全零字节合成�ؓ一�?6位的整型量（0~255)后返回给调用此方法的语句。如果输入流的当前位�|�没有数据，则返�?1�?

OutputStream�c?br>此抽象类是表�C��出字节流的所有类的超�c�R��输出流接受输出字节�q�将�q�些字节发送到某个接收器�?br>

�Ҏ(gu��)��摘要

void close()
          关闭此输出流�q��放与此流有关的所有系�l�资源�?/td>

void flush()
          ��h��此输出流�q�强制写出所有缓冲的输出字节�?/td>

void write(byte[] b)
          ��?b.length 个字节从指定的字节数�l�写入此输出��?/td>

void write(byte[] b, int off, int len)
          ��指定字节数�l�中从偏�U�量 off 开始的 len 个字节写入此输出��?/td>

abstract void write(int b)
          ��指定的字节写入此输出流�?/td>

public abstract void write(int b) throws �Ҏ(gu��)��摘要 abstract void close()
          关闭该流�?/td> void mark(int readAheadLimit)
          标记��中的当前位�|��?/td> boolean markSupported()
          判断此流是否支持 mark() 操作�?/td> int read()
          ��d��单个字符�?/td> int read(char[] cbuf)
          ��字�W�读入数�l��?/td> abstract int read(char[] cbuf, int off, int len)
          ��字�W�读入数�l�的某一部分�?/td> int read( boolean ready()           判断是否准备��d��此流�?/td> void reset()           重置该流�?/td> long skip(long n)           跌��字符�?/td> Writer �c?br> �Ҏ(gu��)��摘要   CharSequence csq)           ��指定字�W�序列追加到�?writer�?/td> append(CharSequence csq, int start, int end)           ��指定字�W�序列的子序列追加到�?writer.Appendable�?/td> abstract void close()           关闭此流�Q�但要先��h��它�?/td> abstract void flush()           ��h��此流�?/td> void write(char[] cbuf)           写入字符数组�?/td> abstract void write(char[] cbuf, int off, int len)           写入字符数组的某一部分�?/td> void write(int c)           写入单个字符�?/td> void write( void write( 节点�c�d�� 节点��?/td> 字符��?/td> File文�g FileInputStream FileOutputStream FileReader FileWriter Memory Array内存数组 ByteArrayInputStream ByteArrayOutputStream CharArrayReader CharArrayWriter Memory String字符�?/td> StringReader StringWriter Pipe��道 PipedInputStream PipedOutputStream PipedReader PipedWriter 常用的处理流处理�c�d�� 字节��?/td> 字符��?/td> Buffering�~�冲 BufferedInputStream BufferedOutputStream BufferedReader BufferedWriter Filtering�q��o FilterInputStream FilterOutputStream FilterReader FilterWirter Converting between bytes and character 字节��{为字�W�流 InputStreamReader OutputStreamWriter Object Serialization 对象序列�?/p> ObjectInputStream ObjectOutputStream Date coversion 基本数据�c�d��转化 DateInputStream DateOutputStream Counting行号处理 LineNumberInputStream LineNumberReader Peeking ahead可回退��?/p> PushBackInputStream PushbackReader Pinting可显�C�处�?/td> PrintStream PrintWriter         基本输入、输出流是定义基本的输入、输出操作的抽象�c�，在Java�E�序中真正实用的是它们的子类�Q�对应于不同的数据源和输入、输��Z�Q务，以及不同的输入、输出流。其中较常用的有�Q�过滤输入、输出流FilterInputStream和FilterOutputStream两个抽象�c�，又分别派生出DataInputStream�Q�DataOutputStream�{�子�c�R��过滤输入、输出流的主要特�Ҏ(gu��)��在输入、输出数据的同时能对所传输的数据做指定�c�d��或格式的转换�Q�即可实现对二进制字节数据的理解和编码�{换。文件输入、输出流FileInputStream和FileOutputStream主要负责完成�Ҏ(gu��)��地磁盘文件的��序��d��操作。管道输入、输出流PipedInputStream和PipedOutputStream负责实现�E�序内部的线�E�间通信或不同程序间通信。字节数�l�流ByteArrayInputStream和ByteArrayOutputStream可实��C��内存�~�冲区的同步��d��。顺序输入流SequenceInputStream可以把两个其他的输入��首��接，合�ƈ成一个完整的输入��，�{�等�?br>       从抽象类Reader和Writer中也�z��Z��些子�c�，�q�些子类使InputStream和OutputStream的以字节为单位输入、输��{换�ؓ以字�W��ؓ单位输入、输出，使用��h��比InputStream和OutputStream要方便很多�?br>       数据输入、输出流DataInputStream和DataOutputStream分别是过滤输入、输出流FilterInputStream和FilterOutputStream的子�c�R��过滤输入、输出流的最主要作用��是在数据源和程序之间加一个过滤处理步骤，对原始数据做特定的加工、处理和变换操作�?br> 标准输入和标准输�?/strong>          当java�E�序需要与外界数据源做输入、输出的数据交换�Ӟ��它需要首先创��Z��个输入或输出�cȝ��对象来完成对�q�个数据源的�q�接。例如，当java�E�序需要读写文件时�Q�它需要先创徏文�g的输入或文�g输出��类的对象。除文�g外，�E�序也经�怋�用字�W�界面的标准输入、输��备进行读写操作�?br>         计算机系�l�都有默认的标准输入讑֤�和标准输��备。对一般的�pȝ��Q�标准输入通常是键盘，标准输出通常是显�C�器屏幕。Java�E�序使用字符界面与系�l�标准输入、输出间�q�行数据通信�Q�即从键盘读入数据，或向屏幕输出数据�Q�是十分常见的操作，为此而频频创��入、输出流�c�d��象将很不方便。�ؓ此java�pȝ��事先定义好两个流对象�Q�分别与�pȝ��的标准输入和标准输出相联�p�，它们是System.in和System.out 肖麦 2007-04-05 11:16 发表评论
java.util包学习（二）集合框架�Q�接口）肖麦 — Wed, 28 Mar 2007 02:54:00 GMT 集合框架的设计目�?br />�Q?�Q�基本集合（动态数�l�、链表、树、和散列表）的实现具有很高的效率 �Q?�Q�这个框架必��d��怸�同类型的集合用相似的方式�q�行处理且具有很高的互用�?br />�Q?�Q�扩展与修改集合必须是容易的.��Z��实现�q�一目标,整个集合框架被设计成一�p�d��的标准接�?�q�且实用工具包中提供了这些接口的几个标准实现,如LinkedList、HashSet和TreeSet�?br />�Q?�Q�允许程序员把标准数�l�集成到集合�l�构中的机制集合框架的Iterator�Q��P代器�Q�接口： Iterator提供了访问集合元素的一�U�标准访问方式：逐个讉K��方式。由于每个集合均实现Iterator接口�Q�所以�Q何集合类的成员均可通过Iterator�cȝ��Ҏ(gu��)��讉K�� 集合框架的接口：下面��介�l�集合框架的每个接口。首先从集合接口开始，因�ؓ它们军_��集合�cȝ��基本�Ҏ(gu��)�?/p> Collection          允许处理一�l�对象，位于集合分层�l�构的顶�? List                    扩展Collection接口来处理序列（卛_��象序列） Set                    扩展Collection接口来处理对象集�Q�其中集合元素必��L��惟一�? SortedSet          扩展Set接口来处理已排序的对象集除了Collection外，集合中还有Comparator、Iterator、ListIterator和RandomAccess接口�?br />Comparator定义怎样比较两个对象�Q�Iterator和ListIterator列�D集合中的对象�Q�而通过实现RandomAccess�Q�列表允许对其元素进行有效的随机讉K��?br /> Collection接口�Q?/strong> Collection接口是构造集合框架的基础�Q��ƈ声明了各�U�集合所共有的核心方法。JDK 不提供此接口的�Q�?i>直接实现�Q�它提供更具体的子接口（�?Set �?List�Q�实现�?br />Collection接口中的�Ҏ(gu��)��Q?br /> Method Summary boolean add (E o)           Ensures that this collection contains the specified element (optional operation). boolean addAll (CollectionE> c)           Adds all of the elements in the specified collection to this collection (optional operation). void clear ()           Removes all of the elements from this collection (optional operation). boolean contains (Object o)           Returns true if this collection contains the specified element. boolean containsAll (Collection c)           Returns true if this collection contains all of the elements in the specified collection. boolean equals (Object o)           Compares the specified object with this collection for equality. int hashCode ()           Returns the hash code value for this collection. boolean isEmpty ()           Returns true if this collection contains no elements. Iterator<E> iterator ()           Returns an iterator over the elements in this collection. boolean remove (Object o)           Removes a single instance of the specified element from this collection, if it is present (optional operation). boolean removeAll (Collection c)           Removes all this collection's elements that are also contained in the specified collection (optional operation). boolean retainAll (Collection c)           Retains only the elements in this collection that are contained in the specified collection (optional operation). int size ()           Returns the number of elements in this collection. Object[] toArray ()           Returns an array containing all of the elements in this collection. T[] toArray (T[] a)           Returns an array containing all of the elements in this collection; the runtime type of the returned array is that of the specified array. List接口 List接口扩展了Collection接口。��用从0开始的索引�Q�可以把一个元素插入到列表中或讉K��列表中的某个元素。除了Collection接口中所定义的方法外�Q�List接口�q�定义了属于它自��q��一些方法。如下图�Q?br />Method Summary boolean add(E o)           Appends the specified element to the end of this list (optional operation). void add(int index, E element)           Inserts the specified element at the specified position in this list (optional operation). boolean addAll(CollectionE> c)           Appends all of the elements in the specified collection to the end of this list, in the order that they are returned by the specified collection's iterator (optional operation). boolean addAll(int index, CollectionE> c)           Inserts all of the elements in the specified collection into this list at the specified position (optional operation). void clear()           Removes all of the elements from this list (optional operation). boolean contains(Object o)           Returns true if this list contains the specified element. boolean containsAll(Collection c)           Returns true if this list contains all of the elements of the specified collection. boolean equals(Object o)           Compares the specified object with this list for equality. E get(int index)           Returns the element at the specified position in this list. int hashCode()           Returns the hash code value for this list. int indexOf(Object o)           Returns the index in this list of the first occurrence of the specified element, or -1 if this list does not contain this element. boolean isEmpty()           Returns true if this list contains no elements. Iterator<E> iterator()           Returns an iterator over the elements in this list in proper sequence. int lastIndexOf(Object o)           Returns the index in this list of the last occurrence of the specified element, or -1 if this list does not contain this element. ListIterator<E> listIterator()           Returns a list iterator of the elements in this list (in proper sequence). ListIterator<E> listIterator(int index)           Returns a list iterator of the elements in this list (in proper sequence), starting at the specified position in this list. E remove(int index)           Removes the element at the specified position in this list (optional operation). boolean remove(Object o)           Removes the first occurrence in this list of the specified element (optional operation). boolean removeAll(Collection c)           Removes from this list all the elements that are contained in the specified collection (optional operation). boolean retainAll(Collection c)           Retains only the elements in this list that are contained in the specified collection (optional operation). E set(int index, E element)           Replaces the element at the specified position in this list with the specified element (optional operation). int size()           Returns the number of elements in this list. List<E> subList(int fromIndex, int toIndex)           Returns a view of the portion of this list between the specified fromIndex, inclusive, and toIndex, exclusive. Object[] toArray()           Returns an array containing all of the elements in this list in proper sequence. T[] toArray(T[] a)           Returns an array containing all of the elements in this list in proper sequence; the runtime type of the returned array is that of the specified array. Set接口 Set接口扩展Set接口�q�定义这样一�U�集合：�q�种集合不允许含有相同的元素。因此，如果试图插入相同的元素到调用集合中，add()��会�q�回false。Set接口没有定义它自��q��Ҏ(gu��)��。所有方法都�l�承自Collection接口�?br />Sorted接口 SortedSet接口扩展Collection接口�q�定义一�U�升序集合。除了Set接口所定义的方法之外，SortedSet接口�q�定义了��表所�l�出的方法，以便集合的操作变得更为方�ѝ�?br />Method Summary ComparatorE> comparator()           Returns the comparator associated with this sorted set, or null if it uses its elements' natural ordering. E first()           Returns the first (lowest) element currently in this sorted set. SortedSet<E> headSet(E toElement)           Returns a view of the portion of this sorted set whose elements are strictly less than toElement. E last()           Returns the last (highest) element currently in this sorted set. SortedSet<E> subSet(E fromElement, E toElement)           Returns a view of the portion of this sorted set whose elements range from fromElement, inclusive, to toElement, exclusive. SortedSet<E> tailSet(E fromElement)           Returns a view of the portion of this sorted set whose elements are greater than or equal to fromElement. 肖麦 2007-03-28 10:54 发表评论 java.util包学习（一�Q�类与接口结构图肖麦 — Wed, 28 Mar 2007 02:01:00 GMT 实用工具包中的接口： java.util.Comparator java.util.Enumeration java.util.EventListener java.util.Formattable java.lang.Iterable java.util.Collection java.util.List java.util.Queue java.util.Set java.util.SortedSet java.util.Iterator java.util.ListIterator java.util.Map java.util.SortedMap java.util.Map.Entry java.util.Observer java.util.RandomAccess 实用工具包中的类 java.lang.Objectjava.util.AbstractCollection (implements java.util.Collection) java.util.AbstractList (implements java.util.List) java.util.AbstractSequentialList java.util.LinkedList (implements java.lang.Cloneable, java.util.List, java.util.Queue, java.io.Serializable) java.util.ArrayList (implements java.lang.Cloneable, java.util.List, java.util.RandomAccess, java.io.Serializable) java.util.Vector (implements java.lang.Cloneable, java.util.List, java.util.RandomAccess, java.io.Serializable) java.util.Stack java.util.AbstractQueue (implements java.util.Queue) java.util.PriorityQueue (implements java.io.Serializable) java.util.AbstractSet (implements java.util.Set) java.util.EnumSet (implements java.lang.Cloneable, java.io.Serializable) java.util.HashSet (implements java.lang.Cloneable, java.io.Serializable, java.util.Set) java.util.LinkedHashSet (implements java.lang.Cloneable, java.io.Serializable, java.util.Set) java.util.TreeSet (implements java.lang.Cloneable, java.io.Serializable, java.util.SortedSet) java.util.AbstractMap (implements java.util.Map) java.util.EnumMap (implements java.lang.Cloneable, java.io.Serializable) java.util.HashMap (implements java.lang.Cloneable, java.util.Map, java.io.Serializable) java.util.LinkedHashMap (implements java.util.Map) java.util.IdentityHashMap (implements java.lang.Cloneable, java.util.Map, java.io.Serializable) java.util.TreeMap (implements java.lang.Cloneable, java.io.Serializable, java.util.SortedMap) java.util.WeakHashMap (implements java.util.Map) java.util.Arrays java.util.BitSet (implements java.lang.Cloneable, java.io.Serializable) java.util.Calendar (implements java.lang.Cloneable, java.lang.Comparable, java.io.Serializable) java.util.GregorianCalendar java.util.Collections java.util.Currency (implements java.io.Serializable) java.util.Date (implements java.lang.Cloneable, java.lang.Comparable, java.io.Serializable) java.util.Dictionary java.util.Hashtable (implements java.lang.Cloneable, java.util.Map, java.io.Serializable) java.util.Properties java.util.EventListenerProxy (implements java.util.EventListener) java.util.EventObject (implements java.io.Serializable) java.util.FormattableFlags java.util.Formatter (implements java.io.Closeable, java.io.Flushable) java.util.Locale (implements java.lang.Cloneable, java.io.Serializable) java.util.Observable java.security.Permission (implements java.security.Guard, java.io.Serializable) java.security.BasicPermission (implements java.io.Serializable) java.util.PropertyPermission java.util.Random (implements java.io.Serializable) java.util.ResourceBundlejava.util.ListResourceBundle java.util.PropertyResourceBundle java.util.Scanner (implements java.util.Iterator) java.util.StringTokenizer (implements java.util.Enumeration) java.lang.Throwable (implements java.io.Serializable) java.lang.Exceptionjava.io.IOExceptionjava.util.InvalidPropertiesFormatException java.lang.RuntimeExceptionjava.util.ConcurrentModificationException java.util.EmptyStackException java.lang.IllegalArgumentExceptionjava.util.IllegalFormatExceptionjava.util.DuplicateFormatFlagsException java.util.FormatFlagsConversionMismatchException java.util.IllegalFormatCodePointException java.util.IllegalFormatConversionException java.util.IllegalFormatFlagsException java.util.IllegalFormatPrecisionException java.util.IllegalFormatWidthException java.util.MissingFormatArgumentException java.util.MissingFormatWidthException java.util.UnknownFormatConversionException java.util.UnknownFormatFlagsException java.lang.IllegalStateExceptionjava.util.FormatterClosedException java.util.MissingResourceException java.util.NoSuchElementExceptionjava.util.InputMismatchException java.util.TooManyListenersException java.util.Timer java.util.TimerTask (implements java.lang.Runnable) java.util.TimeZone (implements java.lang.Cloneable, java.io.Serializable) java.util.SimpleTimeZone java.util.UUID (implements java.lang.Comparable, java.io.Serializable) 肖麦 2007-03-28 10:01 发表评论

Method Summary
`ComparatorE>`	`comparator()` Returns the comparator associated with this sorted set, or `null` if it uses its elements' natural ordering.
`E`	`first()` Returns the first (lowest) element currently in this sorted set.
`SortedSet<E>`	`headSet(E toElement)` Returns a view of the portion of this sorted set whose elements are strictly less than `toElement`.
`E`	`last()` Returns the last (highest) element currently in this sorted set.
`SortedSet<E>`	`subSet(E fromElement, E toElement)` Returns a view of the portion of this sorted set whose elements range from `fromElement`, inclusive, to `toElement`, exclusive.
`SortedSet<E>`	`tailSet(E fromElement)` Returns a view of the portion of this sorted set whose elements are greater than or equal to `fromElement`.

	字节��?/p>	字符��?/p>
输入	InputStream	Reader
输出	OutputStream	Writer

�Ҏ(gu��)��摘要
`int`	`available()` �q�回此输入流�Ҏ(gu��)��的下一个调用方可以不受��d��C��此输入流��d��Q�或跌��Q�的字节数�?/td>
`void`	`close()` 关闭此输入流�q��放与该流兌��的所有系�l�资源�?/td>
`void`	`mark(int readlimit)` 在此输入��中标记当前的位�\|��?/td>
`boolean`	`markSupported()` ��试此输入流是否支持 `mark` �?`reset` �Ҏ(gu��)��?/td>
`abstract int`	`read()` 从输入流��d��下一个数据字节�?/td>
`int`	`read(byte[] b)` 从输入流中读取一定数量的字节�q�将其存储在�~�冲区数�l?`b` 中，以整数�Ş式返回实际读取的字节数�?/td>
`int`	`read(byte[] b, int off, int len)` ��输入流中最�?`len` 个数据字节读入字节数�l�，��读取的�W�一个字节存储在元素 `b[off]` 中，下一个存储在 `b[off+1]` 中，依次�c�L��。读取的字节数最多等�?`len`�?/td>
`void`	`reset()` ��此��重新定位到�Ҏ(gu��)��输入��最后调�?`mark` �Ҏ(gu��)��时的位置�?/td>
`long`	`skip(long n)` 跌��和放弃此输入��中�?`n` 个数据字节�?/td>

�Ҏ(gu��)��摘要
`void`	`close()` 关闭此输出流�q��放与此流有关的所有系�l�资源�?/td>
`void`	`flush()` ��h��此输出流�q�强制写出所有缓冲的输出字节�?/td>
`void`	`write(byte[] b)` ��?`b.length` 个字节从指定的字节数�l�写入此输出��?/td>
`void`	`write(byte[] b, int off, int len)` ��指定字节数�l�中从偏�U�量 `off` 开始的 `len` 个字节写入此输出��?/td>
`abstract void`	`write(int b)` ��指定的字节写入此输出流�?/td>

�Ҏ(gu��)��摘要
`CharSequence csq) ��指定字�W�序列追加到�?writer�?/td>`
`append(CharSequence csq, int start, int end)` ��指定字�W�序列的子序列追加到�?writer.`Appendable`�?/td>
`abstract void`	`close()` 关闭此流�Q�但要先��h��它�?/td>
`abstract void`	`flush()` ��h��此流�?/td>
`void`	`write(char[] cbuf)` 写入字符数组�?/td>
`abstract void`	`write(char[] cbuf, int off, int len)` 写入字符数组的某一部分�?/td>
`void`	`write(int c)` 写入单个字符�?/td>
`void`	`write( void`	`write(`
节点�c�d��	节点��?/td>	字符��?/td>
File文�g	FileInputStream FileOutputStream	FileReader FileWriter
Memory Array内存数组	ByteArrayInputStream ByteArrayOutputStream	CharArrayReader CharArrayWriter
Memory String字符�?/td>		StringReader StringWriter
Pipe��道	PipedInputStream PipedOutputStream	PipedReader PipedWriter

处理�c�d��	字节��?/td>	字符��?/td>
Buffering�~�冲	BufferedInputStream BufferedOutputStream	BufferedReader BufferedWriter
Filtering�q��o	FilterInputStream FilterOutputStream	FilterReader FilterWirter
Converting between bytes and character 字节��{为字�W�流		InputStreamReader OutputStreamWriter
Object Serialization 对象序列�?/p>	ObjectInputStream ObjectOutputStream
Date coversion 基本数据�c�d��转化	DateInputStream DateOutputStream
Counting行号处理	LineNumberInputStream	LineNumberReader
Peeking ahead可回退��?/p>	PushBackInputStream	PushbackReader
Pinting可显�C�处�?/td>	PrintStream	PrintWriter