BlogJava-肖麦-文章分类-JavaAPI

java中的transient(转载)

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

Java语言的关键字，用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。还是不大明白。
    后来，终于搜到这篇文章，写得很详细。Be Careful With Transient Data
    怕万一这篇文章链接失效，收藏起来。Be Careful With Transient Data

    终于明白了。
    当串行化某个对象时，如果该对象的某个变量是transient，那么这个变量不会被串行化进去。也就是说，假设某个类的成员变量是transient，那么当通过ObjectOutputStream把这个类的某个实例保存到磁盘上时，实际上transient变量的值是不会保存的。因为当从磁盘中读出这个对象的时候，对象的该变量会没有被赋值。
    另外这篇文章还提到，当从磁盘中读出某个类的实例时，实际上并不会执行这个类的构造函数，而是读取这个类的实例的状态，并且把这个状态付给这个类的对象。这点我以前似乎不知道。

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

与其他语言的模型相比，finally 关键字是对 Java 异常处理模型的最佳补充。finally 结构使代码总会执行，而不管有无异常发生。使用 finally 可以维护对象的内部状态，并可以清理非内存资源。如果没有 finally，您的代码就会很费解。例如，下面的代码说明，在不使用 finally 的情况下您必须如何编写代码来释放非内存资源：

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

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

　　这段代码创建了一个套接字，并调用 accept 方法。在退出该方法之前，您必须关闭此套接字，以避免资源漏洞。为了完成这一任务，我们在 //2 处调用 close，它是该方法的最后一条语句。但是，如果 try 块中发生一个异常会怎么样呢？在这种情况下，//2 处的 close 调用永远不会发生。因此，您必须捕获这个异常，并在重新发出这个异常之前在 //1 处插入对 close 的另一个调用。这样就可以确保在退出该方法之前关闭套接字。

　　这样编写代码既麻烦又易于出错，但在没有 finally 的情况下这是必不可少的。不幸的是，在没有 finally 机制的语言中，程序员就可能忘记以这种方式组织他们的代码，从而导致资源漏洞。Java 中的 finally 子句解决了这个问题。有了 finally，前面的代码就可以重写为以下的形式：

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

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

　　finally 块确保 close 方法总被执行，而不管 try 块内是否发出异常。因此，可以确保在退出该方法之前总会调用 close 方法。这样您就可以确信套接字被关闭并且您没有泄漏资源。在此方法中不需要再有一个 catch 块。在第一个示例中提供 catch 块只是为了关闭套接字，现在这是通过 finally 关闭的。如果您确实提供了一个 catch 块，则 finally 块中的代码在 catch 块完成以后执行。

　　finally 块必须与 try 或 try/catch 块配合使用。此外，不可能退出 try 块而不执行其 finally 块。如果 finally 块存在，则它总会执行。（无论从那点看，这个陈述都是正确的。有一种方法可以退出 try 块而不执行 finally 块。如果代码在 try 内部执行一条 System.exit(0); 语句，则应用程序终止而不会执行 finally 执行。另一方面，如果您在 try 块执行期间拨掉电源，finally 也不会执行。）

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

Java中"异常机制"的深入研究

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

　Java中"异常机制"的深入研究(转载)

　　作者：陈健明发文时间：2004.03.10

　　由于本文旨在探讨Java"异常机制"的深层原理，因此关于"异常"的使用方法都不做详细说明。首先看一段非常熟悉的用于打开一个文件的C程序段：

　　FILE *fp;

　　fp=fopen(filename,"rw");

　　if(fp==NULL){

　　printf("cannot open file\n");

　　exit(0);

　　}

　　在这段程序中，if条件语句中的一段用来处理没有找到指定文件，或者其它原因无法正确打开指定文件。可是如果遇到一个责任心不强的程序员，他可能认为出现找不到文件的可能性很小，或者由于思路集中在程序功能的实现上而忘记了处理这种情况。这时程序同样可以正确编译，而且一般情况下也不会出现问题。但此时这段程序可以肯定说是不够健壮的，而且一旦这段程序发生了错误也会让程序员很难发现错误出在哪里。在C语言以及其它大多数高级语言中都可以举出很多这种例子。

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

