Java基础-IO流

文章目录

    • 1.文件
        • 1.基本介绍
        • 2.常用的文件操作
          • 1.创建文件的相关构造器和方法
            • 代码实例
            • 结果
          • 2.获取文件相关信息
            • 代码实例
            • 结果
          • 3.目录的删除和文件删除
            • 代码实例
    • 2.IO流原理及分类
        • IO流原理
        • IO流分类
    • 3.FileInputStream
        • 1.类图
        • 2.代码实例
        • 3.结果
    • 4.FileOutputStream
        • 1.类图
        • 2.案例
          • 代码实例
        • 3.综合案例—文件拷贝
          • 代码实例
    • 5.FileReader
        • 1.类图
        • 2.基本介绍
        • 3.案例
          • 代码实例
    • 6.FileWriter
        • 1.类图
        • 2.基本介绍
        • 3.案例
          • 代码实例
    • 7.节点流与处理流
        • 1.基本介绍
        • 2.节点流和处理流的区别和联系
    • 8.BufferedReader
        • 代码实例
    • 9.BufferedWriter
        • 案例
          • 代码实例
    • 10.Buffered拷贝
        • 代码实例
    • 11.Buffered字节处理流
        • 1.基本介绍
        • 2.字节处理流拷贝（图片/音乐）
          • 代码实例
        • 3.字节处理流和字符处理流比较
    • 12.对象处理流（读写对象）
        • 1.序列化和反序列化
          • 介绍
        • 2.ObjectOutputStream
          • 类图
          • 案例
        • 3.ObjectInputStream
          • 类图
          • 案例
          • 对象处理流使用细节
    • 13.标准输入输出流
        • System.in
        • System.out
        • new Scanner(System.in)
    • 14.转换流（字节流转换成字符流并指定编码）
        • 1.字符流出现乱码引出转换流
        • 2.InputStreamReader
          • 解决乱码问题
          • 代码实例
        • 3.OutputStreamWriter
          • 案例
          • 代码示例
    • 15.打印流
        • PrintStream(字节打印流)
          • 代码实例
        • PrintWrite（字符打印流）
          • 代码实例
    • 16.IO流总结
        • 1.示意图
          • 字节流
          • 字符流
        • 2.细节说明
          • 1.字节流和字符流处理的数据
          • 2.处理流的说明
          • 3.转换流的说明
          • 4.打印流
          • 5.常用的流
    • 17.Properties处理配置文件
        • 1.实际需求引出properties配置文件
        • 2.使用Properties读取配置文件信息
        • 3.使用Properties创建配置文件并且修改配置文件信息
    • 18.本章作业
        • 作业一
          • 题目
          • 代码
        • 作业二
          • 题目
          • 代码
        • 作业三
          • 题目
          • 代码

1.文件

1.基本介绍

image-20240109100451116

2.常用的文件操作
1.创建文件的相关构造器和方法

image-20240109102609262

代码实例
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);}}
}
结果

image-20240109102713854

image-20240109102738460

2.获取文件相关信息

image-20240109103334723

代码实例
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());}
}
结果

image-20240109104144473

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

image-20240109104257404

代码实例
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("文件不存在，已经自动创建");}}
}

image-20240109110040204

2.IO流原理及分类

IO流原理

image-20240109111502976

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

IO流分类

image-20240109111550571

3.FileInputStream

1.类图

image-20240109140211217

2.代码实例
package IO_;import org.junit.jupiter.api.Test;import java.io.FileNotFoundException;
import java.io.IOException;/*** @author 孙显圣* @version 1.0*/
public class FileInputStream {//逐个字节读取@Testpublic 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.结果

image-20240109140654781

4.FileOutputStream

1.类图

image-20240109140811361

2.案例

image-20240109141528777

代码实例
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.综合案例—文件拷贝

image-20240109145913432

代码实例
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.类图

image-20240109150140412

2.基本介绍

image-20240109150845843

3.案例

image-20240109153041200

代码实例
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);}}}//按照字符数组读取@Testpublic 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.类图

