java基础 -IO流笔记

610，文件的基础知识

文件流

输入流和输出流都是相对 java程序内存 而言

611，创建文件

在D盘下创建文件。

package com.hspedu.file;

import org.junit.jupiter.api.Test;
import java.io.File;
import java.io.IOException;

//演示创建文件
public class FileCreate {
    public static void main(String[] args) {

    }

    @Test
    //方式 1 new File(String pathname)
    public void create01() throws IOException {
        String filePath = "d:\\news1.txt"; //  路径写  \\，或者， /
        File file = new File(filePath);
        //只有执行了 createNewFile 方法， 才会真正的， 在磁盘创建该文件
        file.createNewFile();
        System.out.println("文件1创建成功");
    }

    @Test
    //方式 2 new File(File parent,String child) //根据父目录文件+子路径构建
    public void create02() throws IOException {
        //这里的 file 对象， 在 java 程序中， 只是一个对象
        File parentFile = new File("d:\\");
        String fileName = "news2.txt";
        File file = new File(parentFile, fileName);
        file.createNewFile();
        System.out.println("文件2创建成功");
    }

    @Test
    //方式 3 new File(String parent,String child) //根据父目录+子路径构建
    public void create03() throws IOException {
        String parentPath = "d:\\";
        String fileName = "news3.txt";
        File file = new File(parentPath, fileName);
        file.createNewFile();
        System.out.println("文件3创建成功");
    }
}

612，获取文件信息

给news1.txt 里写了 hello韩顺平 ，UTF-8编码，一个英文字符占1个字节，一个汉字占3个字节。

package com.hspedu.file;

import org.junit.jupiter.api.Test;
import java.io.File;
import java.io.IOException;

//演示创建文件
public class FileCreate {
    public static void main(String[] args) {

    }

    @Test
    public void info() {
        //先创建文件对象
        File file = new File("d:\\news1.txt");

        //调用相应的方法， 得到对应信息
        //getName、 getAbsolutePath、 getParent、 length、 exists、 isFile、 isDirectory

        System.out.println("文件名字=" + file.getName());
        System.out.println("文件绝对路径=" + file.getAbsoluteFile());
        System.out.println("文件父级目录=" + file.getParent());
        System.out.println("文件大小（字节）=" + file.length());
        System.out.println("文件是否存在=" + file.exists());
        System.out.println("是不是一个文件=" + file.isFile());
        System.out.println("是不是一个目录=" + file.isDirectory());
    }

}

613，目录操作

第1个案例代码写出来后，第2个只需把 filePath 改了就行，所以就不写第2个案例代码了。

第3个案例，因为D:\\demo\\a 是多级目录，mkdir只能创建一级目录，所以用mkdir 创建失败，

package com.hspedu.file;

import org.junit.jupiter.api.Test;
import java.io.File;
import java.io.IOException;

//演示创建文件
public class FileCreate {
    public static void main(String[] args) {

    }

    @Test
    public void m1() {
        String filePath = "d:\\news1.txt";
        File file = new File(filePath);
        if (file.exists()) {
            //调用delete()方法来删除文件，并通过返回值判断删除操作是否成功。
            if(file.delete()) {
                System.out.println(filePath + "删除成功");
            } else {
                System.out.println(filePath + "删除失败");
            }
        } else {
            System.out.println("该文件不存在...");
        }
    }

    @Test
    public void m2() {
        String directoryPath = "D:\\demo\\a";
        File file = new File(directoryPath);
        if(file.exists()) {
            System.out.println(directoryPath + "存在");
        } else {
            if(file.mkdir()) {
                System.out.println(directoryPath + "创建成功");
            } else {
                System.out.println(directoryPath + "创建失败");
            }
        }
    }

}

614，IO流原理和分类

1，原理：

2，流的分类

615，FileInputStream

我们先在D盘创建一个hello.txt文件，里面内容为 hello,world

package com.hspedu.file;

import org.junit.jupiter.api.Test;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

//演示 FileInputStream 的使用(字节输入流 文件--> 程序)
public class FileInputStream_ {
    public static void main(String[] args) {

    }

