关于JAVA语言IO流的一些理解

Java流操作中有关的类或接口：



Java流类图结构：



IO流的分类：

根据传输数据类型的不同：字节流和字符流。

根据数据流向不同：输入流和输出流。

字符流和字节流：

        字符流的由来： 因为数据编码的不同，而有了对字符进行高效操作的流对象。本质其实就是基于字节流读取时，去查了指定的码表。 所以字符流的效率较高于字节流。

        字节流和字符流的区别：

        读写单位不同：字节流以字节（8bit）为单位，字符流以字符为单位，根据码表映射字符，一次可能读多个字节。

        处理对象不同：字节流能处理所有类型的数据（如图片、avi等），而字符流只能处理字符类型的数据。

        所以，如果传输处理的数据为纯文本，优先使用字符流，如果处理的数据包括图片、音频，则选择使用字节流。

1、字符输入流

FileReader类：

创建一个文件的读取流对象，和指定名称的文件相关联。FileReader fr = new FileReader("文本文件名称");

代码示例：

package IOStudy01;

import java.io.FileReader;
import java.io.IOException;

public class FileReaderDemo1 {
/*
* 读取单个字符，读一个取一个
*/
public static void main(String[] args) throws IOException {
//创建一个文件的读取流对象，和指定名称的文件相关联
//要保证该文件存在，如果不存在，则会发生异常FileNotFoundException
FileReader fr = new FileReader("Demo.txt");
//调用读取流对象的read方法，一次读取一个字符，而且会自动往下读，返回作为整数读取的字符
int ch = 0;
while((ch = fr.read())!= -1){
System.out.println("ch: "+ (char)ch);
}
fr.close();
}

}
上述代码在读取文件中的字符时，是一个一个的读取，效率较低，为了提交效率，可以使用一字符数组将其存储起来，并统一输出。通常使用char[] buf = new char[1024];

package IOStudy01;

import java.io.FileReader;
import java.io.IOException;

public class FileReaderDemo2 {
/*
* 读取字符数组，返回读取的个数，没读取到返回-1
*/
public static void main(String[] args) throws IOException {
FileReader fr = new FileReader("Demo.txt");
//定义一个字符数组，用于存储读取到的字符
char[] buf = new char[1024];
//该read(char[])返回的是读取到的个数
int num = 0;
while((num = fr.read(buf))!=-1){
System.out.println(new String(buf,0,num));
}
//		int num = fr.read(buf);
//		System.out.println("num:" + num + "..." + new String(buf));
fr.close();
}

}

BufferedReader类：

为了提高字符流的效率，常使用缓冲区。

代码示例：

package IOStudy02;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReaderDemo {
/*
* 字符缓冲区读取练习，
* 字符读取流缓冲区：
* 该缓冲区提供了一个一次读一行的方法readline()，方便于对文本数据的获取。
* 当读到文件末尾时返回null。
* readline()方法返回回车符之前的字符内容，并不返回回车符。
*/
public static void main(String[] args) throws IOException {
FileReader fr = new FileReader("FileReaderDemo2.txt");
BufferedReader fufr = new BufferedReader(fr);

String line = null;
while((line = fufr.readLine())!=null){
System.out.println(line);
}

// String str = fufr.readLine();
// System.out.println(str);
fufr.close();
}

}字符缓冲区提供了一个一次读取一整行的方法readline()，读取到文件末尾时返回null，常用于循环中，判断是否还应继续读取。

2、字符输出流
FileWriter类

创建一个FileWriter对象，该对象一被初始化，明确被操作文件，该文件会被创建在指定目录下，如果该目录下已有同名文件，该文件将被覆盖。FileWriter fw = new FileWriter("demo.txt");

package IOStudy01;

import java.io.FileWriter;
import java.io.IOException;
/*
* IO流基本操作
*/
public class FileWriterDemo1 {

public static void main(String[] args) throws IOException {
//创建一个FileWriter对象，该对象一被初始化，明确被操作文件
//该文件会被创建在指定目录下，如果该目录下已有同名文件，该文件将被覆盖
//明确数字存放的目的地
FileWriter fw = new FileWriter("demo.txt");
//调用write方法，将字符串写入到流中
fw.write("abcdfg");
fw.write("dasd");
//刷新流对象缓冲中的数据，将数据存储到目的地中
fw.flush();

fw.write("adad");
//关闭流资源，但是关闭流之前，会刷新流对象缓冲中的数据，和flush()方法区别是
//flush()后流未关闭。
fw.close();
}

}注意：字符流写入操作时，使用write()方法后字符串仍未写入文件中，而是存放在流对象的缓冲区中，要使用flush()方法把数据存入文件中，每次操作完流对象后，用使用close()关闭流对象，节省资源。由于close()方法在关闭流对象时会默认先调用flush()方法，所以flush()方法并不是特别必要。但如果你写入的数据较多，应及时使用flush()方法刷新缓冲区，避免内存溢出，数据丢失。
以上程序在每次建立一个流对象后会新建一个demo.txt文件并覆盖原有文件，如果只希望建立流对象，指定被操作文件，不删除原有数据，只是在文件里的数据背后追加数据，可以使用FileWriter fw = new FileWriter("demo.txt",true);。

BufferedWriter类：
为了提高字符流的效率，常使用缓冲区。使用字符缓冲区，写入后一定要使用flush()刷新缓冲区。

复制文本示例代码：
package IOStudy02;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyTestByBuf {

public static void main(String[] args) {
BufferedWriter bufw = null;
BufferedReader bufr = null;
try {
FileWriter fw = new FileWriter("copytext.txt");
FileReader fr = new FileReader("FileReaderDemo2.txt");
bufw = new BufferedWriter(fw);
bufr = new BufferedReader(fr);
String line = null;
4000

while ((line = bufr.readLine())!=null) {
bufw.write(line);
bufw.newLine();
bufw.flush();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
if (bufw!=null) {
try {
bufw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (bufr!=null) {
try {
bufr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

}

字节流与字符流类似：
提供两个代码实例：

复制音乐

package IOStudy03;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyMiu {

public static void main(String[] args) throws IOException {
copy_1();
}
public static void copy_1() throws IOException{
BufferedInputStream bufis = new BufferedInputStream(new FileInputStream("kanong.wav"));
BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("kanong_copy.wav"));
int len = 0;
while((len = bufis.read())!=-1){
bufos.write(len);
}
bufis.close();
bufos.close();
}

}复制图片
package IOStudy03;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyPic {

public static void main(String[] args) {
FileInputStream fis = null;
FileOutputStream fos = null;
try {
fis = new FileInputStream("11.jpg");
fos = new FileOutputStream("22.jpg");
byte[] bty = new byte[1024];
int len = 0;
while((len = fis.read(bty))!=-1){
fos.write(bty, 0, len);
}
} catch (Exception e) {
e.printStackTrace();
}finally{
if (fis!=null) {
try {
fis.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if (fos!=null) {
try {
fos.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

}

}