Java IO流

IO流

流的分类：

文件流：FileInputStream / FileOutputStream / FileReader / FileWriter
缓冲流：BufferedInputStream / BufferedOutputStream / BufferedReader / BufferedWriter

File类

java.io.File类：文件和目录路径名的抽象表示形式，与平台无关。
File能新建、删除、重命名文件和目录，但File不能访问文件本身内容。如果需要访问文件内容本身，则需要使用输入/输出流。
File对象可以作为参数传递给流的构造函数。

File类的常见构造方法：

public File(String pathname): 以pathname为路径创建File对象，可以使绝对路径或相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
public File(String parent,String child): 以parent为父路径，child为子路径创建File对象。

File的静态属性String separator存储了当前系统的路径分隔符，在UNIX中，此字段为‘/’，在Windows中，为‘’。

访问文件名
- getName()
- getPath()
- getAbsoluteFile()
- getAbsolutePath()
- getParent()
- renameTo(File newName)
文件检测：
- exists()
- canWrite()
- canRead()
- isFile()
- isDirectory()
获取常规文件信息
- lastModify()
- Length()
文件操作相关
- createNewFile()
- delete()
目录操作相关
- mkDir()
- list()
- listFiles()

Java IO原理

IO流用来处理设备之间的数据传输。Java程序中，对于数据的输入/输出操作以“流（stream）”的方式进行。java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。

流的分类

按操作数据单位不同分为：字节流（8bit），字符流（16bit）
按数据流的流向不同分为：输入流，输出流
按流的角色的不同分为：节点流，处理流

Java的IO流共涉及40多个子类，实际上非常规则，都是从如下4个抽象基类派生的。由这四个类派生出来的子类名称都是以其父类名作为子类名后缀。

（抽象基类）	字节流	字符流
输入流	InputStream	Reader
输出流	OutputStream	Writer

分类	字节输入流	字节输出流	字符输入流	字符输出流
抽象基类	InputStream	OutputStream	Reader	Writer
访问文件	FileInputStream	FileOutputStream	FileReader	FileWriter
访问数组	ByteArrayInputStream	ByteArrayOutputStream	CharArrayReader	CharArrayWriter
访问管道	PipedInputStream	PipedOutputStream	PipedReader	PipedWriter
访问字符串			StringReader	StringWriter
缓冲流	BufferedInputStream	BufferedOutputStream	BufferedReader	BufferedWriter
转换流			InputStreamReader	OutputStreamWriter
对象流	ObjectInputStream	ObjectOutputStream
	FilterInputStream	FilterOutputStream	FilterReader	FilterWriter
打印流		PrintStream		PrintWriter
推回输入流	PushbackInputStream			PushbackReader
特殊流	DataInputStream	DataOutputStream

文件字节输入流

package io;

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

