随笔档案

所有的流在使用完毕时，都需要调用close方法进行关流，释放资源。
由于流操作都会有异常，如果发生异常就有可能导致close方法不能被调用
所以，IO异常一定要处理，close方法写在finally语句中
1.InputStream : 输入字节流 方法： read()从流(关联的设备)中读一个字节
** int read(buf):从流中读取n个字节放入缓冲区，方法会返回一个读取字节的个数 ips-->buf
读到一个-1，说明读到了流的末尾
 ------------------------------------------------------------------------------------------
|---FileInputStream: 重载的构造函数  (String fileName)  (File file)

2.OutputStream： 输出字节流 :方法 write(int c)将一个字节写入流  (byte)c
write(buf,offset,len)将指定字节数组的一部分写入流。 buf-->ops
 -------------------------------------------------------------------------------------------
|---FileOutputStream: 重载的构造函数 (Strng fileName) (String fileName, boolean append)
 append:指定数据是否追加到文件的末尾，默认是false，覆盖原有的数据，
 设置为true，将数据追加到文件的末尾
3.Reader：输入字符流 int read() 读一个字符   int read(buf)  buf是char[]类型
|---FileReader:  FileReader = InputStreamReader(FileInputStream) 只做了一件事：解码(父类在做)
4.Writer：输出字符流 write(int c) (char)c \  write(String str)
|---|---FileWriter:  FileWriter = OutputStreamWriter(FileOutputStream) 只做了一件事：编码

理解(会用)：
1.装饰设计模式： 对原有的类的进行包装，对方法进行增强
BufferedReader：实现缓冲的功能   创建包装流对象的时候，必须组合一个被包装的底层流
    增加了一个新方法 String readLine() 读一行
