Java笔记036-IO流/节点流和处理流、打印流-PrintStream和PrintWriter、Properties类、IO流章节练习

最新推荐文章于 2024-09-15 09:47:04 发布
最新推荐文章于 2024-09-15 09:47:04 发布
阅读量149 收藏 1
点赞数
分类专栏： Java笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_59621600/article/details/129907027
版权

目录

IO流

节点流和处理流

基本介绍

节点流和处理流一览图

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

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

处理流-BufferedReader和BufferedWriter

应用案例

处理流-BufferedInputStream和BufferedOutputStream

应用案例

对象流-ObjectInputStream和ObjectOutputStream

应用案例

注意事项和细节说明

标准输入输出流

转换流-InputStreamReader和OutputStreamWriter

应用案例

打印流-PrintStream和PrintWriter

应用实例

Properties类

看一个需求

基本介绍

 应用案例

IO流章节练习

1、编程题

2、编程题

3、编程题

IO流

节点流和处理流

基本介绍

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

节点流和处理流一览图

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

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

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

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

/**
 * @author 甲柒
 * @version 1.0
 * @title Reader_
 * @package com19
 * @time 2023/4/2 10:24
 */
public abstract class Reader_ {
    public void readFile() {
    }

    public void readString() {
    }

    //在Reader_抽象类，使用read方法统一管理
    //后面在调用时，利用对象动态绑定机制，绑定到对应的实现子类即可
//    public abstract void read();
}

package com19;

/**
 * @author 甲柒
 * @version 1.0
 * @title FileReader_
 * @package com19
 * @time 2023/4/2 10:25
 */
public class FileReader_ extends Reader_ {
    public void readFile() {
        System.out.println("对文件进行读取~~~");
    }
//    public void read(){
//
//    }
}

package com19;

/**
 * @author 甲柒
 * @version 1.0
 * @title StringReader_ 节点流
 * @package com19
 * @time 2023/4/2 10:26
 */
public class StringReader_ extends Reader_ {
    public void readString() {
        System.out.println("读取字符串~~~");
    }
}

package com19;

/**
 * @author 甲柒
 * @version 1.0
 * @title BufferedReader_ 处理流/包装流
 * @package com19
 * @time 2023/4/2 10:28
 */
public class BufferedReader_ extends Reader_ {
    private Reader_ reader_;//属性 是 Reader_类型

    //接受Reader_ 子类对象
    public BufferedReader_(Reader_ reader_) {
        this.reader_ = reader_;
    }

    public void readFile() {//封装一层
        reader_.readFile();
    }

    //让方法更灵活，多次读取文件，或者加缓冲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();
        }
    }
}

package com19;

/**
 * @author 甲柒
 * @version 1.0
 * @title Test_
 * @package com19
 * @time 2023/4/2 10:31
 */
public class Test_ {
    public static void main(String[] args) {

        BufferedReader_ bufferedReader_ = new BufferedReader_(new FileReader_());
//        bufferedReader_.readFiles(10);
        bufferedReader_.readFile();

        //通过BufferedReader_ 多次读取字符串
        BufferedReader_ bufferedReader_1 = new BufferedReader_(new StringReader_());
        bufferedReader_1.readStrings(5);
    }
}

处理流-BufferedReader和BufferedWriter

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

应用案例

1、使用BufferedReader读取文本文件，并显示在控制台

package com19.reader_;

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

/**
 * @author 甲柒
 * @version 1.0
 * @title BufferedReader_
 * @package com19.reader_
 * @time 2023/4/2 11:00
 */
public class BufferedReader_ {
    public static void main(String[] args) throws Exception {
        String filePath = "E:\\Abstract01.java";
        //创建bufferedReader
        BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));
        //读取
        String line;
        //说明
        //1. bufferedReader.readLine() 是按行读取文件
        //2. 当返回null时，表示文件读取完毕
        while ((line = bufferedReader.readLine()) != null) {
            System.out.println(line);
        }
        //关闭流 注意 只需关闭BufferedReader，
        // 因为底层会 自动去关闭 节点流FileReader
        /*源码解读
            public void close() throws IOException {
                synchronized (lock) {
                    if (in == null)
                        return;
                    try {
                        in.close();//in 就是传入的new FileReader(filePath)，关闭了
                    } finally {
                        in = null;
                        cb = null;
                    }
                }
            }
         */
        bufferedReader.close();
    }
}

 

