Java Api之IO流输入与输出

关注

原创最新推荐文章于 2026-04-07 19:45:00 发布 869 阅读 AI 写同款· GEO 优化 ›

JAVA输入输出 (I/O) 流和文件处理 Java的输入输出(I/O)流提供了读取和写入数据的标准方法。（用于字节流）和ReaderWriter（用于字符流）。通过这些抽象类的多种实现，Java能够处理文件、网络数据等各种输入输出操作。阅读详情

1输入与输出

input	某个设备或者环境进行数据的输入
output	某个设备或者环境进行数据的输出

在java中，java将输入输出抽象为流对象（IO流）来解决，我们以文件设备来解释：

输入流	从文件读取数据或者从键盘输入数据
输出流	向文件写入数据

Io流在java中又分为字节流和字符流：

字节流	所有文件的储存是都是字节（byte）的储存，在磁盘上保留的并不是文件的字符而是先把字符编码成字节，再储存这些字节到磁盘。在读取文件（特别是文本文件）时，也是一个字节一个字节地读取以形成字节序列
字符流	字符流处理的单元为2个字节的Unicode字符，分别操作字符、字符数组或字符串，而字节流处理单元为1个字节，操作字节和字节数组。所以字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的，所以它对多国语言支持性比较好！

2、字符流

字符输出流超类	字符输出流子类
Writer	FileWriter
Writer	BufferedWriter

字符输入流超类	字符输入流子类
Reader	FileReader
Reader	BufferedReader

(1) 字符输出流FileWriter

FileWriter的构造方法：

FileWriter(File file)	根据给定的file对象构造一个FileWriter对象
FileWriter(String filename)	根据给定的文件名对象构造一个FileWriter对象

举例：使用字符流向一个文件输出Hello World！

步骤：

1）创建文件；

2）创建输出流对象；

3）把输出流对象指向文件；

4）清空缓存。

5）关闭输出流

