Java中的IO流

一、File类 

      一个File类的对象，可以表示计算机硬盘上一个具体的文件或目录（文件夹），通过File类的对象，来获取文件/目录的相关信息，但不能读取文件中的内容。

常用方法

package com.wbc.IO.File;

import java.io.File;
import java.util.Date;

public class FileDemo {
    /*
        一个File类的对象，表示计算机硬盘上一个具体的文件或目录（文件夹）
        通过File类的对象，来获取文件或目录的相关信息，例如创建时间，是否可写....但是不可以读取文件中内容的
     */
    public static void main(String[] args) {
        File f =new File("C:\\Users\\17903\\Desktop\\a.txt");//有后缀为文件
        File f1 =new File("C:\\Users\\17903\\Desktop\\a");//无后缀为文件夹
        System.out.println(f.canWrite());//返回布尔值文件是否可以写入
        System.out.println(f.canRead());//返回布尔值文件是否可读
        System.out.println(f1.exists());//判断文件或目录是否存在
        System.out.println(f.getAbsoluteFile());//获取绝对地址
        System.out.println(f.isHidden());//判断是否是隐藏文件
        System.out.println(f.isDirectory());//判断是否是目录
        System.out.println(f.isFile());//判断是否是文件
        System.out.println(new Date(f.lastModified()));//lastModified返回最后修改时间，long类型，需要new一个Date类
        System.out.println(f.getName());//获取文件名
        System.out.println(f.list());//获取下一层子集文件名，返回String类型数组
        System.out.println(f.listFiles());//返回File类型数组
        System.out.println(/*f.createNewFile()*/);//创建新文件
        System.out.println(f.mkdir());//创建单层目录
        System.out.println(f.mkdirs());//创建多层目录
        System.out.println(f.length());//文件内容的长度（字节长度）

    }
}

创建删除

package com.wbc.IO.File;

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

public class FileMethod {
    /*
    File类的方法

     */
    public static void main(String[] args) throws IOException {

        //1、创建文件
        File f =new File("C:\\Users\\17903\\Desktop\\ab.txt");
        if(!f.exists()){//如果文件不存在
            boolean res=f.createNewFile();//创建新的文件（只能创建文件，不能创建目录）
            //当new的时候位置不存在，可能会报错（系统找不到指定的路径）
            System.out.println(res);
        }

        //2、删除文件
        boolean res1=f.delete();
        System.out.println(res1);

        //3、创建文件夹
        File f1 =new File("C:\\Users\\17903\\Desktop\\ab");
            //创建单层目录
            boolean res2=f1.mkdir();
            System.out.println(res2);
            //创建多层目录
            File f2 =new File("C:/aa/bb/cc");
            boolean res3 =f2.mkdirs();
            System.out.println(res3);

        //4、删除文件夹
            //删除单层文件夹
            System.out.println(f1.delete());//delete可以删除文件夹，但只能删除空的文件夹，并且删除后不进回收站
            //删除多层文件夹
                //获取文件夹中子集的名字
                File f3 =new File("C:/aa");
                String[] strings = f3.list();//只能获取当前文件夹的下一级所有文件的名字，下下一级无法获取，在删除时非常麻烦
                for(String s:strings){
                    System.out.println(s);
                }
                //获取文件夹中的子集，将其定义成File类对象
                File[] files=f3.listFiles();
                for(File file:files){
                    file.delete();//只能删除a目录里的文件，而文件夹无法删除
                }
                //递归删除
        /*
         public static void deleteDirectory(File directory) {
            if (directory.isDirectory()) {
                File[] files = directory.listFiles();
                if (files != null) {
                    for (File file : files) {
                        deleteDirectory(file);
                    }
                }
            }
            directory.delete();
        }
         */


    }
}

二、IO流的相关概念