2、使用BufferedWriter将"hello，甲柒"，写入到文件中

package com19.writer_;

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

/**
 * @author 甲柒
 * @version 1.0
 * @title BufferedWriter_
 * @package com19.writer_
 * @time 2023/4/2 11:14
 */
public class BufferedWriter_ {
    public static void main(String[] args) throws IOException {
        String filePath = "E:\\ok.txt";
        //创建BufferedWriter
        //new FileWriter(filePath, true) 表示以追加的方式写入
        //new FileWriter(filePath) 表示以覆盖的方式写入
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath, true));
        bufferedWriter.write("hello1，甲柒~~~");
        bufferedWriter.newLine();
        bufferedWriter.write("hello2，甲柒~~~");
        bufferedWriter.newLine();
        bufferedWriter.write("hello3，甲柒~~~");
        bufferedWriter.newLine();
        //插入一个换行bufferedWriter.newLine();

        //说明：关闭外层流即可，传入的new FileWriter(filePath)，会在底层关闭
        bufferedWriter.close();
    }
}

3、综合使用BufferedReader和BufferedWriter完成文本文件拷贝，注意文件编码

package com19.writer_;

import java.io.*;

/**
 * @author 甲柒
 * @version 1.0
 * @title BufferedCopy_
 * @package com19.writer_
 * @time 2023/4/2 11:33
 */
