java 中简述使用流进行读写文本文件的步骤?

Posted 2023-03-27

一、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接口时，只是表明该类遵循串行化协议，而不需要实现任何特殊的方法。
* 在进行对象串行化时，需要注意将串行化的对象和输入、输出流联系起来，首先通过对
* 象输出流将对象状态保存下来，然后通过对象输入流将对象状态恢复。 参考技术A

读写是两个不同的分支，通常都是分开单独使用的。

可以通过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方法关闭，否则会一直处于打开状态，直至程序停止，增加系统负担。

参考技术B 先要有对象 然后开始解析对象 就是读取 然后保存到byte数组中 然后再写出去