JAVA流 *** 作_随笔

JAVA流 *** 作

文章目录

前言
字节流 abstract抽象类(InputStream/OutputStream)
- 一、字节输入输出节点流(FileInputStream)
- 二、字符输入输出缓冲流
- 三、字节输入/输出数据流
- 四、字节输入/输出对象流
字符流 abstract(Writer/Reader)
- 一、字符输出输入节点流FileWriter/FileReader自带缓冲流
- 二、字符输出输入缓冲流流BufferedWriter/BufferedReader
- 三、字符输入输出桥转换流InputStreamReader/OutputStreamWriter
总结

前言

自己看资料写的，供自己学习记忆使用，流式 *** 作

提示：下面案例仅供参考

字节流 abstract抽象类(InputStream/OutputStream) 一、字节输入输出节点流(FileInputStream)

最小的传输单位-字节，其中可扩充为字节数组加大传输速率
代码如下（示例）：

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

public class test {
    public static void main(String[] args) throws Exception{
        File file = new File("C:\Users\断桥残雪\IdeaProjects\FirstProject01.txt");
        File file2 = new File("C:\Users\断桥残雪\IdeaProjects\FirstProject01.txt");
        //这里不删除没有任何问题，区别在于后面的创建的输出流fileOutputStream是否在源文件内容里追加或覆盖
        if(file2.exists()){
            System.out.println(file2.delete());
        }
        FileInputStream fileInputStream = new FileInputStream(file);
        // fileOutputStream如果文件不存在会自动创建一个空文件
        // 参数（file file,append:Boolean）
        // append:true 指的是是否在源文件内容基础上追加，false则将原文件内容清空后写入数据
        FileOutputStream fileOutputStream = new FileOutputStream(file2,false);
        // 字节输入输出流InputStream/OutputStream 读写最小以一个字节为单位
        int read = fileInputStream.read();  // 内部处理后-1 ~ 255，其中-1是指定的文件结束标志EOF(End Of File)方法看下图
        // 支持数组 参数(数组)或(数组,off,len)数据;起始偏移量;要写入的字节数
        byte[] arr =new byte[]{(byte)229,(byte)164,(byte)169};
        fileOutputStream.write(arr,0,3);
        while(read!=-1) {
            System.out.println(read);
            fileOutputStream.write(read);
            read = fileInputStream.read();
        }
        fileInputStream.close();
        fileOutputStream.close();
        System.out.println("done");
    }
}

read方法返回-1到255具体使用C实现的

二、字符输入输出缓冲流

作用：减少内存IO访问磁盘的次数，提高效率
注意：使用缓冲流需要使用flush()清空缓冲区，清空后还可以继续使用，关闭流只需要关闭最外层流，会自动调用flush()方法
代码如下（示例）总感觉有瑕疵：

import java.io.*;

public class Main {
    public static void main(String[] args) throws Exception{
        File file = new File("C:\Users\断桥残雪\IdeaProjects\FirstProject01.txt");
        File file2 = new File("C:\Users\断桥残雪\IdeaProjects\FirstProject01.txt");
        if(file2.exists()){
            System.out.println(file2.delete());
        }
        FileInputStream fileInputStream = new FileInputStream(file);
        //参数 输入流，缓冲区大小(输入输出都默认8192)
        BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
        FileOutputStream fileOutputStream = new FileOutputStream(file2,false);
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
        int read = bufferedInputStream.read();
        while(read!=-1) {
            System.out.println(read);
            bufferedOutputStream.write(read);
            read = bufferedInputStream.read();
        }
        bufferedInputStream.close();
        bufferedOutputStream.close();
        System.out.println("done");
    }
}

三、字节输入/输出数据流

作用：增强了八种基本数据类型和字符串的功能
注意：与上面不同，底部是直接抛出EOFException的
代码如下（示例）：

import java.io.*;

public class Main {
    public static void main(String[] args) throws Exception{
        //File file = new File("C:\Users\断桥残雪\IdeaProjects\FirstProject01.txt");
        File file2 = new File("C:\Users\断桥残雪\IdeaProjects\FirstProject01.txt");
        //注意一定先写后读，数据流会将流内数据信息整合携带数据类型存入文件
        FileOutputStream fileOutputStream = new FileOutputStream(file2,false);
        DataOutputStream dataOutputStream = new DataOutputStream(fileOutputStream);
        FileInputStream bufferedOutputStream = new FileInputStream(file2);
        DataInputStream dataInputStream = new DataInputStream(bufferedOutputStream);
        dataOutputStream.writeInt(34);
        dataOutputStream.writeBoolean(true);
        dataOutputStream.writeUTF("天下无双");
        dataOutputStream.flush();
        dataOutputStream.close();
        // 结果只有天下无双能正常看到
        // 读 结果34   true    天下无双  按顺序取的，取错报EOFException ，readBoolean读不到不报错返回false
        System.out.println(dataInputStream.readInt()+"   "+dataInputStream.readBoolean()+"    "+dataInputStream.readUTF());
        dataInputStream.close();
        System.out.println("done");
    }
}