public class BufferedCopy_ {
    public static void main(String[] args) {

        //说明
        //1. BufferedReader和BufferedWriter是按照字符操作
        //2. 不要去操作 二进制文件[声音、视频、doc/pdf等]，可能造成文件损坏
        String srcFilePath = "E:\\DynamicBinding.java";
        String destFilePath = "E:\\DynamicBinding2.java";
        BufferedReader bufferedReader = null;
        BufferedWriter bufferedWriter = null;
        String line;
        try {
            bufferedReader = new BufferedReader(new FileReader(srcFilePath));
            bufferedWriter = new BufferedWriter(new FileWriter(destFilePath));
            //读取
            while ((line = bufferedReader.readLine()) != null) {
                //每读取一行，就写入
                bufferedWriter.write(line);
                bufferedWriter.newLine();
            }
            System.out.println("拷贝完毕~~~");
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            //关闭流
            try {
                if (bufferedReader != null) {
                    bufferedReader.close();
                }
                if (bufferedWriter != null) {
                    bufferedWriter.close();
                }
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

处理流-BufferedInputStream和BufferedOutputStream

  •  介绍BufferedInputStream

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

  •  介绍BufferedOutputStream

    BufferedOutputStream是字节流，实现缓冲的输出流，可以将多个字节写入底层输出流中，而不必对每次字节写入调用底层系统

应用案例

要求：编程完成图片/音乐的拷贝(要求使用BufferedInputStream、BufferedOutputStream)

package com19.outputstream_;

import java.io.*;

/**
 * @author 甲柒
 * @version 1.0
 * @title BufferedCopy02
 * @package com19.outputstream_
 * @time 2023/4/2 12:09
 * 编程完成图片/音乐的拷贝
 * (要求使用BufferedInputStream、BufferedOutputStream)
 */
public class BufferedCopy02 {
    public static void main(String[] args) {

//        String srcFilePath = "E:\\249710.jpg";
//        String destFilePath = "E:\\249710副本.jpg";
//        String srcFilePath = "E:\\狙击高手.mp4";
//        String destFilePath = "E:\\狙击高手-副本.mp4";

        //字节流可以操作二进制文件，也可以操作文本文件
        String srcFilePath = "E:\\Equals.java";
        String destFilePath = "E:\\Equals-副本.java";

        //创建BufferedInputStream对象和BufferedOutputStream对象
        BufferedInputStream bufferedInputStream = null;
        BufferedOutputStream bufferedOutputStream = null;

        try {
            //因为FileInputStream 是 InputStream子类
            bufferedInputStream = new BufferedInputStream(new FileInputStream(srcFilePath));
            bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(destFilePath));

            //循环读取文件，并写入到destFilePath
            byte[] buff = new byte[1024];
            int readLen = 0;
            while ((readLen = bufferedInputStream.read(buff)) != -1) {
                bufferedOutputStream.write(buff, 0, readLen);
            }
            System.out.println("文件拷贝成功~~~~");
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            //关闭流
            try {
                if (bufferedInputStream != null) {
                    bufferedInputStream.close();
                }
                if (bufferedOutputStream != null) {
                    bufferedOutputStream.close();
                }
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

对象流-ObjectInputStream和ObjectOutputStream

  • 看一个需求
  1. 将int num = 100 这个 int 数据保存到文件中，并且能够从文件中直接恢复 int 100
  2. 将Dog dog = new Dog("小黄", 3);这个dog对象 保存到文件中，并且能够从文件恢复
  3. 上面的要求，就是 能够将 基本数据类型 或者 对象 序列化 和 反序列化 操作
  • 序列化和反序列化
  1. 序列化就是在保存数据时，保存数据的值和数据类型
  2. 反序列化就是在恢复数据时，恢复数据的值和数据类型
  3. 需要让某个对象支持序列化机制，则必须让其类是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一：
    Serializable//这是一个标记接口
    Externalizable//该接口有方法需要实现，因此一般实现上面的Serializable接口

  • 基本介绍
  1.  功能：提供了对基本类型或对象类型的序列化和反序列化的方法
  2. ObjectOutputStream提供序列化功能
  3. ObjectInputStream提供反序列化功能

应用案例

1、使用ObjectOutputStream序列化基本数据类型和一个Dog对象(name, age)，并保存到data.dat文件中

package com19.outputstream_;

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

/**
 * @author 甲柒
 * @version 1.0
 * @title ObjectOutStream_
 * @package com19.outputstream_
 * @time 2023/4/2 19:25
 */
public class ObjectOutStream_ {
    public static void main(String[] args) throws IOException {
        //序列化后，保存的文件格式，不是文本，而是按照它的格式来保存
        String filePath = "E:\\data.dat";

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));

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

        //保存一个dog对象
        oos.writeObject(new Dog("大黄", 8, "日本", "黄色"));

        //关闭流
        oos.close();
        System.out.println("数据保存完毕(序列化形式)");
    }

}
package com19.outputstream_;

import java.io.Serializable;

/**
 * @author 甲柒
 * @version 1.0
 * @title Dog
 * @package com19.outputstream_
 * @time 2023/4/2 20:10
 */
public class Dog implements Serializable {
    //SerialVersionUID 序列化的版本号，可以提高兼容性
    private static final long serialVersionUID = 1L;
    private static String nation;
    //序列化对象时，默认将里面所有属性都进行序列化，但除了static或transient修饰的成员
    private Master master = new Master();
    private transient String color;
    private String name;
    private int age;

    public Dog(String name, int age, String nation, String color) {
        this.name = name;
        this.age = age;
        this.nation = nation;
        this.color = color;
    }

    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 "Dog{" +
                "color='" + color + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}' + nation + " " + master;
    }
}

package com19.outputstream_;

import java.io.Serializable;

/**
 * @author 甲柒
 * @version 1.0
 * @title Master
 * @package com19.outputstream_
 * @time 2023/4/2 20:37
 */
public class Master implements Serializable {
}

2、使用ObjectInputStream读取data.dat并 反序列化 恢复数据

package com19.inputstream_;

import com19.outputstream_.Dog;

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

/**
 * @author 甲柒
 * @version 1.0
 * @title ObjectInputStream_
 * @package com19.inputstream_
 * @time 2023/4/2 19:47
 */
public class ObjectInputStream_ {
    public static void main(String[] args) throws IOException, ClassNotFoundException {

        //指定反序列化文件
        String filePath = "E:\\data.dat";
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath));

        //读取
        //解读
        //1. 读取(反序列化)的顺序需要和你保存数据(序列化)的顺序一致
        System.out.println(ois.readInt());
        System.out.println(ois.readBoolean());
        System.out.println(ois.readChar());
        System.out.println(ois.readDouble());
        System.out.println(ois.readUTF());
        Object dog = ois.readObject();
        System.out.println("运行类型=" + dog.getClass());
        System.out.println("dog信息=" + dog);

        //细节
        //1.希望调用Dog的方法，需要向下转型
        //2.需要将Dog类的定义，拷贝到 可以引用的位置
        Dog dog2 = (Dog) dog;

        ois.close();
    }
}

注意事项和细节说明

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

标准输入输出流