　　而Java的"异常机制"就是在处理上述问题中给了程序员非常简单而灵活的方式。一般来说，其它高级语言主要是让函数使用者来关注该函数可能会出现的异常情况，而java则是把这件事情交给方法(和函数对应的概念，在Java中称方法)的设计者来做。这对于方法的使用者来说带来的方便是不会因为责任心不强，或者办事丢三那四，会忘了在使用方法时处理可能发生的异常情况。而麻烦就是，在使用一个可能会发生异常的方法时，绝对不能视而不见，而必须做出相应的处理。也就是说象上述C程序段中，如果忘了if程序块，这个程序甚至还能蒙过一个外行上司，但当使用Java来完成这个功能时，只要用到的方法使用了"异常"机制，如果不对可能产生"异常"的方法进行相应处理，java编译器是不会让其通过的。

　　一、"异常类"的组织形式

　　Java系统类中的方法产生的异常都被组织成"异常类"（还有Error类，不在本文讨论范围），此方法和它相关的"异常类"通过throws关键字关联在一起，并且这些类都必须是Exception类的子类。任何一个自己开发的类的方法中如果可能会产生某种异常，也可以将这种异常组织成一个"异常类"，但这个"异常类"同样必须是Exception的子类，或孙子类等等。

　　例1：

　　/*isLegal于检查数据是否合法，当>0时视为合法，返回合法值，

　　*否则视为不合法，抛出"异常"。*/

　　int isLegal(int dt) throws LowZeroException//这种定义本文中均称为方法与"异常"通

　　{　 //过throws建立了关联

　　 if(dt>=0){

　　 return data;

　　 }

　　 else

　　 throw new LowZeroException();

　　}

　　/*自已写的异常类，继承自Exception*/

　　class LowZeroException extends Exception

