Java io文件操作（按字符、字节、行、随机读取，追加，文件操作）

最新推荐文章于 2024-09-12 21:04:39 发布

Hollivan

最新推荐文章于 2024-09-12 21:04:39 发布

阅读量785

点赞数

分类专栏： JAVA

JAVA 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

什么是流：

流是一个抽象的概念。当Java程序需要从数据源读取数据时，会开启一个到数据源的流。数据源可以是文件，内存或者网络等。同样，当程序需要输出数据到目的地时也一样会开启一个流，数据目的地也可以是文件、内存或者网络等。流的创建是为了更方便地处理数据的输入输出。

流分为字节流和字符流。字节流也称为原始数据，需要用户读入后进行相应的编码转换。而字符流的实现是基于自动转换的，读取数据时会把数据按照JVM的默认编码自动转换成字符。

字节流由InputStream和OutputStream处理，而字符流由Reader和Writer处理。Reader和Writer是Java后加入的处理类，出于让数据的处理更方便的目的。

字节流处理类概述：

字节流的处理类有很多，他们都继承自InputStream或者OutputStream抽象类。

输入流：

先谈谈输入流，输入流中跟数据源直接接触的类有：FileInputStream和ByteArrayInputStream，他们分别实现了从文件或者内存中的字节数组读入数据到输入流。

其他的输入流处理类都是装饰类（Decorator模式），下面对他们进行一下简单介绍：

BufferedInputStream：提供了缓冲功能。

DataInputStream: 允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。应用程序可以使用数据输出流写入稍后由数据输入流读取的数据。

PipedInputStream: 允许以管道的方式来处理流。当连接到一个PipedOutputStream后，它会读取后者输出到管道的数据。

PushbackInputStream: 允许放回已经读取的数据。

SequenceInputStream: 能对多个inputstream进行顺序处理。

输出流：

基本上每个输入流类都有一个相应的输出流类，提供相应的输出流处理。

同样，跟数据目的地直接接触的类有：FileOutputStream和ByteArrayOutputStream，前者实现了把数据流写入文件的功能，后者实现了一个输出流，其中的数据被写入一个 byte 数组。缓冲区会随着数据的不断写入而自动增长。可使用toByteArray() 和 toString() 获取数据。

下面对其它的装饰类做一下简单介绍：

BufferedOutputStream：提供了缓冲功能的输出流，在写出完成之前要调用flush来保证数据的输出。

DataOutputStream: 数据输出流允许应用程序以适当方式将基本 Java 数据类型写入输出流中。然后，应用程序可以使用数据输入流将数据读入。

PipedOutputStream: 允许以管道的方式来处理流。可以将管道输出流连接到管道输入流来创建通信管道。管道输出流是管道的发送端。通常，数据由某个线程写入PipedOutputStream 对象，并由其他线程从连接的 PipedInputStream 读取。

PrintStream: 为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。我们经常用到的System.out或者System.err都是PrintStream。

字符流处理类概述：

输入流：

跟数据源直接接触的类：

CharArrayReader: 从内存中的字符数组中读入数据，以对数据进行流式读取。

StringReader：从内存中的字符串读入数据，以对数据进行流式读取。

FileReader：从文件中读入数据。注意这里读入数据时会根据JVM的默认编码对数据进行内转换，而不能指定使用的编码。所以当文件使用的编码不是JVM默认编码时，不要使用这种方式。要正确地转码，使用InputStreamReader。

装饰类：

BufferedReader：提供缓冲功能，可以读取行：readLine();

LineNumberReader: 提供读取行的控制：getLineNumber()等方法。

InputStreamReader: 字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。

输出流：

根数据目的相关的类：

CharArrayWriter：把内存中的字符数组写入输出流，输出流的缓冲区会自动增加大小。输出流的数据可以通过一些方法重新获取。

StringWriter: 一个字符流，可以用其回收在字符串缓冲区中的输出来构造字符串。

FileWriter：把数据写入文件。