字节：计算机最小存储单位是字节，电脑上所有的文件最终都是以字节的形式存储到硬盘的，例如：图片，视频，音频……
字符：文字，其底层还是字节，例如：中--》20013->三个字节
    字符流是一字符为单位进行读写操作，底层将原始的字节转为字符，字符流只能读取纯文本文件（只能读取文字）

字节流：一次读写操作以字节为单位（类为Stream结尾）
    节点字节输入流 ：文件输入字节流InputStream
    处理字节输入流 ：缓冲输入字节流BufferedInputStream
    节点字节输出流 ：文件输出字节流OutputStream
    处理字节输出流 ：缓冲输出字节流BufferedOutputStream
字符流：一次读写操作以字符为单位
    字符输入流Reader
        文件字符转换流InputStreamReader
            文件字符输入流：FileReader

    字符输出流Writer
        文件字符转换流OutputStreamReader
            文件字符输出流：FileWriter
            打印输出字符流：PrintWriter
节点流:原始的流，直接用来操作文件（数据）例如：FileInputStream

处理流:在节点流的基础上，对读到的数据进行二次处理

三、字节流

（1）节点流--FileInputStream、FileOutputStream

package com.wbc.IO.输入输出流.字节流.节点流.File;

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

public class FileStreamMethods {
    /*
    in.read();默认只读取一个字节，返回的是字节编码，效率低下
        in.read(byte[] b);默认一次读一个指定大小的byte数组个字节，返回的是数组中一次实际装入的字节个数，读完后返回-1
    out.write();默认只写入一个字节
        out.write(byte[],int off,int len);将数组中存入的字节写入文件  用法：out.write（数组，开始位置，起始位置）
    .close 关闭流对文件的控制
     */
    public static void main(String[] args) throws IOException {
        File f =new File("C:\\Users\\17903\\Desktop\\a.txt");
        if(!f.exists()){
            f.createNewFile();
        }
        FileInputStream inputStream = new FileInputStream(f);

        File f1 =new File("C:\\Users\\17903\\Desktop\\b.txt");
        if(!f1.exists()){
            f1.createNewFile();
        }
        FileOutputStream outputStream=new FileOutputStream(f1);

        //直接传输，效率满
        int t=0;
        while((t=inputStream.read()) != -1){//读入
            System.out.println(t);
            outputStream.write(t);//写入
        }

        //打包传输，效率块
        byte[] bytes =new byte[100];
        int size=0;
        while((size=inputStream.read(bytes))!=-1){
            outputStream.write(bytes,0,size);//read返回实际装入的字节个数，用size来控制从0写到byte数组实际存入的字节的末尾
        }
        inputStream.close();
        outputStream.close();
    }
}

（2）处理流

1）缓冲输入输出流--BufferedInputStream、BufferedOutputStream

package com.wbc.IO.输入输出流.字节流.处理流;

import java.io.*;

public class BufferedStreamDemo {
    public static void main(String[] args) throws IOException {
        //创建一个缓冲输入流对象
        File f =new File("C:/Users/17903/Desktop/ab.png");
        if(!f.exists()){
            f.createNewFile();
        }
        FileInputStream inputStream = new FileInputStream(f);//节点流
        /*
        底层有一个容量为8192字节的byte数组，节点流读出的字节存入该数组
         */
        BufferedInputStream bufferedInputStream =new BufferedInputStream(inputStream);//多态 传入节点流，负责缓冲处理


        File f1 =new File("C:/Users/17903/Desktop/ba.png");
        if(!f1.exists()){
            f1.createNewFile();
        }
        FileOutputStream outputStream=new FileOutputStream(f1);
        /*
        构造时可以自定义底层缓冲区的大小
        BufferedOutputStream(OutputStream out, int size)
         */
        BufferedOutputStream bufferedOutputStream=new BufferedOutputStream(outputStream);

            byte[] bytes =new byte[1024];
            int size = 0;
            while ((size=bufferedInputStream.read(bytes))!=-1){
                bufferedOutputStream.write(bytes,0,size);
            }
            bufferedInputStream.close();
            bufferedOutputStream.flush();//刷新缓冲区
            bufferedOutputStream.close();

    }
}

