Java进阶03IO流

Java进阶03IO流

引入

字节流

FileInputSream

package com.mingmao.io.fileinputstream;

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

public class Test {
    public static void main(String[] args) throws IOException {
        //实现文件-->程序
        // 方法一
        File file = new File("D:\\file\\javatest\\JavaSE\\java进阶\\file\\a.txt");//a你好，Java, 2021。
        FileInputStream fileInputStream = new FileInputStream(file);

        //读入第一个字节
        //int i=fileInputStream.read();
        // System.out.println(i);//97 a 只读入了一个字节,汉字是两个字节

        //读入文件
        int i1 = fileInputStream.read();
        while (i1 != -1) {
            System.out.print((char) i1); //a你好ï¼Java, 2021ã这是正常结果，因为是用字节流读的
            i1 = fileInputStream.read();
        }
        System.out.println();

        fileInputStream.close();

        //方法二--效率高
        File file1 = new File("D:\\file\\javatest\\JavaSE\\java进阶\\file\\a.txt");
        FileInputStream fileInputStream1 = new FileInputStream(file1);

        //int filelength=fileInputStream1.available();//获取文件长度
        //System.out.println(filelength);//23

        byte[] b = new byte[8];//定义缓冲数组，八个字节八个字节的读，效率高
        int i = fileInputStream1.read(b);//i代表数组中被占用的数量
        while (i != -1) {
            //System.out.println(i);//8 8 7 8+8+7=23
            for (int i2 = 0; i2 < i; i2++) {
                System.out.print((char) b[i2]);//a￤ﾽﾠ￥ﾥﾽ￯ﾼﾌJava, 2021￣ﾀﾂ
            }
            i = fileInputStream1.read(b);
        }
        System.out.println();

        fileInputStream1.close();

        //方法三
        File file2 = new File("D:\\file\\javatest\\JavaSE\\java进阶\\file\\a.txt");
        FileInputStream fileInputStream2 = new FileInputStream(file2);

        int filelength = fileInputStream2.available();//获取文件长度

        byte[] b1 = new byte[filelength*2];
        int i2 = fileInputStream2.read(b1);
        for (int i3 = 0; i3 < i2; i3++) {
            System.out.print((char)b1[i3]);//a￤ﾽﾠ￥ﾥﾽ￯ﾼﾌJava, 2021￣ﾀﾂ
        }
        System.out.println();

        fileInputStream2.close();
    }
}

FlieOutputStream

package com.mingmao.io.fileoutputstream;

import java.io.*;

public class Test {
    public static void main(String[] args) throws IOException {
        //程序-->文件
        //方法一 会覆盖掉原文件
        File file=new File("D:\\file\\javatest\\JavaSE\\java进阶\\file\\b.txt");
        FileOutputStream fileOutputStream=new FileOutputStream(file);

        String str="abc你好!";
        byte[] b=str.getBytes();

        //逐个字节写入
        for (byte b1 : b) {
            fileOutputStream.write(b1);
        }

        fileOutputStream.close();

        //查看是否添加成功
        FileInputStream fileInputStream=new FileInputStream(file);
        int n=fileInputStream.available();
        byte[] bytes=new byte[n*2];
        int i=fileInputStream.read(bytes);
        for (int i1 = 0; i1 < i; i1++) {
            System.out.print((char)bytes[i1]);//abc￤ﾽﾠ￥ﾥﾽ!
        }
        System.out.println();
        fileInputStream.close();

        //方法二--效率高,实现在原文件基础上追加
        File file1=new File("D:\\file\\javatest\\JavaSE\\java进阶\\file\\b.txt");
        FileOutputStream fileOutputStream1=new FileOutputStream(file,true);//加true实现追加而非覆盖

        String str1="abcdefg!";
        byte[] bytes1=str1.getBytes();

        fileOutputStream1.write(bytes1);

        fileOutputStream1.close();

        //查看是否添加成功
        FileInputStream fileInputStream1=new FileInputStream(file);
        int n1=fileInputStream1.available();
        byte[] bytes2=new byte[n1*2];
        int i1=fileInputStream1.read(bytes2);
        for (int i2 = 0; i2 < i1; i2++) {
            System.out.print((char)bytes2[i2]);//abc￤ﾽﾠ￥ﾥﾽ!abcdefg!
        }
        System.out.println();
        fileInputStream1.close();
    }
}

练习 复制文件

package com.mingmao.io.filecopy;

import java.io.*;