    /*
     * 演示读取文件...
     * 单个字节的读取， 效率比较低
     * -> 优化：使用 read(byte[] b)，见readFile02函数中
     */
    @Test
    public void readFile01() throws IOException {
        String filePath = "d:\\hello.txt";
        int readData = 0;

        //创建 FileInputStream 对象， 用于读取 文件
        FileInputStream fileInputStream = new FileInputStream(filePath);

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

        //关闭文件流， 释放资源
        fileInputStream.close();
    }

    /*
     * 使用 read(byte[] b) 读取文件， 提高效率
     */
    @Test
    public void readFile02() throws IOException {
        String filePath = "d:\\hello.txt";

        //字节数组
        byte[] buf = new byte[8];//一次读取8个字节

        int readLenth = 0;
        //创建 FileInputStream 对象， 用于读取 文件
        FileInputStream fileInputStream = new FileInputStream(filePath);

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

        //关闭文件流， 释放资源
        fileInputStream.close();
    }
}

616，FileOutputStream

FileOutputStream 是 字节输出流 OutputStream 的子类

自动创建文件的，没有使用mkdir()

package com.hspedu.file;

import org.junit.jupiter.api.Test;

import java.io.*;

//演示 FileInputStream 的使用(字节输入流 文件--> 程序)
public class FileOutputStream_ {
    public static void main(String[] args) {

    }

    /*
     * 演示使用 FileOutputStream 将数据写到文件中,
     * 如果该文件不存在， 则创建该文件
     */
    @Test
    public void writeFile() throws IOException {
        String filePath = "d:\\a.txt";

        //创建 FileOutputStream 对象
        //1. new FileOutputStream(filePath) 创建方式， 当写入内容是， 会覆盖原来的内容
        //2. new FileOutputStream(filePath, true) 创建方式， 当写入内容是， 是追加到文件后面
        FileOutputStream fileOutputStream = new FileOutputStream(filePath, true);

        //从内存写出一个字节到 d:\\a.txt
//        fileOutputStream.write('H');

        //从内存写出字符串到 d:\\a.txt
        //str.getBytes() 可以把 字符串-> 字节数组
        String str = " hello,world";
//        fileOutputStream.write(str.getBytes());

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

        fileOutputStream.close();
    }

}

617，文件拷贝

有的文件太大了，不能一次性读入到内存中去，所以是读取部分数据

package com.hspedu.file;

import org.junit.jupiter.api.Test;

import java.io.*;

public class FileCopy_ {
    public static void main(String[] args) throws IOException {
        //完成 文件拷贝， 将 d:\图片\4.jpg 拷贝 d:\
        //思路分析
        //1. 创建文件的输入流 , 将文件读入到程序
        //2. 创建文件的输出流， 将读取到的文件数据， 写入到指定的文件
        String srcFilePath = "d:\\图片\\4.jpg";
        String destFilePath = "d:\\4.jpg";//4.jpg不能忘了

        FileInputStream fileInputStream = new FileInputStream(srcFilePath);
        FileOutputStream fileOutputStream = new FileOutputStream(destFilePath);

        //定义一个字节数组,提高读取效果
        byte[] buf = new byte[1024];
        int readLength = 0;
        while((readLength = fileInputStream.read(buf)) != -1) {
            //读取到后， 就写入到文件 通过 fileOutputStream
            //即， 一边读， 一边写
            fileOutputStream.write(buf, 0, readLength);//一定要使用这个方法
        }
        System.out.println("拷贝成功");

        //关闭输入流和输出流， 释放资源
        if (fileInputStream != null) {
            fileInputStream.close();
        }
        if (fileOutputStream != null) {
            fileOutputStream.close();
        }
    }
}

618，文件字符流说明

Reader 和 Writer 是字符流，FileReader 和 FileWriter 是它们的子类

619，FileReader

先在D盘新建一个story.txt，并在里面写内容

package com.hspedu.file;

import org.junit.jupiter.api.Test;

import java.io.*;

public class FileReader_ {
    public static void main(String[] args)  {

    }

    /*
     * 单个字符读取文件
     */
    @Test
    public void readFile01() throws IOException {
        String filePath = "d:\\story.txt";
        int data = 0;

        //1. 创建 FileReader 对象
        FileReader fileReader = new FileReader(filePath);

        //循环读取 使用 read, 单个字符读取
        while ((data = fileReader.read()) != -1) {
            System.out.print((char) data);
        }
        if (fileReader != null) {
            fileReader.close();
        }
    }