2）数据输入输出流--DataIntputStream、DataOutputStream

package com.wbc.IO.输入输出流.字节流.处理流;

import java.io.*;
import java.util.Scanner;

public class DataStreamDemo {
    static Scanner scanner =new Scanner(System.in);
    public static void main(String[] args) throws IOException {
        /*
        网络传输字符时如果使用FileStream十分麻烦

        String s="你好";
        FileOutputStream out =new FileOutputStream("");
                        out.write(s.getBytes());//字符串转为byte数组
        FileInputStream in =new FileInputStream("");
        byte[] bytes =new byte[100];
        int size =in.read(bytes);//接收到之后也是byte数组
        String str =new String(bytes,0,size);
        System.out.println(str);
        out.close();
        in.close();

        可以使用DataStream
        */

        String s=scanner.next();

        File f =new File("C:\\Users\\17903\\Desktop\\c.txt");
        if(!f.exists()){
            f.createNewFile();
        }
        FileOutputStream outputStream=new FileOutputStream(f);
        DataOutputStream dataOutputStream=new DataOutputStream(outputStream);
                        dataOutputStream.writeUTF(s);

        FileInputStream inputStream = new FileInputStream(f);
        DataInputStream dataInputStream =new DataInputStream(inputStream);
                        String s1=dataInputStream.readUTF();
        System.out.println(s1);


    }
}

3)对象输入输出流--ObjectInputStream、ObjectOutputStream

package com.wbc.IO.输入输出流.字节流.处理流.对象输入输出流;

import java.io.*;
import java.util.Date;

public class ObjectStreamDemo {
    /*
    将对象信息写入到文件内使其完整保存下来  ，以免文件结束后对象信息消失
    将对象写入文件的过程叫做对象序列化
    将文件中信息读入到文件的过程叫做对象反序列化
    返回的过程会在程序中创建一个新对象，这也是java中创建对象的另一种方法
     */
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //写入
        String s =new String("Abv");
        Date date = new Date();
        FileOutputStream outputStream =new FileOutputStream("D:/12.txt");
        ObjectOutputStream objectOutputStream =new ObjectOutputStream(outputStream);
        objectOutputStream.writeObject(s);
        objectOutputStream.writeObject(date);
        objectOutputStream.close();

        //读取
        FileInputStream inputStream =new FileInputStream("D:/12.txt");
        ObjectInputStream objectInputStream =new ObjectInputStream(inputStream);
        String s1=(String) objectInputStream.readObject();
        Date date1=(Date)objectInputStream.readObject();
        System.out.println(s1);//Abv
        System.out.println(date1);//Sat Mar 23 09:32:58 CST 2024
        objectInputStream.close();

    }
}

4)自定义对象输入输出流

自定义对象

package com.wbc.IO.输入输出流.字节流.处理流.对象输入输出流.自创对象输入输出;

import java.io.Serializable;
/*
一旦一个类实现了Serializable接口，会自动实现一个序列化编号（唯一）
 */
public class User implements Serializable {
    private static final long serialVersionUID = -5941757266582122064L;//在类中定义一个final的序列编号，当类信息修改，序列号不变
    private String name;
    private String passNum;
    //当添加了transient关键字的属性，在序列化时不会被保存到文件中
    private transient String data;

    public User(String name, String passNum) {
        this.name = name;
        this.passNum = passNum;
    }

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


    //当对象进行修改时，一旦信息进行了修改，序列化编号会发生改变
    //导致序列号发生变化产生报错
    //解决方法:在类中定义一个final的序列编号
}

对象输入输出流

package com.wbc.IO.输入输出流.字节流.处理流.对象输入输出流.自创对象输入输出;

import java.io.*;