package com.file;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class FileCreate {
    public static void main(String[] args) {
        //创建file对象
        File file=null;
        FileWriter fw=null;
        try {
            //创建文件
            file=new File("D:/test/newFile.txt");
            file.createNewFile();
            //创建文件输出流
            fw=new FileWriter(file);
            //把内容写入文件
            fw.write("Hello World!");
            //清空缓存，把内容写入文件
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fw!=null){
                try {
                    //关闭输出流
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

当我们每次使用输出流向文件里写输出数据的时候，写入数据会覆盖文件里原有数据，若是我们想要文件里原有数据不被覆盖，我们可使用FileWrite的追加构造方法：

FileWriter(File file,boolean append)

构造方法的第二个boolean参数用来表示是否追加

FileWriter(String filename, boolean append)

例如我们再向上例中Hello World!后追加Hello China！

package com.file;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class FileCreate {
    public static void main(String[] args) {
        //创建file对象
        File file=null;
        FileWriter fw=null;
        try {
            //创建文件
            file=new File("D:/test/newFile.txt");
            file.createNewFile();
            //创建文件输出流,输出数据将追加在文件中原有数据后面
            fw=new FileWriter(file,true);
            //把内容写入文件
            fw.write("Hello China!");
            //清空缓存，把内容写入文件
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fw!=null){
                try {
                    //关闭输出流
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

从上里可以看出，两次输入的数据（Hello World!Hello China!）是在一行，如果我们想让追加后的数据另起一行呢

在输入数据时“\r\n”表示换行，效果如下：

package com.file;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class FileCreate {
    public static void main(String[] args) {
        //创建file对象
        File file=null;
        FileWriter fw=null;
        try {
            //创建文件
            file=new File("D:/test/newFile.txt");
            file.createNewFile();
            //创建文件输出流,输出数据将追加在文件中原有数据后面
            fw=new FileWriter(file,true);
            //把内容写入文件,并换行
            fw.write("Hello Beijing!\r\n");
            //清空缓存，把内容写入文件
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fw!=null){
                try {
                    //关闭输出流
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

在windows系统中“\r\n”表示换行

在Linux系统中“\n”表示换行

在ios系统中“\r”表示换行

FilterWriter的writer方法还有其他写入功能：

writer(Char[ ] chuf)	写入字符数组
writer(Char[ ] chuf,int offset,int length)	写入字符数组的某一部分
writer(int i)	写入单个字符（int转换为ASCII）
writer(String str)	写入字符串
writer(String [ ] str,int offset,int length)	写入字符串的某一一部分

其他相关方法清查与API

（2）字符输入流FileReader

FileReader的构造方法：

FileReader(File file)	在给定从中读取数据的File的情况下传建一个新的FileReader
FileReader(String fileName)	在给定从中读取数据的File文件名的情况下传建一个新的FileReader

举例：使用字符流从一个文件读取数据！

步骤：

1）创建输入流对象；

2）把输出流对象指向文件；

3）读取数据；

4）关闭输入流。

package com.file;

import java.io.*;

public class FileIO {
    public static void main(String[] args) {
        //创建FileReader对象
        FileReader fr=null;
        try {
            //把输入流指向需要读取的文件
            fr=new FileReader("D:/test/newFile.txt");
            //创建字符数组
            char[] chars=new char[1024];
            int num=-1;
            //读取数据，如果读取完毕，则num将返回-1
            while ((num=fr.read(chars))!=-1){
                //将字符数组中数据转换为字符串并输出到控制台
                String str=new String(chars,0,num);
                System.out.println(str);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fr!=null){
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

(3)字符输入流之BufferedReade

BufferedReader 由Reader类扩展而来，提供通用的缓冲方式文本读取，而且提供了很实用的readLine，读取一个文本行，从字符输入流中读取文本，缓冲各个字符，从而提供字符、数组和行的高效读取。

BufferedReader提供了readLine()方法来读取一行数据

package com.file;

import java.io.*;

public class FileIO {
    public static void main(String[] args) {
        //创建FileReader对象
        FileReader fr=null;
        //BufferedReader
        BufferedReader br=null;
        try {
            //把输入流指向需要读取的文件
            fr=new FileReader("D:/test/newFile.txt");
            //用BufferedReader包装FileReader
            br=new BufferedReader(fr);
            //创建字符串
            String str=null;
            //读取数据，如果读取完毕，则str将返回null
            while ((str=br.readLine())!=null){
                //将字符串输出到控制台
                System.out.println(str);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fr!=null){
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

(4)字符输入流之BufferedWriter

将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。可以指定缓冲区的大小，或者接受默认的大小。在大多数情况下，默认值就足够大了。该类提供了 newLine() 方法，它使用平台自己的行分隔符概念。

package com.file;

import java.io.*;

public class FileCreate {
    public static void main(String[] args) {
        //创建file对象
        File file=null;
        FileWriter fw=null;
        BufferedWriter bw=null;
        try {
            //创建文件
            file=new File("D:/test/newFile.txt");
            if (!file.exists()){
                file.createNewFile();
            }
            //创建文件输出流,输出数据将追加在文件中原有数据后面
            fw=new FileWriter(file,true);
            //用BufferedWriter包装FileWriter
            bw=new BufferedWriter(fw);
            //把内容写入文件,并换行
            bw.write("Hello Xian!");
            bw.newLine();
            bw.write("Hello madi");
            //清空缓存，把内容写入文件
            bw.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fw!=null){
                try {
                    //关闭输出流
                    bw.close();
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

3、字节流

(1)字节输出流OutputStream

OutputStream是整个IO包中字节输出流的最大父类，此类是一个抽象类，如果想要使用此类的话，则首先必须通过子类实例化对象，那么如果现在要操作的是一个文件，则可以使用：FileOutputStream类。通过向上转型之后，可以为OutputStream实例化。具体事例如下：

package com.file;

import java.io.*;

public class OutputStreamDemo {
    public static void main(String[] args) {
        //创建文件对象
        File file = new File("D:/test/newFile2.txt");
        //声明输出流
        OutputStream os=null;
        try {
            //将输出流指向文件对象
            os=new FileOutputStream(file);
            String str="Hello World";
            byte[] bytes=str.getBytes();
            //向指定文件输出数据
            os.write(bytes);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(os!=null){
                try {
                    //关闭输出流
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }}}

（2）字节输入流InputStream

既然程序可以向文件中写入内容，则就可以通过InputStream从文件中把内容读取进来，

与OutputStream类一样，InputStream本身也是一个抽象类，必须依靠其子类，如果现在是从文件中读取，就用FileInputStream来实现。具体事例如下：

package com.file;

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

public class InputStreamDemo {
    public static void main(String[] args) {
        //构造一个文件输入流对象
        InputStream is=null;
        try {
            //将输入流对象指向文件
            is=new FileInputStream("D:/test/newFile2.txt");
            byte[] bytes=new byte[1024];
            //temp用来存储读入的字节长度
            int temp;
            //循环读取数据
            while ((temp=is.read(bytes))!=-1){
                String str=new String(bytes,0,temp);
                System.out.print(str);
            }
            
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (is!=null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        
    }
    }

（3）字节输入流之InputStreamReader

InputStreamReader将字节流转换为字符流。是字节流通向字符流的桥梁。如果不指定字符集编码，该解码过程将使用平台默认的字符编码。

构造方法：

构造一个默认编码集的InputStreamReader类	InputStreamReader isr = new InputStreamReader(InputStream in);
构造一个指定编码集的InputStreamReader类	InputStreamReader isr = new InputStreamReader(InputStream in,String charsetName);

package com.file;

import java.io.*;

public class InputStreamDemo {
    public static void main(String[] args) {
        //构造一个文件输入流对象
        InputStream is=null;
        InputStreamReader isr=null;
        try {
            //将输入流对象指向文件
            is=new FileInputStream("D:/test/newFile2.txt");
            //用InputStreamReader包装FileInputStream
            isr=new InputStreamReader(is);
            char[] chars=new char[1024];
            //temp用来存储读入的字节长度
            int temp;
            //循环读取数据
            while ((temp = isr.read(chars))!= -1){
                String str=new String(chars,0,temp);
                System.out.print(str);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (isr!=null){
                try {
                    isr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (is!=null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
    }

（4）字节输出流之OutputStreamWriter

OutputStreamWriter将字节流转换为字符流。是字节流通向字符流的桥梁。如果不指定字符集编码，该解码过程将使用平台默认的字符编码。

构造方法：

构造一个默认编码集的OutputStreamWriter类	OutputStreamWriter osw = new OutputStreamWriter(OutputStream out);
构造一个指定编码集的OutputStreamWriter类	OutputStreamWriter osw = new OutputStreamWriter(OutputStream out,String charsetName);

package com.file;

import java.io.*;

public class OutputStreamDemo {
    public static void main(String[] args) {
        //创建文件对象
        File file = new File("D:/test/newFile2.txt");
        //声明输出流
        OutputStream os=null;
        //声明OutputStreamWriter对象
        OutputStreamWriter osw=null;
        try {
            //将输出流指向文件对象
            os=new FileOutputStream(file,true);
            //用OutputStreamWriter包装OutputStream
            osw=new OutputStreamWriter(os);
            String str="\r\nHello China!";
            //向指定文件输出数据
            osw.write(str);
            osw.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (osw!=null){
                try {
                    osw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(os!=null){
                try {
                    //关闭输出流
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }


    }
}