    /*
     * 字符数组读取文件
     */
    @Test
    public void readFile02() throws IOException {
        String filePath = "d:\\story.txt";
        int readLength = 0;
        char[] buf = new char[8];

        //1. 创建 FileReader 对象
        FileReader fileReader = new FileReader(filePath);

        //循环读取 使用 read(buf), 返回的是实际读取到的字符数
        //如果返回-1, 说明到文件结束
        while ((readLength = fileReader.read(buf)) != -1) {
            System.out.print(new String(buf, 0, readLength));
        }
        if (fileReader != null) {
            fileReader.close();
        }
    }
}

620，FileWriter

package com.hspedu.file;

import org.junit.jupiter.api.Test;

import java.io.*;

public class FileWriter_ {
    public static void main(String[] args) throws IOException {
        String filePath = "d:\\note.txt";

        //创建 FileWriter 对象
        FileWriter fileWriter = new FileWriter(filePath);//默认是覆盖写入

        //write(int):写入单个字符
        fileWriter.write('H');

        //write(char[]):写入指定数组
        char[] chars = {'a', 'b', 'c'};
        fileWriter.write(chars);

        //write(char[],off,len):写入指定数组的指定部分
        fileWriter.write("韩顺平教育".toCharArray(), 0, 3);

        //write（string） ： 写入整个字符串
        fileWriter.write(" 风雨之后， 定见彩虹");

        //write(string,off,len):写入字符串的指定部分
        fileWriter.write("上海天津", 0, 2);
        //在数据量大的情况下， 可以使用循环操作
        //对应 FileWriter , 一定要关闭流， 或者 flush 才能真正的把数据写入到文件
        fileWriter.close();
    }
}

622，处理流设计模式

模拟修饰器设计模式，代码结构如下图：

Reader_ 类：，后面在调用时，利用对象动态绑定机制，绑定到对应的实现子类即可

package com.hspedu.file;

public abstract class Reader_ {//抽象类

    public void readFile() {}

    public void readString() {}
}

FileReader_ 类代码：

package com.hspedu.file;

//节点流
public class FileReader_ extends Reader_{
    public void readFile() {
        System.out.println("对文件进行读取...");
    }
}

StringReader_ 类代码：

package com.hspedu.file;

//节点流
public class StringReader_ extends Reader_{
    public void readString() {
        System.out.println("读取字符串");
    }
}

BufferedReader_ 类代码：

package com.hspedu.file;

//做成处理流/包装流
public class BufferedReader_ extends Reader_{
    private Reader_ reader_;//属性是 Reader_ 类型

    //接收Reader_ 子类对象
    public BufferedReader_(Reader_ 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();
        }
    }
}

Test_ 类代码：

package com.hspedu.file;

public class Test_ {
    public static void main(String[] args) {
        BufferedReader_ bufferedReader = new BufferedReader_(new FileReader_());
        bufferedReader.readFiles(3);

        //这次希望通过 BufferedReader_ 多次读取字符串
        BufferedReader_ bufferedReader1 = new BufferedReader_(new StringReader_());
        bufferedReader1.readStrings(3);

    }
}

运行结果：

623，BufferedReader

package com.hspedu.file;

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

//演示 bufferedReader 使用
public class BufferedReader_ {
    public static void main(String[] args) throws IOException {
        String filePath = "d:\\story.txt";

        //创建 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。
        bufferedReader.close();
    }
}

624，BufferedWriter

package com.hspedu.file;

import java.io.*;

//演示 BufferedWriter 的使用
public class BufferedWriter_ {
    public static void main(String[] args) throws IOException {
        String filePath = "d:\\story.txt";

        //创建 bufferedWriter//说明:
        //1. new FileWriter(filePath, true) 表示以追加的方式写入
        //2. new FileWriter(filePath) , 表示以覆盖的方式写入
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath));

        bufferedWriter.write("hello, 韩顺平教育");
        bufferedWriter.newLine();//插入一个和系统相关的换行
        bufferedWriter.write("hello, 韩顺平教育");
        bufferedWriter.newLine();

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

625，Buffered拷贝

package com.hspedu.file;

import java.io.*;

