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 {

    //逐个字节读取
    @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.结果

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


    //按照字符数组读取
    @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.类图

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

案例

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); // 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
类图

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);
    }
    //字节流转换成字符流
    @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);
        }
    }
}

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并且执行
        //要写入的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(字节打印流)

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码则需要使用转换流
    @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();
    }
}

作业三
题目

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_ {
    //读取配置文件并且初始化并输出
    @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);
    }
}

image-20240110190729539

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

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

全国农产品价格分析预测可视化系统设计与实现

全国农产品价格分析预测可视化系统设计与实现 【摘要】在当今信息化社会,数据的可视化已成为决策和分析的重要工具。尤其是在农业领域,了解和预测农产品价格趋势对于农民、政府和相关企业都至关重要。为了满足这一需求,设计并实现了全国农产…

Apache SeaTunnel MongoDB CDC 使用指南

随着数据驱动决策的重要性日益凸显,实时数据处理成为企业竞争力的关键。SeaTunnel MongoDB CDC(Change Data Capture) 源连接器的推出,为开发者提供了一个高效、灵活的工具,以实现对 MongoDB 数据库变更的实时捕获和处理。 本文将深入探讨该连…

3月19日做题

[NPUCTF2020]验证🐎 if (first && second && first.length second.length && first!second && md5(firstkeys[0]) md5(secondkeys[0]))用数组绕过first1&second[1] 这里正则规律过滤位(Math.) (?:Math(?:\.\w)?) : 匹配 …

详解命令docker run -d --name container_name -e TZ=Asia/Shanghai your_image

docker run 是Docker的主要命令,用于从镜像启动一个新的容器。下面详细解释并举例说明 -d, --name, -e TZ 参数的用法: -d 或 --detach: 这个标志告诉Docker以守护进程(后台)模式运行容器。这意味着当你执行 docker ru…

②免费AI软件开发工具测评:通义灵码 VS 码上飞

前言 我又双叒叕来测评了!上次给大家带来的是iFlyCode和CodeFlying两款产品的测评,受到了大家的一致好评~ 今天咱就继续来聊聊,这次我们选的的对象是通义灵码和码上飞,从名字上也能看到出来这两款产品一定是跟软件开发有关系的&…

IPD集成产品开发:塑造企业未来竞争力的关键

随着市场竞争的日益激烈,企业对产品开发的要求也越来越高。如何在快速变化的市场环境中,既保证产品的批量生产效率,又满足客户的个性化需求,成为了企业面临的重要挑战。IPD(集成产品开发)模式,作…

Linux 常用操作命令大全

目录 一、命令大集合 1.1 whereis 1.2 which 1.3 sudo 1.4 grep 1.5 free 1.6 top 动态显示进程的状态 1.7 ps 静态显示进程信息 1.8 df 1.9 iostat 看IO性能状态 1.10 yum安装插件命令 1.11 rpm 1.12 scp远程拷贝 1.13 uname 二、linux网络命令 2.1 centos7 防火…

理论学习:with torch.no_grad()

如果不加上“with torch.no_grad():”,模型参数会发生改变吗? 如果不使用with torch.no_grad():,在进行模型推理(即计算outputs_cls net(inputs[batch_size//2:])这一步)时,模型参数不会发生改变&#xf…

#Ubuntu(修改root信息)

(一)发行版:Ubuntu16.04.7 (二)记录: (1)命令行终端: a.右键,open terminal b.快捷键 ctrlaltt (2)进行root修改 sudo passwd &a…

Gradle v8.5 笔记 - 从入门到进阶(基于 Kotlin DSL)

目录 一、前置说明 二、Gradle 启动! 2.1、安装 2.2、初始化项目 2.3、gradle 项目目录介绍 2.4、Gradle 项目下载慢?(万能解决办法) 2.5、Gradle 常用命令 2.6、项目构建流程 2.7、设置文件(settings.gradle.…

linux 安装常用软件

文件传输工具 sudo yum install –y lrzsz vim编辑器 sudo yum install -y vimDNS 查询 sudo yum install bind-utils用法可以参考文章 《掌握 DNS 查询技巧,dig 命令基本用法》 net-tools包 yum install net-tools -y简单用法: # 查看端口占用情况…

2024流星全自动网页生成系统重构版源码

2024流星全自动网页生成系统重构版源码 源码介绍 流星全自动网页生成系统重构版源码分享,所有模板经过精心审核与修改,完美兼容小屏手机大屏手机,以及各种平板端、电脑端和360浏览器、谷歌浏览器、火狐浏览器等等各大浏览器显示。 为用户使…

微信支付宝--充ChatGPTPLUS/openAI key

ChatGPT是人工智能技术驱动的自然语言处理工具,它能够基于在预训练阶段所见的模式和统计规律,来生成回答,还能根据聊天的上下文进行互动,真正像人类一样来聊天交流,甚至能完成撰写论文、邮件、脚本、文案、翻译、代码等…

鸿蒙Harmony应用开发—ArkTS声明式开发(容器组件:Refresh)

可以进行页面下拉操作并显示刷新动效的容器组件。 说明: 该组件从API Version 8开始支持。后续版本如有新增内容,则采用上角标单独标记该内容的起始版本。 子组件 支持单个子组件。 从API version 11开始,Refresh子组件会跟随手势下拉而下移…

恒驰喜讯 | 亮相华为中国合作伙伴大会2024,荣膺最佳服务一致性奖等3大奖项

3月14日至15日,华为中国合作伙伴大会2024在深圳隆重召开。大会以“因聚而生,数智有为”为主题,面向数智化转型的浪潮,华为携手伙伴共同探讨如何通过强化“伙伴华为”体系,帮助客户抓住数智化转型的巨大机遇&#xff0c…

QT信号与槽实现方式

1、第一种实现方式 在QT开发工具UI界面先拖入按钮,然后鼠标右键拖入按钮,点击选中槽,在页面选着需要的信号,然后OK,随即将会跳转到类的.cpp文件,(这种UI代码结合的方式,会自动去绑定…

医药工厂5G智能制造数字孪生可视化平台,推进医药企业数字化转型

医药工厂5G智能制造数字孪生可视化平台,推进医药企业数字化转型。随着科技的不断发展,数字化转型已成为医药企业不可或缺的一部分。5G智能制造医药工厂数字孪生可视化平台作为数字化转型的重要工具,正在逐步改变医药企业的生产方式和管理模式…

UDF提权

目录 一、UDF概述 二、提权条件 三、漏洞复现 (一) 信息收集 1. Nmap信息收集 1.1、查看当前IP地址 1.2、扫描当前网段,找出目标机器 1.3、快速扫描目标机全端口 2. dirb目录扫描 3. 第一个flag 3.1、目录遍历漏洞 3.2、flag 4. 敏感信息利用 (二) 漏…

智能合约 之 ERC-20介绍

什么是ERC20 ERC20全称为Ethereum Request for Comment 20,是一种智能合约标准,用于以太坊网络上的代币发行 姊妹篇 - 如何部署ERC20 ERC20的应用场景 代币化资产,例如:USDT 是一种以美元为背书的ERC20代币,每个USDT代…
最新文章