四、字节输入/输出对象流

作用：封装了基本类型后对象也要来一次
注意：没对象的就不要看了,博主开始new 对象啦
代码如下（示例）：
1.new 一个对象，主要注意要实现Serializable接口，这个接口就是一个标识接口，没有其他作用

import java.io.Serializable;

public class Person implements Serializable {
    private String name;
    private Integer age;

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }

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

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

2.主代码

import java.io.*;

public class Main {
    public static void main(String[] args) throws Exception{
        File file2 = new File("C:\Users\断桥残雪\IdeaProjects\FirstProject01.txt");
        //注意一定先写后读，数据流会将流内数据信息整合携带数据类型存入文件
        FileOutputStream fileOutputStream = new FileOutputStream(file2,false);
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
        FileInputStream fileInputStream = new FileInputStream(file2);
        ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
        Person person = new Person("小明",18);
        // 写 查看依旧是乱码
        objectOutputStream.writeObject(person);
        objectOutputStream.flush();
        objectOutputStream.close();
        // 读
        Person person2 = (Person) objectInputStream.readObject();
        objectInputStream.close();

        System.out.println(person2);
        System.out.println("done");
    }
}

字符流 abstract(Writer/Reader) 一、字符输出输入节点流FileWriter/FileReader自带缓冲流

import java.io.*;

public class Main {
    public static void main(String[] args) throws Exception{
        // 先读后写，因为读出来数据全是数字无意义展示
        File file = new File("C:\Users\断桥残雪\IdeaProjects\FirstProject01.txt");
        File file2 = new File("C:\Users\断桥残雪\IdeaProjects\FirstProject01.txt");
        FileWriter fileWriter = new FileWriter(file2,false);
        FileReader fileReader = new FileReader(file);
        int read = fileReader.read();
        while (read!=-1){
            fileWriter.write(read);
            read = fileReader.read();
        }
        fileReader.close();
        // 加一些其他的字符
        fileWriter.write("你好世界");
        // 换行，windows是这个
        fileWriter.write("rn");
        fileWriter.write("Hello,World");
        fileWriter.flush();
        fileWriter.close();
        System.out.println("done");
    }
}

二、字符输出输入缓冲流流BufferedWriter/BufferedReader

import java.io.*;

public class FileTest {
    public static void main(String[] args) throws Exception{
        // 先读后写，因为读出来数据全是数字无意义展示
        File file = new File("C:\Users\断桥残雪\IdeaProjects\FirstProject01.txt");
        File file2 = new File("C:\Users\断桥残雪\IdeaProjects\FirstProject01.txt");
        FileWriter fileWriter = new FileWriter(file2,false);
        BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);

        FileReader fileReader = new FileReader(file);
        BufferedReader bufferedReader = new BufferedReader(fileReader);

        int read = bufferedReader.read();
        while (read!=-1){
            bufferedWriter.write(read);
            read = bufferedReader.read();
        }
        bufferedReader.close();
        // 加一些其他的字符
        bufferedWriter.write("你好世界");
        // 换行，windows是这个
        bufferedWriter.write("rn");
        bufferedWriter.write("Hello,World");
        bufferedWriter.flush();
        bufferedWriter.close();
        System.out.println("done");
    }
}

三、字符输入输出桥转换流InputStreamReader/OutputStreamWriter

import java.io.*;

public class FileTest {
    public static void main(String[] args) throws Exception {
        File file = new File("C:\Users\断桥残雪\IdeaProjects\FirstProject01.txt");
        // 先创建一个文件输出流
        FileOutputStream fileOutputStream = new FileOutputStream(file);
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream,"UTF-8");
        PrintWriter printWriter = new PrintWriter(outputStreamWriter);
        printWriter.print("妖亦有道，人却无情");
        printWriter.flush();
        printWriter.close();
    }
}

总结以上就是今天要讲的内容，本文仅仅简单介绍了流的使用，有其他框架拥有自己封装的流可自行查阅。

欢迎分享，转载请注明来源：内存溢出

原文地址: https://outofmemory.cn/zaji/4968809.html

JAVA流 *** 作

发表评论

评论列表（0条）