Java基础-IO流

1.文件

1.基本介绍

2.常用的文件操作

1.创建文件的相关构造器和方法

代码实例

package IO_;

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

/**
 * @author 孙显圣
 * @version 1.0
 */
public class FileCreate {
    public static void main(String[] args) {
        //使用三种方式在e盘下创建三个文件

        // new File(String pathname)
        String path1 = "e:\\file1.txt";
        File file = new File(path1); //在内存中创建文件对象
        //调用方法在磁盘中创建文件
        try {
            file.createNewFile();
            System.out.println("创建文件1成功！");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

        // new File(File parent, String child)
        File file1 = new File("e:\\"); //父文件对象
        String child = "file2.txt"; //子文件路径
        File file2 = new File(file1, child);
        try {
            file2.createNewFile();
            System.out.println("创建文件2成功");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

        // new File(String parent, String child)
        String parent = "e:\\"; //父路径
        String child_ = "file3.txt";
        File file3 = new File(parent, child_);
        try {
            file3.createNewFile();
            System.out.println("文件3创建成功");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

结果

2.获取文件相关信息

代码实例

package IO_;

import java.io.File;

/**
 * @author 孙显圣
 * @version 1.0
 */
public class FileInfo {
    public static void main(String[] args) {
        File file = new File("e:\\file1.txt"); //创建文件对象

        System.out.println("文件绝对路径 " + file.getAbsolutePath());
        System.out.println("文件名字 " + file.getName());
        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());
    }
}

结果

3.目录的删除和文件删除

代码实例

package IO_;

import java.io.File;

/**
 * @author 孙显圣
 * @version 1.0
 */
public class FileMkdir {
    public static void main(String[] args) {
        // 判断e:\\file1.txt是否存在，如果存在则删除
        File file = new File("e:\\file1.txt");
        if (file.exists()) {
            file.delete();
            System.out.println("删除成功");
        }
        else {
            System.out.println("删除失败");
        }

        // 判断e:\\demo02是否存在，存在就删除，否则提示不存在
        String path = file.getParent() + "demo02"; //路径拼接
        File file1 = new File(path);
        if (file1.exists()) {
            file1.delete();
            System.out.println("删除成功");
        }
        else {
            System.out.println("删除失败");
        }
 
        // 判断e:\\demo\\a\\b\\c是否存在，如果不存在则创建
        File file2 = new File("e:\\demo\\a\\b\\c");
        if (file2.exists()) {
            System.out.println("已经存在");
        }
        else {
            file2.mkdirs();
            System.out.println("文件不存在，已经自动创建");
        }

    }
}

2.IO流原理及分类

IO流原理

IO流就相当于是外卖小哥，用来传输数据

IO流分类

3.FileInputStream

1.类图

2.代码实例

package IO_;

import org.junit.jupiter.api.Test;

import java.io.FileNotFoundException;
import java.io.IOException;

/**
 * @author 孙显圣
 * @version 1.0
 */
public class FileInputStream {

    //逐个字节读取
    @Test
    public void one() {
        String path = "e:\\hello.txt"; //1.文件路径
        int readData = 0;
        java.io.FileInputStream fileInputStream = null;
        try {
            fileInputStream = new java.io.FileInputStream(path); //2.根据文件路径，创建输入流的对象

            //3.逐个字节读取
            while ((readData = fileInputStream.read()) != -1) { //返回读取的字节，如果返回-1则到文件末尾
                System.out.print((char) readData); //将字节转换成char类型并输出
            }

        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            //4.关闭字节流
            try {
                fileInputStream.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }

    //按照字节数组读取
    public static void main(String[] args) {

        String path = "e:\\hello.txt"; //1.文件路径
        byte[] bytes = new byte[8]; //3.8个容量的字节数组
        int readData = 0;
        java.io.FileInputStream fileInputStream = null;

        try {
            fileInputStream = new java.io.FileInputStream(path); //2.字节流对象
            //4.按照字节数组读取
            while ((readData = fileInputStream.read(bytes)) != -1) { //会将字节读进字节数组中，返回读进的字节数
                System.out.print(new String(bytes, 0, readData)); //将字节数组转换成String类型并且输出
            }
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            //5.关闭字节流
            try {
                fileInputStream.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

3.结果

4.FileOutputStream

1.类图

2.案例

代码实例

package IO_;

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

/**
 * @author 孙显圣
 * @version 1.0
 */
public class FileOutputStream01 {
    public static void main(String[] args) {
        //输出流如果没有那个文件，会自动创建
        String path = "e:\\a.txt"; //1.文件路径
        FileOutputStream fileOutputStream = null; //2.获取文件输出流引用

        try {
//            fileOutputStream = new FileOutputStream(path); //3.获取文件输出流
            fileOutputStream = new FileOutputStream(path, true); //8.设置该文件输出流的写入位置为文件末尾（不覆盖原来的文件）
            //5.输出单个字符
            fileOutputStream.write('h');
            //6.输出字符串
            String a = "hello,world";
            fileOutputStream.write(a.getBytes()); //使用字符串的getBytes来将字符串转化成字节数组
            //7.输出部分字符串
            String b = "hsp,java";
            fileOutputStream.write(b.getBytes(), 0, 3);

        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            //4.关闭文件输出流
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

3.综合案例—文件拷贝

代码实例

package IO_;

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

/**
 * @author 孙显圣
 * @version 1.0
 */
public class FileCopy {
    public static void main(String[] args) {
        //文件源路径
        String src = "C:\\Users\\86156\\Desktop\\images\\1.png";
        //文件目标路径
        String dest = "e:\\1.png";
        //文件输入流
        FileInputStream fileInputStream = null;
        //文件输出流
        FileOutputStream fileOutputStream = null;
        byte[] bytes = new byte[1024]; //用来存储文件输入的字节数组
        int readLength = 0; //记录读取的字节数

        try {
            //获取文件输入流
            fileInputStream = new FileInputStream(src);
            //获取文件输出流
            fileOutputStream = new FileOutputStream(dest);

            //将文件读取到字节数组中
            while ((readLength = fileInputStream.read(bytes)) != -1) {
                fileOutputStream.write(bytes, 0, readLength); //将读取到的部分写入目标文件
            }
            System.out.println("拷贝成功！");

        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            //关闭两个流
            try {
                fileInputStream.close();
                fileOutputStream.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

5.FileReader

1.类图

2.基本介绍

3.案例

代码实例

package IO_;

import org.junit.jupiter.api.Test;

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

/**
 * @author 孙显圣
 * @version 1.0
 */
public class FileReader_ {
    //按照单个字符读取
    public static void main(String[] args) {
        //读取路径
        String src = "e:\\a.txt";
        //获取字符输入流引用
        FileReader fileReader = null;
        int readData = 0; //接收输入的字符

        try {
            //获取字符输入流
            fileReader = new FileReader(src);
            //按照字符，循环读取
            while ((readData = fileReader.read()) != -1) { //这里返回的是单个字符但是，是以int形式返回的
                System.out.print(((char)readData));
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            //关闭字符输入流
            try {
                fileReader.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }


    //按照字符数组读取
    @Test
    public void readMore() {
        //读取路径
        String src = "e:\\a.txt";
        //获取字符输入流引用
        FileReader fileReader = null;
        char[] chars = new char[100]; //用来接收读取的数据
        int redLen = 0; //记录读取长度

        try {
            //获取字符输入流
            fileReader = new FileReader(src);
            //按照字符，循环读取
            while ((redLen = fileReader.read(chars)) != -1) { //这里是将内容读取到char数组，返回的是读取的长度
                System.out.print(new String(chars, 0, redLen)); //将读取到的部分转化成String，并输出
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            //关闭字符输入流
            try {
                fileReader.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

6.FileWriter

1.类图

2.基本介绍

3.案例

代码实例

package IO_;

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

/**
 * @author 孙显圣
 * @version 1.0
 */
public class FileWriter_ {
    public static void main(String[] args) {
        //写入文件地址
        String path = "e:\\a.txt";
        //获取输出字符流引用
        FileWriter fileWriter = null;

        try {
            fileWriter = new FileWriter(path); //获取输出字符流对象
            //写入单个字符
            fileWriter.write('a');
            //写入字符数组
            char[] a = new char[]{'1','2','3'};
            fileWriter.write(a);
            //写入指定字符数组的指定部分
            fileWriter.write("你好，世界".toCharArray(),3,2); //注意这里面的指定位置指的是off（开始位置）len（长度），这里我就是，从3开始2个位置所以是世界
            //写入字符串
            fileWriter.write("字符串");
            //写入部分字符串
            fileWriter.write("韩顺平，java",0, 3);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            //关闭字符流
            try {
                fileWriter.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

7.节点流与处理流

1.基本介绍

简单来说，就是节点流的处理局限性太强，java设计者就设计了处理流，处理流中有一个属性，这个属性是一个类的引用，而这个类是各种节点流的父类，通过将其他节点流的对象赋值给这个属性，就可以向上转型，从而使用这个属性来调用各种节点流的方法

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

1. 节点流式底层流，直接跟数据源相接
2. 处理流（包装类 ）包装节点流，既可以消除不同节点流的实现差异，也可以对提供更方便的方法来完成输入输出
3. 处理流对节点流进行包装，使用了修饰器设计模式，不会与数据源直接相连
4. 重点就是：处理流有一个属性，这个属性是很多子类型的父类，也就是说可以接收很多子类型的对象，接受的谁的对象，掉用的就是谁的方法

8.BufferedReader

代码实例

package IO_;

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

/**
 * @author 孙显圣
 * @version 1.0
 */
public class BufferReader_ {
    public static void main(String[] args) {
        //读取的路径
        String path = "e:\\a.txt";
        //BufferedReader的引用
        BufferedReader bufferedReader = null;
        //接受读取的内容
        String readData = null;
        try {
            bufferedReader = new BufferedReader(new FileReader(path)); //由于要对文件进行操作，所以传入FileReader
            while ((readData = bufferedReader.readLine()) != null) { //按行读取
                System.out.println(readData);
            }
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            try {
                bufferedReader.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

9.BufferedWriter

案例

代码实例

package IO_;

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

/**
 * @author 孙显圣
 * @version 1.0
 */
public class BufferedWriter {
    public static void main(String[] args) throws IOException {
        String path = "e:\\a.txt";
        java.io.BufferedWriter bufferedWriter = new java.io.BufferedWriter(new FileWriter(path, true));//以追加的方式写入
        bufferedWriter.write("韩顺平教育，，，java");
        bufferedWriter.close(); //关闭外层流
    }
}

10.Buffered拷贝

代码实例

package IO_;

import java.io.*;
import java.io.BufferedWriter;

/**
 * @author 孙显圣
 * @version 1.0
 */
public class BufferedCopy {
    public static void main(String[] args) throws IOException {
        //源地址
        String src = "e:\\a.txt";
        //目标地址
        String dest = "e:\\b.txt";
        String readData = null; //存储读取信息

        //获取输入流
        BufferedReader bufferedReader = new BufferedReader(new FileReader(src));
        //获取输出流
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(dest));

        //按行读取信息
        while ((readData = bufferedReader.readLine()) != null) {
            //写入
            bufferedWriter.write(readData);
            bufferedWriter.newLine(); //写入一行
        }
        //关闭
        bufferedWriter.close();
        bufferedReader.close(); 
    }
}

11.Buffered字节处理流

1.基本介绍

2.字节处理流拷贝（图片/音乐）

代码实例

package IO_;

import java.io.*;
import java.io.FileInputStream;

/**
 * @author 孙显圣
 * @version 1.0
 */
public class BufferedCopy02 {
    public static void main(String[] args) throws IOException {
        //源地址
        String src = "e:\\1.png";
        //目标地址
        String dest = "e:\\3.png";
        //存储读取到的字节数组
        byte[] bytes = new byte[1024];
        //存储读取长度
        int readLen = 0;

        //获取输入字节流
        BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(src));
        //获取输出字节流
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(dest));

        //循环读取
        while ((readLen = bufferedInputStream.read(bytes)) != -1) {
            bufferedOutputStream.write(bytes, 0, readLen);
        }
        //关闭字节流
        bufferedInputStream.close();
        bufferedOutputStream.close();
    }
}

3.字节处理流和字符处理流比较

1. 字节处理流主要用于处理二进制文件（视频、图片等），也能处理二进制文件
2. 字符处理流主要用于处理文本文件（效率高），不能处理二进制文件
3. 字节处理流可以写一个字节、字节数组、部分字节数组
4. 字符处理流可以写一个字符、一个字符数组、一个字符串、部分字符数组、部分字符串
5. 简单来说，字节处理的是单个字节，字节数组，字符处理的是单个字符，字符数组，字符串

12.对象处理流（读写对象）

1.序列化和反序列化

介绍

1. 序列化就是在保存数据的时候，保存数据的值和数据类型
2. 反序列化就是在回复数据时，恢复数据的值和数据类型
3. 需要让某个对象支持序列化机制，则必须让其类是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一
   1. Serializable(推荐) 这是一个标记接口，里面没有任何方法
   2. Externalizable

2.ObjectOutputStream

类图

案例

package IO_;

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

/**
 * @author 孙显圣
 * @version 1.0
 */
public class ObjectOutputStream_ {
    public static void main(String[] args) throws IOException {
        //输出文件路径
        String path = "e:\\data.dat"; //注意序列化的文件是dat格式的
        //获取对象输出流
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(path));
        //保存
        objectOutputStream.writeInt(100); // Integer
        objectOutputStream.writeBoolean(true);
        objectOutputStream.writeChar('a');
        objectOutputStream.writeDouble(10.2);
        objectOutputStream.writeUTF("adf");
        objectOutputStream.writeObject(new Dog("jack",12));
        //关闭
        objectOutputStream.close();

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

3.ObjectInputStream

类图

案例

package IO_;

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

/**
 * @author 孙显圣
 * @version 1.0
 */
public class ObjectInputStream_ {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //输入的地址
        String path = "e:\\data.dat";
        //获取对象处理流
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(path));
        // 按照之前序列化的次序来获取对象
        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 o = objectInputStream.readObject();
        System.out.println(o.getClass());
        System.out.println(o);

        //关闭对象处理流
        objectInputStream.close();

    }
}

对象处理流使用细节

1. 在修改了对象处理流的文件之后，需要重新运行一遍程序，保持版本一致性
2. 如果是自定义的对象，要保证该输入流文件可以引入
3. 读写顺序需要一致
4. 序列化或者反序列化对象必须实现Serializable接口
5. 序列化中的类建议添加SerialVersionUID,为了提高版本的兼容性
6. 序列化对象时，默认将里面所有属性都进行序列化，但除了static或transient修饰的成员
7. 序列化对象时，要求里面的属性也需要实现序列化接口
8. 序列化具备可继承性，也就是如果某类已经实现了序列化，则它的所有子类也默认实现了序列化

13.标准输入输出流

System.in

1. 编译类型：InputStream
2. 运行类型：BufferedInputStream（可以处理所有输入，只需要传入相应的InputStream子类即可）
3. 表示的是标准输入 键盘

System.out

1. 编译类型：PrintStream
2. 运行类型：PrintStream
3. 表示的是标准输出 显示器

new Scanner(System.in)

1. 这个就相当于给扫描器传入了接受键盘输入的数据

14.转换流（字节流转换成字符流并指定编码）

1.字符流出现乱码引出转换流

1. 将文件类型改成非utf-8，然后使用字符流读取
2. 如果想解决这个问题，就只能将字符流转换成字节流并且指定编码，然后再转回来

2.InputStreamReader

解决乱码问题

代码实例

package IO_;

import org.junit.jupiter.api.Test;

import java.io.FileInputStream;
import java.io.*;

/**
 * @author 孙显圣
 * @version 1.0
 */
public class CodeQuestion {
    public static void main(String[] args) throws IOException {
        //使用字符流读取文件内容
        String url = "e:\\a.txt";
        //获取字符处理流
        BufferedReader bufferedReader = new BufferedReader(new FileReader(url));
        //读取一行内容
        String s = bufferedReader.readLine();
        System.out.println(s);
    }
    //字节流转换成字符流
    @Test
    public void test() throws IOException {
        String url = "e:\\a.txt";
        //这里是使用文件字节流读取信息，并传入编码，会返回一个字符流的实例
        InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream(url), "gbk");

//        //使用节点流的方式去读
//        char[] chars = new char[100];
//        int readLen;
//        while ((readLen = inputStreamReader.read(chars)) != -1) { //读到字符数组中并返回读取的长度
//            System.out.println(new String(chars, 0, readLen)); //根据读取的长度取出数组内的长度
//        }

        //使用BufferedReader的方式去读
        String re = null;
        BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
        while ((re = bufferedReader.readLine()) != null) {
            System.out.println(re);
        }
    }
}

3.OutputStreamWriter

案例

代码示例

package IO_;

import java.io.*;
import java.io.BufferedWriter;

/**
 * @author 孙显圣
 * @version 1.0
 */
public class FileOutputStream02 {
    public static void main(String[] args) throws IOException {
        //使用OutputStreamWriter 将字节流转换成字符流指定utf-8并且执行
        //要写入的url
        String url = "e:\\a.txt";
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(url), "utf-8"));
        //这里使用OutputStreamWriter将字节流转化为字符流并且指定编码，并且使用BufferedWriter来操作这个字符流
        bufferedWriter.write("世界，你好！");
        bufferedWriter.close();
    }
}

15.打印流

PrintStream(字节打印流)

代码实例

package IO_;

import java.io.FileNotFoundException;
import java.io.PrintStream;

/**
 * @author 孙显圣
 * @version 1.0
 */
public class PrintStream_ {
    public static void main(String[] args) throws FileNotFoundException {
        //使用字节打印流在屏幕打印
        PrintStream out = System.out;
        out.println("你好，世界");

        //修改打印位置为文件中的位置
        System.setOut(new PrintStream("e:\\a.txt"));
        System.out.println("dsfasdfs");

    }
}

PrintWrite（字符打印流）

代码实例

package IO_;

import java.io.*;

/**
 * @author 孙显圣
 * @version 1.0
 */
public class PrintWriter_ {
    public static void main(String[] args) throws IOException {

        PrintWriter printWriter = new PrintWriter(System.out); //传入了一个标准输出到屏幕的对象
        PrintWriter printWriter1 = new PrintWriter(new FileWriter("e:\\a.txt")); //传入了一个输入到文件的对象
        
        printWriter1.print("辅导费");
        printWriter1.close();
        printWriter.println("dagasdg");
        printWriter.close();
    }
}

16.IO流总结

1.示意图

字节流

• InputStream
  • FileInputStream(节点流)
  • BufferedInputStream(处理流)（System.in 标准输入 键盘）
  • ObjectInputStream(对象处理流，反序列化)
• OutputStream
  • FileOutputStream(节点流)
  • BufferedOutputStream(处理流)
  • ObjectOutputStream(对象处理流，序列化)
  • PrintStream(字节打印流)（System.out 标准输出 显示器）

字符流

• Reader
  • FileReader(节点流)
  • BufferedReader(处理流)
  • InputStreamReader(转换流)
• Writer
  • FileWriter(节点流)
  • BufferedWriter(处理流)
  • OutputStreamWriter(转换流)
  • PrintWriter(字符打印流)

2.细节说明

1.字节流和字符流处理的数据

1. 字节流：处理单个字节（字符）、字节数组，一般处理二进制文件时使用
2. 字符流：处理单个字符、字符数组、字符串（可写），一般处理文本文件时使用

2.处理流的说明

1. 字符处理流可以读写String类型，并且 可以读一行，字节处理流还是只能读字节或者字节数组
2. 由于节点流的处理局限性太强，所以产生了处理流
3. 处理流使用了修饰器模式，就是使用一个其他节点流的父类型的属性，通过构造方法来接收其他节点流的实例，接受了谁的实例，这个属性调用的方法就是谁的方法，也就是处理哪个节点
4. 处理流可以处理基类的所有节点子类

3.转换流的说明

1. 为了指定文本文件的编码，又想使用字符流，就产生了转换流
2. 转换流可以接收字节流的实例，用于读写和设置编码，然后返回一个转换流，由于这个转换流也是两大基类节点子类，所以一般使用处理流来处理

4.打印流

1. System.out：默认指向标准输出 显示器的打印流，使用System.setOut可以接收输出到文件的PrintStream类
2. PrintWriter:它的构造方法可以接收一个System.out（指向一个标准输出到显示器的实例），也可以接收一个输出到文件的FileWriter

5.常用的流

1. 一般使用处理流Buffered。。。来进行处理
2. 字节处理流，读写字节数组，需要字节数组缓冲区和计数器，循环条件是不等于-1
3. 字符处理流，读写字符串，可以读一行，需要字符串缓冲区，循环条件是不等于null

17.Properties处理配置文件

1.实际需求引出properties配置文件

在开发中操作数据库需要用户名和密码，如果在程序中写死，则一但更换了数据库则需要修改源代码，所以一般将其写在配置文件中，在代码中使用Properties类来读取

2.使用Properties读取配置文件信息

package IO_;

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

/**
 * @author 孙显圣
 * @version 1.0
 */
public class Properties_ {
    public static void main(String[] args) throws IOException {
        //1.创建实例
        Properties properties = new Properties();
        //2.使用流的方式加载配置文件
        properties.load(new FileReader("src\\mysql.properties"));
        //3.以打印流的方式展示所有文件
        properties.list(System.out); //这里传入一个标准打印流 屏幕
        //4.根据key，获取value信息
        String username = properties.getProperty("username");
        String password = properties.getProperty("password");
        System.out.println("username:" + username);
        System.out.println("password:" + password);
    }
}

3.使用Properties创建配置文件并且修改配置文件信息

package IO_;

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

/**
 * @author 孙显圣
 * @version 1.0
 */
public class Properties_1 {
    public static void main(String[] args) throws IOException {
        //使用properties来创建一个文件赋值并且修改
        //1.创建实例
        Properties properties = new Properties();
        //2.为其设置几个值
        properties.setProperty("username","12344");
        properties.setProperty("password","9999");
        //3.将其存储到配置文件中
        properties.store(new FileWriter("src\\mysql1.properties"), "这个是文档开头注释");

        //4.修改配置文件
        properties.setProperty("username","111111");
        properties.store(new FileWriter("src\\mysql1.properties"),null);

    }
}

18.本章作业

作业一

题目

代码

package IO_;

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

/**
 * @author 孙显圣
 * @version 1.0
 */
public class HomeWork01 {
    public static void main(String[] args) throws IOException {
        //创建文件对象
        File file = new File("e:\\mytemp");
        //判断是否是文件夹，如果不是则创建
        if (!file.isDirectory()) {
            file.mkdirs();
        }

        //在e盘刚才创建的目录下创建文件hello.txt,如果存在则输出内容
        File file1 = new File(file, "hello.txt");
        if (file1.exists()) {
            System.out.println("文件已经存在");
            //写入内容
            BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(file1));
            bufferedWriter.write("你好世界");
            //关闭
            bufferedWriter.close();
        }
        file1.createNewFile();


    }
}

作业二

题目

代码

package IO_;

import org.junit.jupiter.api.Test;

import java.io.*;
import java.io.FileInputStream;

/**
 * @author 孙显圣
 * @version 1.0
 */
public class HomeWork02 {
    public static void main(String[] args) throws IOException {
        File file = new File("e:\\mytemp\\hello.txt");
        //创建对象
        BufferedReader bufferedReader = new BufferedReader(new FileReader(file));
        //存储数据
        String re = null;
        int num = 0; //记录行号
        while ((re = bufferedReader.readLine()) != null) { //按行读取
            num ++;
            //加上行号之后重新输出
            System.out.println(num + re);
            //读取出来
        }
        //关闭
        bufferedReader.close();

    }
    //将文件改成gbk码则需要使用转换流
    @Test
    public void test() throws IOException {
        File file = new File("e:\\mytemp\\hello.txt");
        //使用转换流
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(file), "gbk"));
        String re = null;
        while ((re = bufferedReader.readLine()) != null) {
            System.out.println(re);
        }
        //关闭转换流
        bufferedReader.close();
    }
}

作业三

题目

代码

package IO_;

import org.junit.jupiter.api.Test;

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

/**
 * @author 孙显圣
 * @version 1.0
 */
public class HomeWork03 {
    public static void main(String[] args) throws IOException {
        //创建实例
        Properties properties = new Properties();
        //设置值
        properties.setProperty("name", "tom");
        properties.setProperty("age", "5");
        properties.setProperty("color", "red");
        //存储到文件
        properties.store(new FileOutputStream("src\\dog.properties"), null);
    }
}
class Dog_ {
    //读取配置文件并且初始化并输出
    @Test
    public void test() throws IOException {
        Properties properties = new Properties();
        //加载文件
        properties.load(new FileInputStream("src\\dog.properties"));
        //完成初始化
        properties.setProperty("name","jack");
        //输出文件
        properties.list(System.out);
    }
}