装饰类：

BufferedWriter：提供缓冲功能。

OutputStreamWriter：字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。

PrintWriter: 向文本输出流打印对象的格式化表示形式。

Writer或者OutputStream中的flush(): 刷新该流的缓冲，用于确保数据的输出。

close(): 关闭流并释放与之关联的所有系统资源

其实大家看到下面的图应该就很明白了。

看到这里相信大家对字节流、字符流有一个大致认识了，也对操作流的类有了一个清晰的认识，下面还是通过写代码的方式让大家理解如何操作的。

一、多种方式读文件内容。

1、按字节读取文件内容
2、按字符读取文件内容
3、按行读取文件内容
4、随机读取文件内容

[java] view plain copy print ?

package test.file;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.RandomAccessFile;
import java.io.Reader;
public class ReadFromFile {
/**
* 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。
* @param fileName 文件的名
*/
public static void readFileByBytes(String fileName){
File file = new File(fileName);
InputStream in = null;
try {
System.out.println("以字节为单位读取文件内容，一次读一个字节：");
// 一次读一个字节
in = new FileInputStream(file);
int tempbyte;
while((tempbyte=in.read()) != -1){
System.out.write(tempbyte);
}
in.close();
} catch (IOException e) {
e.printStackTrace();
return;
}
try {
System.out.println("以字节为单位读取文件内容，一次读多个字节：");
//一次读多个字节
byte[] tempbytes = new byte[100];
int byteread = 0;
in = new FileInputStream(fileName);
ReadFromFile.showAvailableBytes(in);
//读入多个字节到字节数组中，byteread为一次读入的字节数
while ((byteread = in.read(tempbytes)) != -1){
System.out.write(tempbytes, 0, byteread);
}
} catch (Exception e1) {
e1.printStackTrace();
} finally {
if (in != null){
try {
in.close();
} catch (IOException e1) {
}
}
}
}
/**
* 以字符为单位读取文件，常用于读文本，数字等类型的文件
* @param fileName 文件名
*/
public static void readFileByChars(String fileName){
File file = new File(fileName);
Reader reader = null;
try {
System.out.println("以字符为单位读取文件内容，一次读一个字节：");
// 一次读一个字符
reader = new InputStreamReader(new FileInputStream(file));
int tempchar;
while ((tempchar = reader.read()) != -1){
//对于windows下，/r/n这两个字符在一起时，表示一个换行。
//但如果这两个字符分开显示时，会换两次行。
//因此，屏蔽掉/r，或者屏蔽/n。否则，将会多出很多空行。
if (((char)tempchar) != '\r'){
System.out.print((char)tempchar);
}
}
reader.close();
} catch (Exception e) {
e.printStackTrace();
}
try {
System.out.println("以字符为单位读取文件内容，一次读多个字节：");
//一次读多个字符
char[] tempchars = new char[30];
int charread = 0;
reader = new InputStreamReader(new FileInputStream(fileName));
//读入多个字符到字符数组中，charread为一次读取字符数
while ((charread = reader.read(tempchars))!=-1){
//同样屏蔽掉/r不显示
if ((charread == tempchars.length)&&(tempchars[tempchars.length-1] != '\r')){
System.out.print(tempchars);
}else{
for (int i=0; i<charread; i++){
if(tempchars[i] == '\r'){
continue;
}else{
System.out.print(tempchars[i]);
}
}
}
}
} catch (Exception e1) {
e1.printStackTrace();
}finally {
if (reader != null){
try {
reader.close();
} catch (IOException e1) {
}
}
}
}
/**
* 以行为单位读取文件，常用于读面向行的格式化文件
* @param fileName 文件名
*/
public static void readFileByLines(String fileName){
File file = new File(fileName);
BufferedReader reader = null;
try {
System.out.println("以行为单位读取文件内容，一次读一整行：");
reader = new BufferedReader(new FileReader(file));
String tempString = null;
int line = 1;
//一次读入一行，直到读入null为文件结束
while ((tempString = reader.readLine()) != null){
//显示行号
System.out.println("line " + line + ": " + tempString);
line++;
}
reader.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (reader != null){
try {
reader.close();
} catch (IOException e1) {
}
}
}
}
/**
* 随机读取文件内容
* @param fileName 文件名
*/
public static void readFileByRandomAccess(String fileName){
RandomAccessFile randomFile = null;
try {
System.out.println("随机读取一段文件内容：");
// 打开一个随机访问文件流，按只读方式
randomFile = new RandomAccessFile(fileName, "r");
// 文件长度，字节数
long fileLength = randomFile.length();
// 读文件的起始位置
int beginIndex = (fileLength > 4) ? 4 : 0;
//将读文件的开始位置移到beginIndex位置。
randomFile.seek(beginIndex);
byte[] bytes = new byte[10];
int byteread = 0;
//一次读10个字节，如果文件内容不足10个字节，则读剩下的字节。
//将一次读取的字节数赋给byteread
while ((byteread = randomFile.read(bytes)) != -1){
System.out.write(bytes, 0, byteread);
}
} catch (IOException e){
e.printStackTrace();
} finally {
if (randomFile != null){
try {
randomFile.close();
} catch (IOException e1) {
}
}
}
}
/**
* 显示输入流中还剩的字节数
* @param in
*/
private static void showAvailableBytes(InputStream in){
try {
System.out.println("当前字节输入流中的字节数为:" + in.available());
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
String fileName = "C:/temp/newTemp.txt";
ReadFromFile.readFileByBytes(fileName);
ReadFromFile.readFileByChars(fileName);
ReadFromFile.readFileByLines(fileName);
ReadFromFile.readFileByRandomAccess(fileName);
}
}

package test.file;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.RandomAccessFile;
import java.io.Reader;

public class ReadFromFile {