public class BufferedCopy_ {
    public static void main(String[] args) throws IOException {
        //1. BufferedReader 和 BufferedWriter 是安装字符操作
        //2. 不要去操作 二进制文件[声音， 视频， doc, pdf ], 可能造成文件损坏
        String srcFilePath = "d:\\story.txt";
        String destFilePath = "d:\\1.txt";
        BufferedReader bufferedReader = new BufferedReader(new FileReader(srcFilePath));
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(destFilePath));
        String line;

        //说明: readLine 读取一行内容， 但是没有换行
        while ((line = bufferedReader.readLine()) != null) {
            //每读取一行， 就写入
            bufferedWriter.write(line);
            //插入一个换行
            bufferedWriter.newLine();
        }
        System.out.println("拷贝成功");

        //关闭流
        if(bufferedReader != null) {
            bufferedReader.close();
        }
        if(bufferedWriter != null) {
            bufferedWriter.close();
        }
    }
}

627，字节处理流拷贝文件

package com.hspedu.file;

import java.io.*;

/*
    *演示使用 BufferedOutputStream 和 BufferedInputStream 使用
    * 使用他们， 可以完成二进制文件拷贝.
    * 思考： 字节流可以操作二进制文件， 可以操作文本文件吗？ 当然可以
*/
public class BufferedCopy_ {
    public static void main(String[] args) throws IOException {
        //1. BufferedReader 和 BufferedWriter 是安装字符操作
        //2. 不要去操作 二进制文件[声音， 视频， doc, pdf ], 可能造成文件损坏
        String srcFilePath = "d:\\图片\\4.jpg";
        String destFilePath = "d:\\1.jpg";

        //创建 BufferedOutputStream 对象 BufferedInputStream 对象
        //因为 FileInputStream 是 InputStream 子类
        BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(srcFilePath));
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(destFilePath));

        //循环的读取文件，并写入到 destFilePath
        byte[] buff = new byte[1024];
        int readLen = 0;

        //当返回 -1 时， 就表示文件读取完毕
        while ((readLen = bufferedInputStream.read(buff)) != -1) {
            bufferedOutputStream.write(buff, 0, readLen);
        }
        System.out.println("拷贝成功");

        //关闭流 , 关闭外层的处理流即可， 底层会去关闭节点流
        if(bufferedInputStream != null) {
            bufferedInputStream.close();
        }
        if(bufferedOutputStream != null) {
            bufferedOutputStream.close();
        }
    }
}

629，ObjectOutputStream

Dog 类

package com.hspedu.file;

import java.io.Serializable;

public class Dog implements Serializable {
    private String name;
    private int age;
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

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

ObjectOutputStream_  类：

package com.hspedu.file;

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

//演示 ObjectOutputStream 的使用，完成数据的序列化
public class ObjectOutputStream_ {
    public static void main(String[] args) throws Exception {
        //序列化后，保存的文件格式不是纯文本的，而是按照它的格式来保存的
        String filePath = "d:\\data.dat";

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));
        //序列化数据到d:\data.dat
        oos.writeInt(100);//int -> Integer（Integer实现了Serializable）
        oos.writeBoolean(true);//boolean -> Boolean（Boolean实现了Serializable）
        oos.writeChar('a');//char -> Character（Character实现了Serializable）
        oos.writeDouble(9.6);//double -> Double（Double实现了Serializable）
        oos.writeUTF("兔年顶呱呱");//String（String实现了Serializable）
        //保存一个dog对象
        oos.writeObject(new Dog("旺财", 10));
        oos.close();
        System.out.println("数据保存完毕（序列化形式）···");
    }
}

630，ObjectInputStream

写本节代码时，不能把上一节代码删了，要保留，重新新建一个类，写本节代码。

ObjectInputStream_ 类：

package com.hspedu.file;

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

//演示 ObjectInputStream 的使用，完成数据的反序列化
public class ObjectInputStream_ {
    public static void main(String[] args) throws Exception{
        //指定反序列化的文件
        String filePath = "d:\\data.dat";

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

        //读取（反序列化）的顺序需要和保存数据（序列化）的顺序一致，否则会出现异常
        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());

        //dog的编译类型是Object，dog的运行类型是 Dog
        Object dog = ois.readObject();
        System.out.println("运行类型：" + dog.getClass());
        System.out.println("Dog信息=" + dog);//底层 Object -> Dog