public class FileCopy {
    public static void main(String[] args) throws IOException {
        //将文件c.txt复制为d.txt
        //acbc nmk!
        File file=new File("D:\\file\\javatest\\JavaSE\\java进阶\\file\\c.txt");
        FileInputStream fileInputStream=new FileInputStream(file);
	File file1=new File("D:\\file\\javatest\\JavaSE\\java进阶\\file\\d.txt");
        FileOutputStream fileOutputStream=new FileOutputStream(file1);

        //读
        int filelength=fileInputStream.available();
        byte[] bytes=new byte[filelength*2];
        int i=fileInputStream.read(bytes);
        fileInputStream.close();

        //写
        fileOutputStream.write(bytes,0,i);
        fileOutputStream.close();
    }
}

字符流

FileReader和FileWriter

package com.mingmao.io.filereaderandfilewriter;

import java.io.*;

public class Test {
    public static void main(String[] args) {
        //完成文件复制 e.txt--f.txt 并处理异常
        File file=new File("D:\\file\\javatest\\JavaSE\\java进阶\\file\\e.txt");
        File file1=new File("D:\\file\\javatest\\JavaSE\\java进阶\\file\\f.txt");
        FileReader fileReader= null;
        FileWriter fileWriter= null;
        try {
            fileReader = new FileReader(file);
            fileWriter = new FileWriter(file1);

            //读写
            char[] chars=new char[10];
            int i=fileReader.read(chars);
            while(i!=-1){
               fileWriter.write(chars);
               i=fileReader.read(chars);
           }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //fileWriter.flush();//刷新流,关闭前会自动刷新
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
            }
            try {
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
            }
        }
    }
}

缓冲字节流

BufferedInputSream和BufferedOutputSream

package com.mingmao.io.bufferedinputsream和bufferedoutputream;

import java.io.*;

public class Test {
    public static void main(String[] args) throws IOException {
        //文件复制e.txt--g.txt
        File file=new File("D:\\file\\javatest\\JavaSE\\java进阶\\file\\e.txt");
        File file1=new File("D:\\file\\javatest\\JavaSE\\java进阶\\file\\g.txt");
        FileInputStream fileInputStream=new FileInputStream(file);
        FileOutputStream fileOutputStream=new FileOutputStream(file1);
        BufferedInputStream bufferedInputStream=new BufferedInputStream(fileInputStream);
        BufferedOutputStream bufferedOutputStream=new BufferedOutputStream(fileOutputStream);

        //读写
        byte[] bytes=new byte[10];
        int i=bufferedInputStream.read(bytes);
        while (i!=-1){
            bufferedOutputStream.write(bytes);
            i=bufferedInputStream.read(bytes);
        }

        //关闭流，倒着关
        bufferedOutputStream.close();
        bufferedInputStream.close();
        fileOutputStream.close();
        fileInputStream.close();
    }
}

缓冲字符流

BufferedReader和BufferedWriter

package com.mingmao.io.bufferedreaderandbufferedwriter;

import java.io.*;

public class Test {
    public static void main(String[] args) throws IOException {
        //复制文件g.txt-->h.txt
        //方式一
        File file=new File("D:\\file\\javatest\\JavaSE\\java进阶\\file\\g.txt");
        File file1=new File("D:\\file\\javatest\\JavaSE\\java进阶\\file\\h.txt");
        FileReader fileReader=new FileReader(file);
        FileWriter fileWriter=new FileWriter(file1);
        BufferedReader bufferedReader=new BufferedReader(fileReader);
        BufferedWriter bufferedWriter=new BufferedWriter(fileWriter);

        //读写
        char[] chars=new char[10];
        int i=bufferedReader.read(chars);
        while (i!=-1){
            bufferedWriter.write(chars);
            i=bufferedReader.read(chars);
        }

        //关闭流
        bufferedWriter.close();
        bufferedReader.close();
        fileWriter.close();
        fileReader.close();

        //方式二--效率更高,按行读
        File file2=new File("D:\\file\\javatest\\JavaSE\\java进阶\\file\\h.txt");
        File file3=new File("D:\\file\\javatest\\JavaSE\\java进阶\\file\\i.txt");
        FileReader fileReader1=new FileReader(file2);
        FileWriter fileWriter1=new FileWriter(file3);
        BufferedReader bufferedReader1=new BufferedReader(fileReader1);
        BufferedWriter bufferedWriter1=new BufferedWriter(fileWriter1);

        String str=bufferedReader1.readLine();
        while(str!=null){
            bufferedWriter1.write(str);
            bufferedWriter1.newLine();//换行
           // bufferedWriter1.write("\r\n");//换行
            str=bufferedReader1.readLine();
        }

        bufferedWriter1.close();
        bufferedReader1.close();
        fileWriter1.close();
        fileReader1.close();
    }
}