image-20240109150519869

2.基本介绍

image-20240109150922491

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

image-20240109155725520

7.节点流与处理流

1.基本介绍

image-20240109161436152

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

image-20240109161417762

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

image-20240109161049346

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)); //由于要对文件进行操作，所以传入FileReaderwhile ((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

案例

image-20240109184303414

代码实例
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拷贝

image-20240109184638373

代码实例
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.基本介绍

image-20240109191214549

image-20240109191438743

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

image-20240109195054481

2.ObjectOutputStream
类图

image-20240109195807417

案例
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); // IntegerobjectOutputStream.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;}@Overridepublic String toString() {return "Dog{" +"name='" + name + '\'' +", age=" + age +'}';}
}
3.ObjectInputStream
类图

image-20240109195829940

案例
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,为了提高版本的兼容性image-20240110101629818
  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.转换流（字节流转换成字符流并指定编码）

image-20240110111826413

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

image-20240110105623912

解决乱码问题
代码实例
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);}//字节流转换成字符流@Testpublic 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);}}
}

image-20240110111714136

3.OutputStreamWriter

image-20240110105857664

案例

image-20240110111940615

代码示例
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并且执行//要写入的urlString url = "e:\\a.txt";BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(url), "utf-8"));//这里使用OutputStreamWriter将字节流转化为字符流并且指定编码，并且使用BufferedWriter来操作这个字符流bufferedWriter.write("世界，你好！");bufferedWriter.close();}
}

15.打印流

PrintStream(字节打印流)

image-20240110132611848

代码实例
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（字符打印流）

image-20240110132737733

代码实例
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配置文件

image-20240110151408363

在开发中操作数据库需要用户名和密码，如果在程序中写死，则一但更换了数据库则需要修改源代码，所以一般将其写在配置文件中，在代码中使用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.本章作业

作业一
题目

image-20240110160323482

代码
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();}
}
作业二
题目

image-20240110161635395

代码
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码则需要使用转换流@Testpublic 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();}
}
作业三
题目

image-20240110164911073

代码
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_ {//读取配置文件并且初始化并输出@Testpublic void test() throws IOException {Properties properties = new Properties();//加载文件properties.load(new FileInputStream("src\\dog.properties"));//完成初始化properties.setProperty("name","jack");//输出文件properties.list(System.out);}
}

image-20240110190729539

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/756256.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

【Flink】Flink 中的时间和窗口之窗口其他API的使用

【Flink】Flink 中的时间和窗口之窗口其他API的使用

1. 窗口的其他API简介 对于一个窗口算子而言，窗口分配器和窗口函数是必不可少的。除此之外，Flink 还提供了其他一些可选的 API，可以更加灵活地控制窗口行为。 1.1 触发器（Trigger） 触发器主要是用来控制窗口什么时候…
阅读更多...
【大模型系列】统一图文理解与生成(BLIP/BLIPv2/InstructBLIP)

【大模型系列】统一图文理解与生成(BLIP/BLIPv2/InstructBLIP)

文章目录 1 BLIP(2022, Salesforce Research)1.1 简介1.2 数据角度1.3 模型角度1.4 BLIP预训练的目标 2 BLIP2(ICML2023, Salesforce)2.1 简介2.2 模型架构2.3 训练细节 3 InstructBLIP(2023, Salesforce)3.1 指令微调技术(Instruction-tuning)3.2 数据集准备3.3 Instruction-a…
阅读更多...
docker入门（二）—— docker三大概念（镜像、容器、仓库）

docker入门（二）—— docker三大概念（镜像、容器、仓库）

docker 的三大必要概念 docker 的三大必要概念——镜像、容器、仓库 docker 架构图 镜像（image）：模版。（web项目：1、环境 2、配置变量 3、上线项目 4、配置项目需要的静态文件）打包成镜像 docker 镜像&a…
阅读更多...
代码随想录阅读笔记-哈希表【两个数组的交集】

代码随想录阅读笔记-哈希表【两个数组的交集】