  • 介绍 
类型默认设备
System.in 标准输入InputStream键盘
System.out 标准输出PrintStream显示器
package com19.standard;

import java.util.Scanner;

/**
 * @author 甲柒
 * @version 1.0
 * @title InputAndOutput
 * @package com19.standard
 * @time 2023/4/3 9:00
 */
public class InputAndOutput {
    public static void main(String[] args) {
        //public final static InputStream in = null;
        //System.in编译类型 InputStream
        //System.in运行类型 BufferedInputStream
        // 表示的是标准输入 键盘
        System.out.println(System.in.getClass());
        //解读
        //1. public final static PrintStream out = null;
        //2. 编译类型 PrintStream
        //3. 运行类型 PrintStream
        //4. 表示标准输出 显示器
        System.out.println(System.out.getClass());
        System.out.println("hello,world~~~");

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入内容");
        String next = scanner.next();
        System.out.println("next=" + next);
    }
}

转换流-InputStreamReader和OutputStreamWriter

  • 文件乱码问题，引出学习转换流的必要性
package com19.transformation;

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

/**
 * @author 甲柒
 * @version 1.0
 * @title CodeQuestion
 * @package com19.transformation
 * @time 2023/4/3 9:24
 */
public class CodeQuestion {
    public static void main(String[] args) throws IOException {
        //读取E:\\a.txt 文件到程序
        //思路
        //1. 创建字符输入流BufferedReader[处理流]
        //2. 使用BufferedReader 读取对象a.txt
        //3. 在默认情况下，读取文件是按照utf-8编码
        String filePath = "E:\\a.txt";
        BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));

        String s = bufferedReader.readLine();
        System.out.println("读取到的内容：" + s);
        bufferedReader.close();
    }
}

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

应用案例

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

package com19.transformation;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * @author 甲柒
 * @version 1.0
 * @title InputStreamReader_
 * @package com19.transformation
 * @time 2023/4/3 11:46
 */
public class InputStreamReader_ {
    public static void main(String[] args) throws IOException {
        String filePath = "E:\\a.txt";
        //解读
        //1. 把FileInputStream 转成 InputStreamReader
        //2. 指定编码 gbk
//        InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream(filePath), "gbk");
        //3. 把InputStreamReader传入BufferedReader
//        BufferedReader bufferedReader = new BufferedReader(inputStreamReader);

        //将2 和3 合在一起
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(filePath), "gbk"));

        //4. 读取
        String s = bufferedReader.readLine();
        System.out.println("读取到的内容：" + s);
        //关闭
        bufferedReader.close();
    }
}

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

package com19.transformation;

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

/**
 * @author 甲柒
 * @version 1.0
 * @title OutputStreamWriter_
 * @package com19.transformation
 * @time 2023/4/3 11:57
 */
public class OutputStreamWriter_ {
    public static void main(String[] args) throws IOException {
        String filePath = "E:\\java.txt";
        String charSet = "utf-8";
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(filePath), charSet);
        osw.write("java从入门到放弃");
        osw.close();
        System.out.println("按照" + charSet + "保存成功");
    }
}

