JavaSE：IO框架

最新推荐文章于 2024-06-12 11:59:04 发布
最新推荐文章于 2024-06-12 11:59:04 发布
阅读量116 收藏 1
点赞数
分类专栏： # JavaSE 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_59463944/article/details/124899676
版权

JavaSE：IO框架

文章目录

前言

即使再小的帆也能远航

一、IO框架课程目标

  • 流的概念
  • 流的分类
  • 字节流
  • 编码方式
  • 字符流
  • File类

二、什么是流

  • 概念：
    • 内存与存储设备（硬盘）之间传输数据的通道

三、流的分类

  • 按流的方向【重点】：
    • 输入流（input）：将<存储设备>中的内容读入到<内存>中
    • 输出流（output）：将<内存>中的内容写入到<存储设备>中
      文件----输入流---->程序
  • 按存储单位：
    • 字节流：以字节为单位，可以读写所有数据
    • 字符流：以字符为单位，只能读写文本数据
  • 按功能：
    • 节点流：具有实际传输数据的读写功能
    • 过滤流：在节点流的基础之上增强功能

四、字节流

1. 字节流的父类（抽象类）：

  • InputStream：字节输入流
    • public int read(){}
    • public int read(byte[] b){}
    • public int read(byte[] b,int off,int len){}
  • OutputStream：字节输出流
    • public int write(){}
    • public int write(byte[] b){}
    • public int write(byte[] b,int off,int len){}

2. 文件字节流（字节流抽象类的子类）：

  • FileInputStream：
    • public void read(byte[] b) //从流中读取多个字节，将读到内容存入b数组，返回实际读到的字节数；如果达到文件的尾部，则返回-1
  • FileOutputStream：
    • public void write(byte[] b) //一次写多个字节，将b数组中所有字节，写入输出流
import java.io.FileInputStream;

/**
 * FileInputStream的使用
 * 文件字节输入流
 */