题目 给定两个数组&#xff0c;编写一个函数来计算它们的交集。 说明&#xff1a; 输出结果中的每个元素一定是唯一的。 我们可以不考虑输出结果的顺序。 提示&#xff1a; 1 < nums1.length, nums2.length < 10000 < nums1[i], nums2[i] < 1000 思路 交集&…
阅读更多...
【源码阅读】EVMⅢ

【源码阅读】EVMⅢ

参考[link](https://blog.csdn.net/weixin_43563956/article/details/127725385 大致流程如下&#xff1a; 编写合约 > 生成abi > 解析abi得出指令集 > 指令通过opcode来映射成操作码集 > 生成一个operation 以太坊虚拟机的工作流程&#xff1a; 由solidity语言编…
阅读更多...
鸿蒙实战开发：【FaultLoggerd组件】讲解

鸿蒙实战开发：【FaultLoggerd组件】讲解

简介 Faultloggerd部件是OpenHarmony中C/C运行时崩溃临时日志的生成及管理模块。面向基于 Rust 开发的部件&#xff0c;Faultloggerd 提供了Rust Panic故障日志生成能力。系统开发者可以在预设的路径下找到故障日志&#xff0c;定位相关问题。 架构 Native InnerKits 接口 Si…
阅读更多...
Linux操作系统——多线程

Linux操作系统——多线程

1.线程特性 1.1线程优点 创建一个新线程的代价要比创建一个新进程小得多与进程之间的切换相比&#xff0c;线程之间的切换需要操作系统做的工作要少很多线程占用的资源要比进程少很多能充分利用多处理器的可并行数量在等待慢速I/O操作结束的同时&#xff0c;程序可执行其他的计…
阅读更多...
《1w实盘and大盘基金预测 day7》

《1w实盘and大盘基金预测 day7》

昨日预测有点差劲&#xff0c;最低点也相差五个点。 打分C 公众号&#xff1a;JavaHelmet 昨天预测&#xff1a; 3052-3062-3076-3115 3067是趋势线&#xff0c;有回踩需求 5-30-60分钟级别顶钝 大盘冲到标红的点位3115或者3100就需注意。不要随意追高&#xff08;最高309…
阅读更多...
备战蓝桥杯---牛客寒假训练营2VP

备战蓝桥杯---牛客寒假训练营2VP

题挺好的&#xff0c;收获了许多 1.暴力枚举&#xff08;许多巧妙地处理细节方法&#xff09; n是1--9,于是我们可以直接暴力&#xff0c;对于1注意特判开头0但N&#xff01;1&#xff0c;对于情报4&#xff0c;我们可以把a,b,c,d的所有取值枚举一遍&#xff0c;那么如何判断有…
阅读更多...
ModbusTCP转Profinet网关高低字节交换切换

ModbusTCP转Profinet网关高低字节交换切换

背景&#xff1a;在现场设备与设备通迅之间通常涉及到从一种字节序&#xff08;大端或小端&#xff09;转换到另一种字节序。大端字节序是指高位字节存储在高地址处&#xff0c;而小端字节序是指低位字节存储在低地址处。在不动原有程序而又不想或不能添加程序下可选用ModbusTC…
阅读更多...
OCP NVME SSD规范解读-13.Self-test自检要求

OCP NVME SSD规范解读-13.Self-test自检要求

4.10节Device Self-test Requirements详细描述了数据中心NVMe SSD自检的要求&#xff0c;这一部分规范了设备自身进行各种健康检查和故障检测的过程。自检对于确保SSD的正常运行和提前预防潜在故障至关重要。 在进行设备自检时&#xff0c;设备应当确保不对用户数据造成破坏&am…
阅读更多...
【人工智能】Gitee AI 天数智芯有奖体验开源AI模型，一定能有所收货，快来体验吧

【人工智能】Gitee AI 天数智芯有奖体验开源AI模型，一定能有所收货，快来体验吧

大家好&#xff0c;我是全栈小5&#xff0c;欢迎阅读小5的系列文章。 这是《人工智能》系列文章&#xff0c;每篇文章将以博主理解的角度展开讲解。 目录 前言两大赛道天数智芯1.模型地址2.天数智芯专区3.选择模型4.模型详情页5.部署模型6.成功部署7.执行例子8.移除模型 千模盲…
阅读更多...
03python注释与输入函数

03python注释与输入函数

Python 注释的作用： 注释可用于解释 Python 代码。 注释可用于提高代码的可读性。 在测试代码时，可以使用注释来阻止执行。 注释可以放在一行的末尾，Python 将忽略该行的其余部分： 实例1 print("Hello, World!") #打印输出Hello，World print（9-3） #输出9…
阅读更多...
【mybatis】objectwrapper解读

【mybatis】objectwrapper解读

简介 在 MyBatis 中&#xff0c;ObjectWrapper 是一个关键的接口&#xff0c;用于详细封装了对象的属性信息。ObjectWrapper 主要用于内部操作&#xff0c;它抽象了对象的属性操作&#xff0c;使得 MyBatis 能够统一处理原生类型、Bean 对象以及 Map 集合等。 类图展示 主要功…
阅读更多...
Vue组件封装方案对比——v-if方式与内置component方式

Vue组件封装方案对比——v-if方式与内置component方式

近期在准备搭建一个通用组件库&#xff0c;而公司现有的各个系统也已有自己的组件库只是没抽离出来&#xff0c;但是目前有两套不同的组件封装方案&#xff0c;所以对于方案的选择比较困惑&#xff0c;于是对两种方式进行了对比&#xff0c;结合网上找到的一些开源组件库进行分…
阅读更多...
抖音店铺规划运营管理计划数据分析工作表

抖音店铺规划运营管理计划数据分析工作表

【干货资料持续更新&#xff0c;以防走丢】 抖音店铺规划运营管理计划数据分析表 部分资料预览 资料部分是网络整理&#xff0c;仅供学习参考。 抖音小店运营规划工作表格&#xff08;完整资料包含以下内容&#xff09; 目录 1. 抖店运营管理决策表&#xff1a;该表格用于记…
阅读更多...
三维指静脉生物识别成像设备设计和多视图验证研究

三维指静脉生物识别成像设备设计和多视图验证研究

文章目录 三维指静脉生物识别成像设备设计和多视图验证研究总结摘要介绍多视角指静脉识别模型结构内容特征编码Transformer(CFET)主导特征选择模块(DFSM) 实验和结果数据集实施细节视角研究池化层的作用消融实验和SOTA方法比较 论文: Study of 3D Finger Vein Biometrics on I…
阅读更多...
Linux——进程通信（三）命名管道

Linux——进程通信（三）命名管道

前言 我们在之前学习了匿名管道与匿名管道的应用——进程池&#xff0c;但是匿名管道的通信&#xff0c;需要有血缘关系的进程&#xff08;通过fork创建的进程们&#xff09;&#xff0c;如果我想让两个毫不相干的进程进行通信&#xff0c;可以采样命名管道的方式&#xff08;…
阅读更多...
Go语言中的锁与管道的运用

Go语言中的锁与管道的运用

目录 1.前言 2.锁解决方案 3.管道解决方案 4.总结 1.前言 在写H5小游戏的时候&#xff0c;由于需要对多个WebSocket连接进行增、删、查的管理和对已经建立连接的WebSocket通过服务端进行游戏数据交换的需求。于是定义了一个全局的map集合进行连接的管理&#xff0c;让所有…
阅读更多...
80后深圳设计师原创设计 妙解中小学生午休难题

80后深圳设计师原创设计 妙解中小学生午休难题

3月17日至21日&#xff0c;深圳国际智能家居博览会在宝安国际会展中心举办。智慧校园展区成为焦点&#xff0c;吸引了众多目光。智荟康科技展出的午休课桌椅产品&#xff0c;为解决中小学生“趴睡”问题而研发&#xff0c;创新实用&#xff0c;在智慧校园展区中备受好评。 &…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023