打印流-PrintStream和PrintWriter

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

应用实例

package com19.printstream;

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

/**
 * @author 甲柒
 * @version 1.0
 * @title PrintStream_
 * @package com19.printstream
 * @time 2023/4/3 14:51
 */
public class PrintStream_ {
    public static void main(String[] args) throws IOException {
        PrintStream out = System.out;
        //在默认情况下，PrintStream输出数据的位置是 标准输出，即显示器
        /*
            public void print(String s) {
                if (s == null) {
                    s = "null";
                }
                write(s);
            }
         */
        out.print("hello,java");
        //因为print底层使用的是write，所以可以直接调用writer进行打印/输出
        out.write("\nJava是最好的语言".getBytes());
        out.close();

        //1.可以去修改打印流输出的位置/设备E:\f1.txt
        //2."hello，甲柒"就会输出到E:\f1.txt
        //3.
        /*
            public static void setOut(PrintStream out) {
                checkIO();
                setOut0(out);//native方法，修改了out
            }
         */
        System.setOut(new PrintStream("E:\\f1.txt"));
        System.out.println("hello，甲柒");
    }
}

package com19.printstream;

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

/**
 * @author 甲柒
 * @version 1.0
 * @title PrintWriter_
 * @package com19.printstream
 * @time 2023/4/3 15:07
 */
public class PrintWriter_ {
    public static void main(String[] args) throws IOException {
//        PrintWriter printWriter = new PrintWriter(System.out);

        PrintWriter printWriter = new PrintWriter(new FileWriter("E:\\f2.txt"));
        printWriter.print("hi~~~,java");
        printWriter.close();//flush + 关闭流，才会将数据写入到文件
        System.out.println("写入完毕");
    }
}

Properties类

看一个需求

如下一个配置文件mysql.properties

ip=192.168.0.13

user=root

pwd=12345

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

分析

  1. 传统方法
  2. 使用Properties类可以方便实现
package com19.properties_;

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

/**
 * @author 甲柒
 * @version 1.0
 * @title Properties01
 * @package com19.properties_
 * @time 2023/4/3 19:01
 */
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) {
            String[] split = line.split("=");
            //如果要求指定的IP值
            if ("ip".equals(split[0])) {
                System.out.println(split[0] + "值是：" + split[1]);
            }
        }
        br.close();
    }
}

src下的mysql.properties文件

ip=192.168.100.100
user=root
pwd=123456

基本介绍

  1. 专门用于读写配置文件的集合类
    配置文件的格式：
    键=值
    键=值
  2. 注意：键值对不需要有空格，值不需要用引号，默认类型是String
  3. Properties的常见方法
  • load：加载配置文件的键值对到Properties对象
  • list：将数据显示到指定设备/流对象
  • getProperty(key)：根据键获取值
  • setProperty(key, value)：设置键值对到Properties对象
  • store：将Properties中的键值对存储到配置文件，在idea中，保存信息到配置文件，如果含有中文，会存储为Unicode码

 应用案例

  1. 使用Properties类完成对mysql.properties的读取
  2. 使用Properties类添加key-val到新文件mysql2.properties中
  3. 使用Properties类完成对mysql.properties的读取，并修改某个key-val
package com19.properties_;

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

/**
 * @author 甲柒
 * @version 1.0
 * @title Properties02
 * @package com19.properties_
 * @time 2023/4/3 19:28
 */
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(System.out);
        //4. 根据key获取对应的值
        String user = properties.getProperty("user");
        String pwd = properties.getProperty("pwd");
        System.out.println("用户名=" + user);
        System.out.println("密码=" + pwd);
    }
}

 

package com19.properties_;

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

/**
 * @author 甲柒
 * @version 1.0
 * @title Properties03
 * @package com19.properties_
 * @time 2023/4/3 19:36
 */