	/**  

	   * 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。  

	   * @param fileName 文件的名  

	   */ 

	public static void readFileByBytes(String fileName){  

	   File file = new File(fileName);  

	   InputStream in = null;  

	   try {  

	    System.out.println("以字节为单位读取文件内容，一次读一个字节：");  

	    // 一次读一个字节  

	    in = new FileInputStream(file);  

	    int tempbyte;  

	    while((tempbyte=in.read()) != -1){  

	     System.out.write(tempbyte);  

	    }  

	    in.close();  

	   } catch (IOException e) {  

	    e.printStackTrace();  

	    return;  

	   }  

	   try {  

	    System.out.println("以字节为单位读取文件内容，一次读多个字节：");  

	    //一次读多个字节  

	    byte[] tempbytes = new byte[100];  

	    int byteread = 0;  

	    in = new FileInputStream(fileName);  

	    ReadFromFile.showAvailableBytes(in);  

	    //读入多个字节到字节数组中，byteread为一次读入的字节数  

	    while ((byteread = in.read(tempbytes)) != -1){  

	     System.out.write(tempbytes, 0, byteread);  

	    }  

	   } catch (Exception e1) {  

	    e1.printStackTrace();  

	   } finally {  

	    if (in != null){  

	     try {  

	      in.close();  

	     } catch (IOException e1) {  

	     }  

	    }  

	   }  

	}  

	/**  

	   * 以字符为单位读取文件，常用于读文本，数字等类型的文件  

	   * @param fileName 文件名  

	   */ 