        //重要细节
        //1.如果我们希望调用Dog的方法，需要向下转型
        //2.需要我们将Dog类的定义，放在可以引用的位置
        Dog dog2 = (Dog) dog;
        System.out.println(dog2.getName());//只输出旺柴

        //关闭流，关闭外层流即可，底层会自动关闭
        ois.close();
    }
}

632，标准输入输出流

package com.hspedu.file;

import java.sql.SQLOutput;
import java.util.Scanner;

public class InputAndOutput {
    public static void main(String[] args) {
        //System 类 的 public final static InputStream in = null;
        //System.in 编译类型 InputStream
        //System.in 运行类型 BufferedInputStream
        // 表示的是标准输入 键盘
        System.out.println(System.in.getClass());
        System.out.println("hello,韩顺平教育");
        System.out.println(System.out.getClass());

        //1，System.out.public final static PrintStream out = null;
        //2，编译类型 PrintStream
        //3，运行类型 PrintStream
        //4，表示标准输出 显示器
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入内容");
        String next = scanner.next();
        System.out.println("next=" + next);
    }
}

633，乱码引出转换流

package com.hspedu.file;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.sql.SQLOutput;
import java.util.Scanner;

public class CodeQuestion {
    public static void main(String[] args) throws IOException {
        //读取d:\\1.txt 文件到程序
        //思路：
        //1，创建字符输入流 BufferedReader[处理流]
        //2，使用 BufferedReader 对象读取 a.txt
        //3，默认情况下，读取文件时按照 utf-8 编码
        String filePath = "d:\\1.txt";
        BufferedReader br = new BufferedReader(new FileReader(filePath));

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

这是UTF-8的编码，输出结果：

这是改成国标码 ANSI，也就是gbk 码的输出结果：

634，InputStreamReader

package com.hspedu.file;

import java.io.*;

//演示使用 InputStreamReader 转换流解决中文乱码问题
//* 将字节流 FileInputStream 转成字符流 InputStreamReader, 指定编码 gbk/utf-8
public class InputStreamReader_ {
    public static void main(String[] args) throws IOException {
        String filePath = "d:\\1.txt";

        //1. 把 FileInputStream 转成 InputStreamReader
        //2. 指定编码 gbk
        InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath), "gbk");

        //3. 把 InputStreamReader 传入 BufferedReader
        //将 2 和 3 合在一起
        BufferedReader br = new BufferedReader(isr);
        String s = br.readLine();

        System.out.println("读取内容=" + s);

        //5. 关闭外层流
        br.close();

    }
}

635，OutputStreamWriter

package com.hspedu.file;

import java.io.*;
import java.nio.charset.Charset;

//演示使用 OutputStreamWriter 使用
//将字节流 FileOutputStream 转成字符流 OutputStreamWriter,
//指定处理的编码 gbk/utf-8/utf8
public class OutputStreamWriter_ {
    public static void main(String[] args) throws IOException {
        String filePath = "d:\\2.txt";
        String charSet = "utf-8";
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(filePath), charSet);
        osw.write("hi,韩顺平");
        osw.close();

        System.out.println("按照 " + charSet + " 保存文件成功~");
    }
}

636，PrintStream, PrintStream

PrintStrean 字节打印流

package com.hspedu.file;

import java.io.*;

// 演示 PrintStream （字节打印流/输出流）
public class PrintStream_ {
    public static void main(String[] args) throws IOException {

        PrintStream out = System.out;
        //在默认情况下， PrintStream 输出数据的位置是 标准输出， 即显示器
        out.print("john, hello");
        //因为 print 底层使用的是 write , 所以我们可以直接调用 write 进行打印/输出
        out.write("韩顺平，你好".getBytes());
        out.close();

        //我们可以去修改打印流输出的位置/设备
        //1. 输出修改成到 "e:\\f1.txt"
        //2. "hello, 韩顺平教育~" 就会输出到 e:\f1.txt
        System.setOut(new PrintStream("d:\\f1.txt"));
        System.out.println("hello, 韩顺平教育~");
    }
}

package com.hspedu.file;

import java.io.*;