public class Properties03 {
    public static void main(String[] args) throws IOException {
        //使用Properties类来创建配置文件，修改配置文件内容

        Properties properties = new Properties();
        //创建
        //1.如果该文件没有key就是创建
        //2.如果该文件有key就是修改
        /*
            Properties父类是 Hashtable，底层就是Hashtable核心方法

            public synchronized V put(K key, V value) {
                // Make sure the value is not null
                if (value == null) {
                    throw new NullPointerException();
                }

                // Makes sure the key is not already in the hashtable.
                Entry<?,?> tab[] = table;
                int hash = key.hashCode();
                int index = (hash & 0x7FFFFFFF) % tab.length;
                @SuppressWarnings("unchecked")
                Entry<K,V> entry = (Entry<K,V>)tab[index];
                for(; entry != null ; entry = entry.next) {
                    if ((entry.hash == hash) && entry.key.equals(key)) {
                        V old = entry.value;
                        entry.value = value;//如果key存在 就替换
                        return old;
                    }
                }

                addEntry(hash, key, value, index);//如果是新的key，就addEntry
                return null;
            }

         */
        properties.setProperty("charset", "utf-8");
        properties.setProperty("user", "甲柒");//注意 保存时 是中文的 Unicode码值
        properties.setProperty("pwd", "abc111");

        //将k-v存储文件中即可
        properties.store(new FileOutputStream("src\\mysql2.properties"), "hello world");//comments注释一般为null
        System.out.println("保存配置文件成功~~~");
    }
}

将Properties中的键值对存储到配置文件，在idea中，保存信息到配置文件，如果含有中文，会存储为Unicode码 

 使用在线Unicode转码工具可得到user

IO流章节练习

1、编程题

  1. 判断E盘下是否有文件夹mytemp，如果没有就创建mytemp
  2. 在E:\\mytemp目录下，创建文件hello.txt
  3. 如果hello.txt已经存在，提示该文件已经存在，就不需要重复创建了
package com19.exercise;

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

/**
 * @author 甲柒
 * @version 1.0
 * @title Exercise01
 * @package com19.exercise
 * @time 2023/4/3 20:48
 */