　　{

　　 public LowZeroException(){

　　 super();

　　 }

　　仔细观察方法isLegal()，它体现出的最值得注意的特色是，它有两种方式的函数出口，一种是通过return语句，返回的是方法本身定义的类型的实例，另一种是通过throw，返回的是"异常类"的对象实例，Java中称之为抛出"异常"。对比一下C中如何处理同样的问题的：

　　int isLegal(int dt) {

　　 if(dt>=0){

　　 return data;

　　 }

　　 else

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

　　}

　　由于C只能通过return返回函数值，所以在处理异常情况时则可能通过以上方式来处理。当然这就要求isLegal()函数的使用者必须知道函数中使用返回值-1来表明出现不合法数据的情况。

　　对比这两种处理方法，可以知道java的"异常机制"把处理异常事件的职能和方法本身的职能通过两个不同出口分离开来。

　　所有这些"异常类"独立于它具体服务的方法被统一组织成一个类树。"异常机制"就好比高校的后勤社会化一样，通过后勤社会化将学校的教学职能和学校的后勤保障分离开来，并且后勤集团的组织形式也是独立于学校主体的。事实证明，这种组织方式不仅提高了服务效率，也提高了服务质量。整个Java体系中的"异常类"组织形式如图1所示：

　　在例1中的isLegal()方法如果在调用过程中没有能正常返回整形数，而是在"异常"产生点产生了"异常"对象，那么这个"异常"对象由谁来接收，并处理它呢？以下就来解答这个问题。

　　二、"异常"的处理过程

　　Java中由try…catch语法来处理"异常"，将关联有"异常类"的方法包含在try{}程序块中，catch(){}关键字可以使用形参，用于和方法产生的"异常"对象结合。当调用某个方法时，引起异常事件发生的条件成立，便会抛出"异常"，原来的程序流程将会在此方法处中断，然后try模块后紧跟的catch中的"形参"和此异常对象完成了结合，继而进入了catch模块中运行。具体过程举例说明：

　　例2：

　　/*将关联有异常的方法包含在try模块中*/

　　int myMethod(int dt){

　　int data = 0;

　　try{

　　 int data = isLegal(dt);

　　}catch(LowZeroException e){

　　 System.out.println("发生数据错误！");

　　}

　　 return data;

　　 }

　　三、"异常"的处理方法

　　有两种方法处理"异常"：第一种如例2，将含有"异常"出口的方法直接放到try块中，然后由紧随其后的catch块捕捉。第二种是不直接监听捕捉被引用方法的"异常"，而是将这个"异常"关联传递给引用方法，同时监听捕捉工作也相应向上传递。

　　例3：

　　int myMethod2(int dt)

　　{

　　 int data = 0;

　　try{

　　 data = myMethod(dt)

　　 }catch(LowZeroException e){

　　 System.out.println("发生数据错误！");

　　 e.printStackTrace();

　　 }

　　 return data;

　　}

　　int myMethod(int dt) throws LowZeroException

　　{

　　 int data = isLegal(dt); //此处引用isLegal()方法，但并没有捕捉它的"异常"

　　return data;

　　}

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

　　LowZeroException:

　　at Example.isLegal

　　at Example myMethod

　　at Example.myMethod2

　　at Example main

　　从上结果中我们可以看到，从LowZeroException"异常"产生点，即包含throw new LowZeroException();子句的方法开始，然后一直追溯到产生当前线程的方法（注意：printStackTrace()并不是追溯到捕捉点结束，而是到产生当前线程的方法结束）。"异常"产生点产生的LowZeroException"异常"对象，首先被赋给了isLegal()关联的LowZeroException类的无名引用，然后继续赋给myMethod()关联的LowZeroException类的无名引用，再继续赋给myMethod2()中的catch块中的形参e，最后在这里被处理掉，这个"异常"对象随即消失。可以说，catch(){}就是"异常"对象的生命终结点。

　　另外还要注意一点，方法与"异常"的关联可以一直向上传递，当传递到与main方法关联后，即在main()方法的定义中使用了throws Exception，这时除了虚拟机没有其它方法能够引用main()方法，且在程序中可能看不到try…catch程序块，但并不会产生错误，因为此时虚拟机会捕捉"异常"，并且会默认的调用printStackTrace()方法打印出"异常"路径。总之只要一个方法关联了"异常"，可以将这个"异常"关联向上传递，但是最终必须使用catch来终止"异常"，或者一直传递到main()方法交给Java虚拟机来结束"异常"对象的生命，否则是通不过编译的。

　　四、使用"异常机制"的需要注意的几点

　　1.一个方法中可能会产生多种不同的异常，你可以设置多个"异常"抛出点来解决这个问题。

　　2."异常"对象从产生点产生后，到被捕捉后终止生命的全过程中，实际上是一个传值过程，所以你可以根据需要，来合理的控制检测到"异常"的粒度。例如在例3中，如果你并不需要知道具体产生的是LowZeroException"异常"，那么你可以使用"异常"的公共父类Exception来结合"异常"对象，即catch(Exception e){…}。同样在"异常"与方法关联的传递过程中，也可以根据需要控制关联"异常"的粒度，即throws后面跟上异常对象的父类名。

　　3."异常机制"中还有一种特殊情况――RuntimeException"异常类"（见图1），这个"异常类"和它的所有子类都有一个特性，就是"异常"对象一产生就被Java虚拟机直接处理掉，即在方法中出现throw 子句的地方便被虚拟机捕捉了。因此凡是抛出这种"运行时异常"的方法在被引用时，不需要有try…catch语句来处理"异常"。

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

java 日期格式化(转载)

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

java 日期格式化
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， 2007/03/09
*/

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

