Java基础-IO流

S-X-S2024-03-20 9:04

文章目录

1.文件

1.基本介绍
2.常用的文件操作
1.创建文件的相关构造器和方法
代码实例
java 复制代码 
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.获取文件相关信息
代码实例
java 复制代码 
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.目录的删除和文件删除
代码实例
java 复制代码 
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.代码实例
java 复制代码 
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.案例
代码实例
java 复制代码 
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.综合案例---文件拷贝
代码实例
java 复制代码 
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.案例
代码实例
java 复制代码 
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.案例
代码实例
java 复制代码 
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

代码实例
java 复制代码 
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

案例
代码实例
java 复制代码 
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拷贝

代码实例
java 复制代码 
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.字节处理流拷贝（图片/音乐）
代码实例
java 复制代码 
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
类图
案例
java 复制代码 
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
类图
案例
java 复制代码 
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
解决乱码问题
代码实例
java 复制代码 
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
案例
代码示例
java 复制代码 
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(字节打印流)
代码实例
java 复制代码 
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（字符打印流）
代码实例
java 复制代码 
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读取配置文件信息
java 复制代码 
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创建配置文件并且修改配置文件信息
java 复制代码 
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.本章作业

作业一
题目
代码
java 复制代码 
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();


    }
}
作业二
题目
代码
java 复制代码 
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();
    }
}
作业三
题目
代码
java 复制代码 
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);
    }
}
相关推荐
苹果醋31 小时前
React源码02 - 基础知识 React API 一览
java·运维·spring boot·mysql·nginx
Hello.Reader1 小时前
深入解析 Apache APISIX
java·apache
了一li1 小时前
Qt中的QProcess与Boost.Interprocess：实现多进程编程
服务器·数据库·qt
菠萝蚊鸭2 小时前
Dhatim FastExcel 读写 Excel 文件
java·excel·fastexcel
算法小白（真小白）2 小时前
低代码软件搭建自学第二天——构建拖拽功能
python·低代码·pyqt
唐小旭2 小时前
服务器建立-错误:pyenv环境建立后python版本不对
运维·服务器·python
码农君莫笑2 小时前
信管通低代码信息管理系统应用平台
linux·数据库·windows·低代码·c#·.net·visual studio
旭东怪2 小时前
EasyPoi 使用$fe:模板语法生成Word动态行
java·前端·word
007php0072 小时前
Go语言zero项目部署后启动失败问题分析与解决
java·服务器·网络·python·golang·php·ai编程
∝请叫*我简单先生2 小时前
java如何使用poi-tl在word模板里渲染多张图片
java·后端·poi-tl
热门推荐
01Cube-Studio：开源大模型全链路一站式中台02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO05校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站06Docker 夺命连环 15 问07构建高效的广告投放系统：应用架构的设计与实现08基于大语言模型（LLM）的合成数据生成、策展和评估的综述09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10【一文读懂】NTN（非地面网络）技术介绍