Java-IO操作

Posted 2021-01-30 进击的巨人

IO流包括字节流（Byte）和字符流（String/char）

字节流：

在JDK中定义了两个抽象类InputStream和OutputStream，它们是字节流的顶级父亲。

InputStream的常用方法：

int read()，从输入流读取一个8位的字节，把它转换为0~255之间的整数，并返回这一整数。

int read(byte[] b )，从输入流读取若干个字节，把它们保存到参数b指定的字节数组中，返回的整数表示读取字节数。

int read(byte[] b ,int  off,int len)，从输入流读取若干个字节，把它们保存到参数b指定的字节数组中，off指定字节数组开始保存数据的起始下标，len表示读取的字节数目。

void close() 关闭此输入流并释放与该流关联的所有系统资源。

OutputStream的常用方法：

void write()，像输出流写入一个8位的字节。

void write(byte[] b )，参数b指定的字节数组的所有字节写到输出流。

void read(byte[] b ,int  off,int len)，把参数b指定的字节数组中从off指定开始的len个字节写入输入流。

void flush()，刷新此输出流并强制写出所有缓冲的输出字节。

void close() 关闭此输出流并释放与该流关联的所有系统资源。

FileInputStream

package stream;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
public class FileInputStreamDemo{
    public static void main(String[] args) {
        File srcFile=new File("CopyStreamDemo.txt");
        try {
            InputStream inputStream=new FileInputStream(srcFile);
            byte[] buffer=new byte[1024];
            int len=-1;
            while((len=inputStream.read(buffer))!=-1) {//从输入流inputStream读取若干字节，把它们保存到参数buffer中去，同时判断是否读到文件末尾
                String text=new String(buffer,0, len, "utf-8");//将字节数组转换为字符串
                System.out.printf(text);
            }
            inputStream.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

FileOutputStream

 1 package stream;
 2 
 3 import java.io.File;
 4 import java.io.FileNotFoundException;
 5 import java.io.FileOutputStream;
 6 import java.io.IOException;
 7 import java.io.OutputStream;
 8 
 9 public class FileOutputStreamDemo {
10 
11     public static void main(String[] args) {
12         File desfile=new File("target.txt");
13         try {
14             String text="我的第一个记事本程序
还有第二行";
15             OutputStream os=new FileOutputStream(desfile);
16             byte[] buffer=text.getBytes("utf-8");//将字符串转换为字节数组
17             os.write(buffer);
18             System.out.println("文件写入完成！");
19             os.close();
20         } catch (FileNotFoundException e) {
21             e.printStackTrace();
22         } catch (IOException e) {
23             e.printStackTrace();
24         }
25     }
26 }

此外，注意在IO包中提供的两个带缓冲的字节流，BufferedInputStream和BufferedOutputStream，它们的构造方法中分别接收InputStream和OutputStream类型的参数作为被包装的对象。

 1 import java.io.BufferedInputStream;
 2 import java.io.BufferedOutputStream;
 3 import java.io.File;
 4 import java.io.FileInputStream;
 5 import java.io.FileNotFoundException;
 6 import java.io.FileOutputStream;
 7 import java.io.IOException;
 8 
 9 public class FileCopy{
10     public static void main(String[] args) {
11         File srcFile=new File("CopyStreamDemo.txt");
12         File desFile=new File("target.java");
13         try {
14             /**
15              * 带缓冲的字节流，BufferedInputStream和BufferedOutputStream，二者接收InputStream和OutputStream作为参数
16              */
17             BufferedInputStream is=new BufferedInputStream(new FileInputStream(srcFile));
18             BufferedOutputStream os=new BufferedOutputStream(new FileOutputStream(desFile));
19             byte[] buffer=new byte[1024];
20             int len=-1;
21             System.out.println("正在复制文件，请稍后...");
22             while((len=is.read(buffer))!=-1) {
23                 os.write(buffer,0,len);
24             } 
25             System.out.println("文件复制完成！");
26             is.close();
27             os.close();
28         } catch (FileNotFoundException e) {
29             e.printStackTrace();
30         } catch (IOException e) {
31             e.printStackTrace();
32         }
33     }
34 }

字符流：

字符流也有两个顶级父亲，分别是Reader和Writer，其中Reader是字符输入流，用于从某个源设备读取字符，Writer是字符输出流，用于向某个目标设备写入字符。

其中，FileReader和FileWriter用于读写文件，BufferedReader和BufferedWriter是具有缓冲功能的流，它们可以提高读写效率。

FileReader和FileWriter实现文件读写：

 1 package chars;
 2 
 3 import java.io.File;
 4 import java.io.FileNotFoundException;
 5 import java.io.FileReader;
 6 import java.io.FileWriter;
 7 import java.io.IOException;
 8 import java.io.Reader;
 9 import java.io.Writer;
10 
11 public class CopyByCharsDemo {
12     public static void main(String[] args) {
13         File srcFile=new File("BufferedReaderDemo.txt");
14         File desFile=new File("dest.txt");
15         try {
16             Reader reader=new FileReader(srcFile);
17             Writer writer=new FileWriter(desFile);
18             char[] buffer=new char[1024];
19             int len=-1;
20             while((len=reader.read(buffer))!=-1) {
21                 writer.write(buffer);
22             }
23             System.out.println("复制完成！");
24             reader.close();
25             writer.close();
26         } catch (FileNotFoundException e) {
27             e.printStackTrace();
28         } catch (IOException e) {
29             e.printStackTrace();
30         }
31         
32     }
33 }

BufferedReader

 1 package chars;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.File;
 5 import java.io.FileNotFoundException;
 6 import java.io.FileReader;
 7 import java.io.IOException;
 8 /**
 9  * 文件Reader,BufferedReader同BufferedInputStream一样，内部参数是new FileReader(srcFile)
10  * @author Administrator
11  *
12  */
13 public class BufferedReaderDemo {
14     public static void main(String[] args) {
15         File srcFile=new File("CopyByCharsDemo.txt");
16         try {
17             BufferedReader bReader=new BufferedReader(new FileReader(srcFile));
18             String res=null;
19             while((res=bReader.readLine())!=null) {//每次读取一行文本，判断是否到文件结尾
20                 System.out.println(res);
21             }
22             bReader.close();
23         } catch (FileNotFoundException e) {
24             e.printStackTrace();
25         } catch (IOException e) {
26             e.printStackTrace();
27         }
28     }
29 
30 }

总结：

1.文件读取时，不论是用InputStream还是Reader还是BufferedInputStream读取时都用len，while（（len=is.read(buffer)）!=-1）,但是在BufferedReader中，定义一个String res=null,这时的判断条件是 while((res=br.readLine())!=null)
2.文件读写完成后，记得要善后，即is.close()