//演示 PrintWriter 使用方式
public class PrintStream_ {
    public static void main(String[] args) throws IOException {

        //PrintWriter printWriter = new PrintWriter(System.out)
        PrintWriter printWriter = new PrintWriter(new FileWriter("d:\\f2.txt"));
        printWriter.print("hi, 北京你好~~~");
        //flush + 关闭流, 才会将数据写入到文件..
        printWriter.close();
    }
}

638，配置文件引出Properties

用传统的方法

先在src 下创建一个 properties文件，文件名叫 mysql.properties

ip=192.168.100.100
user=root
pwd=12345

主文件代码：

注意 这个路径没有冒号

package com.hspedu.file.properties_;

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

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("=");
            //System.out.println(split[0] + "值是：" + split[1]);

            //如果我们要求指定的 ip 值
            if("ip".equals(split[0])) {
                System.out.println(split[0] + "值是：" + split[1]);
            }
        }
        br.close();
    }
}

639，Properties读文件

package com.hspedu.file.properties_;

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

public class Properties01 {
    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);
    }
}

640，Properties修改文件

package com.hspedu.file.properties_;

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

public class Properties01 {
    public static void main(String[] args) throws IOException {
        //使用 Properties 类来创建 配置文件, 修改配置文件内容
        Properties properties = new Properties();
        properties.setProperty("charset", "utf8");//注意保存时， 是中文的 unicode 码值
        properties.setProperty("user", "汤姆");
        properties.setProperty("pwd", "abc111");
        //将 k-v 存储文件中即可
        properties.store(new FileOutputStream("src\\mysql2.properties"), null);
        System.out.println("保存配置文件成功~");
    }
}

641，本章家庭作业01

package com.hspedu.file.homework;

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

public class Homework01 {
    public static void main(String[] args) throws IOException {
        String directoryPath = "d:\\mytemp";
        File file = new File(directoryPath);
        if (!file.exists()) {
            //创建目录
            if(file.mkdirs()) {
                System.out.println("创建 " + directoryPath + " 创建成功");
            } else {
                System.out.println("创建 " + directoryPath + " 创建失败");
            }
        }

        String filePath = directoryPath + "\\hello.txt";  // d:\mytemp\hello.txt
        file = new File(filePath);
        if (!file.exists()) {
            //创建文件
            if (file.createNewFile()) {
                System.out.println(filePath + " 创建成功~");

                //如果文件存在，我们就使用BufferedWriter 字符输入流写入内容
                BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(file));
                bufferedWriter.write("hello, world~~ 韩顺平教育");
                bufferedWriter.close();

            } else {
                System.out.println(filePath + " 创建失败");
            }
        } else {
            //如果文件已经存在，给出提示信息
            System.out.println(filePath + " 已经存在，不存在重复创建...");
        }
    }
}

642，本章家庭作业02

package com.hspedu.file.homework;

import java.io.*;

public class Homework02 {
    public static void main(String[] args) throws IOException {
        String filePath = "d:\\story.txt";
        BufferedReader br = null;
        String line = "";
        int lineNum = 0;
        br = new BufferedReader(new FileReader(filePath));
        while ((line = br.readLine()) != null) {//循环读取
            System.out.println(++lineNum + " " + line);
        }
        if (br != null) {
            br.close();
        }
    }
}

643，本章家庭作业03

package com.hspedu.file.homework;

import org.junit.jupiter.api.Test;

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

public class Homework03 {
    public static void main(String[] args) throws IOException {
        String filePath = "src\\dog.properties";
        Properties properties = new Properties();
        properties.load(new FileReader(filePath));
        String name = properties.getProperty("name");
        int age = Integer.parseInt(properties.getProperty("age"));// String -> int
        String color = properties.getProperty("color");

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

        //将创建的Dog对象，序列化到文件 d:dog.dat
        String serFilePath = "d:\\dog.dat";
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(serFilePath));
        oos.writeObject(dog);

        //关闭流
        oos.close();
        System.out.println("dog对象，序列化完成...");
    }

    @Test
    public void m1() throws IOException, ClassNotFoundException {
        String serFilePath = "d:\\dog.dat";
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(serFilePath));
        Dog dog = (Dog)ois.readObject();

        System.out.println("====反序列化后 dog====");
        System.out.println(dog);

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

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

运行 m1方法后的结果：