public class StreamTest1 {
    public static void main(String[] args) {
//        try{
//            FileInputStream in=new FileInputStream("C:\Users\Administrator\documents\JavaSE\test\abc\test1.txt");
//            byte[] b=new byte[10];  //设置一个byte数组，接收读取的文件的内容
//
//            int len=0; //设置一个读取数据的长度
//
//            //in.read(b); //in.read()方法的返回值是读取数据的长度，如果读取到最后一个数据，还会向后读一个，此时返回值为-1
//            //即当in.read()返回值为-1时，文件读取完毕
//            while ((len=in.read(b))!=-1){
//                System.out.println(new String(b,0,len));
//            }
//            System.out.println(new String(b));
//            in.close();  //注意，流在使用完毕后一定要关掉
//        }catch (Exception e){
//            e.printStackTrace();
//        }
        //testFileOutputStream();
        String in = "C:\Users\Administrator\documents\JavaSE\test\abc\ubuntu-18.04.5-live-server-amd64.iso";
        String out = "C:\Users\Administrator\documents\JavaSE\test\abc\cc\ubuntu-18.04.5-live-server-amd64-copy.iso";
        copyFile(in, out);

    }

    
    public static void testFileOutputStream(){
        try {
            FileOutputStream out=new FileOutputStream("C:\Users\Administrator\documents\JavaSE\test\abc\test2.txt");
            String str="hello java!";
            out.write(str.getBytes()); //把数据写到内存
            out.flush();  //把内存中的数据写到硬盘
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void copyFile(String inPath, String outPath){
        try {
            //FileInputStream in = new FileInputStream("C:\Users\Administrator\documents\JavaSE\test\abc\test1.txt");
            //FileOutputStream out = new FileOutputStream("C:\Users\Administrator\documents\JavaSE\test\abc\test2.txt");
            FileInputStream in = new FileInputStream(inPath);
            FileOutputStream out = new FileOutputStream(outPath);
            byte[] b = new byte[100000];
            int len = 0;
            while (((len = in.read(b)) != -1)){
                out.write(b,0, len);  //参数1是写的缓冲数组，参数2是从数组的哪个位置开始，参数3是写的长度
            }
            out.flush();
            out.close();
            in.close();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

文件字符输入流

读取文件操作步骤：

建立一个流对象，将已存在的一个文件加载进流。
FileReader fr = new FileReader("Test.txt");
创建一个临时存放数据的数组。
char[] ch = new char[1024];
调用流对象的读取方法将流中的数据读入到数组中。
fr.read(ch)

package io;


import java.io.*;

public class FileReaderTest {
    public static void main(String[] args) {
        String path = "C:\Users\Administrator\documents\JavaSE\test\abc\test1.txt";
        testFileReader(path);

        testFileWriter("Hello Java!","C:\Users\Administrator\documents\JavaSE\test\abc\cc\test5.txt");

        copyFile("C:\Users\Administrator\documents\JavaSE\test\abc\cc\test5.txt",
                "C:\Users\Administrator\documents\JavaSE\test\abc\cc\dd\test6.txt");
    }

    
    public static void testFileReader(String inPath){
        try {
            FileReader fr=new FileReader(inPath);  //创建文件字符输入流的对象
            char[] c = new char[10]; //创建临时存放数据的字符数组

            int len = 0;

            while ((len = fr.read(c)) != -1){
                System.out.println(new String(c,0,len));
            }
            fr.close();  //关闭流

        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    
    public static void testFileWriter(String text, String outPath){
        try {
            FileWriter fw = new FileWriter(outPath);
            fw.write(text); //写到内存中
            fw.flush(); //写到硬盘中
            fw.close();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    
    public static void copyFile(String inPath, String outPath){
        try {
            FileReader fr = new FileReader(inPath);
            FileWriter fw = new FileWriter(outPath);

            char[] c = new char[100];
            int len=0;
            while ((len = fr.read(c)) != -1){  //读取数据
                fw.write(c,0,len);  //写入数据
            }
            fw.flush();
            fw.close();
            fr.close();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

缓冲流

为了提高数据读写的速度，Java API内部提供了带缓冲功能的流类，在使用这些流类时，会创建一个内部缓冲区数组。
根据数据操作单位可以把缓冲流分为：

BufferedInputStream 和 BufferedOutputStream
BufferedReader 和 BufferedWriter

缓冲流要“套接”在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写的效率，同时增加了一些新的方法。

对于输出的缓冲流，写出的数据会先在内存中缓存，使用flush()将会使内存中的数据立刻写出。

FileInputStream，FileOutputStream与FileReader，FileWriter都是计算机与硬盘之间的IO操作，基于硬盘的读写相对比较慢，这个操作的速度受到硬盘的读写速度制约，为了能提高读写速度，一定程度上绕过硬盘的限制，Java提供了一种缓冲流来实现。

缓冲流就是先把数据缓冲到内存里，在内存中去做IO操作，基于内存的IO操作要比基于硬盘的IO操作快非常多。

缓冲字节流

package io.buffered;

import java.io.*;

public class BufferedTest {
    public static void main(String[] args) {
        try {
            //testBufferedInputStream();
            testBufferOutputStream();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    
    public static void testBufferedInputStream() throws Exception {
        //文件字节输入流对象
        FileInputStream in =new FileInputStream("C:\Users\Administrator\documents\JavaSE\基础语法\src\io\buffered\tt.txt");

        //把文件字节输入流放入缓冲字节输入流对象
        BufferedInputStream br = new BufferedInputStream(in);

        byte[] b= new byte[100];

        int len = 0;
        while ((len = br.read(b)) != -1){
            System.out.println(new String(b,0,len));
        }
        br.close();
        in.close();
    }

    
    public static void testBufferOutputStream(){
        try {
            //创建字节输出流对象
            FileOutputStream out = new FileOutputStream("C:\Users\Administrator\documents\JavaSE\基础语法\src\io\buffered\tt1.txt");

            //把字节输出流对象放到缓冲字节输出流中
            BufferedOutputStream bo = new BufferedOutputStream(out);

            copyFile();

            String s="Hello Java!";

            bo.write(s.getBytes()); //写到内存里
            bo.flush();  //写到硬盘里、

            bo.close();
            out.close();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    
    public static void copyFile() throws Exception {
        //缓冲输入流
        BufferedInputStream br=new BufferedInputStream(new FileInputStream("C:\Users\Administrator\documents\JavaSE\test\abc\test1.txt"));

        //缓冲输出流
        BufferedOutputStream bo = new BufferedOutputStream(new FileOutputStream("C:\Users\Administrator\documents\JavaSE\test\abc\test2.txt"));

        byte[] b = new byte[1024];

        int len = 0;  //设置一个每次读取到的数据的长度

        while ((len = br.read(b)) != -1){
            bo.write(b,0,len);  //写到内存中
        }
        bo.flush(); //写到硬盘中
        bo.close();
        br.close();
    }
}

缓冲字符流

package io.buffered;

import java.io.*;


public class BufferedReaderTest {
    public static void main(String[] args) {
        try {
            //testBufferedReader();
            //testBufferedWriter();
            copyFile();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    
    public static void testBufferedReader() throws Exception {
        FileReader r = new FileReader("C:\Users\Administrator\documents\JavaSE\基础语法\src\io\buffered\tt2.txt");
        BufferedReader br = new BufferedReader(r);
        char [] c = new char[100];
        int len=0;
        while ((len = br.read(c)) != -1){
            System.out.println(new String(c,0,len));
        }
        br.close();
        r.close();
    }

    
    public static void testBufferedWriter() throws Exception{
        FileWriter fw= new FileWriter("C:\Users\Administrator\documents\JavaSE\基础语法\src\io\buffered\tt3.txt");
        BufferedWriter bw= new BufferedWriter(fw);
        String s = "Hello,I'm Alex.";
        bw.write(s);
        bw.flush();
        bw.close();
        fw.close();
    }

    
    public static void copyFile() throws Exception{
        BufferedReader br=new BufferedReader(new FileReader("C:\Users\Administrator\documents\JavaSE\基础语法\src\io\buffered\tt3.txt"));
        BufferedWriter bw=new BufferedWriter(new FileWriter("C:\Users\Administrator\documents\JavaSE\基础语法\src\io\buffered\tt4.txt"));
        char [] c=new char[100];
        int len=0;
        while ((len=br.read(c))!=-1){
            bw.write(c,0,len);
        }
        bw.flush();
        bw.close();
        br.close();
    }
}

注意：缓冲流是把数据缓冲到内存中。

转换流

转换流提供了在字节流和字符流之间的转换。
Java API提供了两个转换流：InputStreamReader和OutputStreamWriter

字节中的数据都是字符时，转换成字符流更高效。

InputStreamReader用于将字节流中读取到的字节按指定字符集解码成字符。需要和InputStream“套接”。

构造方法：

InputStreamReader(InputStream in)

public InputStreamReader(InputStream in, String charsetName)

如：Reader isr= new InputStreamReader(System.in, "ISO5334_1");

所有的文件都有编码格式，一般来说，TXT和java文件有三种编码：

ISO8859-1，西欧编码，是纯粹英文编码，不适用于汉字
GBK和UTF-8，这两种编码适用于中文和英文

一般使用UTF-8编码

package io.buffered;

import java.io.*;

public class TransferTest {
    public static void main(String[] args) {
        try {
            //testInputStreamReader();
            testOutputStreamWriter();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    
    public static void testInputStreamReader() throws Exception {
        FileInputStream fs = new FileInputStream("C:\Users\Administrator\documents\JavaSE\基础语法\src\io\buffered\test.txt");

        //把字节流转换为字符流
        InputStreamReader in= new InputStreamReader(fs,"UTF-8"); //参数1是字节流，参数2是编码

        char[] c = new char[100];
        int len=0;
        while ((len = in.read(c))!=-1){
            System.out.println(new String(c,0,len));
        }
        in.close();
        fs.close();
    }

    
    public static void testOutputStreamWriter() throws Exception{
        FileOutputStream out=new FileOutputStream("C:\Users\Administrator\documents\JavaSE\基础语法\src\io\buffered\fotest.txt");
        OutputStreamWriter os = new OutputStreamWriter(out,"UTF-8");
        os.write("你好呀");
        os.flush();
        os.close();
        out.close();
    }

}

标准输入输出流

System.in和System.out分别代表了系统标准的输入和输出设备。
默认输入设备是键盘，输出设备是显示器。
System.in的类型是InputStream
System.out的类型是PrintStream，是OutputStream的子类FilterOutputStream的子类

package io.buffered;

import java.io.*;

public class TestIOStream {
    public static void main(String[] args) {
        try {
            //testSystemInput();
            writeToTXT();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void testSystemInput() throws IOException {
        //创建一个接收键盘输入数据的输入流
        InputStreamReader is = new InputStreamReader(System.in);

        //把输入流放到缓冲流里
        BufferedReader br= new BufferedReader(is);

        String str="";  //定义一个临时接收数据的字符串
        while ((str=br.readLine())!=null){
            System.out.println(str);
        }
        br.close();
        is.close();
    }

    
    public static void writeToTXT() throws IOException {
        //创建一个接收键盘输入数据的输入流
        InputStreamReader is = new InputStreamReader(System.in);
        BufferedWriter out = new BufferedWriter(new FileWriter("C:\Users\Administrator\documents\JavaSE\基础语法\src\io\buffered\tt2.txt"));
        //把输入流放到缓冲流里
        BufferedReader br= new BufferedReader(is);
        String line="";  //定义一个临时接收数据的字符串
        while ((line=br.readLine()) != null){
            if(line.equals("over")){
                break;
            }
            //读取的每一行都写到指定的TXT文件
            out.write(line);
        }
        out.flush();
        out.close();
        br.close();
        is.close();
    }
    
}

Java IO流

Java相关栏目本月热门文章