public class Demo01 {
    public static void main(String[] args) throws Exception{
        //1. 创建
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        //2. 读取文件
        //2.1 单个字节读取
//        int data = 0;
//        while((data = fis.read())!=-1){
//            System.out.println((char) data);
//        }
//        System.out.println("========");
        //2.2 一次读取多个字节
//        byte[] buf = new byte[3];
//        int count = fis.read(buf);
//        System.out.println(new String(buf));
//        System.out.println(count);
//        int count2 = fis.read(buf);
//        System.out.println(new String(buf));
//        System.out.println(count2);
//        int count3 = fis.read(buf);
//        System.out.println(new String(buf));
//        System.out.println(count3);
//        int count4 = fis.read(buf);
//        System.out.println(new String(buf));
//        System.out.println(count4);
        byte[] buf = new byte[3];
        int count = 0;
        while((count=fis.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
        //3. 关闭
        fis.close();
        System.out.println("执行关闭");

    }
}


import java.io.FileOutputStream;

/**
 * FileOutputStream文件字节输出流的使用
 */
public class Demo02 {
    public static void main(String[] args) throws Exception{
        //1. 创建
        FileOutputStream fos = new FileOutputStream("d:\\bbb.txt",true);
        //append添加方法 有true就接着往下写，没有true就执行覆盖添加
        //2. 写入文件
        //2.1 单个单个字节写入
        fos.write(97);
        fos.write('b');
        fos.write('c');
        fos.write('\n');
        //2.2 多个字节一次写入
        String string = "helloworld";
        fos.write(string.getBytes());
        fos.write('\n');
        //3. 关闭
        fos.close();
        System.out.println("执行完毕");
    }
}

3. 字节流复制文件

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

/**
 * 使用文件字节流实现文件的复制
 * （复制一次等于输入一次加输出一次）
 */
public class Demo03 {
    public static void main(String[] args) throws Exception{
        //1. 创建流
        //1.1 文件字节输入流
        FileInputStream fis = new FileInputStream("d:\\001.png");
        //1.2 文件字节输出流
        FileOutputStream fos = new FileOutputStream("d:\\002.jpg");
        //2. 一边读，一边写
        byte[] buf = new byte[1024];
        int count = 0;
        while((count=fis.read(buf))!=-1){
            fos.write(buf,0,count);
        }
        //3. 关闭
        fis.close();
        fos.close();
        System.out.println("复制完毕");
    }
}

4. 字节缓冲流

  • 缓冲流：BufferedInputStream/BufferedOutputStream
    • 提高IO效率，减少访问磁盘的次数
    • 数据存储在缓冲区中，flush是将缓存区的内容写入文件中，也可以直接close
  • BufferedInputStream：字节输入缓冲流
  • BufferedOutputStream；字节输出缓冲流
import java.io.BufferedInputStream;
import java.io.FileInputStream;

/**
 * BufferedInputStream使用字节缓冲流读取
 */
public class Demo04 {
    public static void main(String[] args) throws Exception{
        //1. 创建
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);
        //2. 读取
        //先读取到数组，再从数组里读取单个字节来输出
//        int data = 0;
//        while ((data = bis.read())!=-1){
//            System.out.print((char)data);
//        }
        //
        byte[] buf = new byte[1024];
        int count = 0;
        while ((count = bis.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
        //3. 关闭
        bis.close();
        //关闭bis默认fis一起关闭
    }
}


import java.io.BufferedOutputStream;
import java.io.FileOutputStream;

/**
 * BufferedOutputStream使用字节缓冲流写入文件
 */
public class Demo05 {
    public static void main(String[] args) throws Exception{
        //1. 创建
        FileOutputStream fos = new FileOutputStream("d:\\buffer.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //2. 写入文件
        for (int i = 0; i < 10; i++) {
            bos.write("helloworld\r\n".getBytes()); //先写入了8k的缓冲区内
            bos.flush();//刷新硬盘
        }
        //3. 关闭（内部默认一起调用flush方法）
        bos.close();
    }
}

5. 对象流

  • 对象流：ObjectInputStream/ObjectOutputStream
    • 增强了缓冲区功能
    • 增强了读写8种基本数据类型和字符串功能
    • 增强了读写对象的功能
      • readObject() 从流中读取一个对象
      • writeObject(Object obj) 向流中写入一个对象
      • 使用流传输对象的过程称为序列化、反序列化
        • 从内存中写入文件到硬盘中的过程称之为序列化，反之为反序列化

1. 序列化

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

/**
 * 使用ObjectOutputStream实现对象的序列化（写入文件）
 * 要求：序列化类名必须要实现Serializable接口
 */
public class Demo06 {
    public static void main(String[] args) throws Exception{
        //1. 创建
        FileOutputStream fos = new FileOutputStream("d:\\stu.bin");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        //2. 序列化（写入操作）
        Student zhangsan = new Student("张三",20);
        oos.writeObject(zhangsan);
        //3. 关闭
        oos.close();
        System.out.println("序列化完毕");
    }
}

import java.io.Serializable;

public class Student implements Serializable {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

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

2. 反序列化

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

/**
 * 使用ObjectInputStream实现反序列化（读取重构成对象）
 */
public class Demo07 {
    public static void main(String[] args) throws Exception{
        //1. 创建
        FileInputStream fis = new FileInputStream("d:\\stu.bin");
        ObjectInputStream ois = new ObjectInputStream(fis);
        //2. 读取文件（反序列化）
        Student s = (Student) ois.readObject();
        //3. 关闭
        ois.close();
        System.out.println("执行完毕");
        System.out.println(s.toString());
    }
}

3. 序列化和反序列化 注意事项

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;

/**
 * 使用ObjectOutputStream实现对象的序列化（写入文件）
 * 要求：
 * (1)序列化类名必须要实现Serializable接口
 * (2)序列化类中的对象属性（内部类）要求也要实现Serializable接口
 * (3)序列化版本号ID，即serialVersionUID，保证序列化的类和反序列化的类是同一个类
 * (4)使用transient（瞬间的）修饰属性，这个属性就不能被序列化
 * (5)静态属性不能被序列化
 * (6)序列化多个对象，可以借助集合实现
 */
public class Demo06 {
    public static void main(String[] args) throws Exception{
        //1. 创建
        FileOutputStream fos = new FileOutputStream("d:\\stu.bin");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        //2. 序列化（写入操作）
        Student zhangsan = new Student("张三",20);
        Student lisi = new Student("李四",22);
//        oos.writeObject(zhangsan);
//        oos.writeObject(lisi);
        ArrayList<Student> list = new ArrayList<>();
        list.add(zhangsan);
        list.add(lisi);
        oos.writeObject(list);
        //3. 关闭
        oos.close();
        System.out.println("序列化完毕");
    }
}

import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.util.ArrayList;

/**
 * 使用ObjectInputStream实现反序列化（读取重构成对象）
 */
public class Demo07 {
    public static void main(String[] args) throws Exception{
        //1. 创建
        FileInputStream fis = new FileInputStream("d:\\stu.bin");
        ObjectInputStream ois = new ObjectInputStream(fis);
        //2. 读取文件（反序列化）
//        Student s = (Student) ois.readObject();
//        Student s2 = (Student) ois.readObject();
        ArrayList<Student> list = (ArrayList<Student>) ois.readObject();
        //3. 关闭
        ois.close();
        System.out.println("执行完毕");
//        System.out.println(s.toString());
//        System.out.println(s2.toString());
        System.out.println(list.toString());

    }
}

import java.io.Serializable;

public class Student implements Serializable {
    /**
     * serialVersionUID:序列号版本ID
     */
    private static final long serialVersionUID = 100L;

    private String name;
    private transient int age;
    public static String country = "中国";

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

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

五、常见字符编码

  • ISO-8859-1 收录除ASCII外，还包括西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号

  • UTF-8 针对Unicode码表的可变长度字符编码

  • GB2312 简体中文，95年前

  • GBK 简体中文、扩充，95年后

  • BIG5 台湾，繁体中文

    当编码方式和解码方式不一致时，会出现乱码

六、字符流

1. 字符流的父类（抽象类）

  • Reader：字符输入流
  • Writer：字符输出流
import java.io.FileInputStream;

/**
 * 字符流：
 * 一个汉字是三个字节
 */
public class Demo01 {
    public static void main(String[] args) throws Exception{
        //1. 创建
        FileInputStream fis = new FileInputStream("d:\\hello.txt");
        //2. 读取文件
        //2.1 单个字节读取
//        int data = 0;
//        while((data = fis.read())!=-1){       //12个字节（4个汉字）
//            System.out.println((char) data);
//        }
//        System.out.println("========");
        //2.2 一次读取多个字节
        byte[] buf = new byte[3];
        int count = 0;
        while((count=fis.read(buf))!=-1){
            System.out.print(new String(buf,0,count));
        }
        //3. 关闭
        fis.close();
        System.out.println("\n执行关闭");

    }
}

2. 文件字符流

  • FileReader：
    public int read(char[] c) //从流中读取多个字符，将读到内容存入c数组，返回实际读到的字符数；如果达到文件的尾部，则返回-1
  • FileWriter：
    • public void write(String str) //一次写多个字符，将b数组中所有字符，写入输出流
import java.io.FileReader;

/**
 * 使用FileReader读取文件
 */
public class Demo02 {
    public static void main(String[] args) throws Exception{
        //1. 创建
        FileReader fr = new FileReader("d:\\hello.txt");
        //2. 读取
        //2.1 单个字符读取
//        int data = 0;
//        while((data=fr.read())!=-1){    //读取一个字符
//            System.out.print((char)data);
//        }
        //2.2 多个字符读取
        char[] buf = new char[1024];
        int count = 0;
        while((count = fr.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
        //3. 关闭
        fr.close();
    }
}

import java.io.FileWriter;

/**
 * 使用FileWriter写入文件
 */
public class Demo03 {
    public static void main(String[] args) throws Exception{
        //1. 创建
        FileWriter fw= new FileWriter("d:\\write.txt");
        //2. 写入
        for (int i = 0; i < 10; i++) {
            fw.write("java是世界上最好的语言\r\n");
            fw.flush();
        }
        //3. 关闭
        fw.close();
        System.out.println("执行关闭");
    }
}

3. 字符流复制文件

import java.io.FileReader;
import java.io.FileWriter;

/**
 * 使用FileReader和FileWriter复制文本文件，不能复制图片或二进制文件
 * 使用字节流可以复制任意文件
 */
public class Demo04 {
    public static void main(String[] args) throws Exception{
        //1. 创建
        FileReader fr = new FileReader("d:\\write.txt");
        FileWriter fw = new FileWriter("d:\\write2.txt");
        //2. 读写
        int data = 0;
        while((data=fr.read())!=-1){
            fw.write(data);
            fw.flush();
        }
        //3. 关闭
        fr.close();
        fw.close();
        System.out.println("复制完毕");
    }
}

4. 字符缓冲流

  • 缓冲流：BufferedReader/BufferedWriter
    • 高效读写
    • 支持输入换行符
    • 可一次写一行、读一行
import java.io.BufferedReader;
import java.io.FileReader;

/**
 * 使用字符缓冲流读取文件
 * BufferedReader
 */
public class Demo05 {
    public static void main(String[] args) throws Exception{
        //1. 创建
        FileReader fr = new FileReader("d:\\write.txt");
        BufferedReader br = new BufferedReader(fr);
        //2. 读取
        //2.1 单个单个读
//        char[] buf = new char[1024];
//        int count = 0;
//        while((count=br.read(buf))!=-1){
//            System.out.print(new String(buf,0,count));
//        }
        //2.2 一行一行读
        String line = null;
        while((line=br.readLine())!=null){
            System.out.println(line);
        }
        //3. 关闭
        br.close();
    }
}


import java.io.BufferedWriter;
import java.io.FileWriter;

/**
 * BufferedWriter的使用
 */
public class Demo06 {
    public static void main(String[] args) throws Exception{
        //1. 创建
        FileWriter fw = new FileWriter("d:\\buffer.txt");
        BufferedWriter bw = new BufferedWriter(fw);
        //2. 写入
        for (int i = 0; i < 10; i++) {
            bw.write("好好学习，天天向上");
            bw.newLine();   //写入一个换行符 windows \r\n  Linux \n
            bw.flush();
        }
        //3. 关闭
        bw.close();
        System.out.println("执行完毕");
    }
}

5. 打印流

  • PrintWriter：
    • 封装了print() / println() 方法，支持写入后换行
    • 支持数据原样打印
/**
 * PrintWriter的使用
 */
public class Demo07 {
    public static void main(String[] args) throws Exception{
        //1. 创建
        PrintWriter pw = new PrintWriter("d:\\print.txt");
        //2. 打印
        pw.println(97);
        pw.println(true);
        pw.println(3.14);
        pw.println('a');
        pw.println("无语");
        //3. 关闭
        pw.close();
        System.out.println("执行完毕");
    }
}

6. 转换流

  • 桥转换流：InputStreamReader / OutputStreamReader
    • 可将字节流转换为字符流
    • 可设置字符的编码方式
  • InputStreamReader：字节流（硬盘）通向字符流（内存）的桥梁
  • OutputStreamReader：字符流（内存）通向字节流（硬盘）的桥梁
import java.io.FileInputStream;
import java.io.InputStreamReader;

/**
 * 使用InputStreamReader读取文件，指定使用的编码
 */
public class Demo08 {
    public static void main(String[] args) throws Exception{
        //1. 创建
        FileInputStream fis = new FileInputStream("d:\\write.txt");
        InputStreamReader isr = new InputStreamReader(fis,"utf-8"); 
        //必须保证文件的编码和指定的编码是一致的，否则会出现乱码
        //2. 读取
        int data = 0;
        while((data=isr.read())!=-1){
            System.out.print((char)data);
        }
        //3. 关闭
        isr.close();
    }
}


import java.io.FileOutputStream;
import java.io.OutputStreamWriter;

/**
 * 使用OutputStreamWriter写入文件，使用指定的编码
 */
public class Demo09 {
    public static void main(String[] args) throws Exception{
        //1. 创建
        FileOutputStream fos = new FileOutputStream("d:\\info.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos,"utf-8");
        //2. 写入
        for (int i = 0; i < 10; i++) {
            osw.write("我爱北京，我爱故乡！\r\n");
            osw.flush();
        }
        //3. 关闭
        osw.close();
        System.out.println("执行成功");
    }
}

七、File类

1.File类

  • 概念：代表物理盘符中的一个文件或者文件夹
  • 方法：
    • createNewFile() //创建一个新文件
    • mkdir() //创建一个新目录
    • delete() //删除文件或空目录
    • exists() //判断File对象所代表的对象是否存在
    • getAbsolutePath() //获取文件的绝对路径
    • getName() //获取文件的绝对路径
    • getParent() //获取文件/目录所在的目录 (父目)
    • isDirectory() //是否是目录
    • isFile() //是否是文件
    • length() //获取文件的长度
    • listFiles() //列出目录中的所有内容
    • renameTo() //修改文件名为

2. 文件操作

import java.io.File;
import java.util.Date;

/**
 * File类的使用
 * (1)分隔符
 * (2)文件操作
 * (3)文件夹操作
 */
public class Demo01 {
    public static void main(String[] args) throws Exception {
//        separator();
        fileOperator();
    }

    //(1)分隔符
    public static void separator(){
        System.out.println("路径分隔符："+ File.pathSeparator);
        System.out.println("名称分隔符："+File.separator);
    }

    //
    public static void fileOperator() throws Exception{
        //1. 创建文件
        File file = new File("d:\\file.txt");
//        File file = new File("file.txt");
        //System.out.println(file);
        if(!file.exists()) {
            boolean b = file.createNewFile();
            System.out.println("创建结果：" + b);
        }
        //2. 删除文件
        //2.1 直接删除
//        System.out.println("删除结果："+file.delete());
        //2.2 使用JVM退出时删除
//        file.deleteOnExit();
//        Thread.sleep(5000); //休眠（等待）5秒钟
        //3. 获取文件信息
        System.out.println("获取文件的绝对路径："+file.getAbsolutePath());
        System.out.println("获取路径："+file.getPath());
        System.out.println("获取文件名称"+file.getName());
        System.out.println("获取父目录："+file.getParent());
        System.out.println("获取文件长度："+file.length());
        System.out.println("文件创建时间："+new Date(file.lastModified()).toLocaleString());
        //4. 判断
        System.out.println("是否可写："+file.canWrite());    //属性-->只读
        System.out.println("是否是文件："+file.isFile());     
        System.out.println("是否隐藏："+file.isHidden());    //属性-->隐藏
    }
}

3. 文件夹

import java.io.File;
import java.util.Date;

/**
 * File类的使用
 * (1)分隔符
 * (2)文件操作
 * (3)文件夹操作
 */
public class Demo01 {
    public static void main(String[] args) throws Exception {
//        separator();
//        fileOperator();
        directoryOper();
    }

    //(3)文件夹操作
    public static void directoryOper() throws Exception{
        //1. 创建文件夹
        File dir = new File("d:\\aaa\\bbb\\ccc");
        System.out.println(dir.toString());
        if(!dir.exists()){
//            dir.mkdir();    //只能创建单级目录
            System.out.println("创建结果："+dir.mkdirs());   //创建多级目录
        }
        //2. 删除文件夹
        //2.1 直接删除（空目录，且只删除最后一级）
//        System.out.println("删除结果："+dir.delete());
        //2.2 使用JVM删除
//        dir.deleteOnExit();
//        Thread.sleep(5000);
        //3. 获取文件夹信息
        System.out.println("获取绝对路径："+dir.getAbsolutePath());
        System.out.println("获取路径："+dir.getPath());
        System.out.println("获取文件夹名称"+dir.getName());
        System.out.println("获取父目录："+dir.getParent());
        System.out.println("文件创建时间："+new Date(dir.lastModified()).toLocaleString());
        //4. 判断
        System.out.println("是否是文件夹："+dir.isDirectory());
        System.out.println("是否隐藏："+dir.isHidden());    //属性-->隐藏
        //5. 遍历文件夹
        File dir2 = new File("d:\\图片");
        String[] files = dir2.list();   //list()返回一个字符串数组   //listFiles()返回一个file数组
        System.out.println("========");
        for (String file : files) {
            System.out.println(file);
        }
    }
}

4. FileFilter接口

  • public interface FileFilter
    • boolean accept（File pathname）
  • 当调用File类中的listFiles()方法时，支持传入FileFilter接口接口实现类，对获取文件进行过滤，只有满足条件的文件才可出现在listFiles()的返回值中
import java.io.File;
import java.io.FileFilter;
import java.util.Date;

/**
 * File类的使用
 * (1)分隔符
 * (2)文件操作
 * (3)文件夹操作
 */
public class Demo01 {
    public static void main(String[] args) throws Exception {
//        separator();
//        fileOperator();
        directoryOper();
    }

    //(3)文件夹操作
    public static void directoryOper() throws Exception{

        //5. 遍历文件夹
        File dir2 = new File("d:\\图片");
        String[] files = dir2.list();   //list()返回一个字符串数组   //listFiles()返回一个file数组
        System.out.println("========");
        for (String string : files) {
            System.out.println(string);
        }
        //6. FileFilter接口的使用
        System.out.println("========");
        File[] files2 = dir2.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                if (pathname.getName().endsWith(".jpg")) {
                    return true;
                }
                return false;
                //返回值为true，则返回所有文件
            }
        });
        for (File file : files2) {
            System.out.println(file.getName());
        }
    }
}

5. 递归遍历和递归删除

import java.io.File;

/**
 * 案例1：递归遍历文件夹
 * 案例2：递归删除文件夹
 */
public class ListDemo {
    public static void main(String[] args) {
//        listDir(new File("d:\\图片"));
        deleteDir(new File("d:\\图片"));
    }

    //案例1：递归遍历文件夹
    public static void listDir(File dir){
        File[] files = dir.listFiles();
        System.out.println("文件夹：\n"+dir.getName()+"\n"+dir.getAbsolutePath());
        if(files!=null&&files.length>0){
            for (File file : files) {
                if(file.isDirectory()){
                    listDir(file);
                }else{
                    System.out.println("文件名：\n"+file.getName()+"\n"+file.getAbsolutePath());
                }
            }
        }
    }

    //案例2：递归删除文件夹
    public static void deleteDir(File dir){
        File[] files = dir.listFiles();
        if(files!=null&&files.length>0){
            for (File file : files) {
                if(file.isDirectory()){
                    deleteDir(file);    //递归
                }else{
                    System.out.println("文件名：\n"+file.getName()+"\n"+file.getAbsolutePath()+"\n删除了"+file.delete());
                }
            }
            System.out.println("文件夹：\n"+dir.getName()+dir.getAbsolutePath()+"\n删除了"+dir.delete());
        }
    }
}

八、Properties

  1. Properties:属性集合
  2. 特点：
    • 存储属性名和属性值
    • 属性名和属性值都是字符串类型
    • 没有泛型
    • 和流有关
  3. 使用：
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Properties;
import java.util.Set;

/**
 * Properties集合的使用
 */
public class Demo01 {
    public static void main(String[] args) throws IOException {
        //1. 创建集合
        Properties properties = new Properties();
        //2. 添加数据
        properties.setProperty("username","zhangsan");
        properties.setProperty("age","20");
        System.out.println(properties.toString());
        //3. 遍历
        //3.1 keySet
        //3.2 entrySet
        //3.3 StringPropertyNames()
//        Set<String> pronames = properties.stringPropertyNames();
//        for (String pro : pronames) {
//            System.out.println(pro+"===="+properties.getProperty(pro));
//        }
        //4. 和流有关的方法
        //4.1 list方法
//        PrintWriter pw = new PrintWriter("d:\\print.txt");
//        properties.list(pw);
//        pw.close();
//        System.out.println("执行完毕");
        //4.2 store方法 保存
//        FileOutputStream fos = new FileOutputStream("d:\\store.properties");
        FileOutputStream fos = new FileOutputStream("d:\\printOut.txt");
//        properties.store(fos,"注释");
//        fos.close();
//        System.out.println("执行完毕2");
        //4.3 load方法 加载
        Properties properties2 = new Properties();
        FileInputStream fis = new FileInputStream("d:\\store.properties");
        properties2.load(fis);
        fis.close();
        System.out.println(properties2.toString());
    }
}

总结

即使再小的帆也能远航

进击的嗷呜兔兔
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《JavaSE系列教程》
緑水長流*z
08-10 7万+
本专栏内容是为零基础正在学习Java的学习者量身定制的学习路线及方案，本教程字数超20w+，插图超过400+，知识体系极其全面，案例极其丰富。本配备有专门的学习群及学习视频，读者可加学习群与正在学习该阶段的人一同学习，有任何不懂的也可以观看于此教程配套的学习视频。
Java SE IO框架
Settle是小天的博客
05-18 152
I/o框架 流的概念 概念：内存与存储设备之间传输数据的通道。数据借助流传输 流的分类 按方向【！！！】： 输入流：将<存储设备>中的内容读入到<内存>中。 输出流：将<内存>中的内容写入到<存储设备>中。 图解： 按单位： 字节流：以直接为单位，可以读写所有数据。 字符流：以字符为单位，只能读写文本数据。 按功能： 节点流：具有实际传输数据的读写功能。 过滤流：在节点流的基础之上增强功能。 字节流 字节流的父类（抽象类
【Java编程】JavaSE基础总结（五）：I/O
书山有路，学海无涯。记录成长，追逐梦想
09-15 214
I/O 简而言之，就是输入输出，那么为什么会有 I/O 呢？其实 I/O 无时无刻都在我们的身边，比如 读取硬盘上的文件，网络文件传输，鼠标键盘输入，也可以是 接受单片机发回的数据，而能够支持这些操作的设备就是 I/O 设备。
JavaSE集合框架（JavaSE大全）
weixin_45008931的博客
05-25 538
集合框架介绍 集合框架是JAVA中一系列关于集合的实现类和接口。 集合可以看做是一种容器，用来存储对象（集合只能存对象），与数组相类似，但特性不一样。集合的功能更强大，集合类的空间容量时可以调整的。集合类都在java.util包下。 集合和数组的区别： （1）集合专门用来存放对象，不能直接存储基本数据类型，但可以存储包装类型。数组可以存放基本数据类型等数据。 （2）集合中的数据可以是不同类，数组中只能存放同类型数据 （3）数组一旦被定义，不可以被修改，集合中的数据可以被修改 集合框架结构 Java的集合框架
【JavaSE】IO流
知识输出、记录学习
10-14 686
尚硅谷JavaSE笔记——IO流。个人实践总结，知识记忆架构不一定适合所有人，建议先阅读文章目录
javase:序列化与反序列化
qq_46128504的博客
09-26 99
javase:序列化与反序列化序列化引入序列化与反序列化原理序列化用法序列化与反序列化实现transient关键字乱码问题解析 序列化引入 1.对象存储在文件 2.对象在网络中传输 序列化与反序列化原理 1.序列化：将内存中的对象转化成byte流这个过程 2.反序列化：将byte流转换成内存中的对象的过程 3.序列化与反序列化原理 序列化用法 1.在网络中数据传输(json/xml) 2.RPC框架 3.对敏感字段加密 序列化与反序列化实现 1.实体类实现序列化接口 2.创建IO管道流 3.写对象wri
JavaSE整体知识框架图：
Alucard6y的博客
08-31 1135
JavaSE整体知识框架图： 常用API汇总： IO流整理： 面向对象： 反射： 集合： 设计模式： 网络编程： 正则表达式：
Java IO流框架图
猫头虎：授渔优于赠鱼，兴趣引领智慧，探索之乐尤显珍贵。商务合作：Libin9iOak，共赴知识与乐趣的探索之旅！
01-05 293
Java IO流框架图 IO流分类： 方向： a. 输出流：用以将<内存>中的内容写入到<存储设备>当中。 b.输入流：用以将<存储设备>中的内容读入到<内存>当中。 单位： a. 字节流：以字节为单位，可以读写所有数据。 b.字符流：以字符为单位，可以读写文本数据。 功能： a. 节点流：实际传输数据。 b.过滤流：强加节点流功能。 流在开发中如何应用？ 创建节点流(字节流) 创建桥转换流，同时设置编码方式 包装过滤流 读/写操作 关闭流(只需要关闭最
【JavaSE】网络编程：IO演进之路、多线程版BIO、线程池版BIO
知识输出、记录学习
10-14 694
尚硅谷+黑马 的学习结合笔记
JavaSE:实现象棋游戏
月临水的博客
03-24 1341
JavaSE:实现象棋游戏
commons-io-2.11.0.jar
11-25
commons-io-2.11.0.jar
JavaSE_JavaSE学习资料_
10-02
JavaSE的编程资料，包括基础，集合框架，IO流等等
JavaSE最全教程
01-03
最全的javaSE 教程，包含Java语言基础、流程控制、函数、数组、对象、修饰符、接口、内部类、集合、异常处理、多线程、IO框架、反射、OOAO初步等基础知识点汇总
狂神笔记，b站狂神说课程笔记大全(最新)
09-19
9、JavaSE：集合框架 10、JavaSE：IO流 11、JavaSE：多线程 12、JavaSE：网络编程 13、JavaSE：Gui编程 14、JavaSE：注解和反射 15、MySQL和JDBC 16、前端：Html5 17、前端：CSS3 18、前端：JavaScript、jQuery 19、...
狂神说上课笔记未删减 Java基础到技术升级
08-09
9、JavaSE：集合框架 10、JavaSE：IO流 11、JavaSE：多线程 12、JavaSE：网络编程 13、JavaSE：Gui编程 14、JavaSE：注解和反射 15、MySQL和JDBC 16、前端：Html5 17、前端：CSS3 18、前端：JavaScript、...
简单的项目部署脚本（转载）
u010230019的博客
06-09 652
有些项目团队喜欢使用docker启动java服务,那么我们同样可以将上述脚本稍做改造,来实现基于shell+docker的简单项目部署能力。可以将核心节点的错误或者失败内容通过webhook发送到对应的告警平台,比如钉钉、飞书机器人等。把~/.ssh/id_rsa.pub内容添加到远程仓库的ssh秘钥中。执行start.sh脚本打包部署。start.sh脚本内容。
Java——简单图书管理系统
m0_74100417的博客
06-09 1460
数据类型变量iffor数组方法类和对象封装继承多态抽象类和接口今天就是把上述知识点全部都用起来 图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理
修改菜品——后端Java
weixin_53717695的博客
06-09 465
修改菜品——后端Java
（Javascript）AI数字人mp4转canvas播放并去除背景绿幕
最新发布
lx_nhs的博客
06-12 445
去除前：去除后： 3、可能会出现的报错 （1）视频路径跨域问题：解决：vue开启代理
javase 8 源码
09-01
它包括了核心的Java类库，如java.lang、java.util、java.io等等，以及其他各种模块，如JavaFX、Java集合框架、JDBC等等。 通过阅读Javase 8源码，开发人员可以深入了解Java SE 8平台的各个模块的实现细节，了解Java...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值