Java基础——IO流

Wen先森

已于 2022-07-06 12:01:00 修改

阅读量271

点赞数 2

分类专栏： java 文章标签： java

于 2022-07-06 11:59:22 首次发布

本文链接：https://blog.csdn.net/qq_41596778/article/details/124476522

版权

java 专栏收录该内容

47 篇文章 1 订阅

订阅专栏

文件

文件，文件是保存数据的地方，如word文档，excel表格文件，txt文件等。他可以保存图片、声音、视频等数据。

文件在程序中是以流的形式来操作的

流：数据在数据源（文件）和程序（内存）之间经历的路径

输入流：数据从数据源（文件）到程序（内存）的路径

输出流：数据从程序（内存）到数据源（文件）的路径

常用的文件操作

创建文件对象相关构造器和方法

new File(String pathName)//根据路径构建一个File对象

new File(File parent,String child)//根据父目录文件+子路径构建

new File(String parent,String child)//根据父目录+子路径构建

createNewFile 创建新文件

package com.study.srv.demo17;

import org.junit.Test;

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

/**
 * @author Wen先森
 * @version 1.0
 * @date 2022/4/28 16:52
 * 演示创建文件
 */
public class Demo01 {
    public static void main(String[] args) {

    }
    //方式1 new File(String filePath)
    @Test
    public void create01(){
        String filePath="D:\\new1.txt";
        File file = new File(filePath);
        try {
            file.createNewFile();
            System.out.println("文件创建成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //方式2 new File(File parent,String child)
    //根据父目录文件+子路径构建
    @Test
    public void create02(){
        File file = new File("D:\\");
        String fileName="new2.txt";
        File file1 = new File(file,fileName);
        //这里的file对象，在Java程序中，只是一个对象
        //只有执行了creatNewFile方法，才会真正的在磁盘创建该文件
        try {
            file1.createNewFile();
            System.out.println("文件创建成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //方式3 new File(String parent ,String child)//根据父目录+子路径构建
    @Test
    public void create03(){
        String parentPath="D:\\";
        String fileName="new3.txt";
        File file = new File(parentPath,fileName);
        //这里的file对象，在Java程序中，只是一个对象
        //只有执行了creatNewFile方法，才会真正的在磁盘创建该文件
        try {
            file.createNewFile();
            System.out.println("文件创建成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

获取文件相关信息

方法名	方法说明
getName()	获取文件名
getAbsolutePath()	获取绝对路径
getParent()	获取文件父级目录
length()	获取文件大小（字节）
exists()	判断文件是否存在
isFile()	判断是不是一个文件
isDirectory()	判断是不是一个目录

package com.study.srv.demo17;

import org.junit.Test;

import java.io.File;

/**
 * @author Wen先森
 * @version 1.0
 * @date 2022/4/28 17:40
 */
public class Demo02 {
    public static void main(String[] args) {

    }

    @Test
    public void info() {
        //先创建文件对象
        File file = new File("D:\\new1.txt");

        //调用相应的方法，得到对应信息
        //文件名
        System.out.println("文件名=" + file.getName());
        //绝对路径
        System.out.println("文件绝对路径=" + file.getAbsolutePath());
        //文件父级目录
        System.out.println("文件父级目录=" + file.getParent());
        //文件大小（字节）
        System.out.println("文件大小（字节）=" + file.length());
        //文件是否存在
        System.out.println("文件是否存在=" + file.exists());
        //是不是一个文件
        System.out.println("是不是一个文件=" + file.isFile());
        //是不是一个目录
        System.out.println("是不是一个目录=" + file.isDirectory());
    }
}

目录的操作和文件删除

mkdir创建一级目录、mkdirs创建多级目录、delete删除空目录或文件

mkdir() 返回类型boolean

mkdirs() 返回类型boolean

package com.study.srv.demo17;

import org.junit.Test;

import java.io.File;

/**
 * @author Wen先森
 * @version 1.0
 * @date 2022/4/29 10:34
 */
public class Demo03 {
    public static void main(String[] args) {

    }
    //判断D:\\new1.txt是否存在，如果存在就删除。
    @Test
    public void m1() {
        String pathName="D:\\\\new1.txt";
        File file = new File(pathName);
        if (file.exists()){
            if (file.delete()){
                System.out.println("文件删除成功！");
            }else {
                System.out.println("文件删除失败！");
            }
        }else {
            System.out.println("文件不存在！");
        }
    }
    //判断D:\\demo03是否存在，存在就删除，否则提示不存在并创建
    @Test
    public void m2() {
        String pathName="D:\\demo02";
        File file = new File(pathName);
        if (file.exists()){
            if (file.delete()){
                System.out.println("目录删除成功！");
            }else {
                System.out.println("目录删除失败！");
            }
        }else {
            System.out.println("目录不存在！");
            if (file.mkdir()){
                System.out.println("目录创建成功！");
            }else {
                System.out.println("目录创建失败！");
            }
        }
    }
    //判断D:\\demo03\\a\\b\\c目录是否存在，如果存在提示存在，否则就创建
    @Test
    public void m3() {
        String pathName="D:\\demo03\\a\\b\\c";
        File file = new File(pathName);
        if (file.exists()){
            System.out.println("目录存在！");
        }else {
            System.out.println("目录不存在！");
            if (file.mkdirs()){//mkdir创建一级目录、mkdirs创建多级目录
                System.out.println("目录创建成功！");
            }else {
                System.out.println("目录创建失败！");
            }
        }
    }
}

IO流原理及流的分类

Java IO流原理

I/O是Input/Output的缩写，I/O技术是非常实用的技术，用于处理数据传输。读/写文件，网络通讯等。
Java程序中，对于数据的输入/输出操作以“流(stream)”的方式进行。
java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过方法输入或输出数据。
输入input：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中。
输出output：将程序（内存）数据输出到磁盘、光盘等存储设备中。

流的分类

按操作数据单位不同分为：字节流（8 bit）二进制文件，字符流（按字符）文本文件。
按数据流的流向分为：输入流，输出流。
按流的角色的不同分为：节点流，处理流/包装流。

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

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

IO流体系图-常用的类

IO流体系图

FileInputStream介绍

package com.study.srv.demo17;

import org.junit.Test;

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

/**
 * @author Wen先森
 * @version 1.0
 * @date 2022/5/12 10:40
 *
 * FileInputStream输入流
 */
public class Demo04 {
    public static void main(String[] args) {

    }

    /**
     * 使用FileInputStream的read方法读取的是单个字节，效率比较低。
     * 此时我们可以使用read(byte[] b)读取文件
     */
    @Test
    public void readFile(){

        String path="D:\\new2.txt";
        FileInputStream fileInputStream=null;
        int read=0;
        try {
            //创建FileInputStream对象，用于读取文件
            fileInputStream = new FileInputStream(path);
            //FileInputStream中的read方法
            //从该输入流读取一个字节的数据。如果没有输入可用，此方法将被阻止。
            //如果返回-1，表示已经到末尾，表示读取完毕
            while ((read=fileInputStream.read())!=-1) {
                System.out.print((char) read);//将int转为char显示
            }
        }  catch (IOException e) {
            e.printStackTrace();
        }finally {
            //最后一定要关闭文件流 ，释放资源
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 使用read(byte[] b)方法读取文件
     */
    @Test
    public void readFile2(){
        String path="D:\\new2.txt";
        FileInputStream fileInputStream=null;
        //字节数组
        byte[] bytes = new byte[3];//一次读取3个字节
        int read=0;
        try {
            //创建FileInputStream对象，用于读取文件
            fileInputStream = new FileInputStream(path);
            //FileInputStream中的read(byte[] b)方法
            //从该输入流读取最多b.length字节的的数据到字节数组。此方法将被阻塞，直到某些输入可用
            //如果返回-1，表示已经到末尾，表示读取完毕
            //fileInputStream.read(bytes)读取正常，返回的是实际读取到的字节数
            while ((read=fileInputStream.read(bytes))!=-1) {
                //但是这样写会被偏移量所限制，
                System.out.print(new String(bytes,0,read));
                //也可以直接new String对象
                String str=new String(bytes);
                System.out.print(str);
                //将int转为char显示
            }
        }  catch (IOException e) {
            e.printStackTrace();
        }finally {
            //最后一定要关闭文件流 ，释放资源
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

FileOutputStream介绍

package com.study.srv.demo17;

import org.junit.Test;

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

/**
 * @author Wen先森
 * @version 1.0
 * @date 2022/5/12 14:15
 * FileOutputStream输出流
 */
public class Demo05 {
    public static void main(String[] args) {

    }

    /**
     * 使用FileOutputStream将数据写入到文件中
     * 若文件不存在，则创建该文件
     */
    @Test
    public void writeFile01(){
        //创建FileOutputStream对象
        String path="d:\\a.txt";
        FileOutputStream fileOutputStream=null;
        try {
            //得到一个FileOutputStream对象
            fileOutputStream=new FileOutputStream(path);
            //正常创建的的FileOutputStream对象通过write方法写入数据，会把原本的数据覆盖掉。
            //所以可以在创建对象时加入true，表示数据拼接。
//            fileOutputStream=new FileOutputStream(path,true);
            //写入一个字节
//            fileOutputStream.write('h');
            //写入字符串
            String str="hello,你好！";
//            fileOutputStream.write(str.getBytes());
            //str.getBytes()会把字符串->字节数组
            //write(byte[] b,int off,int len)将len字节从位于偏移量off的的指定字节数组写入此文件输出流。
            //即从字节数组下标为off的位置到之后len数量的字节写入到文件输出流之中。
            fileOutputStream.write(str.getBytes(),2,3);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

文件拷贝

利用输入流读取文件数据再利用输出流将读取的数据写入到目标文件。

package com.study.srv.demo17;

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

/**
 * @author Wen先森
 * @version 1.0
 * @date 2022/5/12 15:35
 * 文件拷贝
 */
public class Demo06 {
    public static void main(String[] args) {
        //完成文件拷贝，将D:\\1.gif拷贝到E:\\
        //思路：先读数据，再把读取的数据保存到目标文件
        //1.创建文件输入流，将文件读入到程序
        //2.创建文件的输出流，将读取到的文件数据写入到指定文件
        String pathA="D:\\1.gif";
        String pathB="E:\\3.gif";
        //定义一个字节数组，提高读取效率
        byte[] bytes=new byte[1024];
        int len=0;
        FileInputStream fileInputStream=null;
        FileOutputStream fileOutputStream=null;
        try {
            fileInputStream=new FileInputStream(pathA);
            fileOutputStream=new FileOutputStream(pathB);
            while ((len=fileInputStream.read(bytes))!=-1) {
                //读取到后，就写入文件，即边读边写。
                //不能用 fileOutputStream.write(bytes);因为有可能最后读取不够字节，这样会导致文件无法使用
                //一定要用write(byte[] b,int off,int len)
                fileOutputStream.write(bytes,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if (fileInputStream!=null) {
                    fileInputStream.close();
                }
                if (fileOutputStream!=null) {
                    fileOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

FileReader相关方法

new FileReader(File/String) ：创建FileReader对象。
read:每次读取单个字符，返回该字符，如果到文件末尾返回-1.
read(char[]):批量读取多个字符到数组，返回读取到的字符数，如果到文件末尾返回-1.
new String(char[]):将char[]数组转换成String。
new String(char[],off,len):将char[]的指定部分转换为String。

FileWriter常用方法

new FileWriter(File/String):覆盖模式，相当于流的指针在首段，将原本的数据覆盖掉。
new FileWriter(File/String,true):追加模式，相当于流的指针在尾端，写到原本的数据之后。
writer(int):写入单个字符。
writer(char[]):写入指定数组。
writer(char[],off,len):写入指定数组的指定部分。
writer(string):写入整个字符串。
writer(sting,off,len):写入字符串的指定部分。toCharArray:将String转换成char[]

FileWriter使用后，必须要关闭(close)或刷新(flush),否则写入不到指定的文件。

FileReader和FileWriter应用

package com.study.srv.demo17;

import org.junit.Test;

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

/**
 * @author Wen先森
 * @version 1.0
 * @date 2022/5/12 17:34
 * FileReader
 */
public class Demo07 {
    public static void main(String[] args) {

    }

    @Test
    public void fileReader1(){
        String path="D:\\new3.txt";
        FileReader fileReader=null;
        int data=' ';
        try {
            fileReader=new FileReader(path);
            //读取数据 使用read（单个字符）
            while ((data=fileReader.read())!=-1){
                System.out.print((char)data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }


    @Test
    public void fileReader2(){
        String path="D:\\new3.txt";
        FileReader fileReader=null;
        char[] chars=new char[1024];
        int data=' ';
        try {
            fileReader=new FileReader(path);
            //读取数据 使用read(char[]),返回的是实际读取到的字符数
            //如果返回-1，说明读到文件结尾
            while ((data=fileReader.read(chars))!=-1){
                System.out.print(new String(chars,0,data));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

package com.study.srv.demo17;

import org.junit.Test;

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

/**
 * @author Wen先森
 * @version 1.0
 * @date 2022/5/12 17:53
 * FileWriter
 */
public class Demo08 {
    public static void main(String[] args) {

    }

    @Test
    public void fileWriter(){
        //创建FileWriter对象
        FileWriter fileWriter=null;
        char[] chars={'a','b','c'};
        try {
            fileWriter=new FileWriter("E:\\c.txt",true);
            fileWriter.write("Java程序设计\n");
            fileWriter.write("数据结构\n");

//            writer(int):写入单个字符。
            fileWriter.write('h');
//            writer(char[]):写入指定数组。
            fileWriter.write(chars);
//            writer(char[],off,len):写入指定数组的指定部分。
            fileWriter.write(chars,1,1);
//            writer(string):写入整个字符串。
            fileWriter.write("\n计算机算法与导论");
//            writer(sting,off,len):写入字符串的指定部分。toCharArray:将String转换成char[]
            fileWriter.write("数据库概论\n",0,6);
            fileWriter.write("数据库概论\n".toCharArray(),0,6);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                //FileWriter一定要关闭流，或者flush才能真正的将数据写入到文件。
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

节点流和处理流

基本介绍

节点流可以从一个特定的数据源读写数据，如FileReader、FileWriter
处理流（也叫包装流）是“连接” 在已经存在的流（节点流或处理流）之上，为程序提供更强大的读写功能，也更加灵活，如BufferedReader、BufferedWriter。

节点流和处理流一览表

分类	字节输入流	字节输出流	字符输入流	字符输出流
抽象基类	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	Filter
打印流		PrintStream		PrintWriter
推回输入流	PushbackInputStream		PushbackReader
特殊流	DataInputStream	DataOutputStream

注：红色为字节流，紫色为处理流

节点流和处理流的区别和联系

节点流是底层流/低级流，直接跟数据源相接。
处理流（包装类）包装节点流，既可以消除不同节点流的实现差异，也可以提供更方便的方法来完成输入输出。
处理流（也叫包装流）对节点流进行包装，使用了修饰器设计模式，不会直接与数据源相连

处理流的功能主要体现在一下两个方面

性能的提高：主要以增加缓冲的方式来提高输入输出的效率。
操作的便捷：处理流可能提供了一系列便捷的方法来一次输入输出大批量的数据，使用更加灵活方便。

处理流-BufferedReader和BufferedWriter

在源码中，BufferedReader类中，有属性Reader，即可以封装一个节点流，该节点流可以是任意的，只要是Reader子类都可（FileReader、CharArrayReader、PipedReader等等，只要是Reader的子类就可以，但是一次只能放一个），这也说明包装流更加强大。通过传入的Reader（子类）来决定访问文件/数组/管道。

BufferedWriter原理同上：

代码模拟：

package com.study.srv.demo17;

/**
 * @author Wen先森
 * @version 1.0
 * @date 2022/6/29 10:37
 * 模拟流
 */
public class Demo09 {
    public static void main(String[] args) {
        BuffReader buffReader = new BuffReader(new FileReader());
        buffReader.reader();
        buffReader.fileReader(4);

        BuffReader buffReader1 = new BuffReader(new ArrayReader());
        buffReader1.fileReader(3);

        BuffReader buffReader2 = new BuffReader(new PipeReader());
        buffReader2.fileReader(2);

    }


}

abstract class AbstractReader {
    public void printf() {
    }
    //抽象方法可以用空方法体，也可以用abstract
    //public abstract void printf();
}


/**
 * 模拟节点流
 */
class FileReader extends AbstractReader {
    @Override
    public void printf() {
        System.out.println("对文件进行打印");
    }
}


/**
 * 模拟节点流
 */
class ArrayReader extends AbstractReader {
    @Override
    public void printf() {
        System.out.println("对数组进行打印");
    }
}


/**
 * 模拟节点流
 */
class PipeReader extends AbstractReader {
    @Override
    public void printf() {
        System.out.println("对管道进行打印");
    }
}

/**
 * 模拟包装流/处理流
 */
class BuffReader extends AbstractReader {
    /**
     * 属性是AbstractReader类型
     */
    private AbstractReader in;

    /**
     * 接受AbstractReader子类对象
     *
     */
    public BuffReader(AbstractReader in) {
        this.in = in;
    }

    /**
     * 封装一层方法
     */
    public void reader() {
        in.printf();
    }

    /**
     * 多次调用
     *
     */
    public void fileReader(int num) {
        for (int i = 0; i < num; i++) {
            in.printf();
        }
    }
}

BufferedReader和BufferedWriter属于字符流，是按照字符来读取数据，关闭时处理流，只需要关闭外层流即可。

因为在使用包装流，就是通过外层的包装流最终调用了内层包装的节点流，所以在关闭处理流/包装流的时候，底层会自动关闭内层包装的节点流。

BufferedReader示例：

package com.study.srv.demo17;

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

/**
 * @author Wen先森
 * @version 1.0
 * @date 2022/6/29 15:53
 */
public class Demo10 {
    public static void main(String[] args) throws IOException {
        //读取文件路径
        String src="E:\\c.txt";
        //创建包装流BufferedReader对象
        BufferedReader bufferedReader = new BufferedReader(new FileReader(src));
        String line;
        //bufferedReader.readLine())是按行读取，
        //通过下列字符之一即认为某行已终止：换行 ('\n')、回车 ('\r') 或回车后直接跟着换行。
        //包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null
        while ((line=bufferedReader.readLine())!=null){
            System.out.println(line);
        }
        //关闭外层包装/处理流，就会自动关闭内部的节点流
        bufferedReader.close();
    }
}

BufferedWriter示例：

package com.study.srv.demo17;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

/**
 * @author Wen先森
 * @version 1.0
 * @date 2022/6/29 16:23
 * 演示BufferedWriter使用
 */
public class Demo11 {
    public static void main(String[] args) throws IOException {
        //文件地址，有则直接写入，无则先创建文件再进行写入
        String src="E:\\test.txt";
        //创建一个处理流BufferedWriter对象，并且设置节点流默认拼接写入
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(src,true));
        bufferedWriter.write("这是一条测试");
        //换行，写入一个行分隔符。行分隔符字符串由系统属性 line.separator 定义，
        // 并且不一定是单个新行 ('\n') 符。 
        bufferedWriter.newLine();
        bufferedWriter.write("这是一条新的测试数据2");
        //同样写入完毕后，关闭包装流/处理流。
        bufferedWriter.close();
    }
}

文件拷贝：

package com.study.srv.demo17;

import java.io.*;
import java.io.FileReader;

/**
 * @author Wen先森
 * @version 1.0
 * @date 2022/6/29 17:10
 * 利用包装流实现文件拷贝
 */
public class Demo12 {
    public static void main(String[] args) {
        //所选复制文件地址
        String src="E:\\c.txt";
        //所选复制后文件地址
        String path="E:\\copy.txt";
        BufferedReader bufferedReader=null;
        BufferedWriter bufferedWriter = null;
        String line;

        try {
            //创建处理流/包装流，BufferedReader和BufferedWriter对象
            //值得注意的是BufferedReader和BufferedWriter是字符处理流
            //不能去操作二进制文件，会造成文件损坏
            bufferedReader = new BufferedReader(new FileReader(src));
            bufferedWriter = new BufferedWriter(new FileWriter(path));
            //一行一行读取
            while ((line=bufferedReader.readLine())!=null){
                //一行一行写入
                bufferedWriter.write(line);
                //换行
                bufferedWriter.newLine();
            }
            System.out.println("文件拷贝完毕");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭包装流
            try {
                if (bufferedReader!=null) {
                    bufferedReader.close();
                }
                if (bufferedWriter!=null) {
                    bufferedWriter.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

处理流-BufferedInputStream 和 BufferedOutputStream

BufferedInputStream是字节流，在创建BufferInputStream时，会创建一个内部缓冲区数组。

package com.study.srv.demo17;

import java.io.*;

/**
 * @author Wen先森
 * @version 1.0
 * @date 2022/6/30 11:48
 * 使用BufferedInputStream和BufferedOutputStream拷贝文件
 * 完成二进制文件拷贝
 */
public class Demo13 {
    public static void main(String[] args) {
        //复制对象地址
        String pathA = "E:\\c.txt";
        //复制后地址
        String pathB = "E:\\x.txt";
        //创建BufferedInputStream和BufferedOutputStream对象
        BufferedInputStream bufferedInputStream = null;
        BufferedOutputStream bufferedOutputStream = null;

        byte[] bytes = new byte[1024];
        int length;
        try {
            //FileInputStream是InputStream子类
            bufferedInputStream = new BufferedInputStream(new FileInputStream(pathA));
            bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(pathB));
            //循环读取文件，被写入到复制文件中去。
            //如果到达流末尾，则返回 -1。
            while ((length = bufferedInputStream.read(bytes)) != -1) {
                //将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此缓冲的输出流。
                bufferedOutputStream.write(bytes, 0, length);
            }
            System.out.println("拷贝完毕");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (bufferedInputStream != null) {
                    bufferedInputStream.close();
                }
                if (bufferedOutputStream != null) {
                    bufferedOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

值得注意的是，字节流可以操作二进制文件（字节），也可以操作字符文件（因为字节是基本单位）。但是字符流不能操作二进制文件。

对象处理流

序列化和反序列化

序列化就是在保存数据时，保存数据的值和数据类型。
反序列化就是在恢复数据时，恢复数据的值和数据类型。
需要让某个对象支持序列化机制，则必须让其类是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一：
1. Serializable //这是一个标记接口，没有方法。
2. Externalizable //该接口有方法需要实现，因此我们一般实现上面Serializable 接口。

ObjectInputStream和ObjectOutputStream

功能：提供了对基本类型或对象类型的序列化和反序列化的方法。
ObjectOutputStream提供序列化功能。
ObjectInputStream提供反序列化功能。

示例：

package com.study.srv.demo17;

import java.io.Serializable;

/**
 * @author Wen先森
 * @version 1.0
 * @date 2022/7/4 14:33
 * 创建一个公共类
 */
public class Test implements Serializable {
    private String name;
    private int age;

    public Test(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Test{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

package com.study.srv.demo17;

import java.io.*;

/**
 * @author Wen先森
 * @version 1.0
 * @date 2022/7/4 11:09
 * 演示ObjectOutputStream的使用，完成数据的序列化
 */
public class Demo14 {
    public static void main(String []args) throws IOException {
        //序列化文件地址，保存的文件格式，不是文本格式而是按照自己格式保存。
        String src="E:\\t.dat";
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(src));
        //int类型自动——>Integer(Integer类实现了Serializable)
        oos.writeInt(12);
        //double类型自动——>Double(Double类实现了Serializable)
        oos.writeDouble(3.14);
        //boolean类型自动——>Boolean(Boolean类实现了Serializable)
        oos.writeBoolean(false);
        //char类型自动——>Character(Character类实现了Serializable)
        oos.writeChar('s');
        //String(Integer类实现了Serializable)
        oos.writeUTF("无聊");
        //如果想保存一个对象，要让对象实现Serializable接口
        oos.writeObject(new Test("测试",16));
        //关闭处理流
        oos.close();
        System.out.println("数据按照序列化保存完毕");
    }
}

package com.study.srv.demo17;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

/**
 * @author Wen先森
 * @version 1.0
 * @date 2022/7/4 12:03
 * 演示ObjectInputStream的使用，完成数据的反序列化
 */
public class Demo15 {
    public static void main(String[] args) throws IOException {
        //反序列化文件
        String src="E:\\t.dat";
        //创建ObjectInputStream对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(src));

        //读取（反序列化）数据顺序时，顺序需要与保存（序列化）数据保持一致。
        System.out.println(ois.readInt());
        System.out.println(ois.readDouble());
        System.out.println(ois.readBoolean());
        System.out.println(ois.readChar());
        System.out.println(ois.readUTF());
        try {
            //object的编译类型时Object，object的运行类型是Test
            Object object = ois.readObject();
            System.out.println("运行类型="+object.getClass());
            System.out.println("Test信息="+object);

            //如果要调用Test中的方法，需要向下转型。
            //则我们需要将Test类的定义，转移到可以引用的位置（设成公共类）
            Test test=(Test)object;
            System.out.println(test.getName());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        //关闭处理流
        ois.close();
    }
}

注意事项

读写顺序必须一致。
要求实现序列化或反序列化对象，需要实现Serializable。
序列化的类中建议添加SerialVerisonUID，为了提高版本兼容性。
序列化对象时，默认将里面所有属性都进行序列化，但除了static或transient修饰的成员。
序列化对象时，要求里面属性的类型也需要实现序列化接口。
序列化具备可继承性，也就是如果某类已经实现了序列化，则它的所有子类也已经默认实现了序列化。

package com.study.srv.demo17;

import java.io.Serializable;

/**
 * @author Wen先森
 * @version 1.0
 * @date 2022/7/4 14:33
 * 创建一个公共类
 */
public class Test implements Serializable {
    private String name;
    private int age;
    /**
     * 序列化对象时，默认将里面所有属性都进行序列化，但是除了static或transient修饰的成员。
     */
    private static String sex;
    private transient String nation;
    /**
     * 串行版本uid,序列化的版本号，可以提高兼容性。
     */
    private static final Long serialVersionUID=1L;
    public Test(String name, int age,String sex,String nation) {
        this.name = name;
        this.age = age;
        Test.sex =sex;
        this.nation=nation;
    }

    @Override
    public String toString() {
        return "Test{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", nation='" + nation + '\'' +
                ", sex='" + sex +'\'' +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

}

序列化对象时，默认将里面所有属性都进行序列化，但是除了static或transient修饰的成员。

/**
 * 序列化对象时，要求里面属性的类型也要实现序列化接口
 */
private Test2 test2=new Test2();

如果属性类型未实现序列化，则会出现异常。

所以要将属性类型也实现序列化接口。

标准输入输出流

标准	编译类型	运行类型	默认设备
System.in 标准输入	InputStream	BufferedInputStream	键盘
System.out 标准输出	PrintStream	PrintStream	显示器

package com.study.srv.demo17;

import java.io.InputStream;
import java.io.PrintStream;
import java.util.Scanner;

/**
 * @author Wen先森
 * @version 1.0
 * @date 2022/7/4 16:02
 */
public class Demo16 {
    public static void main(String[] args) {
        //System.in的编译类型是InputStream，运行类型为BufferedInputStream
        //表示标准键盘输入  键盘
        InputStream in = System.in;
        System.out.println("运行类型="+in.getClass());
        //传统用法，Scanner从标准输入键盘接收数据
        Scanner scanner = new Scanner(System.in);
        int num = scanner.nextInt();

        //System.out的编译类型是PrintStream，运行类型为PrintStream
        //表示标准键盘输出  显示器
        PrintStream out = System.out;
        System.out.println("运行类型="+out.getClass());

        //传统用法，System.out.println
        System.out.println(num);
    }
}

转换流

InputStreamReader：Reader的子类，可以将InputStream（字节流）包装成（转换）Reader（字符流）。
OutputStreamWriter：Writer的子类，实现将OutputStream（字节流）包装成Writer（字符流）。
当处理纯文本数据时，如果使用字符效率更高，并且可以有效解决中文问题，所以建议将字节流转换为字符流。
可以在使用指定编码格式（比如utf-8，gbk，gb2312，ISO8859-1等）。

package com.study.srv.demo17;

import java.io.*;
import java.io.FileReader;

/**
 * @author Wen先森
 * @version 1.0
 * @date 2022/7/4 18:00
 * 中文乱码
 * 使用InputStreamReader转换流解决中文乱码
 * 将字节流FileInputStream转换成字符流InputStreamReader，指定编码gbk/utf-8
 */
public class Demo17 {
    public static void main(String[] args) throws IOException {
        //读取e:\\c.txt 文件到程序
        String src="e:\\c.txt";
        //默认情况下，读取文件是按照utf-8格式进行编码的
        //1.转换FileInputStream字节流为InputStreamReader字符流
        //2.指定编码格式为GBK
        //InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream(src),"GBK");
        //将InputStreamReader 传入BufferedReader
        //BufferedReader bufferedReader = new BufferedReader(inputStreamReader);

        //也可以直接套用
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(src),"GBK"));
        String num;
        while ((num=bufferedReader.readLine())!=null){
            System.out.println(num);
        }
        //关闭外层处理流
        bufferedReader.close();

    }
}

package com.study.srv.demo17;

import java.io.*;

/**
 * @author Wen先森
 * @version 1.0
 * @date 2022/7/5 16:46
 * 演示OutputStreamWriter使用
 * 把FileOutputStream字节流转换为OutputStreamWriter
 */
public class Demo18 {
    public static void main(String[] args) throws IOException {
        //读取e:\\c.txt 文件到程序
        String src="e:\\c.txt";
        String path="E:\\css.txt";
        String charSet="utf-8";
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(src),"GBK"));
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream(path),charSet);
        BufferedWriter bufferedWriter = new BufferedWriter(outputStreamWriter);
        String num;
        while ((num=bufferedReader.readLine())!=null){
            bufferedWriter.write(num);
            bufferedWriter.newLine();
        }
        bufferedReader.close();
        bufferedWriter.close();

    }
}

打印流

打印流只有输出流，没有输入流：PrintStream、PrintWriter

PrintStream

package com.study.srv.demo17;

import java.io.IOException;
import java.io.PrintStream;

/**
 * @author Wen先森
 * @version 1.0
 * @date 2022/7/5 17:37
 */
public class Demo19 {
    public static void main(String[] args) throws IOException {
        PrintStream printStream=System.out;
        //默认情况下，PrintStream输出数据的位置是 标准输出，即显示器
        printStream.print("测试一下");
        /*
            底层机制为
                    public void print(String s) {
                            if (s == null) {
                                s = "null";
                            }
                            write(s);
                        }
         */
        printStream.write("测试一下".getBytes());
        printStream.close();

        //可以修改打印流输出的位置/设备
        //打印到E:\ss.txt里
        System.setOut(new PrintStream("E:\\ss.txt"));
        System.out.println("还是测试");
    }
}

PrintWriter

package com.study.srv.demo17;

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

/**
 * @author Wen先森
 * @version 1.0
 * @date 2022/7/6 10:37
 */
public class Demo20 {
    public static void main(String[] args) throws IOException {
        PrintWriter printWriter=new PrintWriter(System.out);
        printWriter.print("测试");
        printWriter.close();

        //也可以修改打印输出路径
        PrintWriter printWriter1 = new PrintWriter(new FileWriter("E:\\sc.txt"));
        printWriter1.print("最终测试");
        printWriter1.close();

    }
}

在PrintWriter中修改打印输出路径，打印流必须要关闭，否则默认数据被清除，但打印流的数据需要关闭流之后才会写入到文件中。

Properties类

package com.study.srv.demo17;

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

/**
 * @author Wen先森
 * @version 1.0
 * @date 2022/7/6 10:50
 * 操作properties文件
 */
public class Demo21 {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new FileReader("src/com/study/srv/demo17/mysql.properties"));
        String line;
        while ((line=bufferedReader.readLine())!=null){
            String[] split = line.split("=");
            if (split[0].equals("ip")) {
                System.out.println(split[0] + "的值是：" + split[1]);
            }
        }
        bufferedReader.close();
    }
}

可以看出有普通的流对于properties文件操作过于繁琐，同样也无法保证数据的正确性，所以需要用专门的properties类操作properties文件。

基本介绍

专门用来读取配置文件的集合类，并且对配置文件格式有严格要求

配置文件格式：

键=值

键=值

键值对不需要有空格，值不需要用引号一起来。默认类型是String。
Properties类的常见方法
- load:加载配置文件的键值对到Properties对象
- list:将数据显示到指定设备
- getProperty(key):根据键获取值
- setProperty(key,value):设置键值对到Properties对象（存在修改，不存在添加）
- store:将Properties中的键值对存储到配置文件，在idea中，保存信息到配置文件，如果含有中文，会存储unicode码

package com.study.srv.demo17;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;

/**
 * @author Wen先森
 * @version 1.0
 * @date 2022/7/6 11:25
 * 演示Properties
 */
public class Demo22 {
    public static void main(String[] args) throws IOException {
        //1.先创建Properties对象
        Properties properties = new Properties();
        //2.加载指定配置文件
        properties.load(new FileReader("src/com/study/srv/demo17/mysql.properties"));
        //3.把k-v显示出来
        properties.list(System.out);
        //4.根据键找到值
        String ip = properties.getProperty("ip");
        System.out.println("ip是："+ip);

    }
}

package com.study.srv.demo17;

import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.Properties;

/**
 * @author Wen先森
 * @version 1.0
 * @date 2022/7/6 11:38
 * Properties类创建和修改配置文件
 */
public class Demo23 {
    public static void main(String[] args) throws IOException {
        Properties properties = new Properties();

        //创建
        //1.如果文件已经有key，就是修改
        //2.如果文件没有可以，就是创建
        properties.setProperty("userName","测试");
        properties.setProperty("userPwd","123456");
        //将k-v存储到文件中
        //store(Writer writer, String comments)中的comments是注释，可以填入null，也可以写入注释

        //使用FileWriter字符流写入，中文也会直接写入
        properties.store(new FileWriter("src/com/study/srv/demo17/sql.properties"),"设置sql连接");
        //使用FileOutputStream字节流写入，中文会转为unicode写入
        //properties.store(new FileOutputStream("src/com/study/srv/demo17/sql.properties"),"设置sql连接");

    }
}

Wen先森

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java基础——IO流

文件，文件是保存数据的地方，如word文档，excel表格文件，txt文件等。他可以保存图片、声音、视频等数据。文件在程序中是以流的形式来操作的流：数据在数据源（文件）和程序（内存）之间经历的路径输入流：数据从数据源（文件）到程序（内存）的路径输出流：数据从程序（内存）到数据源（文件）的路径获取文件相关信息方法名方法说明 getName() 获取文件名 getAbsolutePath() 获取绝对路径 g
复制链接

扫一扫