        /** Date类的格式: 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年4月16日星期六 */
        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文件操作(一)

肖麦 — Thu, 05 Apr 2007 03:16:00 GMT

流、文件及基于文本的应用

1、流式输入与输出

为进行数据的输入、输出操作，Java中把不同的输入、输出源（键盘、文件、网络连接等）抽象为“流”（Stream），有两种基本的流：输入流和输出流。

（1）输入流：只能从中读取数据，而不能向其写出数据。

（2）输出流：只能向其写出数据，而不能从中读取数据。

流实际上指在计算机的输入与输出之间运动的数据的序列，流序列中的数据既可以是未经加工的原始二进制数据，也可以是经一定编码处理后符合某种格式规定的特定数据，如字符流序列、数字流序列等。

1.1、字节流与字符流

按处理数据的类型，流可以分为字节流和字符流，它们处理的信息的基本单位分别是字节（byte）与字符（char）。

输入字节流的类为InputStream

输出字节流的类为OutputStream

输入字符流的类为Reader

输出字符流的类为Writer

如下表，这四个类是抽象类，其他的输入输出流类都是它们的子类。

字节流与字符流

	字节流	字符流
输入	InputStream	Reader
输出	OutputStream	Writer

InputStream类

方法摘要
`int`	`available()` 返回此输入流方法的下一个调用方可以不受阻塞地从此输入流读取（或跳过）的字节数。
`void`	`close()` 关闭此输入流并释放与该流关联的所有系统资源。
`void`	`mark(int readlimit)` 在此输入流中标记当前的位置。
`boolean`	`markSupported()` 测试此输入流是否支持 `mark` 和 `reset` 方法。
`abstract int`	`read()` 从输入流读取下一个数据字节。
`int`	`read(byte[] b)` 从输入流中读取一定数量的字节并将其存储在缓冲区数组 `b` 中，以整数形式返回实际读取的字节数。
`int`	`read(byte[] b, int off, int len)` 将输入流中最多 `len` 个数据字节读入字节数组，将读取的第一个字节存储在元素 `b[off]` 中，下一个存储在 `b[off+1]` 中，依次类推。读取的字节数最多等于 `len`。
`void`	`reset()` 将此流重新定位到对此输入流最后调用 `mark` 方法时的位置。
`long`	`skip(long n)` 跳过和放弃此输入流中的 `n` 个数据字节。

第一个read（）方法从输入流的当前位置处读入一个字节（8位）的二进制数据，然后以此数据为低位字节，配上一个全零字节合成为一个16位的整型量（0~255)后返回给调用此方法的语句。如果输入流的当前位置没有数据，则返回-1。

OutputStream类
此抽象类是表示输出字节流的所有类的超类。输出流接受输出字节并将这些字节发送到某个接收器。

方法摘要
`void`	`close()` 关闭此输出流并释放与此流有关的所有系统资源。
`void`	`flush()` 刷新此输出流并强制写出所有缓冲的输出字节。
`void`	`write(byte[] b)` 将 `b.length` 个字节从指定的字节数组写入此输出流。
`void`	`write(byte[] b, int off, int len)` 将指定字节数组中从偏移量 `off` 开始的 `len` 个字节写入此输出流。
`abstract void`	`write(int b)` 将指定的字节写入此输出流。

public abstract void write(int b) throws IOException
将指定的字节写入此输出流。write 的常规协定是：向输出流写入一个字节。要写入的字节是参数 b 的八个低位。b 的 24 个高位将被忽略。 OutputStream 的子类必须提供此方法的实现。
flush()方法刷新缓冲区的内容。对于缓冲流式输出来说，write()方法所写的数据并没有直接传到与输出流相连的外部设备上，而是先暂时存放在流的缓冲区中，等到缓冲区中的数据积累到一定数量，再统一执行一次向外部设备的写操作把它们全部写到外部设备上。这样处理可以降低计算机对外部设备的读写次数，大大提高系统的效率。但是在某些情况下，缓冲区中的数据不满时就需要将它写到外部设备上，此时应使用强制清空缓冲区并执行外部设备写操作的flush()方法。

Reader类
Reader类与InputStream类相似，都是输入流，但差别在于Reader类读入的是字符（char），而不是字节。

