java流的读写
① java的几种IO流读取文件方式
一、超类：
字节流： InputStream（读入流） OutputStream(写出流）
字符流： Reader（字符 读入流） Writer （字符写出流）
二、文件操作流
字节流： FileInputStream ，FileOutputStream
字符流： FileReader, FileWriter(用法与字节流基本相同，不写）
//1.指定要读 的文件目录及名称
File file =new File("文件路径");
//2.创建文件读入流对象
FileInputStream fis =new FileInputStream(file);
//3.定义结束标志,可用字节数组读取
int i =0 ;
while((i = fis.read())!=-1){
//i 就是从文件中读取的字节，读完后返回-1
}
//4.关闭流
fis.close();
//5.处理异常
//1.指定要写到的文件目录及名称
File file =new File("文件路径");
//2.创建文件读入流对象
FileOutputStream fos =new FileOutputStream(file);
//3.定义结束标志
fos.write(要写出的字节或者字节数组);
//4.刷新和关闭流
fos.flush();
fos.close();
//5.处理异常
三、缓冲流：
字节缓冲流： BufferedInputStream,BufferedOutputStream
字符缓冲流：BufferedReader ,BufferedWriter
缓冲流是对流的操作的功能的加强，提高了数据的读写效率。既然缓冲流是对流的功能和读写效率的加强和提高，所以在创建缓冲流的对象时应该要传入要加强的流对象。
//1.指定要读 的文件目录及名称
File file =new File("文件路径");
//2.创建文件读入流对象
FileInputStream fis =new FileInputStream(file);
//3.创建缓冲流对象加强fis功能
BufferedInputStream bis =new BufferedInputStream(fis);
//4.定义结束标志,可用字节数组读取
int i =0 ;
while((i = bis.read())!=-1){
//i 就是从文件中读取的字节，读完后返回-1
}
//5.关闭流
bis.close();
//6.处理异常
//1.指定要写到的文件目录及名称
File file =new File("文件路径");
//2.创建文件读入流对象
FileOutputStream fos =new FileOutputStream(file);
//3.创建缓冲流对象加强fos功能
BufferedOutputStream bos=new BufferedOutputStream(fos);
//4.向流中写入数据
bos.write(要写出的字节或者字节数组);
//5.刷新和关闭流
bos.flush();
bos.close();
//6.处理异常
四、对象流
ObjectInputStream ,ObjectOutputStream
不同于以上两种类型的流这里只能用字节对对象进行操作原因可以看上篇的编码表比照原理
ObjectOutputStream对象的序列化：
将java程序中的对象写到本地磁盘里用ObjectOutputStream
eg：将Person类的对象序列化到磁盘
创建Person类
注1：此类要实现Serializable接口，此接口为标志性接口
注2：此类要有无参的构造函数
注3：一旦序列化此类不能再修改
class Person implements Serializable{
public Person(){}
}
2.创建对象流对象
注：要增强功能可以将传入文件缓冲流
ObjectOutputStream oos =new ObjectOutputStream(
new FileOutputStream(new File("文件路径")));
3.写入对象 ，一般会将对象用集合存储起来然后直接将集合写入文件
List<Person> list =new ArrayList<>();
list.add(new Person());
...(可以添加多个）
oos.writeObject(list);
4.关闭流，处理异常
oos.flush();
oos.close();
五、转换流：
这类流是用于将字符转换为字节输入输出，用于操作字符文件，属于字符流的子类，所以后缀为reader，writer；前缀inputstream，outputstream；
注 ：要传入字节流作为参赛
InputStreamReader: 字符转换输出流
OutputStreamWriter：字符转换输入流
//1.获取键盘输入的字节流对象
inInputStream in =Stream.in;
/*2.用转换流将字节流对象转换为字符流对象，方便调用字符缓冲流的readeLine()方法*/
InputStreamReader isr =new InputStreamReader(in);
/*5.创建字符转换输出流对象osw，方便把输入的字符流转换为字节输出到本地文件。*/
OutputStreamWriter osw =new OutputStreamWriter(new
FileOutputStream(new File("文件名")));
/*3.现在isr是字符流，可以作为参数传入字符缓冲流中*/
BufferedReader br =new BufferedReader(isr);
/*4.可以调用字符缓冲流br的readLine()方法度一行输入文本*/
String line =null;
while((line =br.readLine()){
osw.write(line);//osw是字符流对象，可以直接操作字符串
}
注：InputStreamReader isr =new InputStreamReader(new "各种类型的字节输入流都行即是：后缀为InputStream就行");
OutputStreamWriter osw =new OutputStreamWriter(new
"后缀为OutputStream就行");
六、区别记忆
1.对象流是可以读写几乎所有类型的只要是对象就行，而字节字符流，只能读写单个字节字符或者字节字符数组，以上没有读写字节字符数组的；注意对象流只有字节流！
2.字符和字节循环读入的结束条件int i=0; (i =fis.read())!=-1
用字符数组复制文件(fr 读入流 ，fw写出流）,字节流也是相同的用法
int i = 0; char[] c = new char[1024];
while((i = fr.reade()) !=-1)）{
fw.write(c,0,i);
}
123456
3.对象流里面套缓冲流的情景：
new ObjectInputStream(new BufferedInputStream(new FileInputStream(new File(“文件路径”))));
4.记忆流及其功能的方法：
前缀表示功能，后缀表示流的类型；
比如说FileInputStream 前缀：File,表示操作的磁盘，后缀：intputstream,表示是字节输入流。
同理 FileReader：表示操作文件的字符流
ObjectInputStream ：操作对象的字节输入流
5.拓展：获取键盘输入的字符的缓冲流的写法：
new BufferedReader(new InputStreamReader(System.in)));
将字节以字符形式输出到控制台的字符缓冲流的写法：
new BufferedWriter（ new OutputStreamWriter（System.out))
② java中怎么用io流读写文件
importjava.io.BufferedReader;
importjava.io.BufferedWriter;
importjava.io.FileReader;
importjava.io.FileWriter;
importjava.io.IOException;
publicclassTest14{
publicstaticvoidmain(String[]args)throwsIOException{
StringfPath="C:/test.txt";
//读
BufferedReaderbr=newBufferedReader(newFileReader(fPath));
System.out.println(br.readLine());
br.close();////使用后记得关闭
//写
BufferedWriterbw=newBufferedWriter(newFileWriter(fPath));
bw.write("写一段话到文件里");
bw.flush();
bw.close();//使用后记得关闭
}
}
③ java中关于文件流的读写(Writer Reader)
public class BufferedReader extends Reader
{
public BufferedReader (Reader in)//构造方法
public class BufferedReader (Reader in,int sz)//sz 指定字符缓冲区长度
public String readLine()throws IOException//读取一行字符串，输入流结束时返回null
}
public class BufferedWriter extends Writer
{
public BufferedWriter (Writer out)//构造方法
public class BufferedWriter(Writer out,int sz)//sz 指定字符缓冲区长度
public void newLine()throws IOException//写入一个换行符
}
④ java中关于文件流的读写(Writer Reader)
你好 我刚刚做了个例子 方便你看
class_writer class 这个例子是从 一个文件中读取数据然后插入了数据库中 你可以只看读取与插入的过程 希望能帮到你.
public class writer {
public boolean writ(String str) {
boolean success=false;
str = str.replaceAll(" ", "").replaceAll("\"", "");
String[] strs = str.split(",");
BaseJDBC base = new BaseJDBC();
String ML = "";
Statement stmt;
Connection conn;
ML = "'"+strs[0].replace(" ", "").trim() + "','"
+ strs[1].replace(" ", "").trim() + "','"
+ strs[2].replace(" ", "").trim() + "','"
+ strs[3].replace(" ", "").trim() + "','"
+ strs[4].replace(" ", "").trim()+ "','"
+ strs[5].replace(" ", "").trim()+"','"
+ strs[6].replace(" ", "").trim()+"'";
String query = "INSERT INTO BANK_INFO VALUES(" + ML + ")";
if (!strs[0].equals("参与者行号")) {
try {
conn=base.genConn();
stmt = conn.createStatement();
int num=stmt.executeUpdate(query);
if(num==1)success=true;
stmt.close();
conn.close();
System.out.println();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println(e.getMessage());
}
}
return success;
}
//class readingclass
public class reading {
public static void readFileByLines(String fileName) {
File file = new File(fileName);
BufferedReader reader = null;
try {
reader = new BufferedReader(new FileReader(file));
String tempString = null;
int line = 1;
while ((tempString = reader.readLine()) != null) {
writer w=new writer();
try {
tempString.getBytes("utf-8");
} catch (UnsupportedEncodingException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
if(!w.writ(tempString)){
System.out.println("第"+line+"行出现异常："+tempString);
}else{
System.out.println("第"+line+"行初始化成功！");
}
line++;
}
reader.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e1) {
}
}
}
}
//1927
public static void main(String[] args) {
// TODO Auto-generated method stub
String fileName = "D:\\BankInfo_20110714094211.csv";
readFileByLines(fileName);
}
⑤ java 中简述使用流进行读写文本文件的步骤
InputStream
三个基本的读方法
abstract int read() ： 读取一个字节数据，并返回读到的数据，如果返回-1，表示读到了输入流的末尾。
int read(byte[] b) ： 将数据读入一个字节数组，同时返回实际读取的字节数。如果返回-1，表示读到了输入流的末尾。
int read(byte[] b, int off, int len) ：将数据读入一个字节数组，同时返回实际读取的字节数。如果返回-1，表示读到了输入流的末尾。off指定在数组b中存放数据的起始偏移位置；len指定读取的最大字节数。
OutputStream
三个基本的写方法
abstract void write(int b) ：往输出流中写入一个字节。
void write(byte[] b) ：往输出流中写入数组b中的所有字节。
void write(byte[] b, int off, int len) ：往输出流中写入数组b中从偏移量off开始的len个字节的数据。
其它方法
void flush() ：刷新输出流，强制缓冲区中的输出字节被写出。
void close() ：关闭输出流，释放和这个流相关的系统资源。
⑥ java缓冲流读写数据
---下面都是以字节流方式操作---
//读数据：
BufferedInputStreambis=newBufferedInputStream(newFileInputStream("xx.xx"));
byte[]b=newbyte[1024];
intlen=0;
while((len=bis.read(b))!-1){
//这样就读取并输出了，如果是别的文件的话乱码，因为二进制文件
System.out.println(newString(b,0,len));
}
bis.close();//关闭流，节省资源
//写数据：
BufferedOutputStreambos=newBufferedOutputStream(newFileOuputStream("xx.xx"));
//使用缓冲区写二进制字节数据
bos.write("xxxxx".getBytes());
bos.close();//关闭流，节省资源
如果字符流的话就是：
BufferedReader //读取
BufferedWriter //写入
⑦ java中字节流读写和字符流读写怎么理解
字节流与字符流主要的区别是他们的的处理方式
字节流是最基本的，所有的InputStream和OutputStream的子类都是,主要用在处理二进制数据，它是按字节来处理的
但实际中很多的数据是文本，又提出了字符流的概念，它是按虚拟机的encode来处理，也就是要进行字符集的转化
这两个之间通过 InputStreamReader,OutputStreamWriter来关联，实际上是通过byte[]和String来关联
在实际开发中出现的汉字问题实际上都是在字符流和字节流之间转化不统一而造成的
在从字节流转化为字符流时，实际上就是byte[]转化为String时，
public String(byte bytes[], String charsetName)
有一个关键的参数字符集编码，通常我们都省略了，那系统就用操作系统的lang
而在字符流转化为字节流时，实际上是String转化为byte[]时，
byte[] String.getBytes(String charsetName)
也是一样的道理
⑧ 如何使用Java 输出/输出流进行读写数据
在“面向对象编程：Java collection更有效管理elements”一文中，我们讨论了Java 集合类架构中的类和功能并介绍了它的排序功能。在本文中，我们将学习Java 平台提供的这些I/O类，接口和操作。让我们先从了解Java 数据流开始。 数据流 Java所有的I/O机制都是基于数据流的，这些数据流表示了字符或者字节数据的流动序列。Java的I/O流提供了读写数据的标准方法。任何Java中表示数据源的对象都会提供以数据流的方式读写它的数据的方法。 Java.io是大多数面向数据流的输入/输出类的主要软件包。这个软件包包含了两个抽象类，InputStream和OutputStream。所有其它面象数据流的输入/输出类都要扩展这两个基类。 java.io软件包提供了一些类和接口，它们在由InputStream和OuputStream类提供的读写操作的顶端定义了一些有用的抽象。例如，ObjectInputStream类提供了让你把输入/输出流中的数据当成对象来读取的方法，而ObjectOutputStream类提供了让你能够把Java对象写入数据流中的方法。 优化读写过程 JDK 1.1 增加了一套读写类，它们提供了比现有数据流类更有用的抽象和更好的输入/输出性能。例如，BufferedReader和BufferedWriter 类被用来从基于字符的输入和输出流中读取和写入文本。BufferdReader 类缓存字符以更高效的读取字符串，数组和文本行。BufferedWriter类缓存字符以更高效的写入字符串，数组和文本行。BufferedReader和BufferedWriter 类可以按需求进行设置。 Java输入/输出架构提供的读取器和写入器类包括 LineNumberReader 类，CharArrayReader类，FileReader类，FilterReader类，PushbackReader类，PipedReader类，StringReader类以及其它一些类。这些类是在InputStream和OuputStream类顶部的包裹类因此提供了与InputStream和OuputStream类相似的方法。但是，这些类为读写特定的对象，比方文件，字符数组和字符串等等提供了更高效而有用的抽象。 读取数据 当你从一个相应的数据源对象里提取输入流或者是创建一个读取器对象的时候就会自动打开一个输入流。例如，要为一个文件打开输入流，我们只需要以下面的方式把文件名传递给Java.io.FileReader对象的构造函数： java.io.FileReader fileReader = new java.io.FileReader("/home/me/myfile.txt".net/forum/images/smiles/icon_wink.gif border=0>; 要按顺序读取FileReader底层的输入流中的一个字节数据，只需要使用不带参数的read方法。表A中的代码段从一个文件读取文本数据，一次一个字符，然后把它写入System.out里。 要从输入流读取指定数目的字节数据到char数组里，只需要使用带一个char[]参数的read方法。数组的长度被用来确定应该读取的字符的个数。表B演示了这个技术。 要关闭一个输入流以及这个流使用的所有系统资源，你只需要以下面的方式调用close方法： fileReader.close(); 写入数据 象一个输入流一样，输出流通常在你从相应的数据源提取它或者是在你创建一个写入对象的时候被自动的打开。例如，要为一个文件打开输出流，我们把文件的名字传递给java.io.FileWriter对象的构造函数，如下所示： java.io.FileWriter fileWriter = new java.io.FileWriter("/home/me/out.txt".net/forum/images/smiles/icon_wink.gif border=0>; 要将一个特定的字符写入到输出流中，可以使用带一个int参数的write方法，int参数代表要定入的字符。 int aChar = (int)'X'; fileWriter.write(aChar); 要在输出流给定的偏移地址写入一个char数组中特定数目的字符，你可以使用带一个char[]参数，一个int 偏移量参数和一个int长度参数的write方法，如下面的例子所示： fileWriter.write(buffer, 0, byteCount); 要关闭一个输出流并释放所有与之相关的系统资源，可以使用close方法，就象这样： fileWriter.close(); 要强迫写出一个输出流中的所有数据，可以使用下面的flush方法： fileWriter.flush(); 把它们全部综合起来 我们可以使用我们学习过的这些函数从一个文件中读取数据并同时写到另一个文件中去，如表C所示。 总结Java的输入/输出机制为从不同的数据源读取和写入字符增加了一套简单而标准化的API。你对一种数据源使用Java流的经验能够让你容易的使用其它由Java提供的数据源类型。 在我们下一篇文章中，我们将会开始学习Java平台的联网和远程通讯架构。我们将会把我们对Java流的讨论扩展到这些环境并演示如何打开远程数据源，并象操作本地数据源，比方文件一样，写入数据和读取数据
⑨ java 文件读写流
读写是两个不同的分支，通常都是分开单独使用的。
可以通过BufferedReader 流的形式进行流缓存，之后通过readLine方法获取到缓存的内容。
BufferedReader bre = null;
try {
String file = "D:/test/test.txt";
bre = new BufferedReader(new FileReader(file));//此时获取到的bre就是整个文件的缓存流
while ((str = bre.readLine())!= null) // 判断最后一行不存在，为空结束循环
{
System.out.println(str);//原样输出读到的内容
}；
备注： 流用完之后必须close掉，如上面的就应该是：bre.close()，否则bre流会一直存在，直到程序运行结束。
可以通过“FileOutputStream”创建文件实例，之后过“OutputStreamWriter”流的形式进行存储，举例：
OutputStreamWriter pw = null;//定义一个流
pw = new OutputStreamWriter(new FileOutputStream(“D:/test.txt”),"GBK");//确认流的输出文件和编码格式，此过程创建了“test.txt”实例
pw.write("我是要写入到记事本文件的内容");//将要写入文件的内容，可以多次write
pw.close();//关闭流
备注：文件流用完之后必须及时通过close方法关闭，否则会一直处于打开状态，直至程序停止，增加系统负担。
⑩ java 中简述使用流进行读写文本文件的步骤
一、Java IO学习基础之读写文本文件
Java的IO操作都是基于流进行操作的，为了提高读写效率一般需要进行缓冲。
简单的示例程序如下：
/**
* 读出1.txt中的内容，写入2.txt中
*
*/
import java.io.*;
public class ReadWriteFile{
public static void main(String[] args){
try{
File read = new File("c:\\1.txt");
File write = new File("c:\\2.txt");
BufferedReader br = new BufferedReader(
new FileReader(read));
BufferedWriter bw = new BufferedWriter(
new FileWriter(write));
String temp = null;
temp = br.readLine();
while(temp != null){
//写文件
bw.write(temp + "\r\n"); //只适用Windows系统
//继续读文件
temp = br.readLine();
}
bw.close();
br.close();
}catch(FileNotFoundException e){ //文件未找到
System.out.println (e);
}catch(IOException e){
System.out.println (e);
}
}
}
以上是一个比较简单的基础示例。本文上下两部分都是从网上摘抄，合并在一起，方便下自己以后查找。
二、Java IO学习笔记+代码
文件对象的生成和文件的创建
/*
* ProcessFileName.java
*
* Created on 2006年8月22日, 下午3:10
*
* 文件对象的生成和文件的创建
*/
package study.iostudy;
import java.io.*;
public class GenerateFile
{
public static void main(String[] args)
{
File dirObject = new File("d:\\mydir");
File fileObject1 = new File("oneFirst.txt");
File fileObject2 = new File("d:\\mydir", "firstFile.txt");
System.out.println(fileObject2);
try
{
dirObject.mkdir();
}catch(SecurityException e)
{
e.printStackTrace();
}
try
{
fileObject2.createNewFile();
fileObject1.createNewFile();
}catch(IOException e)
{
e.printStackTrace();
}
}
}
文件名的处理
/*
* ProcessFileName.java
*
* Created on 2006年8月22日, 下午3:29
*
* 文件名的处理
*/
package study.iostudy;
import java.io.*;
/*
* 文件名的处理
* String getName(); 获得文件的名称，不包含文件所在的路径。
* String getPath(); 获得文件的路径。
* String getAbsolutePath(); 获得文件的绝对路径。
* String getParent(); 获得文件的上一级目录的名称。
* String renameTo(File newName); 按参数中给定的完整路径更改当前的文件名。
* int compareTo(File pathName); 按照字典顺序比较两个文件对象的路径。
* boolean isAbsolute(); 测试文件对象的路径是不是绝对路径。
*/
public class ProcesserFileName
{
public static void main(String[] args)
{
File fileObject1 = new File("d:\\mydir\\firstFile.txt");
File fileObject2 = new File("d:\\firstFile.txt");
boolean pathAbsolute = fileObject1.isAbsolute();
System.out.println("* * * * * * * * * * * * * * * * * * * * * * * * ");
System.out.println("There are some information of fileObject1's file name:");
System.out.println("fileObject1: " + fileObject1);
System.out.println("fileObject2: " + fileObject2);
System.out.println("file name: " + fileObject1.getName());
System.out.println("file path: " + fileObject1.getPath());
System.out.println("file absolute path: " + fileObject1.getAbsolutePath());
System.out.println("file's parent directory: " + fileObject1.getParent());
System.out.println("file's absoulte path: " + pathAbsolute);
int sameName = fileObject1.compareTo(fileObject2);
System.out.println("fileObject1 compare to fileObject2: " + sameName);
fileObject1.renameTo(fileObject2);
System.out.println("file's new name: " + fileObject1.getName());
}
}
测试和设置文件属性
/*
* SetterFileAttribute.java
*
* Created on 2006年8月22日, 下午3:51
*
* 测试和设置文件属性
*/
package study.iostudy;
import java.io.*;
public class SetterFileAttribute
{
/*
* File类中提供的有关文件属性测试方面的方法有以下几种：
* boolean exists(); 测试当前文件对象指示的文件是否存在。
* boolean isFile(); 测试当前文件对象是不是文件。
* boolean isDirectory(); 测试当前文件对象是不是目录。
* boolean canRead(); 测试当前文件对象是否可读。
* boolean canWrite(); 测试当前文件对象是否可写。
* boolean setReadOnly(); 将当前文件对象设置为只读。
* long length(); 获得当前文件对象的长度。
*/
public static void main(String[] args)
{
File dirObject = new File("d:\\mydir");
File fileObject = new File("d:\\mydir\\firstFile.txt");
try
{
dirObject.mkdir();
fileObject.createNewFile();
}catch(IOException e)
{
e.printStackTrace();
}
System.out.println("* * * * * * * * * * * * * * * * * * * * * * * * ");
System.out.println("there are some information about property of file object:");
System.out.println("file object : " + fileObject);
System.out.println("file exist? " + fileObject.exists());
System.out.println("Is a file? " + fileObject.isFile());
System.out.println("Is a directory?" + fileObject.isDirectory());
System.out.println("Can read this file? " + fileObject.canRead());
System.out.println("Can write this fie? " + fileObject.canWrite());
long fileLen = fileObject.length();
System.out.println("file length: " +fileLen);
boolean fileRead = fileObject.setReadOnly();
System.out.println(fileRead);
System.out.println("Can read this file? " + fileObject.canRead());
System.out.println("Can write this fie? " + fileObject.canWrite());
System.out.println("* * * * * * * * * * * * * * * * * * * * * * * * ");
}
}
文件操作方法
/*
* FileOperation.java
*
* Created on 2006年8月22日, 下午4:25
*
* 文件操作方法
*/
package study.iostudy;
import java.io.*;
/*
* 有关文件操作方面的方法有如下几种:
* boolean createNewFile(); 根据当前的文件对象创建一个新的文件。
* boolean mkdir(); 根据当前的文件对象生成一目录，也就是指定路径下的文件夹。
* boolean mkdirs(); 也是根据当前的文件对象生成一个目录，
* 不同的地方在于该方法即使创建目录失败，
* 也会成功参数中指定的所有父目录。
* boolean delete(); 删除当前的文件。
* void deleteOnExit(); 当前Java虚拟机终止时删除当前的文件。
* String list(); 列出当前目录下的文件。
*/
public class FileOperation
* 找出一个目录下所有的文件
package study.iostudy;
import java.io.*;
public class SearchFile
{
public static void main(String[] args)
{
File dirObject = new File("D:\\aa");
Filter1 filterObj1 = new Filter1("HTML");
Filter2 filterObj2 = new Filter2("Applet");
System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
System.out.println("list HTML files in directory: " + dirObject);
String[] filesObj1 = dirObject.list(filterObj1);
for (int i = 0; i < filesObj1.length; i++)
{
File fileObject = new File(dirObject, filesObj1[i]);
System.out.println(((fileObject.isFile())
? "HTML file: " : "sub directory: ") + fileObject);
}
System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
String[] filesObj2 = dirObject.list(filterObj2);
for (int i = 0; i < filesObj2.length; i++)
{
File fileObject = new File(dirObject, filesObj2[i]);
System.out.println(((fileObject.isFile())
? "htm file: " : "sub directory: ") + fileObject);
}
}
}
class Filter1 implements FilenameFilter
{
String fileExtent;
Filter1(String extentObj)
{
fileExtent = extentObj;
}
public boolean accept(File dir, String name)
{
return name.endsWith("." + fileExtent);
}
}
class Filter2 implements FilenameFilter
{
String fileName;
Filter2(String fileName)
{
this.fileName = fileName;
字符流处理
* ProcesserCharacterStream.java
* 字符流处理
*
* java.io包中加入了专门用于字符流处理的类，这些类都是Reader和Writer类的子类，
* Reader和Writer是两个抽象类，只提供了一系列用于字符流处理的接口，不能生成这
* 两个类的实例。
* java.io包中用于字符流处理的最基本的类是InputStreamReader和OutputStreamWriter，
* 用来在字节流和字符流之间作为中介。
*
* 下面是InputStreamReader类和OutputStreamWriter类的常用方法：
*
* public InputStreamReader(InputStream in)
* 根据当前平台缺省的编码规范，基于字节流in生成一个输入字符流。
* public InputStreamReader(InputStream in, String sysCode)throws UnSupportedEncodingException
* 按照参数sysCode指定的编码规范，基于字节流in构造输入字符流，如果不支持参数sysCode中指定的编码规范，就会产生异常。
* public OutputStreamWriter(OutputStream out)
* 根据当前平台缺省的编码规范，基于字节流out生成一个输入字符流。
* public OutputStreamWriter(OutputStream out, String sysCode) throws UnsupportedEncodingException
* 按照参数sysCode指定的编码规范，基于字节流out构造输入字符流，如果不支持参数sysCode中指定的编码规范，就会产生异常。
* public String getEncoding()
* 获得当前字符流使用的编码方式。
* public void close() throws IOException
* 用于关闭流。
* public int read() throws IOException
* 用于读取一个字符。
* public int read(char[] cbuf, int off, int len)
* 用于读取len个字符到数组cbuf的索引off处。
* public void write(char[] cbuf, int off, int len) throws IOException
* 将字符数组cbuf中从索引off处开始的len个字符写入输出流。
* public void write(int c) throws IOException
* 将单个字符写入输入流。
* public void write(String str, int off, int len) throws IOException
* 将字符串str中从索引off位置开始的ltn个字符写入输出流。
*
* 此外，为了提高字符流处理的效率，在Java语言中，引入了BufferedReader和BufferWriter类，这两个类对字符流进行块处理。
* 两个类的常用方法如下：
* public BufferedReader(Reader in)
* 用于基于普通字符输入流in生成相应的缓冲流。
* public BufferedReader(Reader in, int bufSize)
* 用于基于普通字符输入流in生成相应的缓冲流，缓冲区大小为参数bufSize指定。
* public BufferedWriter(Writer out)
* 用于基于普通字符输入流out生成相应的缓冲流。
* public BufferedWriter(Writer out, int bufSize)
* 用于基于普通字符输入流out生在相应缓冲流，缓冲流大小为参数bufSize指定。
* public String readLine() throws IOException
* 用于从输入流中读取一行字符。
* public void newLine() throws IOException
* 用于向字符输入流中写入一行结束标记，值得注意的是，该标记不是简单的换行符"\n"，而是系统定义的属性line.separator。
在上面的程序中，我们首先声明了FileInputStream类对象inStream和
* FileOutputStream类的对象outStream，接着声明了BufferInputStream
* 类对象bufObj、BufferedOutputStream类对象bufOutObj、
* DataInputStream类对象dataInObj以及PushbackInputStream类对象pushObj，
* 在try代码块中对上面这些对象进行初始化，程序的目的是通过BufferedInputStream
* 类对象bufInObj和BufferedOutputStream类对象bufOutObj将secondFile.txt
* 文件中内容输出到屏幕，并将该文件的内容写入thirdFile.txt文件中，值得注意的是，
* 将secondFile.txt文件中的内容输出之前，程序中使用
* "System.out.println(dataInObj.readBoolean());" 语句根据readBoolean()结果
* 输出了true，而secondFile.txt文件开始内容为“Modify”，和一个字符为M，
* 因此输出的文件内容没有“M”字符，thirdFile.txt文件中也比secondFile.txt
* 文件少第一个字符“M”。随后，通过PushbackInputStream类对象pushObj读取
* thirdFile.txt文件中的内容，输出读到的字符，当读到的不是字符，输出回车，将字符
* 数组pushByte写回到thirdFile.txt文件中，也就是“ok”写回文件中。
* 对象串行化
* 对象通过写出描述自己状态的数值来记录自己，这个过程叫做对象串行化。对象的寿命通
* 常是随着生成该对象的程序的终止而终止，在有些情况下，需要将对象的状态保存下来，然后
* 在必要的时候将对象恢复，值得注意的是，如果变量是另一个对象的引用，则引用的对象也要
* 串行化，串行化是一个递归的过程，可能会涉及到一个复杂树结构的串行化，比如包括原有对
* 象，对象的对象等。
* 在java.io包中，接口Serializable是实现对象串行化的工具,只有实现了Serializable
* 的对象才可以被串行化。Serializable接口中没有任何的方法，当一个类声明实现Seriali-
* zable接口时，只是表明该类遵循串行化协议，而不需要实现任何特殊的方法。
* 在进行对象串行化时，需要注意将串行化的对象和输入、输出流联系起来，首先通过对
* 象输出流将对象状态保存下来，然后通过对象输入流将对象状态恢复。