public class Exercise01 {
    public static void main(String[] args) {
        /**
         * 判断E盘下是否有文件夹mytemp，如果没有就创建mytemp
         * 在E:\mytemp目录下，创建文件hello.txt
         * 如果hello.txt已经存在，提示该文件已经存在，就不需要重复创建了
         * */
        String srcFilePath = "E:\\mytemp";
        String str = "hello world甲柒";
        File file = new File(srcFilePath);

        if (file.exists()) {//exists 存在
            System.out.println(srcFilePath + " 文件夹存在");
        } else {
            if (file.mkdirs()) {
                System.out.println(srcFilePath + " 文件夹创建成功");
            } else {
                System.out.println(srcFilePath + " 文件夹创建失败");
            }
        }

        File file1 = new File(srcFilePath, "hello.txt");
        if (file1.exists()) {//exists 存在
            System.out.println(file1 + " 文件已存在，请不要重复创建");
        } else {
            try {
                file1.createNewFile();
                System.out.println(file1 + " 文件创建成功~·");

                //如果文件存在，就使用BufferedWriter字符输入流写入内容
//                BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(file1));
//                bufferedWriter.write(str);
//                bufferedWriter.close();//一定要关闭流
                //使用FileOutputStream
                FileOutputStream fileOutputStream = new FileOutputStream(file1);
                fileOutputStream.write(str.getBytes());
                fileOutputStream.close();//一定要关闭流
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

首次执行后

再次执行

2、编程题

要求：使用BufferedReader读取一个文本文件，为每行加上行号，再连同内容一并输出到屏幕上

附加题：将文件编码改成了gbk，解决出现中文乱码问题

提示使用转换流，将FileInputStream->InputStreamReader->BufferedReader

package com19.exercise;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * @author 甲柒
 * @version 1.0
 * @title Exercise02
 * @package com19.exercise
 * @time 2023/4/3 21:56
 */
public class Exercise02 {
    public static void main(String[] args) throws IOException {
        String filePath = "E:\\A.txt";
        String line;
        int lineNum = 1;
        String charSet = "gbk";
        BufferedReader bufferedReader = null;
        bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(filePath), charSet));
        while ((line = bufferedReader.readLine()) != null) {
            System.out.println(lineNum + line);
            lineNum++;
        }
        bufferedReader.close();//关闭流
    }
}

3、编程题

  1. 编写一个dog.properties
    name=tom
    age=5
    color=red
  2. 编写Dog类(name, age, color)创建一个dog对象，读取dog.properties用相应的内容完成属性初始化，并输出
  3. 将创建的Dog对象，序列化到文件dog.dat文件，并输出反序列化在控制台
package com19.exercise;

import org.junit.jupiter.api.Test;

import java.io.*;
import java.util.Properties;

/**
 * @author 甲柒
 * @version 1.0
 * @title Exercise03
 * @package com19.exercise
 * @time 2023/4/3 22:30
 */
public class Exercise03 {
    public static void main(String[] args) throws IOException {
        /**
         * 编写一个dog.properties
         * name=tom
         * age=5
         * color=red
         * 编写Dog类(name, age, color)创建一个dog对象，读取dog.properties用相应的内容完成属性初始化，并输出
         * 将创建的Dog对象，序列化到文件dog.dat文件
         */

        Properties properties = new Properties();
        properties.setProperty("name", "tom");
        properties.setProperty("age", "5");
        properties.setProperty("color", "red");
        properties.store(new FileOutputStream("src\\dog.properties"), null);

        properties.load(new FileReader("src\\dog.properties"));
        String name = properties.get("name") + "";
        int age = Integer.parseInt(properties.get("age") + "");
        String color = String.valueOf(properties.get("color"));

        properties.list(System.out);
        Dog dog = new Dog(name, age, color);
        System.out.println("=====dog对象信息=====");
        System.out.println(dog);

        //将创建的Dog对象，序列化到文件dog.dat文件
        String filePath = "E:\\dog.dat";
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(filePath));
        objectOutputStream.writeObject(dog);
        objectOutputStream.close();
        System.out.println("Dog对象序列化完成");

    }

    //实现反序列化
    @Test
    public void m1() throws IOException, ClassNotFoundException {
        String filePath = "E:\\dog.dat";
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(filePath));
        Dog dog = (Dog) objectInputStream.readObject();
        System.out.println("======反序列化后的Dog对象信息======");
        System.out.println(dog);
        objectInputStream.close();
    }
}

class Dog implements Serializable {
    private String name;
    private int age;
    private String color;

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

    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;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

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

 

自动创建dog.properties

生成序列化文件