方法摘要
`abstract void`	`close()` 关闭该流。
`void`	`mark(int readAheadLimit)` 标记流中的当前位置。
`boolean`	`markSupported()` 判断此流是否支持 mark() 操作。
`int`	`read()` 读取单个字符。
`int`	`read(char[] cbuf)` 将字符读入数组。
`abstract int`	`read(char[] cbuf, int off, int len)` 将字符读入数组的某一部分。
`int`	`read(CharBuffer target)` 试图将字符读入指定的字符缓冲区。
`boolean`	`ready()` 判断是否准备读取此流。
`void`	`reset()` 重置该流。
`long`	`skip(long n)` 跳过字符。

Writer 类

方法摘要
`Writer`	`append(char c)` 将指定字符追加到此 writer。
`Writer`	`append(CharSequence csq)` 将指定字符序列追加到此 writer。
`Writer`	`append(CharSequence csq, int start, int end)` 将指定字符序列的子序列追加到此 writer.`Appendable`。
`abstract void`	`close()` 关闭此流，但要先刷新它。
`abstract void`	`flush()` 刷新此流。
`void`	`write(char[] cbuf)` 写入字符数组。
`abstract void`	`write(char[] cbuf, int off, int len)` 写入字符数组的某一部分。
`void`	`write(int c)` 写入单个字符。
`void`	`write(String str)` 写入字符串。
`void`	`write(String str, int off, int len)` 写入字符串的某一部分。

1、2节点流和处理流
按照流是否直接与特定的地方（如磁盘、内存、设备等）相连，分为节点流与处理流两类。
（1）节点流(Node Stream)：可以从或向一个特定的地方（节点）读写数据。如文件流FileReader
（2）处理流（Processing Stream）：是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写功能。处理流又称为过滤流，如缓冲处理流BufferReader。
节点流与处理流的关系：节点流直接与节点（如文件）相连，而处理流对节点流或其他处理流进一步进行处理（如缓冲、组装成对象，等等）。
处理流的构造方法总是要带一个其他流对象作为参数。如：
BufferedReader iin = new BufferedReader(new FileReader(file));
常用的节点流：

节点类型	节点流	字符流
File文件	FileInputStream FileOutputStream	FileReader FileWriter
Memory Array内存数组	ByteArrayInputStream ByteArrayOutputStream	CharArrayReader CharArrayWriter
Memory String字符串		StringReader StringWriter
Pipe管道	PipedInputStream PipedOutputStream	PipedReader PipedWriter

常用的处理流

处理类型	字节流	字符流
Buffering缓冲	BufferedInputStream BufferedOutputStream	BufferedReader BufferedWriter
Filtering过滤	FilterInputStream FilterOutputStream	FilterReader FilterWirter
Converting between bytes and character 字节流转为字符流		InputStreamReader OutputStreamWriter
Object Serialization 对象序列化	ObjectInputStream ObjectOutputStream
Date coversion 基本数据类型转化	DateInputStream DateOutputStream
Counting行号处理	LineNumberInputStream	LineNumberReader
Peeking ahead可回退流	PushBackInputStream	PushbackReader
Pinting可显示处理	PrintStream	PrintWriter

        基本输入、输出流是定义基本的输入、输出操作的抽象类，在Java程序中真正实用的是它们的子类，对应于不同的数据源和输入、输出任务，以及不同的输入、输出流。其中较常用的有：过滤输入、输出流FilterInputStream和FilterOutputStream两个抽象类，又分别派生出DataInputStream，DataOutputStream等子类。过滤输入、输出流的主要特点是在输入、输出数据的同时能对所传输的数据做指定类型或格式的转换，即可实现对二进制字节数据的理解和编码转换。文件输入、输出流FileInputStream和FileOutputStream主要负责完成对本地磁盘文件的顺序读写操作。管道输入、输出流PipedInputStream和PipedOutputStream负责实现程序内部的线程间通信或不同程序间通信。字节数组流ByteArrayInputStream和ByteArrayOutputStream可实现与内存缓冲区的同步读写。顺序输入流SequenceInputStream可以把两个其他的输入流首尾相接，合并成一个完整的输入流，等等。
       从抽象类Reader和Writer中也派生出一些子类，这些子类使InputStream和OutputStream的以字节为单位输入、输出转换为以字符为单位输入、输出，使用起来比InputStream和OutputStream要方便很多。
       数据输入、输出流DataInputStream和DataOutputStream分别是过滤输入、输出流FilterInputStream和FilterOutputStream的子类。过滤输入、输出流的最主要作用就是在数据源和程序之间加一个过滤处理步骤，对原始数据做特定的加工、处理和变换操作。