System类对IO流的支持

package com.mingmao.io.system;

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

public class Test {
    public static void main(String[] args) throws IOException {
        /*Scanner scanner=new Scanner(System.in);
        System.out.println("请输入一个数：");
        int num=scanner.nextInt();
        System.out.println(num);
         */

        InputStream inputStream=System.in;
        System.out.println("请输入一个字符串：");
        int n=inputStream.read();

        PrintStream printStream=System.out;//打印流，数据失去了原来的数据类型，全部变为String
        printStream.println(n);
        printStream.println(new Date());

        //扫描硬盘上的文件
        Scanner scanner=new Scanner(new FileInputStream(new File("D:\\file\\javatest\\JavaSE\\java进阶\\file\\i.txt")));
        while(scanner.hasNext()){
            System.out.println(scanner.nextLine());
        }
    }
}

转换流

InputSreamReader和OutputSreamWriter

package com.mingmao.io.inputsreamreaderandoutputsreamwriter;

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

public class Test {
    public static void main(String[] args) throws IOException {
        //将键盘录入的内容输出到硬盘上的文件上i.txt
        //方式一
        /*Scanner scanner=new Scanner(System.in);
        System.out.println("请输入一列字符串：");
        String  str=scanner.nextLine();

        File file=new File("D:\\file\\javatest\\JavaSE\\java进阶\\file\\i.txt");
        FileWriter fileWriter=new FileWriter(file,true);
        BufferedWriter bufferedWriter=new BufferedWriter(fileWriter);

        bufferedWriter.newLine();
        bufferedWriter.write(str);
        bufferedWriter.close();
        fileWriter.close();
        scanner.close();
         */

        //方式二
        InputStream inputStream=System.in;
        InputStreamReader inputStreamReader=new InputStreamReader(inputStream);//转换流
        BufferedReader bufferedReader=new BufferedReader(inputStreamReader);
        File file1=new File("D:\\file\\javatest\\JavaSE\\java进阶\\file\\g.txt");
        OutputStream outputStream=new FileOutputStream(file1,true);
        OutputStreamWriter outputStreamWriter=new OutputStreamWriter(outputStream);//转换流
        //FileWriter fileWriter1=new FileWriter(file1,true);
        BufferedWriter bufferedWriter1=new BufferedWriter(outputStreamWriter);

        System.out.println("请输入要录入文件的字符串，输入exit结束录入：");
        String str1=bufferedReader.readLine();
        while (str1!=null){
            if(str1.equals("exit")){
                break;
            }
            bufferedWriter1.newLine();
            bufferedWriter1.write(str1);
            str1=bufferedReader.readLine();
        }

        bufferedWriter1.close();
        bufferedReader.close();
        //fileWriter1.close();
        outputStreamWriter.close();
        outputStream.close();
        inputStreamReader.close();
        inputStream.close();
    }
}

数据流

DataInputStream和DataOutputStream

package com.mingmao.io.datainputstreamanddataoutputstream;

import java.io.*;

public class Test {
    public static void main(String[] args) throws IOException {
        //操纵基本数据类型
        //写
        DataOutputStream dataOutputStream=new DataOutputStream(new FileOutputStream(new File("D:\\file\\javatest\\JavaSE\\java进阶\\file\\j.txt")));
        dataOutputStream.writeInt(90);
        dataOutputStream.writeBoolean(true);
        dataOutputStream.writeChar('a');
        dataOutputStream.writeDouble(9.87);
        dataOutputStream.writeFloat(9.98f);
        dataOutputStream.writeUTF("java");

        /*
        正确的，程序可以看懂
           Z a@#絧Ｗ
            =A?   Z a@#絧Ｗ
            =A?   Z a@#絧Ｗ
             =A? java
         */
        dataOutputStream.close();

        //读
        DataInputStream dataInputStream=new DataInputStream(new FileInputStream("D:\\file\\javatest\\JavaSE\\java进阶\\file\\j.txt"));
        int i=dataInputStream.readInt();
        System.out.println(i);
        boolean b=dataInputStream.readBoolean();
        System.out.println(b);
        char c=dataInputStream.readChar();
        System.out.println(c);
        double d=dataInputStream.readDouble();
        System.out.println(d);
        float f=dataInputStream.readFloat();
        System.out.println(f);
        String str=dataInputStream.readUTF();
        System.out.println(str);

        dataInputStream.close();
    }
}

对象流

ObjectInputStream和ObjectOutputStream 序列化和反序列化

package com.mingmao.io.objectinputstreamandobjectoutputstream;