	public static void readFileByChars(String fileName){  

	   File file = new File(fileName);  

	   Reader reader = null;  

	   try {  

	    System.out.println("以字符为单位读取文件内容，一次读一个字节：");  

	    // 一次读一个字符  

	    reader = new InputStreamReader(new FileInputStream(file));  

	    int tempchar;  

	    while ((tempchar = reader.read()) != -1){  

	     //对于windows下，/r/n这两个字符在一起时，表示一个换行。  

	     //但如果这两个字符分开显示时，会换两次行。  

	     //因此，屏蔽掉/r，或者屏蔽/n。否则，将会多出很多空行。  

	     if (((char)tempchar) != '\r'){  

	      System.out.print((char)tempchar);  

	     }  

	    }  

	    reader.close();  

	   } catch (Exception e) {  

	    e.printStackTrace();  

	   }  

	   try {  

	    System.out.println("以字符为单位读取文件内容，一次读多个字节：");  

	    //一次读多个字符  

	    char[] tempchars = new char[30];  

	    int charread = 0;  

	    reader = new InputStreamReader(new FileInputStream(fileName));  

	    //读入多个字符到字符数组中，charread为一次读取字符数  

	    while ((charread = reader.read(tempchars))!=-1){  

	     //同样屏蔽掉/r不显示  

	     if ((charread == tempchars.length)&&(tempchars[tempchars.length-1] != '\r')){  

	      System.out.print(tempchars);  

	     }else{  

	      for (int i=0; i<charread; i++){  

	       if(tempchars[i] == '\r'){  

	        continue;  

	       }else{  

	        System.out.print(tempchars[i]);  

	       }  

	      }  

	     }  

	    }  

	      

	   } catch (Exception e1) {  

	    e1.printStackTrace();  

	   }finally {  

	    if (reader != null){  

	     try {  

	      reader.close();  

	     } catch (IOException e1) {  

	     }  

	    }  

	   }  

	}  

	/**  

	   * 以行为单位读取文件，常用于读面向行的格式化文件  

	   * @param fileName 文件名  

	   */ 

	public static void readFileByLines(String fileName){  

	   File file = new File(fileName);  

	   BufferedReader reader = null;  

	   try {  

	    System.out.println("以行为单位读取文件内容，一次读一整行：");  

	    reader = new BufferedReader(new FileReader(file));  

	    String tempString = null;  

	    int line = 1;  

	    //一次读入一行，直到读入null为文件结束  

	    while ((tempString = reader.readLine()) != null){  

	     //显示行号  

	     System.out.println("line " + line + ": " + tempString);  

	     line++;  

	    }  

	    reader.close();  

	   } catch (IOException e) {  

	    e.printStackTrace();  

	   } finally {  

	    if (reader != null){  

	     try {  

	      reader.close();  

	     } catch (IOException e1) {  

	     }  

	    }  

	   }  

	}  

	/**  

	   * 随机读取文件内容  

	   * @param fileName 文件名  

	   */ 

	public static void readFileByRandomAccess(String fileName){  

	   RandomAccessFile randomFile = null;  

	   try {  

	    System.out.println("随机读取一段文件内容：");  

	    // 打开一个随机访问文件流，按只读方式  

	    randomFile = new RandomAccessFile(fileName, "r");  

	    // 文件长度，字节数  

	    long fileLength = randomFile.length();  

	    // 读文件的起始位置  

	    int beginIndex = (fileLength > 4) ? 4 : 0;  

	    //将读文件的开始位置移到beginIndex位置。  

	    randomFile.seek(beginIndex);  

	    byte[] bytes = new byte[10];  

	    int byteread = 0;  

	    //一次读10个字节，如果文件内容不足10个字节，则读剩下的字节。  

	    //将一次读取的字节数赋给byteread  

	    while ((byteread = randomFile.read(bytes)) != -1){  

	     System.out.write(bytes, 0, byteread);  

	    }  

	   } catch (IOException e){  

	    e.printStackTrace();  

	   } finally {  

	    if (randomFile != null){  

	     try {  

	      randomFile.close();  

	     } catch (IOException e1) {  

	     }  

	    }  

	   }  

	}  

	/**  

	   * 显示输入流中还剩的字节数  

	   * @param in  

	   */ 

	private static void showAvailableBytes(InputStream in){  

	   try {  

	    System.out.println("当前字节输入流中的字节数为:" + in.available());  

	   } catch (IOException e) {  

	    e.printStackTrace();  

	   }  

	}  

	   