标准输入和标准输出
         当java程序需要与外界数据源做输入、输出的数据交换时，它需要首先创建一个输入或输出类的对象来完成对这个数据源的连接。例如，当java程序需要读写文件时，它需要先创建文件的输入或文件输出流类的对象。除文件外，程序也经常使用字符界面的标准输入、输出设备进行读写操作。
         计算机系统都有默认的标准输入设备和标准输出设备。对一般的系统，标准输入通常是键盘，标准输出通常是显示器屏幕。Java程序使用字符界面与系统标准输入、输出间进行数据通信，即从键盘读入数据，或向屏幕输出数据，是十分常见的操作，为此而频频创建输入、输出流类对象将很不方便。为此java系统事先定义好两个流对象，分别与系统的标准输入和标准输出相联系，它们是System.in和System.out

肖麦 2007-04-05 11:16 发表评论

java.util包学习（二）集合框架（接口）

肖麦 — Wed, 28 Mar 2007 02:54:00 GMT

集合框架的设计目标
（1）基本集合（动态数组、链表、树、和散列表）的实现具有很高的效率
（2）这个框架必须允许不同类型的集合用相似的方式进行处理且具有很高的互用性
（3）扩展与修改集合必须是容易的.为了实现这一目标,整个集合框架被设计成一系列的标准接口,并且实用工具包中提供了这些接口的几个标准实现,如LinkedList、HashSet和TreeSet。
（4）允许程序员把标准数组集成到集合结构中的机制
集合框架的Iterator（迭代器）接口：
Iterator提供了访问集合元素的一种标准访问方式：逐个访问方式。由于每个集合均实现Iterator接口，所以任何集合类的成员均可通过Iterator类的方法访问
集合框架的接口：
下面将介绍集合框架的每个接口。首先从集合接口开始，因为它们决定集合类的基本特性

Collection 允许处理一组对象，位于集合分层结构的顶层
List 扩展Collection接口来处理序列（即对象序列）
Set 扩展Collection接口来处理对象集，其中集合元素必须是惟一的
SortedSet 扩展Set接口来处理已排序的对象集

除了Collection外，集合中还有Comparator、Iterator、ListIterator和RandomAccess接口。
Comparator定义怎样比较两个对象；Iterator和ListIterator列举集合中的对象；而通过实现RandomAccess，列表允许对其元素进行有效的随机访问。

Collection接口：
Collection接口是构造集合框架的基础，并声明了各种集合所共有的核心方法。JDK 不提供此接口的任何直接实现：它提供更具体的子接口（如 Set 和 List）实现。
Collection接口中的方法：

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开始的索引，可以把一个元素插入到列表中或访问列表中的某个元素。除了Collection接口中所定义的方法外，List接口还定义了属于它自己的一些方法。如下图：

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接口并定义这样一种集合：这种集合不允许含有相同的元素。因此，如果试图插入相同的元素到调用集合中，add()将会返回false。Set接口没有定义它自己的方法。所有方法都继承自Collection接口。
Sorted接口
SortedSet接口扩展Collection接口并定义一种升序集合。除了Set接口所定义的方法之外，SortedSet接口还定义了小表所给出的方法，以便集合的操作变得更为方便。

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包学习（一）类与接口结构图

肖麦 — 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.Object
- java.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.ResourceBundle
  - java.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.Exception
    - java.io.IOException
      - java.util.InvalidPropertiesFormatException
    - java.lang.RuntimeException
      - java.util.ConcurrentModificationException
      - java.util.EmptyStackException
      - java.lang.IllegalArgumentException
        java.util.IllegalFormatException
        java.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.IllegalStateException
        java.util.FormatterClosedException
      - java.util.MissingResourceException
      - java.util.NoSuchElementException
        java.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 发表评论