 反序列化结果

 

甲柒
关注
专栏目录
Java基础篇之IO流，动力节点老杜详细笔记
qq_45769329的博客
01-21 1427
详细讲解IO流，主要聚焦如何使用、掌握常用方法等
[疯狂Java]I/O：处理流、PrintStream简介、I/O体系、字符串作为流节点
Lirx_Tech的专栏
04-22 1381
1. 处理流PrintStream的简单使用：     1) 处理流最大的特点就是对节点流的包装，因此只要构造器的参数是节点流的一定就是处理流（PrintStream、BufferedStream等），而构造器参数是节点本身的就是节点流（FileInputStream等）；     2) 处理流的两大好处：操作简单（对象方法使用很简单，基本源自各编程语言的模型，通用性强）、执行效率更高；  
java的几种写入方法（PrintStream，FileWriter，BufferedWriter）
weixin_45721136的博客
06-22 882
java的几种写入方法（PrintStream，FileWriter，BufferedWriter） PrintStream（字节打印流）方法写入： String data="hello java"; PrintStream ps=new PrintStream("E:/1.txt"); //1.txt不管存不存在都会被创建/覆盖 start =System.currentTimeMillis(); ps.print(data); ps.close(); //用完及时关闭
PrintStream类和PrintWriter类(转)
a651944226的专栏
02-06 1418
JAVA IO操作总结：节点流和处理流
郭滋滋儿
01-01 595
JAVA IO操作总结——节点流和处理流
【Java学习笔记】65 - 文件类，IO流--节点流、处理流、对象流、转换流、打印流
qq_41891655的博客
11-07 1003
1）节点流可以从一个特定的数据源读写数据，如FileReader、 FileWriter [源码]2）处理流(也叫包装流)是“连接”在已存在的流(节点流或处理流)之上，为程序提供更为强大的读写功能，如BufferedReader. BufferedWriter [源码]1. InputStreamReader:Reader的子类，可以将InputStream(字节流)包装成(转换)成Reader(字符流)
B站韩顺平java学习笔记（十八）-- IO流 章节
LW_20180806的博客
04-18 3399
一 文件 文件是保存数据的地方。 1 文件流 文件在程序中是以流的形式来操作的。 流：数据在数据源（文件）和程序（内存）之间经历的路径； 输入流：数据从数据源（文件）到程序（内存）的路径； 输出流：数据从程序（内存）到数据源（文件）的路径。 二 IO流原理及流的处理 三 节点流和处理流 四 输入流 五 输出流 六 Properties类 ...
Java基础---I/O流笔记
weixin_55935744的博客
03-21 353
Java基础---I/O流笔记
Java IO流超详细笔记
Willing卡卡的博客
06-29 857
本文主要分享了有关IO的知识，从IO的分类开始依次说了字节流（读写相关的操作、字节缓冲流）、字符编码（编码和解码问题）、字符流（读写相关的操作、字符缓冲流）、其他比较重要的流（内存操作流程、打印流、对象流......）、序列化反序列化以及Properties类（store和load方法）
韩顺平 Java IO流 自学笔记
m0_67946241的博客
09-12 707
自己照着课程写得IO笔记
java学习笔记-初学IO流
weixin_43958958的博客
06-08 632
目 录什么是IOIO流的分类Java中的IO流java中需要掌握的流：16个java.io.FileInputStream（字节输入流）java.io.FileOutputStream（字节输出流）文件Copy使用字节流copy使用字符流Copyjava.io.BufferedReader（带有缓冲区的【字符】输入流）java.io.InputStreamReader（转换流） 什么是IO I：Input 读 O：Output 写 通过IO可以完成硬盘文件的读写 IO流的分类 按照流的方向进行分类： 输入
节点流和处理流详解
一个真ikun
09-17 2650
本篇详解JavaSE中io流的节点流和处理流部分。
JAVA自学笔记（IO流）
lol666111的博客
06-29 122
流 概念：内存与存储设备之间传输数据的通道 数据借助流进行传输 流的分类 按方向 输入流（input）：将 存储设备 中的内容读入到 内存 中 输出流（output）： 将 内存 中的内容写入到 存储设备 中 按单位 字节流：以字节为单位，可以读写所有数据 字符流：以字符为单位，只能读写文本数据 按功能 节点流：具有实际传输数据的读写功能 过滤流：在节点流的基础之上增强功能
Java中节点流和处理流的简单认知
qq_41657790的博客
04-16 1251
开发工具与关键技术：MyEclipse 10、Java 作者：曾浩源 撰写时间：2019年04月14日 在程序中所有的数据都是以流的方式进行传输或保存的，所以在Java中IO流也是必不可少的。Java中的IO流在java.io包中。 在java.io包中不管是操作文件和目录都是使用File类来操作，File能新建、删除、重命名文件和目录，但是File不能访问文件内容本身。 而需要操作文件内容在ja...
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1114
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
最新发布
xiaocaij_icai的博客
09-15 156
");
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 920
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
Java IO流深入解析：从File类到各种流的运用
打印流（PrintStream/PrintWriter）提供了格式化输出的功能，可以方便地打印文本、数值或其他对象。 数据流（DataInputStream/DataOutputStream）用于处理基本数据类型和字符串的序列化，使得数据能在不同环境之间...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

甲柒

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

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

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

打赏作者

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

抵扣说明：

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

余额充值