Java基础 - IO流常用类以及节点流处理流扩展

已于 2022-02-01 16:09:21 修改
阅读量1.1k 收藏
点赞数
分类专栏： 笔记 成长阶段 文章标签： java 开发语言 后端
于 2022-01-28 19:26:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39123467/article/details/122735489
版权

文章目录

IO流常用类

InputStream：字节输入流

InputStream抽象类是所有类字节输入流的超类

InputStream 常用的子类

请添加图片描述

1.FileInputStream：文件输入流

案例
  1. 请使用FileInputStream 读取 hello.txt 文件，并将文件内容显示到控制台。
read（）方法
package com.taotao.inputstream;

import org.testng.annotations.Test;

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

/**
 * Create By 刘鸿涛
 * 2022/1/26 9:32
 * 演示FileInputStream的使用
 */
public class FileInputStream_ {
    public static void main(String[] args) {

    }
    /*
        演示读取文件
     */
    @Test
    public void readFile01(){
        String filePath = "d:\\hello.txt";
        int readDate = 0;
        //把fileInputStream定义到这里，扩大作用域
        FileInputStream fileInputStream = null;
        try {
            //创建 FileInputStream 对象，用于读取 文件
            fileInputStream = new FileInputStream(filePath);

            //从该输入流读取一个字节的数据，如果没有输入可用，此方法将阻止。
            //如果返回-1，表示读取完毕
            while((readDate = fileInputStream.read())!= -1){
                System.out.print((char)readDate);   //转成char显示
            }

            //IO异常
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //如果不关闭流，会浪费资源
            //关闭文件流，释放资源
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

read(byte[] b) 方法

package com.taotao.inputstream;

import org.testng.annotations.Test;

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

/**
 * Create By 刘鸿涛
 * 2022/1/26 9:32
 * 演示FileInputStream的使用
 */
public class FileInputStream_ {
    public static void main(String[] args) {

    }
    /*
        演示读取文件
     */
    @Test
    public void readFile01(){
        String filePath = "d:\\hello.txt";
        //字节数组
        byte[] buf = new byte[8]; //一次读取8个字节
        int readLen = 0;
        //把fileInputStream定义到这里，扩大作用域
        FileInputStream fileInputStream = null;
        try {
            //创建 FileInputStream 对象，用于读取 文件
            fileInputStream = new FileInputStream(filePath);

            //从该输入流读取最多b.length字节的数据到字节数组。此方法将阻塞，直到某些输入可用
            //如果返回-1，表示读取完毕
            //如果读取正常，返回实际读取的字节数
            while((readLen = fileInputStream.read(buf))!= -1){
                System.out.println(new String(buf, 0, readLen));   //
            }

            //IO异常
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //如果不关闭流，会浪费资源
            //关闭文件流，释放资源
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

请添加图片描述

2.FileOutputStream：字节输出流

package com.taotao.outputstream_;

import org.testng.annotations.Test;

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

/**
 * Create By 刘鸿涛
 * 2022/1/26 12:19
 */
public class FileOutStream01 {
    public static void main(String[] args) {

    }
    /**
     *演示使用FileOutputStream 将数据写到文件中
     * 如果该文件不存在，则创建该文件
     */
    @Test
    public void writeFile(){
        //创建 FileOutputStream对象
        /**
         * 注意！
         * 1.new FileOutputStream(filePath)创建方式，当写入内容时，会覆盖原来的内容
         * 2.new FileOutputStream（filePath，true）创建方式，当写入内容是，是追加到文件后面,
         */
        String filePath = "d:\\a.txt";
        //扩大作用域
        FileOutputStream fileOutputStream = null;

        try {
            //得到 FileOutputStream对象 对象                     ,这里的true是append，根据是否需要覆盖填写
            fileOutputStream = new FileOutputStream(filePath,true);

            //1.写入一个字节
//            fileOutputStream.write('a');

            //2.写入字符串
            String str = "hello,world";
            //str.getBytes() 可以把 字符串 -> 字节数组
//            fileOutputStream.write(str.getBytes());

            //3.write(byte[] b,int off, int len)将 len字节从位于偏移量 off的指定字节数组写入此文件输出流
            fileOutputStream.write(str.getBytes(), 0, str.length());

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }

    }
}
案例
  1. 要求：编程完成图片/音乐 的拷贝

请添加图片描述

package com.taotao.outputstream_;

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

/**
 * Create By 刘鸿涛
 * 2022/1/26 14:31
 */
public class FileCopy {
    public static void main(String[] args) {
        //完成 文件拷贝，将d:\\jing.jpg 拷贝 c:\\
        //思路分析
        //1.创建文件的输入流 ，将文件读入到程序
        //2.创建文件的输出流，将读取到的文件数据，写入到指定的文件
        String filePath = "d:\\\\jing.jpg";
        String copyFilePath = "d:\\demo\\jing.jpg";
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;

        try {
            //文件输入流
            fileInputStream = new FileInputStream(filePath);

            //文件输出流
            fileOutputStream = new FileOutputStream(copyFilePath);

            //定义一个字节数组，提高读取效果
            byte[] buf = new byte[1024];   //一次读取1024个字节
            int readLen = 0;
            while((readLen = fileInputStream.read(buf)) != -1){
                //读取到后，就写入到文件 通过 fileOutputStream
                //即，是一边读，一边写
                fileOutputStream.write(buf, 0, readLen);    //一定要用这个方法
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //关闭输入流和输出流，及时释放资源
                if(fileInputStream != null){
                    fileInputStream.close();
                }
                if(fileOutputStream != null){
                    fileOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
}

FileReader 和 FileWriter介绍

请添加图片描述

请添加图片描述

FileReader 和 FileWriter 是字符流，即按照字符来操作io

FileReader相关方法

  1. new FileReader（File/String）
  2. read:每次读取单个字符，返回该字符，如果是到文件末尾返回-1
  3. read（char[]）:批量读取多个字符到数组，返回读取到的字符数，如果到文件末尾返回-1

案例

package com.taotao.reader;


import org.testng.annotations.Test;

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

/**
 * Create By 刘鸿涛
 * 2022/1/27 7:45
 */
public class FileReader_ {
    public static void main(String[] args) {

    }
    /**
     * 单个字符读取文件
     */
    @Test
    public void readFile01() {
        String filePath = "d:\\story.txt";
        FileReader fileReader = null;
        //后面需要转化char
        int data = 0;
        //1.创建FileReader对象
        try {
            fileReader = new FileReader(filePath);
            //循环读取 使用read
            while ((data = fileReader.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileReader != null) {
                    fileReader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     *多个字符读取
     */
    @Test
    public void readFile02() {
        String filePath = "d:\\story.txt";
        FileReader fileReader = null;
        int readLen = 0;
        //一次读取8个字符
        char[] buf = new char[8];
        //1.创建FileReader对象
        try {
            fileReader = new FileReader(filePath);
            //循环读取 使用read(buf),返回的是实际读取到的字符数
            //如果返回-1，说明到文件结束
            while ((readLen = fileReader.read(buf)) != -1) {
                System.out.print(new String(buf, 0, readLen));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileReader != null) {
                    fileReader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

相关API

  1. new String（char[]）:将char[]转换成String
  2. new String（char[],off,len）:将char的指定部分转换成String

FileWriter常用方法

  1. new FileWriter（File/String）：覆盖模式，相当于流的指针在首端
  2. new FileWriter（File/String，true）：追加模式，相当于流的指针在尾端
  3. write（int）：写入单个字符
  4. write（char[]）：写入指定数组
  5. write（char[]，off，len）：写入指定数组的指定部分
  6. write（String）：写入整个字符串
  7. write（String，off，len）：写入字符串的指定部分

案例

使用FileWriter将“风雨之后，定见彩虹”写入到note.txt文件中，注意细节

package com.taotao.writer_;

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

/**
 * Create By 刘鸿涛
 * 2022/1/27 8:40
 */
public class FileWriter_ {
    public static void main(String[] args) {
        FileWriter fileWriter = null;
        String filePath = "d:\\story.txt";
        char[] arr = {'1','2'};
        try {
            fileWriter = new FileWriter(filePath, false);    //true表示追加

//            1. write（int）：写入单个字符
            fileWriter.write("H");      //一定要关闭流，不然语句无效！！！

//            2. write（char[]）：写入指定数组
            fileWriter.write(arr);                              //12

//            3. write（char[]，off，len）：写入指定数组的指定部分
            fileWriter.write("arr".toString(),0, 1);  //1

//            4. write（String）：写入整个字符串
            fileWriter.write("刘鸿涛大大");      //刘鸿涛大大

//            5. write（String，off，len）：写入字符串的指定部分
            fileWriter.write("刘鸿涛大大",0,4);
            //在数据量大的情况下，可以使用循环操作

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileWriter != null){
//                    fileWriter.flush();

                    //关闭文件流，等价 flush() + 关闭
                    fileWriter.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

相关API

String类

toCharArray：将String转换为char[]

注意

FileWriter使用后，必须要关闭（close）或刷新（flush），否则写入不到指定的文件！

节点流和处理流

基本介绍

分类字节输入流字节输出流字符输入流字符输出流
抽象基类InputStreamOutputStreamReaderWriter
访问文件FileInputStreamFileOutputStreamFileReaderFileWriter
访问数组ByteArrayInputStreamByteArrayOutputStreamCharArrayReaderCharArrayWriter
访问管道PipedInputStreamPipedOutputStreamPipedReaderPipedWriter
访问字符串StringReaderStringWriter
缓冲流BufferedInputStreamBufferedOutputStreamBufferedReaderBufferedWriter
转换流InputStreamReaderOutputStreamWriter
对象流ObjectInputStreamObjectOutputStream
抽象基类FilterInputStreamFilterOutputStreamFilterReaderFilterWriter
打印流PrintStreamPrintWriter
推回输入流PushBackInputStreamPushbackReader
特殊流DataInputStreamDataOutputStream

节点流

  1. 节点流可以从一个特点的数据源读写数据，如FileReader、FileWriter

  2. 简单来说：节点流就是你在市场买了只鸡，外卖员送的就是鸡

请添加图片描述

包装流

  1. 处理流（也叫包装流）是“连接”在已存在的流（节点流或处理流）之上，为程序提供更为强大的读写功能，也更加灵活，如BufferedReader、BufferedWriter
  2. 简单来说：包装流就是你买了只鸡，外卖员给你送的是红烧鸡

请添加图片描述

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

  1. 节点流是底层流/低级流，直接跟数据源相接
  2. 处理流包装节点流，既可以消除不同节点流的实现差异，也可以提供更方便的写法来完成输入输出
  3. 处理流（也叫包装流）对节点流进行包装，使用了修饰器设计模式，不会直接与数据源相连
处理流（包装流）的功能主要体现在以下两个方面
  1. 性能的提高：主要以增加缓冲的方式来提高输入输出的效率
  2. 操作的便捷：处理流可能提供了一系列便捷的方法来一次输入输出大批量的数据，使用更加灵活方便

图表汇总

请添加图片描述

处理流（包装流）底层机制剖析==修饰器设计模式

举例

我们先创建两个节点流，分别继承抽象类Reader_

StringReader_类

package com.taotao.writer_;

/**
 * Create By 刘鸿涛
 * 2022/1/27 11:43
 * 节点流
 */
public class StringReader_  extends Reader_{
    public void readString(){
        System.out.println("读取字符串");
    }
}

FileReader_类

package com.taotao.writer_;

/**
 * Create By 刘鸿涛
 * 2022/1/27 11:41
 * 节点流
 */
public class FileReader_ extends Reader_ {
    public void readFile(){
        System.out.println("对文件进行读取");
    }
}

抽象类Reader_

package com.taotao.writer_;

/**
 * Create By 刘鸿涛
 * 2022/1/27 11:40
 */
public abstract class Reader_ { //抽象类
    public void readFile(){}
    public void readString(){}
}

示范包装流BuffereReader_继承抽象类Reader_,利用多态

package com.taotao.writer_;



/**
 * Create By 刘鸿涛
 * 2022/1/27 11:52
 * 做成处理流（包装流）
 */
public class BufferedReader_ extends Reader_ {
    private Reader_ reader_; //属性是 Reader_类型
	
    //接手Reader_子类对象
    public BufferedReader_(Reader_ reader_){
        this.reader_ = reader_;
    }
    
    //这边封装一层，还是调用自己的方法，也是可以的
    public void readFile(reader_){
        this.reader_ = reader_;
    }

    //===================================================
   	//这边我们可以扩展功能
    //让方法更加灵活，多次读取文件，或者加缓冲char[]...
    public void readFiles(int num){
        for(int i = 0; i < num; i++){
            reader_.readFile();
        }
    }

    //扩展 readString，批量处理字符串数据
    public void readStrings(int num){
        for(int i = 0; i < num; i++){
            reader_.readString();
        }
    }
}

我们创建Text类，测试

package com.taotao.writer_;

/**
 * Create By 刘鸿涛
 * 2022/1/27 11:56
 */
public class Test {
    public static void main(String[] args) {
        BufferedReader_ bufferedReader_ = new BufferedReader_(new FileReader_());
        BufferedReader_ bufferedReader_1 = new BufferedReader_(new StringReader_());
//        bufferedReader_.readFiles(10);
        bufferedReader_1.readStrings(1);
    }
}
结论
  • 统一到一个抽象方法里，调用时用动态绑定机制绑定到它的实现子类

处理流（专题）

BufferedReader和BufferedWriter

请添加图片描述

  • BufferedReader 和 BufferedWriter 属于字符流，是按照字符来读取数据的
  • 关闭时，只需要关闭外层流即可
  • 主要用来处理非【二进制】文件

BufferedReader案例

  • 使用BufferedReader读取文本文件，并显示在控制台
package com.taotao.reader_;

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

/**
 * Create By 刘鸿涛
 * 2022/1/28 7:49
 * 演示bufferedreader 使用
 */
public class BufferedReader_ {
    public static void main(String[] args) throws Exception {
        String filePath = "d:\\story.txt";
        //创建bufferedReader
        BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));
        String line;

        //1.bufferedReader.readLine()) 是按行读取
        //2.如果不等于空，他就执行
        while((line = bufferedReader.readLine()) != null){
            System.out.println(line);
        }

        //关闭流，这里注意，只需要关闭 BufferedReader，因为底层会自动关闭节点流FileReader
        bufferedReader.close();
        //底层

//        public void close() throws IOException {
//            synchronized (lock) {
//                if (in == null)
//                    return;
//                try {
//                    in.close();       //in就是传入的FileReader
//                } finally {
//                    in = null;
//                    cb = null;
//                }
//            }
//        }
    }
}

BufferedWriter案例

使用BufferedWriter 将“文本”写入到文件中

package com.taotao.writer_;

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

/**
 * Create By 刘鸿涛
 * 2022/1/28 8:19
 */
public class BufferedWriter_ {
    public static void main(String[] args)throws Exception {
        String writerPath = "d:\\hello.txt";
        //写入时一定要注意是否覆盖
        BufferedWriter bw = new BufferedWriter(new FileWriter(writerPath,true));

        //使用FileWriter的子类方法
        //newLine()方法换行
        bw.write("刘鸿涛");

        //注意关闭节点流
        bw.close();     //此语句会关闭节点流

    }
}
知识点
  • FileWriter对象可以直接创建文件

综合应用

  • 使用BufferedReader 和 BufferedWriter ，完成文件拷贝
注意
        //1.BufferedReader 和 BufferedWriter 是按照字符操作
        //2.不要去操作二进制文件【声音，视频，doc，pdf等等】，可能造成文件损坏

package com.taotao.writer_;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;

/**
 * Create By 刘鸿涛
 * 2022/1/28 8:44
 */
public class BufferedCopy_  {
    public static void main(String[] args)throws Exception {
        //1.BufferedReader 和 BufferedWriter 是按照字符操作
        //2.不要去操作二进制文件【声音，视频，doc，pdf等等】，可能造成文件损坏
        String filePath = "d:\\story.txt";
        String targetPath = "d:\\Hello.txt";
        BufferedReader br = new BufferedReader(new FileReader(filePath));
        BufferedWriter bw = new BufferedWriter(new FileWriter(targetPath,true));
        System.out.println("success");
        String line;

        while ((line = br.readLine()) != null){
            //每读取一行就写入
            bw.write(line);
            //因为我们是按行读取，但是上面方法不会换行处理，所以我们需要换行
            bw.newLine();
        }

        if (br != null){
            br.close();
        }
        if (bw != null){
            bw.close();
        }
    }
}

BufferedInputStream 和 BufferedOutputStream

  • 主要用来处理【二进制】文件，也可以用来处理文本文件
  • BufferedInputStream是字节流，在创建BufferedInputStream时，会创建一个内存缓冲区数组

请添加图片描述

package com.taotao.writer_;

import java.io.*;

/**
 * Create By 刘鸿涛
 * 2022/1/28 9:34
 */
public class BufferedCopy02 {
    public static void main(String[] args)throws IOException {
        String imgPath = "d:\\jing.jpg";
        String targetPath = "d:\\jing02.jpg";
        BufferedInputStream  bi = new BufferedInputStream(new FileInputStream(imgPath));
        BufferedOutputStream bo = new BufferedOutputStream(new FileOutputStream(targetPath, true));

        byte[] buf = new byte[1024];
        int readLen = 0;
        while((readLen = bi.read(buf)) != -1){
            bo.write(buf, 0, readLen);
        }

        //关闭流
        if (bi != null){
            bi.close();
        }
        if (bo != null){
            bo.close();
        }
    }
}

ObjectInputStream和ObjectOutputStream

序列化和反序列化

  1. 序列化就是在保存数据时，保存数据的值和数据类型
  2. 反序列化就是在恢复数据时，恢复数据的值和数据类型
  3. 需要让某个对象支持序列化机制，则必须让其类是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一：

Serializable //这是一个标记接口

Externalizeble //这个接口有方法需要实现，因此我们一般实现上面的

请添加图片描述

请添加图片描述

请添加图片描述

序列化案例
package com.taotao.outputstream_;


import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * Create By 刘鸿涛
 * 2022/1/28 10:22
 */
public class ObjectOutputStream_ {
    public static void main(String[] args) throws Exception{
        //序列化后，保存的文件格式，不是纯文本，而是按照他的格式来保存
        String filePath = "d:\\data.dat";
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(filePath));

        //序列化数据到 d:\data.dat
        objectOutputStream.writeInt(100);    //int -> Integer (都实现了Serializable)
//        objectOutputStream.writeInt(100);
        objectOutputStream.writeBoolean(true);  //boolean -> Boolean (实现了 Serializable)
        objectOutputStream.writeChar('a');      //char -> Character (实现了 Serializable)
        objectOutputStream.writeDouble(9.5);;   //double -> Double (实现了 Serializable)
        objectOutputStream.writeUTF("涛涛");      //String    (实现了 Serializable)

        //保存一个dog对象
        objectOutputStream.writeObject(new Dog("汪汪"));

        objectOutputStream.close();
        System.out.println("数据保存完毕(序列化形式)");
    }
}

//如果需要序列化某个类的对象，实现Serializable
class Dog implements Serializable {
    private String name;

    public Dog(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                '}';
    }
}
反序列化案例
package com.taotao.inputstream;

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

/**
 * Create By 刘鸿涛
 * 2022/1/28 12:28
 */
public class ObjectInputStream_ {
    public static void main(String[] args)throws IOException,ClassNotFoundException {
        //指定反序列化的文件
        String filePath = "d:\\data.dat";

        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(filePath));

        //读取
        //老师解读
        //1.读取（反序列化）的顺序需要和你保存数据（序列化）的顺序一致
        //2.否则会出现异常
        System.out.println(objectInputStream.readInt());
        System.out.println(objectInputStream.readBoolean());
        System.out.println(objectInputStream.readChar());
        System.out.println(objectInputStream.readDouble());
        System.out.println(objectInputStream.readUTF());

        Object dog = objectInputStream.readObject();
        System.out.println("运行类型=" + dog.getClass());
        System.out.println("dog信息=" + dog); //底层 Object -> Dog

        //这里是特别重要的地方：当我们的类中有其他方法时，比如toString，我们需要把整个类拿过来
        //1.如果我们希望调用Dog的方法，拷贝到可以引用的位置
        //2.需要我们将Dog类的定义，copy到可以引用的位置

        //关闭流，关闭外层流，底层会自动关闭FileInputStream流
            objectInputStream.close();
    }
}
class Dog implements Serializable {
    private String name;

    public Dog(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                '}';
    }
}
细节
  1. 读写顺序要一致
  2. 要求实现序列化或反序列化对象，需要实现 Serializable
  3. 序列化的类中建议添加SerialVersionUID，为了提高版本的兼容性
  4. 序列化对象时，默认将里面所有属性都进行序列化，但除了static或transient修饰的成员
  5. 序列化对象时，要求里面属性的类型也需要实现序列化接口
public class Dog implements Serializable{
	private Master master = new Master();	//Master也要实现Serializable
}
  1. 序列化具备可继承性，也就是如果某类已经实现了序列化，则它的所有子类已经默认实现了序列化

请添加图片描述

标准输入输出流

介绍

类型默认设备
System.in 标准输入InputStream键盘
System.out 标准输出PrintStream显示器
package com.taotao.standard_;

/**
 * Create By 刘鸿涛
 * 2022/1/28 13:56
 */
public class InputAndOutput {
    public static void main(String[] args) {
        //System.in 类 的 public final static InputStream in = null;
        // System.in 编译类型 InputStream
        // System.in 运行类型 BufferedInputStream
        // 表示的是标准输入 键盘
        System.out.println(System.in.getClass());   //BufferedInputStream

        //System.out 类 的 public final static PrintStream out =
        // 编译类型 PrintStream
        // 运行类型 PrintStream
        // 表示标准输出 显示器
        System.out.println(System.out.getClass());  //PrintStream
    }
}

结论

  • 传统方法System.out.println("");是使用out对象将数据输出到显示器
  • 传统方法，Scanner是从标准输入 键盘接收数据

转换流

引出转换流

package com.taotao.transformation;

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

/**
 * Create By 刘鸿涛
 * 2022/1/31 14:44
 * 看一个中文乱码问题
 */
public class CodeQuestion {
    public static void main(String[] args)throws Exception {
        //读取d:\\a.txt 文件到程序
        //思路
        //1.创建字符输入流  bufferedReader[处理流]
        //2.使用 BufferedReader 对象读取a.txt

        String filePath = "d:\\a.txt";
        BufferedReader br = new BufferedReader(new FileReader(filePath));

        String s = br.readLine();
        System.out.println("读取到的内容" + s);

        br.close();
    }
}

如果文件改为非utf-8，并且文件中有中文的话就会出现乱码

请添加图片描述

请添加图片描述

InputStreamReader

请添加图片描述

Reader的子类，可以将InputStream（字节流）包装成（转换成）Reader（字符流）

案例

编程将 字节流FileInputStream包装成（转换成） 字符流InputStreamReader，对文件进行读取（按照utf-8、格式），进而在包装成BufferedReader

package com.taotao.transformation;

import java.io.*;

/**
 * Create By 刘鸿涛
 * 2022/1/31 15:12
 * 演示使用 InputSteamReader 转换成解决中文乱码问题
 * 将字节流FileInputStream 转换成字符流 InputStreamReader，指定编码gbk/uft-8
 */
public class InputSteamReader_ {
    public static void main(String[] args) throws IOException {
        String filePath = "d:\\a.txt";
        //解读
        //1.把 FileInputStream 转成 InputStreamReader
        //2.指定编码gbk
        InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath), "gbk");
        //3.把 InputStreamReader 传入 BufferedReader
        BufferedReader br = new BufferedReader(isr);
        //4.读取
        String s = br.readLine();
        System.out.println("读取内容=" + s);
        br.close();
    }
}

也可以将第二步和第三步合起来

BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(filePath),gbk));

OutputStreamWriter

请添加图片描述

Writer的子类，实现将OutputStream（字节流）包装成Writer（字符流）

当处理纯文本数据时，如果使用字符流效率更高，并且可以有效解决中文问题，所以建议将字节流转换成字符流

可以在使用时指定编码格式（比如 utf-8，gbk，gb2312，ISO8859-1等）

案例

编程将 字节流 FileOutputStream 包装成（转换成）字符流 OutputStreamWriter，对文件进行写入（按照gbk格式，可以指定其他，比如utf-8）

package com.taotao.transformation;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

/**
 * Create By 刘鸿涛
 * 2022/1/31 15:40
 * 演示OutputStreamWriter使用
 * 把FileOutputStream 字节流，转换成字符流 OutputStreamWriter
 * 指定处理的编码 gbk/utf-8/utf8
 */
public class OutputStreamWriter_ {
    public static void main(String[] args) throws IOException {
        String filePath = "d:\\taotao.txt";
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(filePath), "utf-8");
        osw.write("hi,涛涛");
        osw.close();
    }
}

打印流

打印流只有输出流，没有输入流

PrintStream

请添加图片描述

案例代码
package com.taotao.printstream;

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

/**
 * Create By 刘鸿涛
 * 2022/1/31 18:05
 * 演示PrintStream（字节打印流）
 */
public class PrintStream_ {
    public static void main(String[] args)throws IOException {
        PrintStream out = System.out;
        //在默认情况下 PrintStream 输出数据的位置是 标准输出，即显示器
        out.print("taotoa");
        //因为print底层使用的是write，所以我们可以直接调用write进行打印/输出
        out.write("涛涛".getBytes());
        out.close();

        //我们可以去修改打印流输出的位置/设备
        //1.输出到"d:\\f1.txt"
        //2.“刘洪涛”会输出到"d:\\f1.txt"
        System.setOut(new PrintStream("d:\\f1.txt"));
        System.out.println("刘鸿涛");
    }
}

PrintWriter

请添加图片描述

案例代码
package com.taotao.transformation;

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

/**
 * Create By 刘鸿涛
 * 2022/1/31 18:15
 * 演示 PrintWriter 使用方式
 */
public class PrintWriter_ {
    public static void main(String[] args)throws IOException {
        //标准输出流
//        PrintWriter printWriter = new PrintWriter(System.out);
        PrintWriter printWriter = new PrintWriter(new FileWriter("d:\\f1.txt"));
        printWriter.print("涛涛");

        //flush + 关闭流，才会将数据写入到文件
        printWriter.close();
    }
}

Properties类

基本介绍

1.专门用于读写配置文件的集合类

配置文件的格式：

键 = 值

键 = 值

2.注意：键值对不需要有空格，值不需要用引号一起来。默认类型是String

常见方法

  • load：加载配置文件的键值对到Properties对象
  • list：将数据显示到指定设备
  • getProperty（key）：根据键获取值
  • setProperty（key，value）：设置键值对到Properties对象
  • store：将Properties中的键值对存储到配置文件，在idea中，保存信息到配置文件，如果含有中文，会存储为unicode码

unicode码查询工具

查询工具

需求

如下一个配置文件 mysql.properties

ip = 192.168.0.13
user = root
pwd = 12345

请问编程读取ip 、 user 和 pwd 的值是多少

传统方法

package com.taotao.properties_;

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

/**
 * Create By 刘鸿涛
 * 2022/1/31 18:42
 */
public class Properties01 {
    public static void main(String[] args) throws IOException {
        //读取mysql.properties文件，并得到ip,user 和 pwd
        BufferedReader br = new BufferedReader(new FileReader("src\\mysql.properties"));
        String line = "";
//        while ((line = br.readLine())!= null){
//            System.out.println(line);
//        }
        while ((line = br.readLine()) != null){ //循环读取
            String[] split = line.split("=");
            System.out.println(split[0] + "值是：" + split[1]);
        }
        br.close();
    }
}

使用Properties类可以方便实现

package com.taotao.properties_;

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

/**
 * Create By 刘鸿涛
 * 2022/2/1 12:38
 */
public class Properties02 {
    public static void main(String[] args) throws IOException {
        //使用Properties 类来读取 mysql.properties 文件

        //1.创建Properties对象
        Properties properties = new Properties();
        //2.加载指定配置文件
        properties.load(new FileReader("src\\mysql.properties"));
        //3.把k-v显示控制台
        properties.list(new PrintStream("d:\\a.txt"));
        //4.根据key 获取对应的值
        String user = properties.getProperty("user");
        String pwd = properties.getProperty("pwd");
        System.out.println("用户名" + user + "\n密码" + pwd);
    }
}

案例Properties类创建修改文件

package com.taotao.properties_;

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

/**
 * Create By 刘鸿涛
 * 2022/2/1 14:17
 */
public class Properties03 {
    public static void main(String[] args) throws IOException {
        //使用Properties 类来创建配置文件，修改配置文件内容

        Properties properties = new Properties();
        //创建
        properties.setProperty("charset","utf8");
        properties.setProperty("user","汤姆");//注意保存时，是中文的 unicode码值
        properties.setProperty("pwd","abc111");

        //将k-v 存储文件中即可、     FileOutputStream字节流
        properties.store(new FileOutputStream("src\\mysql2.properties"),null);
        System.out.println("保存配置文件成功");

        //当然我们可以通过key轻松修改value，比如
        properties.setProperty("user","jack");
        //此时他的user就会被替换为jack
    }
}
鬼鬼骑士
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
第一章 java 基础 - 08.IO输入流与输出流
yancyang的博客
09-26 4520
无意间都到一篇《走心的安卓工程师跳槽经验分享》，发现自己工作几年了，技术方面虽然有了飞跃的进步，可是不知道自己的技术到了什么地步，每个方面我都涉及到了，但都不深，这大概是初级工程师的诟病吧！ 即使知道也不知道从何下手，非常感谢《走心的安卓工程师跳槽经验分享》的作者！ 感兴趣的朋友和我一起走下去吧！ 08.IO输入流与输出流 java的核心库java.io提供了全面的IO接口。包括：文件读写、标准设...
java中的io流开发用的多吗_JAVA基础之IO流知识总结（够详细了吗
weixin_28796657的博客
02-23 1585
欢迎关注CSDN：程序员小羊微信公众号：程序员小羊博客园：程序员小羊一、IO流体系图IO常用的几个流：【I/O流原理作用】Input/Output：输入输出机制输入机制：允许java程序获取外部设备的数据(磁盘，光盘，网络等)。输出机制：保留java程序中的数据，输出到外部设备上(磁盘，光盘等)。二、流的分类：通过不同的方法，可以对于进行分类。1. 按照功能来划分：输入流：只能从中读取数据，而不能...
【Java基础-3】吃透Java IO：字节流、字符流、缓冲流
热门推荐
云深不知处
09-23 15万+
什么是Java-IO？字符流和字节流的区别与适用场景是什么？缓冲流到底实现了什么？如何高效地读写文件？ 本文用大量的示例图和实例，带你吃透Java IO。
节点流与处理流：深入解析Java中的IO流
✨ 欢迎来到【Seal ^_^ 的CSDN博客】！这里是我记录技术心得、分享经验的地方。✨
07-10 4223
在Java的IO（输入/输出）库中，节点流（Node Stream）和处理流（Processing Stream）是两个重要的概念。虽然它们都是用于数据的输入和输出，但它们在功能和使用上有所不同。
Java IO流最全详解
Mekeater的博客
07-21 1503
一个程序总是离不开数据的输入（Input）输出（IO），而Java IO流就是用于程序从外部读取数据，以及向外部写出数据的java处理包，本文详细讲解Java IO包中常用的IO流，通过本文的知识，可以使得你在开发中随心所欲的高效使用IO流。......
【Java】IO流 - 节点流和处理流【Buffered】
Lov1_BYS的博客
11-20 1246
节点流和处理流的区别，BufferedReader/BufferedWriter和BufferedInputStream/BufferedOutputStream的使用
java io流上传图片_Java IO流
weixin_28724003的博客
02-24 869
一、基本概念IO是Java对数据的操作是通过流的方式，数据传输是需要通道的，而IO流就是数据传输的通道。IO流可以形象的比喻为运送货物的传输带。IO流用来处理设备之间的数据传输，上传文件和下载文件，Java用于操作流的对象都在IO包中。总结一下，Java IO输入机制就是为了允许程序读取外部数据(包括来自于磁盘、光盘等存储设备的数据)和用户输入的数据。Java的IO流通过java.io包下的类和接...
java 中 IO 流有哪些？
ConstXiong
04-22 1万+
java 中 IO 流有哪些？ 按数据流向:输入流和输出流 输入和输出都是从程序的角度来说的。输入流：数据流向程序；输出流：数据从程序流出。 按处理单位:字节流和字符流 字节流：一次读入或读出是8位二进制；字符流：一次读入或读出是16位二进制。 JDK中后缀是Stream是字节流；后缀是Reader，Writer是字符流。 按功能功能:节点流和处理...
Java之节点流和处理流（Buffered字节字符处理流）
墨辰JC的博客
01-17 1953
Java中的流按照功能可以分为节点流和处理流。其中节点流是直接用来访问数据源，而数据源又分为文件、内存、管道(线程间通信使用)，所以就需要不同的类来进行处理。每次从数据源中读取的数据单位又可以分为字节和字符。节点流：可以从一个特定的数据源读写数据，如FileReader、FileWriter等（程序用于直接操作目标设备所对应的类）处理流：是“连接”已存在的流（节点流和处理流）之上，为程序提供强大的读写功能，更加灵活。
简单总结Java IO中stream流的使用方法
09-02
节点流直接与数据源（如文件、数组、字符串或管道）交互，而处理流则是建立在已有流之上的，用于增强或扩展节点流的功能。 **节点流**主要包括： - 文件流（如FileInputStream和FileOutputStream，用于读写文件） -...
IO流体系继承结构图_动力节点Java学院整理
10-25
Java的IO流体系是Java平台的核心特性之一，用于处理数据的输入和输出。这个体系结构设计得相当丰富和灵活，可以适应多种不同的场景。我们主要从两个方面来理解这个体系：对称性质和处理器模式。 首先，IO流的对称...
Java基础精品课20-IO.zip
05-20
- 按功能分：节点流（如FileInputStream）和处理流（如BufferedReader）。 3. **基本流类**： - `FileInputStream` 和 `FileOutputStream` 用于读写文件。 - `System.in`, `System.out`, `System.err` 分别代表...
JAVA IO流的讲解资源
01-05
6. **装饰器模式**：Java IO中的装饰器模式允许在不改变原有类的基础上添加新的功能，如BufferedInputStream、BufferedReader等，这些装饰类增强了基础流类的功能，如缓冲数据、处理格式等。 7. **非流式部分**：非...
JAVAIO流学生课件PPT教案学习.pptx
09-30
除了基本的流类型，Java I/O系统还包括节点流和处理流的概念。节点流是直接与特定I/O设备交互的流，如FileInputStream和FileOutputStream，它们直接操作数据源。而处理流，又称为高级流，如BufferedInputStream和...
java学习----递归
qq_56798493的博客
07-13 163
【代码】java学习----递归。
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
最新发布
m0_73456341的博客
07-14 789
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 629
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
Spring Security 授权
persistence_PSH的博客
07-14 869
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
Java流技术详解：节点流与处理流的分类与操作
JDK（Java Development Kit）中包含了大量的流类，主要分布在`java.io`包内，这些类被设计成三个主要类别：输入流、输出流、以及字符流和字节流。 1. **Java流式输入/输出原理** 在Java中，数据的读写操作通过流...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

鬼鬼骑士

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值