public class ObjectStreamTest {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //在使用对象输入输出流时，必须先new Output再new Input
        FileOutputStream fileOutputStream =new FileOutputStream("D:/123456.txt");
        ObjectOutputStream objectOutputStream=new ObjectOutputStream(fileOutputStream);
        User user =new User("abc","1232456");

        //当一个类的对象用对象输入输出流写入或输出时，需要实现序列化接口
        objectOutputStream.writeObject(user);
        //Exception in thread "main" java.io.NotSerializableException
        //提示自创对象没有序列化编码


        FileInputStream fileInputStream =new FileInputStream("D:/123456.txt");
        ObjectInputStream objectInputStream=new ObjectInputStream(fileInputStream);
        User user1 =(User)objectInputStream.readObject();
        System.out.println(user1);
    }
}

四、字符流

（1）节点流--FileReader、FIleWriter

package com.wbc.IO.输入输出流.字符流.节点流;

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

public class FileReaderWriterDemo {
    /*
    writer.write方法：void write(char cbuf[], int off, int len) throws IOException
    reader.read方法：int read(char cbuf[]) throws IOException
     */
    public static void main(String[] args) throws IOException {
        File f =new File("C:\\Users\\17903\\Desktop\\a.txt");
        if(!f.exists()){
            f.createNewFile();
        }
        FileReader reader = new FileReader(f);

        File f1 =new File("C:\\Users\\17903\\Desktop\\b.txt");
        if(!f1.exists()){
            f1.createNewFile();
        }
        FileWriter writer = new FileWriter(f1);

        char[] chars =new char[100];
        int size=0;
        while((size=reader.read(chars))!=-1){
            writer.write(chars,0,size);
        }
        reader.close();
        writer.flush();
        writer.close();


    }
}

（2）处理流

1）缓冲输入输出流--BufferedWriter、BufferedReader

package com.wbc.IO.输入输出流.字符流.处理流;

import java.io.*;

public class BufferedReaderWriter {
    public static void main(String[] args) throws IOException {
        File f =new File("C:\\Users\\17903\\Desktop\\a.txt");
        if(!f.exists()){
            f.createNewFile();
        }
        FileReader reader = new FileReader(f);
        BufferedReader bufferedReader =new BufferedReader(reader);

        File f1 =new File("C:\\Users\\17903\\Desktop\\b.txt");
        if(!f1.exists()){
            f1.createNewFile();
        }
        //true表示可以追加
        // FileWriter(File file, boolean append) throws IOException
        FileWriter writer = new FileWriter(f1,true);
        BufferedWriter bufferedWriter =new BufferedWriter(writer);

       /* //遍历字符添加
        char[] chars =new char[100];
        int size=0;
        while((size=bufferedReader.read(chars))!=-1){
            bufferedWriter.write(chars,0,size);
        }*/

        //遍历行添加
        String line =null;
        while((line=bufferedReader.readLine())!=null){
            System.out.println(line);
            bufferedWriter.write(line,0,line.length());
            bufferedWriter.newLine();//换行符
        }
        bufferedReader.close();
        bufferedWriter.flush();
        bufferedWriter.close();



    }
}

2）打印输出处理流--printWriter

package com.wbc.IO.输入输出流.字符流.处理流.打印输出处理流;

import java.io.FileNotFoundException;
import java.io.PrintWriter;

public class PrintWriterDemo {
    public static void main(String[] args) throws FileNotFoundException {
        /*
        PrintWriter
        单项输出，
        后面再javaEE（服务器开发）中，可以使用PrintWriter从后端程序向前端程序相应数据
         */

        PrintWriter printWriter =new PrintWriter("C:\\Users\\17903\\Desktop\\index.html");
            printWriter.write("<h1>你好</h1>");
            printWriter.write("<h2>你好</h2>");
            printWriter.write("<h3>你好</h3>");
        printWriter.close();
    }
}