	public static void main(String[] args) {  

	   String fileName = "C:/temp/newTemp.txt";  

	   ReadFromFile.readFileByBytes(fileName);  

	   ReadFromFile.readFileByChars(fileName);  

	   ReadFromFile.readFileByLines(fileName);  

	   ReadFromFile.readFileByRandomAccess(fileName);  

	}  

}

二、将内容追加到文件尾部

[java] view plain copy print ?

package test.file;
import java.io.FileWriter;
import java.io.IOException;
import java.io.RandomAccessFile;
public class AppendToFile {
/**
* A方法追加文件：使用RandomAccessFile
* @param fileName 文件名
* @param content 追加的内容
*/
public static void appendMethodA(String fileName, String content){
try {
// 打开一个随机访问文件流，按读写方式
RandomAccessFile randomFile = new RandomAccessFile(fileName, "rw");
// 文件长度，字节数
long fileLength = randomFile.length();
//将写文件指针移到文件尾。
randomFile.seek(fileLength);
randomFile.writeBytes(content);
randomFile.close();
} catch (IOException e){
e.printStackTrace();
}
}
/**
* B方法追加文件：使用FileWriter
* @param fileName
* @param content
*/
public static void appendMethodB(String fileName, String content){
try {
//打开一个写文件器，构造函数中的第二个参数true表示以追加形式写文件
FileWriter writer = new FileWriter(fileName, true);
writer.write(content);
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
String fileName = "C:/temp/newTemp.txt";
String content = "new append!";
//按方法A追加文件
AppendToFile.appendMethodA(fileName, content);
AppendToFile.appendMethodA(fileName, "append end. /n");
//显示文件内容
ReadFromFile.readFileByLines(fileName);
//按方法B追加文件
AppendToFile.appendMethodB(fileName, content);
AppendToFile.appendMethodB(fileName, "append end. /n");
//显示文件内容
ReadFromFile.readFileByLines(fileName);
}
}

package test.file;

import java.io.FileWriter;
import java.io.IOException;
import java.io.RandomAccessFile;

public class AppendToFile {

	/**  

	   * A方法追加文件：使用RandomAccessFile  

	   * @param fileName 文件名  

	   * @param content 追加的内容  

	   */ 

	public static void appendMethodA(String fileName, String content){  

	   try {  

	    // 打开一个随机访问文件流，按读写方式  

	    RandomAccessFile randomFile = new RandomAccessFile(fileName, "rw");  

	    // 文件长度，字节数  

	    long fileLength = randomFile.length();  

	    //将写文件指针移到文件尾。  

	    randomFile.seek(fileLength);  

	    randomFile.writeBytes(content);  

	    randomFile.close();  

	   } catch (IOException e){  

	    e.printStackTrace();  

	   }  

	}  

	/**  

	   * B方法追加文件：使用FileWriter  

	   * @param fileName  

	   * @param content  

	   */ 

	public static void appendMethodB(String fileName, String content){  

	   try {  

	    //打开一个写文件器，构造函数中的第二个参数true表示以追加形式写文件  

	    FileWriter writer = new FileWriter(fileName, true);  

	    writer.write(content);  

	    writer.close();  

	   } catch (IOException e) {  

	    e.printStackTrace();  

	   }  

	}  

	   

	public static void main(String[] args) {  

	   String fileName = "C:/temp/newTemp.txt";  

	   String content = "new append!";  

	   //按方法A追加文件  

	   AppendToFile.appendMethodA(fileName, content);  

	   AppendToFile.appendMethodA(fileName, "append end. /n");  

	   //显示文件内容  

	   ReadFromFile.readFileByLines(fileName);  

	   //按方法B追加文件  

	   AppendToFile.appendMethodB(fileName, content);  

	   AppendToFile.appendMethodB(fileName, "append end. /n");  

	   //显示文件内容  

	   ReadFromFile.readFileByLines(fileName);  

	}  
}

二、文件的各种操作类

[java] view plain copy print ?