import java.io.*;

public class Test {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //操作引用数据类型
        //写
        ObjectOutputStream objectOutputStream=new ObjectOutputStream(new FileOutputStream(new File("D:\\file\\javatest\\JavaSE\\java进阶\\file\\k.txt")));
        objectOutputStream.writeObject(new Student(18,"小红"));
        objectOutputStream.writeInt(12);
        objectOutputStream.writeBoolean(false);
        objectOutputStream.writeObject(new Student(17,"小明"));
        objectOutputStream.close();

        //读
        ObjectInputStream objectInputStream=new ObjectInputStream(new FileInputStream(new File("D:\\file\\javatest\\JavaSE\\java进阶\\file\\k.txt")));
        Object object=objectInputStream.readObject();
        System.out.println(object);
        System.out.println(objectInputStream.readInt());
        System.out.println(objectInputStream.readBoolean());
        System.out.println(objectInputStream.readObject());
        objectInputStream.close();
    }
}

package com.mingmao.io.objectinputstreamandobjectoutputstream;

import java.io.Serializable;

public class Student implements Serializable {//序列化标志
    private int age;
    private String name;

    public Student() {
    }

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

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

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

如果一个类中的属性是引用数据类型，那么这个属性对行的类也必须进行序列化

package com.mingmao.io.objectinputstreamandobjectoutputstream;

import java.io.*;

public class Test1 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //写
        ObjectOutputStream objectOutputStream=new ObjectOutputStream(new FileOutputStream("D:\\file\\javatest\\JavaSE\\java进阶\\file\\l.txt"));
        Student1 student1=new Student1(18,"小红","123456",new Sex("女"));
        student1.school="mm";
        objectOutputStream.writeObject(student1);
        objectOutputStream.close();

        //读
        ObjectInputStream objectInputStream=new ObjectInputStream(new FileInputStream("D:\\file\\javatest\\JavaSE\\java进阶\\file\\l.txt"));
        System.out.println(objectInputStream.readObject());
        //Student1{age=18, name='小红', password='null', sex=Sex{sex='女'}, school=mm}
        objectInputStream.close();
    }
}

package com.mingmao.io.objectinputstreamandobjectoutputstream;

import java.io.Serializable;

public class Student1 implements Serializable {
    private int age;
    private String name;
    static String school;
    transient String password;//密码保护
    private Sex sex;

    public Student1(int age, String name, String password, Sex sex) {
        this.age = age;
        this.name = name;
        this.password = password;
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    public static String getSchool() {
        return school;
    }

    public static void setSchool(String school) {
        Student1.school = school;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Sex getSex() {
        return sex;
    }

    public void setSex(Sex sex) {
        this.sex = sex;
    }

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

package com.mingmao.io.objectinputstreamandobjectoutputstream;

import java.io.Serializable;

public class Sex implements Serializable {
    private String sex;

    public Sex(String sex) {
        this.sex = sex;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Sex{" +
                "sex='" + sex + '\'' +
                '}';
    }
}

文件夹的复制

package com.mingmao.io.foldercopy;

import java.io.*;

public class Test {
    public static void main(String[] args) {
        File srcFile=new File("D:\\file\\javatest\\JavaSE\\java进阶\\file\\dir1");
        File targetFile=new File("D:\\file\\javatest\\JavaSE\\java进阶\\file\\dir2");
        try {
            copyDir(srcFile,targetFile);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        }
    }

    public static void copyFile(File srcFile,File targetFile) throws IOException {//只能用字节流，因为字符流不能复制图片和视频
        BufferedInputStream bufferedInputStream=new BufferedInputStream(new FileInputStream(srcFile));
        BufferedOutputStream bufferedOutputStream=new BufferedOutputStream(new FileOutputStream(targetFile));
        byte[] bytes=new byte[120];
        int i=bufferedInputStream.read(bytes);
        while (i!=-1){
            bufferedOutputStream.write(bytes,0,i);
            i=bufferedInputStream.read(bytes);
        }
        bufferedOutputStream.close();
        bufferedInputStream.close();
    }

    public static void copyDir(File srcFile,File targetFile) throws IOException {
        if(!targetFile.exists()){
            targetFile.mkdir();
        }

        File[] files=srcFile.listFiles();
        for (File file : files) {
            if(file.isFile()){
                copyFile(new File(srcFile+"\\"+file.getName()),new File(targetFile+"\\"+file.getName()));
            }else{
                copyDir(new File(srcFile+"\\"+file.getName()),new File(targetFile+"\\"+file.getName()));
            }
        }

    }
}

Filter

学习视频

学习视频1