|--LineNumberReader: 增加了行号功能，getLineNumber() 、setLineNumber()
BufferedWriter：实现了缓冲功能  new BufferedWriter(new FileWriter("1.txt");
    增加了新方法  newLine() 另起一行
BufferedInputStream：实现缓冲的功能
BufferedOutputStream：实现缓冲的功能

2.InputStreamReader： 转换流   : 包装，实现了编码解码的功能
new InputStreamReader(new FileInputStream("1.txt"));

3.使用包装流包装System.in，读键盘方便，可以读一行
BufferedReader br =
 new BufferedReader(new InputStreamReader(System.in));
String line = br.readLine();
 
 
IO需要会写的程序： BufferedReader和BufferedWriter包装InputStream和OutputStream，读一行写一行

  BufferedReader和BufferedWriter包装Reader和Writer
  BufferedInputStream和BufferedOutputStream包装InputStream和OutputStream
  用基础流读写，自定义数组作为缓冲区，实现拷贝
  
-------以下做一个总结:

io流:数据传输的中转站-->IO流-->目的地

 IO流一般都是成对出现的,也就是说按照流的分向:输入流-->输出流
 IO流按照操作来分: 字节流-->字符流
 
一.字符流
基类:Reader(读)Writer(写)
|-Reader
 |--BufferedReader:对Reader进行了包装,提供了缓冲区(8192),有ReadLine()方法
  构造函数:BufferedReader(Reader r);
 |--InputStreamReader:转换流:将字节流转换成字符流:new InputStreamReader(System.in);
  |--FileReader:读取文件的字符流,FileReader(File file) FileReader(String fileName);
|-Writer
 |--BufferedWriter:包装流:常用的方法write(String s)、flush()刷新  newLine()换行
  构造函数:BufferedWriter(Writer w);
 |--OutputStreamWriter:转换流: new OutputStreamWriter(System.out);
  |--FileWriter:写入文件,FileWriter(File file)  FileWriter(String fileName)
   FileWriter(File file,boolean append),FileWriter(String fileName,boolean append)
   当append为true,将写入到文件的末尾处,当为false时,从文件开头开始写.就会覆盖原来的.默认为false
   
二.字节流:
|-InputStream(输入流)
 |--FileInputStream:读取文件的字符流,和FileReader基本是一样
 |--FilterInputStream:过滤流,一般不使用,只是针对了InputStream进行了包装
  |--BufferedInputStream:包装类:BufferedReader(InputStream in),提供缓存功能
  
|-OutputStream(输出流)
 |--FileOutputStream:写入文件的字符流,和FileWriter基本一样
 |--FilterOutputStream
  |--BufferedOutputStream:包装类:BufferedWriter(OutputStream out);
  
三.使用IO流必须要捕获异常,原因在于我们必须要还资源(关闭流)

 1 FileWriter fw = null;
 2 try
 3 {
 4     fw = new FileWriter("src/1.txt");
 5 }
 6 catch(IOException e)
 7 {
 8     e.printStractTrace();
 9 }
10 finally
11 {
12     try{if(fw!=null)fw.close();}catch(IOException){e.printStackTrace();}
13 }

四.File文件类
1.构造方法:
File(File parnt,String child)
根据prent抽象路径名和child路径名字符串创建一个新的file实例.
File(String pathname)
通过将给定的路径名字来创建一个新的file实例.
File(String parent, String child)
根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例.

2.常用方法:
isFile:判断对象是否是一个标准文件
isDirectory:判断对象是否为一个文件夹
isAbsolute:判断是否为一个绝对路径
exists:判断对象指定的文件是否存在
createNewFile:根据对象的描述创建一个对象
getName:获得文件名
getPath:获得路径名
getParent:获得文件的父级抽象路径
getAbsolutepath:获得文件的绝对路径名
mkdir:创建此抽象路径指定的目录,(只能在存在的文件夹下创建一个目录)
mkdirs:创建此抽象路径指定的目录,包括所有必须但不存在的目录.创建多级目录(c:/a/b/c)
list(FilenameFilter filter)：根据指定过滤器遍历文件夹中的所有文件，返回String[]
 如果对象为标准文件，则返回null，如果对象是一个空文件夹，则返回空数组。length为0
 FilenameFilter是一个接口，只有一个方法accept，我们需要实现接口的accept方法。
 实现类是给list方法自动调用的
 方法的参数是list方法传给我们的，返回的结果也是给list方法去用。
listFiles：和list基本一样，返回值类型不一样，返回File[]。
常用案例：遍历目录下所有的文件和文件夹   拷贝一个文件夹  .

五:RandomAccessFile 文件流,可以读写
1.RandomAccessFile(File file,String mode)、RandomAccessFile(String fileName,String mode)
 mode:常用的: r,只读 rw读写
2.有很多read和write方法.
 seek方法,指定从那个位置开始读seek(0) ,从原有的位置覆盖掉
skipBytes(int n)：跳过多少个字节

六:PrintStream、PrintWriter打印流
有一个特殊的方法print可以实现打印
write方法是直接将字节和字符写出去
print：首先调用对象的toString方法转成字符串(如果是基本数据类型，会先自动装箱)
 再将字符串编码成字节数组，调用write方法写出去

七:SequenceInputStream序列流
可以将多个字节流组合起来
构造方法：SequenceInputStream(Enumeration<? extends InputStream> e) 
  //Enumeration可以通过Vector来获得，如果用的是ArrayList，如何获得呢？
     SequenceInputStream(InputStream in1,InputStream in2)

八:ObjectInputStream、ObjectOutputStream操作对象的字节流
一般成对出现
使用writeObject方法写入的对象，只能由readObject方法读出来
操作的对象必须实现java.io.Serializable序列化接口，该对象才可以被序列化和反序列化。
序列化: Java中规定的一种保存对象的数据格式

九:DataInputStream、DataOutputStream操作基本数据类型，格式化数据
readInt、writeInt等方法。
writeInt写入一个整数，文件大小为4字节。证明就是把基本数据类型对应的字节写出去了，没有丢失精度

十:ByteArrayInputStream、ByteArrayOutputStream对Byte数组进行读写的字节流，针对内存进行读写
源和目的地都是内存，一般用于对内存中的数据进行处理。

十一:PipedInputStream、PipedOutputStream管道流
1、输入管道流
构造方法：PipedInputStream(PipedOutputStream pos)实现拼接
也可以通过connect(PipedOutputStream pos)方法进行拼接

2、输出管道流
构造方法：PipedOutputStream(PipedInputStream pis)实现拼接
也可以通过connect(PipedInputStream pis)方法进行拼接

 1 --Test:序列化与反序列化..
 2 package com.java.kudy_Say;
 3 
 4 import java.io.FileNotFoundException;
 5 import java.io.FileOutputStream;
 6 import java.io.IOException;
 7 import java.io.ObjectOutputStream;
 8 import java.io.Serializable;
 9 import java.util.ArrayList;
10 import java.io.ObjectInputStream;
11 import java.io.FileInputStream;
12 /*
13     序列化与反序列化的过程
14 */
15 public class Test {
16     
17     public static void main(String[]args) throws FileNotFoundException, IOException,ClassNotFoundException
18     {
19             
20 /*        Student s1 = new Student("张三",18);
21         Student s2 = new Student("王五",19);
22         Student s3 = new Student("李四",20);
23         Student s4 = new Student("大毛",21);
24         ObjectOutputStream oos = 
25                 new ObjectOutputStream(new FileOutputStream("f:/a.txt"));
26         ArrayList<Student> al = new ArrayList<Student>();
27         al.add(s1);
28         al.add(s2);
29         al.add(s3);
30         al.add(s4);
31         oos.writeObject(al);
32         oos.close();//关闭流
33         //首先我们把内容放到一个集合里面去
34 */
35         ObjectInputStream ois = 
36                 new ObjectInputStream(new FileInputStream("f:/a.txt"));
37         ArrayList<Student> al = (ArrayList<Student>)ois.readObject();
38         for(Student s :al)
39             System.out.println(s);
40         ois.close();
41     
42     
43         
44     }
45 }
46 
47 //必须要实现一个类
48 class Student implements Serializable
49 {
50     private String name;
51     private int age;
52     Student(){}
53     Student(String name,int age)
54     {
55         this.name = name;
56         this.age = age;
57     }
58     public String toString()
59     {
60         return name+"@"+age;
61     }
62 }

教程由JAVA中文网整理校对发布(javaweb.cc)

     Abstract Window Toolkit(AWT)抽象窗口工具集
　 一个用本地图形组件实现的图形接口。这些组件提供了大部分的本地组件。这个接口正逐步被Swing组件所替代，参见Swing Set.

　 Abstract 抽象的
　 一个Java语言中的关键字，用在类的声明中来指明一个类是不能被实例化的，但是可以被其它类继承。一个抽象类可以使用抽象方法，抽象方法不需要实现，但是需要在子类中被实现

　 abstract class 抽象类
　 含有一个或多个抽象方法的类，不能被实例化。定义抽象类的目的是使其他类能够从它继承，并且通过实现抽象方法使这个类具体化

　 abstract method 抽象方法
　 没有实现的方法

　 access control 访问控制
　 控制用户或程序访问资源的权限，保证资源的一致性的方法

　 API 应用程序接口
　 Application Programming Interface的缩写。指导应用程序开发人员访问类方法和类状态的说明

　 applet 小应用程序
　 通常在Web浏览器中执行的一个Java组件，同样可以在其他的支持applet模型的应用程序或设备中执行
　
　 Applet container applet容器
　 一个支持applet的容器

　 argument 参数
　 在函数调用中使用的数据项。一个参数可以是常量、变量或表达式
　
　 array 数组
　 相同类型的数据的集合，每一个数据项通过一个整数唯一标识

　 ASCII
　 American Standard Code for Information Interchange的缩写。一个标准的7位字符编码，参见Unicode

       Bean
　　一个可以重用的组件，可以通过组合Bean来创建应用程序

　　bean-managed persistence
　　当一个实体bean实例和资源管理器交换数据的时候，由实体bean实例来管理

　　bean-managed transaction
　　Enterprise Bean定义事务的界限的时候

　　binary operator 二值操作符
　　有两个操作数的操作符

　　bit 位
　　计算机中表示信息的最小单位，只有0和1两个值

　　bitwise operator 位操作符
　　并行的对一个或多个操作数的位进行单独的操作。比如二进制逻辑运算符（&,|,^），二进制移位符（<<,>>,>>>）和求补运算符（~）

　　block 块
　　在Java语言中，任何被大括号括起来的程序段。

　　boolean 逻辑型
　　指一个表达式或一个变量只能有true或者false两种类型。Java语言提供了boolean类型以及true和false两个常量

　　break
　　一个Java的关键字，用来改变程序执行流程，立刻从当前语句的下一句开始执行从。如果后面跟有一个标签，则从标签对应的地方开始执行

　　business logic 商业逻辑
　　实现某个应用功能的代码。在Enterprise JavaBeans模型中，这种逻辑是由某个Enterprise Javabean的方法实现的。

　　business method 商业方法
　　某个Enterprise Javabean的方法用来实现商业逻辑或者某个应用的规则。

　　Byte 字节
　　顺序的8位bit，Java语言中有对应的byte类型

　　bytecode 字节码
　　由Java编译器生成的跟机器相关代码，由Java解释器执行

　　callback methods 回调方法
　　组件的方法，由存放该组件的容器来调用的，用来在组件生命周期中通知它重要的事件

　　case
　　Java语言的关键字，用来定义一组分支选择，如果某个值和switch中给出的值一样，就会从该分支开始执行。

　　casting
　　强制类型转化换
　
　　catch
　　Java的一个关键字，用来声明当try语句块中发生运行时错误或非运行时异常时运行的一个块。

　　char
　　Java语言的一个关键字，用来定义一个字符类型

　　class 类
　　在Java语言中定义一个特定类的实现。一个类的定义包含成员变量，成员方法，还有这个类实现的接口，以及这个类的父类。如果没有显式指明父类，那么它的父类会隐式的被认为是Object。

　　class method 类方法
　　不需要引用特定对象就可以使用的方法，类方法的作用域是全局的，而不是某个特定的类实例，也被称作静态方法static method，参看instance method

　　classpath 类路径
　　Classpath是一个环境变量，用来向Java虚拟机和基于Java的应用程序指明系统类库和用户类库的位置（比如，工具包在JDK1.1.X/bin目录中）

　　class variable 类变量
　　一个和整个类相关的数据项，而不是只和某个实例，类变量在类定义中定义，也被称作static field,参看instance variable.

　　codebase
　　和<APPLET>标签中的Code属性配合给出找到applet类的完整路径：Code给出文件的名字，Codebase指出包含该文件的URL路径

　　comment 注释
　　在编程语言中被编译器忽略的解释性语句。在Java中注释使用//或/*…*/定界

　　compiler 编译器
　　一个把源代码翻译成机器可以执行的代码的程序。Java编译器把Java源码翻译成Java虚拟机能够识别的字节码，参见interpreter

　　component 组件
　　一种被容器所支持的应用级的软件单元。组件在使用的时候是可配置的。J2EE平台定义了四种类型的组件：Enterprise Bean，Web components，applets和application client。

　　component contract
　　组件和它的容器之间的规范。这种规范包括：组件的生命周期的管理，一个上下文的接口，组件可以通过它获得容器的信息和服务，以及每个容器必须提供的一系列服务。

　　component environment
　　应用程序组件提供商定义的一个集合，使组件在J2EE组件的名字空间中可见。环境选项由组件的使用描述符指明。每一个组件命名并访问它的环境配置值通过使用java:comp/evn JNDI上下文。这些值可以是组件所依赖的一个对象，比如JDBC DataSouce，或者一个简单值，比如一个税率。

　　Connector 连接器
　　一个标准的扩充机制使容器可以提供到EISs的连接。一个连接器连接到特定的EIS，由资源适配器和针对EIS的应用开发工具组成。一个资源适配器插入到一个容器通过在连接器体系结构中定义的系统级的联系。

　　connector architecture
　　一个集成J2EE和EISs的体系结构。这个体系结构中有两大部分：一个EIS厂商提供的资源适配器和一个允许这个适配器插入的J2EE服务器。这个体系结构定义了一系列资源适配器为了能插入J2EE服务器而必须支持的规范，比如事务，安全，资源管理。

　　Constructor 构造函数
　　一个创建对象的伪方法。在Java语言中构造函数是和类同名的成员函数。构造函数一般用在new操作符之后。

　　Container 容器
　　一个为组件提供生命周期管理，安全，配置，和运行时服务的实体。每一个类型的容器（EJB, Web, JSP, servlet, applet, 和application client）也会提供各自组件相关的服务

　　container-managed persistence
　　当一个实体bean实例和资源管理器交换数据的时候，由资源管理器来管理

　　container-managed transaction
　　当一个EJB容器定义一个事务的边界的时候，一个Bean必须使用这种事务类型

　　continue
　　一个Java的关键字，用来打断当前循环过程，从当前循环的最后重新开始执行，如果后面跟有一个标签，则从标签对应的地方开始执行。

　　core class 核心类
　　一个Java平台上的标准的公共类或接口。Java平台的核心类，至少在所有的能支持Java的操作系统的平台上都是可用的。一个完全用Java编写的程序只需要Java核心类就可以运行了，这意味着它能够在任何地方运行，参看100% Pure Java(TM).

　　Core Packages 核心包
　　在任何Java平台和任何兼容平台上必须被支持的API的集合。

　　Declaration 声明
　　一个在标识符和属性之间建立联系的语句，不需要必要的存储分配或具体实现。参见definition

　　default 缺省的
　　一个Java语言的关键字，作为在switch语句中的所有case之后的可选项，如果所有的case条件都没有被满足，就会执行default语句
　
　　delegation 授权
　　一种某个负责人批准另外一个负责人在一定限制下使用它的身份或特权的行为

　　deprecation
　　指不再推荐的类，接口，构造函数，方法或成员变量，可能在以后的版本中会消失

　　derived from
　　类X "derived from" 类Y就是指类X是从类Y继承过来的，参见subclass, superclass

　　distributed 分布的
　　在多于一个的地址空间内运行
　　
　　distributed application 分布式应用
　　由不同的运行于分离的运行环境下的组件构成的应用程序，通常是在不同的平台上通过网络互联起来。典型的分布式应用是二端（Client/Server），三端（client/middleware/server）和n端（client/multiple middleware/multiple server）

　　do
　　一个Java语言的关键字，用来声明一个循环，这个循环的结束条件可以通过while关键字设置

　　DOM
　　Document Object Model的缩写。一棵由拥有包含遍历这棵树并且生成相应XML文档的接口的对象构成的树，符合W3C的规范

　　double
　　一个Java语言的关键字，用来定义一个double类型的变量

　　EJB container EJB容器
　　一个实现了J2EE体系结构中EJB组件规范的容器。这个规范指定了一个Enterprise bean的运行时环境，包括安全，一致性，生命周期，事务，配置，和其他的服务。一个EJB容器可以由EJB或者J2EE服务器提供。

　　EJB Container Provider EJB容器提供商
　　提供EJB容器的厂商

　　EJB context EJB上下文
　　一个允许Enterprise Bean使用容器提供的服务和获得客户-请求（client-invoke）方法调用者信息的对象

　　EJB home object
　　一个提供关于Enterprise Bean生命周期操作（创建，删除，查找）的对象。这个对象的类型是由容器的配置工具产生的。EJB home object实现了Enterpeise Bean的home接口。客户通过引用一个EJB home object来进行生命周期的操作。客户使用JNDI来定位一个EJB home object

　　EJB .jar file
　　一个包含EJB模块的JAR文件

　　EJB module
　　一个由一个或多个Enterprise bean和一个EJB配置描述符组成的软件单元。

　　EJB object
　　实现了enterprise bean的remote接口的对象。客户不能直接引用一个enterprise bean的实例；客户总是引用一个EJB object。EJB object的类型是由容器的配置工具生成的。

　　EJB server
　　为EJB容器提供服务的软件。比如，典型的，一个EJB容器总是依靠一个作为EJB Server一部分的事务管理器来进行双向的确认在所有参与的资源管理器之间。J2EE体系结构假设EJB容器和EJB Server是由同一厂商提供的，所以没有制定这两个实体之间的规范。一个EJB Server可以包含一个或多个EJB Container

　　EJB Server Provider
　　提供EJB Server的厂商

　　EIS resource
　　一个为客户提供符合EIS规范的功能的实体。例子有：一条或多条数据库中的记录，在一个ERP系统中的一个business object，在一个事务处理系统中的一个事务程序

　　else
　　一个Java语言的关键字，如果if语句的条件不满足就会执行该语句。

　　encapsulation 封装
　　一个模块中的内部属性，因为对象会封装数据和实现，使用者可以把对象看作一个能提供服务的黑匣子。实例变量可以被添加，删除，或改变。只要这个对象所提供的服务是不变的，使用这个对象的代码就可以继续使用而不需要修改，参见instance variable, instance method.

　　enterprise bean
　　实现商业任务和商业实体的组件；或者是一个entity bean，或者是一个session bean

　　Enterprise Information System (EIS)
　　一个包含企业已经存在的获取企业级信息的系统的应用程序，这些应用程序为企业提供了一个信息结构。一个EIS系统提供很好定义的服务的集合给它的客户。这些服务在客户看来是本地的和/或者远程的接口。EIS的例子有：一个ERP系统，一个事务处理系统的主框架，一个遗留的数据库系统。

　　Enterprise Bean Provider Enterprise Bean提供商
　　生产enterprise bean，remote和home接口，配置描述符文件，并把这些打包入JAR文件的应用程序开发人员

　　Enterprise JavaBeans(TM) (EJB)
　　一个用于开发和使用面向对象的，分布式的，企业级应用程序的组件体系结构。使用Enterprise JavaBeans体系结构编写的软件是可扩展的，面向事务的，多用户的，安全的。

　　entity bean
　　一个代表由数据库维护的持久数据的enterprise bean。一个entity bean可以管理它自己的持久性，或者把这个功能授权给它的容器。一个　　entity bean由一个主键来标识。如果存放entity bean的容器崩溃了，那么这个entity bean，它的主键，以及任何远程的引用都能从崩溃中幸存下来。

　　ebXML
　　ebXML建立在XML(Extensive Markup Language)之上，目的是提供一系列模块化的规范，使任何地方的任何规模的企业都能够通过Internet指导商业活动。它提供了公司和组织一个标准的方法来交换数据，指导商业关系，交流数据通过公共的形式，定义并注册商业过程

　　exception 异常
　　一个在程序执行过程中阻止程序正常执行的事件，通常是一个错误。Java语言通过try，catch和throw关键字支持异常的处理，参见exception
handler

　　exception handler
　　一段处理特定类型的异常的代码。如果程序能够从异常中恢复过来，那么在处理完异常之后程序可以继续执行。

　　executable content
　　在HTML文件中执行的应用程序，参见applet。

　　extends 继承
　　类X 通过extend 类Y来添加功能，或者添加变量，或者添加方法，或者覆盖类Y的方法。一个接口extends另外一个接口来添加方法。类X称为类Y的一个子类，参见derived from

　　field 域
　　一个类的数据成员。除非显式指明，否则一个field不是static的

　　final
　　一个Java语言的关键字。你只能定义一个实体一次，以后不能改变它或继承它。更严格的讲：一个final修饰的类不能被子类化，一个final修饰的方法不能被重写，一个final修饰的变量不能改变其初始值。

　　finally
　　一个Java语言的关键字，用来执行一段代码不管在前面定义的try语句中是否有异常或运行时错误发生。

　　float
　　一个Java语言的关键字，用来定义一个浮点数变量

　　for
　　一个Java语言的关键字，用来声明一个循环。程序员可以指定要循环的语句，推出条件和初始化变量。

　　FTP
　　基本的Internet文件传输协议（File Transfer Protocol）。FTP是基于TCP/IP协议的，它允许在主机之间通过Internet传送文件。参见TCP/IP

　　formal parameter list
　　在一个方法的定以中指定的参数。参见actual parameter list

　　handle
　　一个标识enterprise bean的对象。客户可以串行化handle，以后从串行化中恢复handle来得到一个对enterprise bean的引用

　　hexadecimal 十六进制的
　　使用16作为基的计数系统。记号0-9和a-f（或者A-F）代表了数字0到15。在Java中16进制数必须带有0x前缀。参见octal

　　hierarchy
　　关系的一种分类，除了最高层的对象（通常称作root），每一个对象有一个专门的上层对象。每个对象可以由一个或多个下层对象在层次关系中。在Java中，root对象是Object

　　home interface
　　enterprise bean两个接口中的一个。home接口定义了0个或多个方法来创建和删除一个enterprise bean。对于session bean，home接口定义了创建和删除方法，然而对于entity bean，home接口定义了创建，查找和删除的方法。

　　home handle
　　一个对象，能够用来得到对一个home接口的引用。一个home handle能够被串行化写入持久存储器中，通过反串行化来得到这个引用。
　
　　HTML
　　HyperText Markup Language的缩写。这是一个文件格式，基于SGML，为了超文本在Internet上的传输。它十分简单，允许嵌入图片，声音，视频流，表单域和简单的文本格式。对其他对象的引用被嵌入到URLs中。

　　HTTP
　　HyperText Transfer Protocol的缩写。Internet的协议，基于TCP/IP，用来获得远程主机上的超文本。参见TCP/IP。

　　HTTPS
　　建立在SSL协议之上的超文本传输协议（HTTP）

　　IDL
　　接口定义语言（Interface Definition Language）的缩写，使用Java(TM)编写的API提供基于标准的和CORBA的交互性和连接性。

　　identifier 标识符
　　在Java程序中一个对象的名称

　　IIOP
　　Internet Inter-ORB Protocol的缩写。一个用来在CORBA对象请求代理之间交流的协议。

　　if
　　Java编程语言的一个关键字，用来生成一个条件测试，如果条件为真，就执行if下的语句。

　　implements
　　Java(TM)编程语言的一个关键字，在类的声明中是可选的，用来指明当前类实现的接口。

　　import
　　Java(TM)编程语言的一个关键字，在源文件的开始部分指明后面将要引用的一个类或整个包，这样就不必在使用的时候加上包的名字。

　　inheritance 继承
　　一个概念：一个类型会自动包含其父类型（supertypes）的变量和方法。参见superclass, subclass。

　　initialization parameter
　　初始化Servlet上下文的参数。

　　instance 实例
　　一个特定类型的对象。在Java(TM)语言中，一个对象是由new操作符创建的。
　　
　　instance method 实例方法
　　任何跟一个类的实例相关的方法，也称作method。参见class method。

　　instance variable 实例变量
　　任何和一个特定对象相关的数据项。每一个类的实例有一份类定义中声明的实例变量的拷贝，也称作field。参见class variable。

　　instanceof
　　一个二操作数的Java(TM)语言关键字，用来测试第一个参数的运行时类型是否和第二个参数兼容。

　　int
　　Java(TM)的一个关键字，用来定义一个整形变量

　　interface
　　Java(TM)的一个关键字，用来定义一系列的方法和常量。它可以被类实现，通过implements关键字。

　　Internet
　　一个由全球各个组织，各个国家的数百万的主机组成的巨大的一个网络。它是由很多小网络物理的连接在一起而成的，数据通过公共的一组协议传输。

　　IP
　　Internet Protocol的缩写，Internet的基本协议，它提供不可靠的主机间的数据包的传送。它不保证是否数据包能够正确传送，需要多久的时间来传送，或者当有多个包时是否按顺序到达。建立在该协议之上的协议提供连接和可靠性的概念。参见 TCP/IP.

　　interpreter 解释器
　　一个可选解码并且执行代码中的每一句语句的模块。Java(TM)解释器解码并执行为符合Java虚拟机规范的字节码。参见compiler, runtime system。

　　ISV
　　Independent Software Vendor的缩写

本篇文章来自Java中文网：http://javaweb.cc/other/english/2212.shtml

教程由JAVA中文网整理校对发布(javaweb.cc)

       J2EE application
　　任何可配置的J2EE功能单元。可能是由一个或多个软件模块与一个J2EE应用程序配置描述符打包成.ear文件。J2EE应用程序通常设计成在多机环境下运行的分布式应用。
　
　　J2EE product
　　一个遵循J2EE平台规范的实现。

　　J2EE Product Provider
　　提供J2EE产品的生产商。

　　J2EE server
　　J2EE Product的运行时部分。一个J2EE提供Web和/或EJB容器。

　　JAE
　　Java(TM) Application Environment的缩写。Java Development Kit (JDK(TM))的源代码。

　　JAR Files (.jar)
　　Java ARchive的缩写。一种把许多文件聚合到一个文件的一种文件格式。

　　JAR file format
　　JAR是一种把许多文件聚合到一个文件的平台无关一种文件格式。许多个用Java编写的applet以及它们所需要的组件（.class文件，图片，声音和其他资源文件）能够被打包到一个JAR文件中，以便以后在单独一个HTTP请求中就能够下载到客户端。它同样支持文件压缩和数字签名。

　　Java(TM)
　　是Sun公司的商标，标识了一系列在独立的和网络化的环境中创建并安全的运行程序的技术。

　　Java Application Environment (JAE)
　　Java Development Kit (JDK(TM))的源代码。

　　Java(TM) 2 Platform, Standard Edition (J2SE platform)
　　核心的Java技术平台

　　Java(TM) 2 Platform, Enterprise Edition (J2EE platform)
　　一个用来开发和配置企业应用程序的环境。J2EE平台由一系列的服务，应用程序接口（APIs）和提供开发多级的，基于Web的功能的协议组成。

　　Java(TM) 2 SDK, Enterprise Edition
　　Sun公司的对J2EE平台的一个实现。这个实现提供了一个可操作的J2EE平台的定义。

　　JavaBeans(TM)
　　一个可移植的，平台无关的，可重用的组件模型。

　　Java Blend(TM)
　　一个通过映射数据库数据到Java编程环境中的对象（Object）和映射对象到数据库使程序员能够简化数据库应用开发的产品。

　　Java Card(TM) API
　　一个和ISO 7816-4兼容的应用开发环境，集中在smart card上。

　　JavaCheck(TM)
　　一个工具，用来检查一个应用程序或一个applet是否符合某个规范。

　　Java(TM) Compatibility Kit (JCK)
　　一个测试包，一组工具，和其它的一些需求，用来检查一个实现是否和Java平台规范和软件参考实现兼容。

　　Java Database Connectivity (JDBC(TM))
　　一个Java平台和大量数据库平台之间互联的平台无关的工业标准。JDBC(TM)提供了调用级的API来操作支持SQL语言的数据库。

　　Java Developer Connection(SM)
　　一个为个人开发者设计的服务，提供在线训练，产品打折，专题文章，错误信息和一些早期的版本兼容性信息。

　　Java Development Kit (JDK(TM))
　　一个软件开发平台，支持使用Java语言编写Applet或应用程序。

　　Java(TM) Enterprise API
　　这个API使编写大型的，可能在一个组织中或Internet上与其它应用程序共享多媒体数据的商业或数据库应用程序变得简单。在Java(TM)
Enterprise API家族中已经有四个APIs被设计出来。

　　Java(TM) Foundation Classes (JFC)
　　一个扩展，把图形用户接口加入到抽象窗口工具集（AWT）中。

　　Java(TM) IDL
　　一个提供J2EE平台与CORBA交互能力和互联能力的技术。这些兼容性使J2EE应用程序能够通过OMG IDL和IIOP调用远程网络上的操作。

　　Java(TM) Interface Definition Language (IDL)
　　用Java编写的APIs，提供标准化的与CORBA（Common Object Request Broker Architecture）的交互能力和互联能力。

　　Java(TM) Message Service (JMS)
　　使用企业级消息系统的API，比如IBM MQ Series，TIBCO Reanezvous等。

　　Java Naming and Directory Interface(TM) (JNDI)
　　一组用来提供多重命名和目录服务的APIs的集合。

　　JavaOS(TM)
　　一个基于Java的操作系统，对各种计算和用户平台进行了优化。JavaOS(TM)操作环境提供了一个运行时规范，使Java程序能够直接运行在硬件平台之上而不需要宿主操作系统。

　　Java(TM) Platform
　　由Java编程语言，一组APIs，类库，其它在开发，编译，错误检查中要用到的程序，和一个能够装载并执行class文件的Java虚拟机组成。

　　除此之外，Java平台的目标是提供一组一致的兼容的实现。符合兼容性规范的实现能够得到Sun公司的兼容性标志。

　　Java 2是当前的一代Java平台。
　

　　Jini(TM) Technology
　　一组Java APIs，可能是任何一个Java 2平台的可选包。Jini API使网络设备和服务变得透明，不再需要用户去管理系统或网络使其正常工作。
　　Jini在目前是任何一个Java平台版本的一个可选软件包。

　　JNDI
　　Java Naming and Directory Interface(TM)的缩写，一组用来提供重命名和目录服务的APIs的集合。

　　JPEG
　　Joint Photographic Experts Group的缩写。 由这个小组建立的一个图象文件压缩标准。它通过几乎察觉不出的图象质量的损失来实现了巨大的图象压缩比。

　　JRE
　　Java(TM) runtime environment的缩写。一个Java Development Kit (JDK(TM))的子集，适合最终用户和希望重新发布运行环境的开发人员。Java runtime environment由Java虚拟机，Java核心类和支持文件组成。

　　Just-in-time (JIT) Compiler
　　一个在Java运行时，把所有字节码转换为本地代码的编译器。这样就会加速Java的执行，相对Java虚拟机的解释执行。

　　JVM
　　参见: Java(TM) Virtual Machine (JVM)

本篇文章来自Java中文网：http://javaweb.cc/other/english/2213.shtml

教程由JAVA中文网整理校对发布(javaweb.cc)

       lexical
　　关于如何把源代码翻译成各种编译器能够识别的记号

　　literal
　　整数，浮点数，字符的基本表示方法。比如，字面上3.0是一个双精度浮点数，"a"是一个字符。

　　local variable
　　一个块中可见的数据项，但是对块外面的代码是不可见的。比如，任何在一个方法中声明的变量是一个局部变量，不能在方法外面被使用。
　
　　long
　　Java语言的一个关键字，用来定义一个long类型的变量。
　　　　

　　member
　　类的一个域或者方法，除非显式指明，否则一个member不是静态的。

　　method
　　类中定义的一个方法，参见instance method, class method，除非显式指明，否则一个method不是静态的。

　　module
　　一个软件单位，由一个或多个相同容器类型的J2EE组件和一个相同类型的配置描述符组成。有三种module类型：EJB，Web，和Application Client。模块可以被配置成独立的单元或嵌入到应用程序中。

　　Mosaic
　　一个提供简单图形界面，使用户能够方便的访问Internet上的数据的程序。这些数据可能是简单文件，或者超文本文档。Mosaic是由NCSA的一个小组编写的。

　　multithreaded
　　描述一个程序，它的代码被设计成拥有多个同时被执行的部分。参见thread。

        object
　　面向对象程序的主要的一个构造块。每一个对象是一个编程单元，由数据（instance methods）和功能（instance methods）组成，参见class。

　　object-oriented design
　　一个软件设计方法，通过类和对象为抽象和具体的对象的特点建模。

　　octal
　　使用8作为基的计数系统。使用数字0-7。在Java中8进制数必须带有0前缀。参见hexadecimal。

　　One
　　Open Net Environment的缩写，由Sun组织，主要工业参与商资助，描述了一个易于理解的体系结构，用来创建，编译和配置Web服务。ONE是平台无关的，基于完全开放的标准。Sun ONE指代一个特定的由Sun和iPlanet提供的对这个体系结构的实现。

　　Optional Packages
　　一个或多个APIs的集合，在Java平台上，它们是可用的，并且可能在兼容平台上也被支持。
　　随着时间推移，Optional Packages可能因为市场需要而变成必需的。

　　ORB
　　Object Request Broker的缩写。一个函数库，使CORBA对象能够定位另一个对象且和它通讯。

　　OTS
　　Object Transaction Service的缩写，一组接口定义使CORBA对象能够处理事务。

　　overloading
　　在同一个作用域里面使用一个标识符指代多个对象。在Java语言中，你可以overload方法，但不能是变量和操作符。

　　overriding
　　在子类中对在父类中定义的方法提供一个不同的实现。
　　re-entrant enterprise bean
　　一个enterprise bean，能够被并发的，交叉的，或递归的调用，并且相互之间不干扰。

　　reference
　　一个内容是地址的数据元素。

　　remote interface
　　enterprise bean两个接口中的一个。remote接口定义了能够被客户调用的商业方法。

　　remove method
　　在home接口中定义的方法，客户端可以调用它来删除一个enterprise bean。

　　resource adapter
　　一个系统级的软件驱动，被EJB容器和应用程序客户用来连接到一个EIS。通常一个resource adapter总是针对某一特定EIS的。它以函数库的形式提供，运行在使用它的服务器或客户地址空间中。一个resource adapter插入到一个容器中。应用程序组件配置容器，然后使用客户端API（由adapter提供的）或者由高层抽象生成的工具来访问下面的EIS。resource adapter和EJB容器配合提供与EIS连接的下层机制 - 事务，安全，和连接池。

　　resource manager
　　提供访问一组共享对象的能力。一个recource manager参与一个被事务管理器外部控制和调整的事务。一个resource manager通常和访问它的客户运行在不同的主机上和不同的地址空间中。

　　resource manager connection
　　代表一个和资源管理器的会话的对象。

　　resource manager connection factory
　　一个用来创建资源管理器对象的对象。
本篇文章来自Java中文网：http://javaweb.cc/other/english/2214.shtml

教程由JAVA中文网整理校对发布(javaweb.cc)

       role (development)
　　在开发和配置一个基于J2EE技术的应用程序的过程中某个对象起到的作用。role有：应用程序组件提供者，应用程序编译者, 应用程序配置者
, J2EE平台提供者, EJB容器提供者, EJB容器提供者, Web容器提供者, Web服务器提供者,工具提供者和系统管理员。

　　role (security)
　　一个抽象的逻辑的用户组，由Application Assembler定义。当一个application被配置的时候，roles被映射到安全标识，比如负责人或者组，在操作和环境中。

　　role mapping
　　把由容器所识别的组和负责人和由配置描述符定义的安全角色联系起来的一个过程。在组件被安装到服务器之前，安全角色必须被配制器映射。

　　rollback
　　当一个事务中所有的对数据库的更新被取消的一个点。

　　root
　　在对象层次中的一个对象，所有对象都是从它继承而来的，root对象在层次图中没有上层对象，参见hierarchy, class, package。

　　RPC
　　Remote Procedure Call的缩写。通过向远程主机发送网络数据包执行，看上去就跟普通的调用过程（或方法调用）是一样的，

　　runtime system
　　一个软件环境，其中能够运行为Java虚拟机编译的程序。runtime system包含了为了装入用Java编写的程序，动态连接本地方法，内存管理，异常处理和实现一个Java虚拟机（可能是Java一个解释器）所必须的代码。SAX
　　Simple API for XML的缩写。一个为访问XML文档提供的事件驱动的，串行访问的机制。

　　Sandbox
　　由许多的系统组件组成，从作为应用程序一部分运行的安全管理器，到Java虚拟机中的和语言本身的安全措施。SandBox保证一个不可信任的，可能恶意攻击的应用程序不能访问系统资源。

　　scope
　　一个特性标识，用来规定哪些地方标识符是可见的。Java环境中的大多数标识符拥有类或者局部的scope。实例变量和类变量有类的scope；它们在类的外部或者子类中使用时必须在它们前面加上一个类名前缀（对类变量和类方法）或者类实例名。所有其他的在方法内部定义的变量具有局部scope；它们只能在封闭的块中使用。

　　Secure Socket Layer (SSL)
　　一个为了个人隐私在Web服务器和浏览器之间进行加密的协议。

　　security attributes
　　一组和负责人相关联的属性。Security attributes能够和一个负责人相关联，通过J2EE产品提供商制定的认证协议。

本篇文章来自Java中文网：http://javaweb.cc/other/english/2215.shtml

教程由JAVA中文网整理校对发布(javaweb.cc)

       security constraint
　　一个明确的方法来注释想要的对Web内容的保护。一个security constraint由一系列Web资源，一个认证限制和用户数据限制组成。

　　security context
　　一个对象，封装了跟安全有关的两个实体之间的共享状态信息。

　　security permission
　　由J2SE定义的J2EE平台用来表述应用组件供应商必须遵循的编程限制的一个机制。

　　security permission set
　　J2EE产品提供商为每一个组件类型的执行所必须提供的安全允许的最小集合。

　　security policy domain
　　一个作用域，其中安全策略被定义并且由安全管理员强制执行。一个security policy domain有以下的几个特征：
　　　它有一组用户（或者负责人）
　　　它有一个很好定义的认证协议来认证用户
　　　它可能有组的概念来简化安全策略的设置

　　security technology domain
　　一个作用域，其中同样的安全机制被用来强制执行一个安全策略。在单个technology domain中可以存在多个security policy domain。

　　server principal
　　服务器在操作系统中执行的地位。

　　servlet
　　一种扩展Web服务器功能的Java程序，动态生成文档，并且使用使用请求应答的方式和用户交互。
　
       stream
　　Stream是一个简单的从发送着到接受者的数据字节流。有两种基本的分类，所以java.io包包含两个抽象类（InputStream和OutputStream）。
　
　　subarray
　　一个在另一个数组中的数组。

　　subclass
　　从某个类派生出来的类，可能是和一个或多个类之间的关系。参见superclass, supertype。

　　subtype
　　如果类型X继承或者实现了类型Y，那么X是Y的一个subtype。参见supertype。

　　superclass
　　一个类，某个类是从它派生而来的，可能是和一个或多个类之间的关系。参见subclass, subtype。

　　super
　　Java语言的一个关键字，用来访问父类的类成员。

　　supertype
　　一个类型的父类型是指它所实现的所有接口和继承的类型，参见subtype, superclass。

　　switch
　　Java语言的关键字，用来计算一个变量，在后面用来匹配由case语句指定的值，以决定执行哪一组语句。

　　Swing Set
　　一系列图形用户接口GUI）组件的代码名称，能够在任何支持Java虚拟机的本地平台上一致的运行。因为它们是完全用Java语言编写的，这些组件可能提供的功能比本地平台提供的等价功能更为强大。（和AWT对比）

　　synchronized
　　Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。（
 
　　TCP/IP
　　Transmission Control Protocol based on IP的缩写。这是一个Internet协议，提供可靠的基于流的从一个主机到另一个的数据传输。参见IP。

　　Technology Compatibility Kit (TCK)
　　一个测试包，一组工具，和其它必需的东西，用来证明一个特定的Sun的技术的实现是否和应用程序规范兼容或者是否和Sun和Sun设计的参考实现兼容。

　　this
　　Java语言的关键字，用来代表它出现的类的一个实例。this可以用来访问类变量和类方法。
 
 

　　UDDI
　　Universal Description Discovery and Integration的缩写。UDDI提供了一个全局的，公共的，基于XML的，在线的商业注册，商业用户通过它可以注册并宣传它们的Web服务。UDDI定义Internet版的白页和黄页电话号码本。

　　Unicode
　　ISO 10646定义的16位长的字符集。参见ASCII。Java环境中所有的源代码都是用Unicode编写的。

　　URI
　　Uniform Resource Identifier的缩写。一个用来标识抽象或物理资源的简洁字符串。一个URI或者是一个URL或者是一个URN。URLs和URNs是具体的确实存在的实体。URI是一个抽象的父类。

　　URL
　　Uniform Resource Locator的缩写。一个使用文本指代WWW网站上任意数据的标准。一个URL通常是这样的"protocol://host/localinfo"，protocol指明传输对象的时候使用的协议（比如HTTP或FTP），host指明在Internet上找到一台主机的名字，localinfo是一个传递给远程主机上协议处理器的字符串（常常是一个文件名）。

　　URL path
　　通过一个HTTP请求传递的URL，来使用一个servlet。URL由Context Path + Servlet Path + PathInfo组成，其中被请求的servlet是与Context Path相关联的servlet上下文的一部分。如果这个上下文是默认的上下文，以Web服务器的URL名字空间的基目录为根，那么这个路径前缀将会是一个空字符串。否则这个路径前缀以/开始，但是不是以/结束。Servlet Path部分直接和激活这个请求的映射对应。这个路径以/字符开始。PathInfo是请求路径的一部分，但不是Context Path或者Servlet Path的一部分。

　　URN
　　Uniform Resource Name的缩写。唯一标识一个实体的标识符，但是不能给出实体的位置。系统可以先在本地寻找一个实体，在它试着在Web上找到该实体之前。它也允许Web位置改变，然而这个实体却还是能够被找到。
 
　　variable
　　由一个标识符命名的数据项。每一个variable有一种类型，比如一个整数或者一个对象，和一个作用域。参见class variable, instance variable, local variable。

　　virtual machine
　　一个抽象的计算设备规范，可以使用不同的方法实现，软件的或者硬件的。你把程序编译成virtual machine的指令集和你把程序编译成微处理器指令集是十分相似的。Java(TM) virtual machine*由字节码指令集合，一组寄存器，一个堆栈，一个垃圾收集堆和一个存放方法的区域
本篇文章来自Java中文网：http://javaweb.cc/other/english/2216.shtml

教程由JAVA中文网整理校对发布(javaweb.cc)

       vocabulary
　　传统上，软件程序被编写，然后编译成直接和计算机中驱动微处理器工作的操作系统相关的机器码。Java平台通过提供一个程序编写编译，然后能够通过网络传输并且在任何由足够兼容性的虚拟机的平台上运行的模型减轻了这种依赖型。

　　这个模型提供了额外的好处，高安全性，即因为程序可以被虚拟机验证一致性在通过网络传输之后，也因为虚拟机运行在安全的"sandbox"的中，能够阻止一些特定的破坏性的行为。

　　软件开发人员已经投入Java语言的怀抱，因为它减少了编写程序和支持软件代码的费用和时间。他们不再需要为不同的操作系统和不同的微处理器重新编写功能相同的代码。正在配置应用程序的公司和组织喜欢Java，因为它减少了购买和修改不同版本的应用程序使其适应各自网络环境中各种类型的计算机和服务器的费用。

　　void
　　Java语言的关键字，用在Java语言的方法声明中说明这个方法没有任何返回值。"void"也可以用来表示一句没有任何功能的语句。

　　volatile
　　Java语言的关键字，用在变量的声明中表示这个变量是被同时运行的几个线程异步修改的。
　　一个UNIX命令，使用它将会等待所有的后台进程结束，并且报告他们的结束状态。

　　Web application, distributable
　　用J2EE技术编写的应用程序，所以它可以被配置到一个分布运行在一台或多台主机的多个Java虚拟机中的Web容器中。这种类型的应用程序的配置描述符使用可分布的元素。

　　Web component
　　一个通过相应为请求提供服务的组件，或者是一个Servlet或者是一个JSP页面。

　　Web container
　　实现J2EE体系结构中Web组件协议的容器。这个协议规定了一个Web组件运行时的环境，包括安全，一致性，生命周期管理，事务，配置和其它的服务。一个提供和JSP和J2EE平台APIs界面相同服务的容器。一个Web container 由Web服务器或者J2EE服务器提供。

　　Web container, distributed
　　一个Web容器，能够运行一个标记为分布式的，在同一台主机或不同主机上的多个Java虚拟机中运行的Web应用程序。

　　Web server
　　提供访问Inetrnet，Intranet或者Extranet服务的软件。一个Web server运行在Web站点上，提供对HTTP和其它协议的支持，并且运行服务器端的程序（比如CGI脚本或者servlets）来实现一定的功能。在J2EE体系结构中，Web Server为Web容器提供服务。比如，一个Web容器通常依靠Web Server来处理HTTP消息。J2EE平台假设一个Web容器总是运行在同一个厂商提供的Web Server之上，所以没有制定这两个实体之间的协议。一个Web Server可以运行一个或多个Web容器。

IO(Input OutPut)流

IO流用来处理设备之间的数据传输

JAVA对数据的操作是通过流的方式

JAVA用于操作流的对象都在IO包中

流按操作对象分为两种: 字节流,字符流

流按流向分为: 输入流,输出流.

其它的内容还是比较简单的,注意的是以下这几个自定义包装类:

实现1.

MyBufferedReader.class

 1 package com.javami.kudy.Code13;
 2 import java.io.IOException;
 3 import java.io.Reader;  //读取字符流的抽象类
 4 import java.io.IOException;
 5 /*
 6  * 自定义MyBufferedReader包装Reader,提供了一个缓冲区的功能.提供了ReadLine功能.
 7  * 1.用一个次组合,拿到被包装的Reader对象
 8  * 2.定义一个字符数组作为缓冲区
 9  * 3.实现一个read方法,填充缓冲区,从缓冲区那里返回一个字符
10  * 4.定义一个readLine方法,内部调用read方法,循环读取一行,进行返回
11  * 5.定义一个close方法,关闭地底层所包装的流
12  */
13 public class MyBufferedReader  extends Reader{
14     private Reader r;
15     char[] buf = new char[1024];
16     int len =0;
17     int pos = 0;
18     public MyBufferedReader(Reader r)
19     {
20         this.r = r;
21     }
22     /*
23      * 实现read()方法,实现缓存的功能
24      * 分析:
25      * 1.当别人第一次调用该方法的时,一次性的去填充缓冲区
26      * 2.定义一个len变量记住缓冲区的可用字符的数量
27      * 3.将数组的第一个元素返回
28      * 4.当别人第二次调用的时,将数组的二个元素返回
29      * 5.每次返回元素 len --
30      * 6.当len为零时,说明数组没有可用字符啦,那么这时候返回一个-1
31      * 
32      * 思路:
33      * 1.定义两个成员变量,len记住可用字符数量,pos记住当前字符的角标
34      * 2.判断len是否为0,如果为零要填充缓冲区.并且pos为零
35      * 3.判断len,如果为-1,则返回-1
36      * 4.将pos位置的元素返回.pos++
37      */
38     public int read() throws IOException
39     {
40         if(len ==0)
41         {
42             len = r.read(buf);
43             pos = 0;
44         }
45         if(len==-1)
46             return -1;
47         len--;
48         return buf[pos++];
49     }
50     
51     /*
52      * 实现readLine方法,实现读一行的功能,
53      * 1.循环调用自己的方法的read方法,读取字符
54      * 2.知道回车的字符,方法就结束
55      */ 
56     public String readLine() throws IOException
57     {
58         StringBuilder sb = new StringBuilder();
59         int ch;
60         while((ch=read())!=-1)
61         {
62             if(ch=='\r')
63                 continue;
64             if(ch=='\n')
65                 break;
66             sb.append((char)ch);
67             if(ch==-1&&sb.length()==0)
68                 return null;
69         }
70         return sb.toString(); //转换成字符串
71     }
72     @Override
73     public void close() throws IOException {
74         r.close();
75     }
76 
77     @Override
78     public int read(char[] cbuf, int off, int len) throws IOException {
79         int count=0;
80         for(int i=0; i<off+len; i++)
81         {
82             int ch = read();
83             if(ch==-1)
84                 break;
85             count++;
86             buf[i] = (char)ch;
87         }
88         return count;
89     }
90 
91     
92     
93 }

MyBufferedWriter.class  这个主要是写入

 1 package com.javami.kudy.Code13;
 2 import java.io.IOException;
 3 import java.io.Writer;
 4 
 5 public class MyBufferedWriter  extends Writer{
 6     
 7     private Writer w;
 8     private char[] buf = new char[1024];
 9     private int pos = 0;
10     
11     public MyBufferedWriter(Writer w)
12     {
13         this.w = w;
14     }
15     /*
16      * 定义Writer方法,实现写一个字符,实现缓存的功能
17      * 1.定义一个变量pos记住当前的写入位置
18      * 2.每次调用都使用这个方法都会传入一个字符,将字符缓存到数组pos位置里面去
19      * 3.pos++
20      * 4.每次上来就判断,如果pos =1024,刷新缓冲区 ,pos = 0
21      */
22     public void Writer(int ch)throws IOException
23     {
24         if(pos == 1024)
25         {
26             flush(); //刷新一下缓冲区.并且初始化为零
27             pos = 0;
28         }
29         buf[pos++] = (char)ch;
30     }
31     @Override
32     public void close() throws IOException {
33         flush();
34         w.close();
35     }
36 
37     @Override
38     public void flush() throws IOException { 
39         w.write(buf,0,pos); //把buf0-pos位置的内容写入进去
40     }
41     public void writer(String data)throws IOException
42     {
43         char[] chars = data.toCharArray(); //转换成字符
44         for(char c : chars)
45             write(c);
46     }
47     public void newline()throws IOException
48     {
49         write("\r\n"); //所谓的换行就是一个
50     }
51     @Override
52     public void write(char[] cbuf, int off, int len) throws IOException {
53         for(int i=0; i<off+len; i++)
54         {
55             w.write(buf[i]);
56         }
57         
58     }
59 
60 }

由于每次都要关闭流啊~~无奈.只好使用一个类来实现它们

CloseUtil.class

 1 package com.javami.kudy.Code13;
 2 import java.io.IOException;
 3 import java.io.Reader;
 4 import java.io.Writer;
 5 public class CloseUtil {
 6     private CloseUtil(){}
 7     public static void close(Reader r,Writer w)throws IOException
 8     {
 9         try
10         {
11             if(r!=null)
12                 r.close();
13         }
14         finally
15         {
16             if(w!=null)
17             w.close();
18         }
19     }
20 }

一个简单的测试类:

 1 package com.javami.kudy.Code13;
 2 import java.io.FileReader;
 3 import java.io.FileWriter;
 4 import java.io.IOException;
 5 
 6 public abstract class BufferedTest {
 7 
 8     /**
 9      * @param args
10      */
11     public static void main(String[] args)
12     {
13         MyBufferedReader mr = null;
14         MyBufferedWriter mw = null;
15         try
16         {
17             mr = new MyBufferedReader(new FileReader("src/a.txt"));
18             mw = new MyBufferedWriter(new FileWriter("src/b.txt"));
19             int len;
20             while((len=mr.read())!=-1)
21             {
22                 mw.Writer(len);
23             }
24         }
25         catch(IOException e)
26         {
27             e.printStackTrace();
28         }
29         finally
30         {
31             try
32             {
33                 CloseUtil.close(mr, mw);
34             }
35             catch(IOException e)
36             {
37         }
38         }
39     }
40 }

BufferedReader 与 BufferedWriter 的存储图:

以上这几个都是比较难理解的..~~

加油啦..