凯哥带你从零学大数据系列之Java篇---第二十六章:IO流详解

课程大纲:

  • IO流的简介
  • 基础的IO流(重点)
  • 常见的其他流

http://1.IO流的简介

1.1. 什么是IO流

IO流: Input/Output Stream

流: 指的是一串流动的数据, 在数据在流中按照指定的方向进行流动。 实现数据的读取、写入的功能。

1.2. IO流的使用场景

使用File类, 只能做关于文件的操作, 获取属性、 创建文件、 删除文件、 移动文件等操作, 但是不包含读取文件中的内容。 如果需要读取、修改文件中的内容, 此时就需要使用IO流来完成了。

使用场景: 对某一个文件进行读取或者写入操作。

注意事项:
IO流是对一个文件进行读写的, 不是一个文件夹! 在使用IO流的时候, 不要建立与一个文件夹的连接。

1.3. IO流的分类

按照不同的分类标准, 能够得到不同分类的IO流:

  • 按照流中流动的数据单位:
    • 字节流: 流中流动的数据, 是以字节为单位的。
    • 字符流: 流中流动的数据, 是以字符为单位的。

 

  • 按照流中数据流动的方向:
    • 输入流: 数据从文件流动到程序中。
    • 输出流: 数据从程序流动到文件中。

2.基础的IO流

2.1. 基础的IO流类的简介

其实在 http://java.io 包中, 有很多很多的类, 都是来描述IO流的。 但是基本上所有的IO流的类, 都是直接或间接的继承自四大父类流。

  • 字节输入流: InputStream
  • 字节输出流: OutputStream
  • 字符输入流: Reader
  • 字符输出流: Writer

2.2. IO流使用的注意事项

  • 四大父类流, 都是抽象类, 都不能实例化对象。 因此, 需要借助他们的子类实现数据的读写。
  • 流对象一旦实例化完成, 将建立一个程序与文件之间的连接。 这个连接会持有这个文件。 如果这个连接不断, 此时这个文件就是一个被使用中的状态, 此时将无法对这个文件进行其他的操作, 例如删除。
  • 一个流在使用完成之后, 切记! 一定要进行流的关闭。

2.3. 建立程序与文件的连接

其实, 就是建立了程序与文件之间连接的管道, 实现数据在这个管道之内进行流动。 管道分为不同的类型: 字节输入流、 字节输出流、 字符输入流、 字符输出流。 下面以字节输入流 InputStream 为例。

2.3.1. 标准流程

  • try结构外面, 声明流对象, 为了在finally中使用。
  • 在try结构里面, 实例化流对象, 并捕获异常。
  • 在finally结构中, 对流进行关闭。 在关闭的时候, 需要考虑流对象是否是null, 以及要处理 IOException 异常。
import java.io.*;

/**
 * @Description 测试文件与程序的连接建立
 */
public class IO1 {
    public static void main(String[] args) {
        // 在外面声明变量
        InputStream inputStream = null;
        try {
            // 实例化一个FileInputStream对象,向上转型为InputStream类型类型。
            // 这个实例化如果完成,将会建立程序与文件之间的连接。
            // 建立好之后,数据就可以从文件中流动到程序中。
            // 注意: 数据流动到程序中,并不意味着文件中没有数据了!
            // 这个过程中,会出现 FileNotFoundException 的异常,原因: 路径写错了,这个路径上没有文件
            inputStream = new FileInputStream("file\\day25\\source");
            // 数据的读取操作
            // 在数据读取的过程中,也会出现 IOException 异常。一旦出现异常,后序的代码都不执行了,直接执行catch语句了
            // 流的关闭,不能放到try里面。需要放到finally中。
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            // 流在使用结束之后,一定要进行关闭。
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

2.3.2. try结构的特使使用

在 JDK1.7 之后, 可以在try后面添加一对小括号。 将 AutoClosable 接口实现类的对象, 实例化放到小括号中完成。 此时, 在try结构执行结束的时候, 会自动的调用AutoClosable接口实现类中的close方法, 进行流的关闭。 这样写的流的建立比较简单, 也是后面我们最主要使用的方式。

import java.io.*;

/**
 * @Description 常见的IO流的创建的方式
 */
public class IO2 {
    public static void main(String[] args) {
        /**
         * try结构的特殊语法: try ()
         * 将 AutoClosable 接口的实现类对象的实例化放到小括号中。
         * 此时,在离开了try结构的时候,会自动的对这个类进行close方法的调用
         */
        try (InputStream inputStream = new FileInputStream("file\\day25\\source")) {
		// 数据的读取操作
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println(new File("file\\day25\\source").delete());
    }
}

2.4. InputStream

2.4.1. InputStream简介

这是一个字节输入流。 从方向来说, 是一个输入流, 数据是从文件中流动到程序中, 是为了读取文件中的数据的。 从数据单位来说, 这个流中流动的数据是以字节为单位的。

2.4.2. 文件的读取

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

/**
 * @Description 使用字节流进行数据的读取
 */
public class InputStreamTest {
    public static void main(String[] args) {
        // 1. 建立程序与文件之间的连接,用来读取这个文件
        try (InputStream inputStream = new FileInputStream("file\\day25\\source")) {
            // 2. 读取字节流中的数据,需要有一个字节数组,用来读取数据
            //    这个数组长度,不用和文件一样大小,找一个大小合适的数组读取即可
            byte[] array = new byte[32];
            // 3. 声明一个整型变量,用来记录每次读取了多少个字节的数据
            int length = 0;
            // 3. 循环读取数据
            while ((length = inputStream.read(array)) != -1) {
                // 将读取到的字节数组中的数据,转成字符串输出
                // 为了去除最后一次进行读取数据的时候,上次读取残留的问题
                // 最后一次读取的数据,只有指定部分是我们需要的数据
                String str = new String(array, 0, length);
                System.out.print(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.5. OutputStream

2.5.1. OutputStream简介

字节输出流。 从方向上来分, 是一个输出流, 数据从程序中流动到文件中, 实现文件的写操作。 从流中流动的数据单位来分, 是一个字节流, 流中流动的数据是以字节为单位的。

2.5.2. 文件的写

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

/**
 * @Description 字节输出流,写文件
 */
public class OutputStreamTest {
    public static void main(String[] args) {
        // 1. 实例化一个管道,连接文件和程序。
        //    对于FileOutputStream来说,如果目标文件不存在,则会自动的创建。
        //    当无法创建这个文件的时候(父级目录不存在),创建会失败,会触发 FileNotFoundException 。
        try (OutputStream outputStream = new FileOutputStream("file\\day25\\dst", true)) {
            // 2. 准备需要写入到这个文件中的数据
            String message = "你好,师姐";
            // 3. 将数据写入到输出流中,由输出流写入到文件中
            outputStream.write(message.getBytes());

            // 冲刷缓冲区,将缓冲区中的数据强制流动到文件中。
            // 在流关闭的时候,会自动的调用。
            outputStream.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
​

2.6. 案例: 文件拷贝

2.6.1. 需求分析

实现, 将一个文件拷贝到另外一个地方。 注意, 这个不是剪切, 拷贝完成之后, 原文件还在。

实现方式: 借助两个流来完成。

  • 使用字节流输入, 循环读取原文件中的数据。
  • 使用字节输出流, 将每次读取到的数据, 写入到目标文件中。

2.6.2. 示例代码

import java.io.*;

/**
 * @Description 使用字节流实现文件的拷贝
 */
public class FileCopy {
    public static void main(String[] args) {
        boolean ret = copy("C:\\Users\\luds\\Desktop\\src.mp4", "C:\\Users\\luds\\Desktop\\dst.mp4");
        System.out.println(ret);
    }

    /**
     * 实现功能: 将源文件中的数据拷贝到目标文件
     * @param srcPath 原文件路径
     * @param dstPath 目标文件路径
     * @return 拷贝的结果
     */
    private static boolean copy(String srcPath, String dstPath) {
        // 1. 判断目标路径上,是否有文件存在
        File dst = new File(dstPath);
        if (dst.exists()) {
            return false;
        }
        // 2. 实现文件的拷贝
        try (InputStream inputStream = new FileInputStream(srcPath);
             OutputStream outputStream = new FileOutputStream(dst)) {
            // 拷贝的过程
            // 2.1. 实例化一个字节数组
            byte[] array = new byte[1024];
            // 2.2. 声明一个整型变量,用来记录每次读取到了多少个字节的数据
            int length = 0;
            // 2.3. 循环读取数据
            while ((length = inputStream.read(array)) != -1) {
                // 2.4. 将读取到的数据,写入到输出流中
                outputStream.write(array, 0, length);
            }
            // 2.5. 冲刷缓冲区
            outputStream.flush();
            return true;
        }
        catch (IOException e) {
            e.printStackTrace();
            return false;
        }
    }
}

2.7. Reader

2.7.1. Reader的简介

这是一个字符输入流。 从方向来说, 是一个输入流, 数据是从文件中流动到程序中, 是为了读取文件中的数据的。 从数据单位来说, 这个流中流动的数据是以字符为单位的。

2.7.2. 读取文件

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

/**
 * @Description 字符输入流读取数据
 */
public class ReaderTest {
    public static void main(String[] args) {
        // 读取过程与字节输入流完全相同,只需要将使用到的类换一下即可。
        try (Reader reader = new FileReader("file\\day25\\src")) {
            // 1. 实例化一个字符数组
            char[] array = new char[100];
            // 2. 声明一个变量,用来记录每次读取到了多少个数据
            int length = 0;
            // 3. 循环读取数据
            while ((length = reader.read(array)) != -1) {
                String str = new String(array, 0, length);
                System.out.print(str);
            }
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.8. Writer

2.8.1. Writer的简介

字符输出流。 从方向上来分, 是一个输出流, 数据从程序中流动到文件中, 实现文件的写操作。 从流中流动的数据单位来分, 是一个字符流, 流中流动的数据是以字符为单位的。

2.8.2. 文件的写操作

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

/**
 * @Description 使用字符流写数据
 */
public class WriterTest {
    public static void main(String[] args) {
        // 1. 实例化相关的类
        try (Writer writer = new FileWriter("file\\day25\\target", true)) {
            // 2. 将数据写入到输出流中
            writer.write("hello, world");
            // 3. 冲刷缓冲区
            writer.flush();
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
}

 

2.9. 案例: 文件拷贝

2.9.1. 需求分析

实现, 将一个文件拷贝到另外一个地方。 注意, 这个不是剪切, 拷贝完成之后, 原文件还在。

实现方式: 借助两个流来完成。

  • 使用字符输入流, 循环读取原文件中的数据。
  • 使用字符输出流, 将每次读取到的数据, 写入到目标文件中。

2.9.2. 示例代码

/**
  * 使用字符流实现文件的拷贝
  * @param srcPath 原文件路径
  * @param dstPath 目标文件路径
  */
private static void fileCopy2(String srcPath, String dstPath) {
    // 2. 循环读取目标文件中的数据
    try (Reader reader = new FileReader(srcPath); Writer writer = new FileWriter(dstPath)) {
        // 3. 循环读取源文件中的数据
        char[] array = new char[100];
        int length = 0;
        while ((length = reader.read(array)) != -1) {
            // 4. 将读取到的数据写入到输出流
            writer.write(array, 0, length);
        }
        writer.flush();
        return true;
    }
    catch (IOException e) {
        e.printStackTrace();
        return false;
    }
}

3. 常见的其他流

3.1. 缓冲流

3.1.1. 缓冲流的简介

给普通的IO流, 套上一个缓冲区。 所有的使用缓冲流进行的读写操作, 都是和缓冲区进行交互的, 避免了频繁的IO操作。 这样一来, 带来的好处就是可以提高读写的效率。 这个缓冲区, 其实是一个数组。

常见的缓冲流:

  • BufferedInputStream : 缓冲字节输入流
  • BufferedOutputStream : 缓冲字节输出流
  • BufferedReader : 缓冲字符输入流
  • BufferedWriter : 缓冲字符输出

3.1.2. 缓冲字节流

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

/**
 * @Description BufferedInputStream使用
 */
public class BufferedInputStreamTest {
    public static void main(String[] args) {
        // 过程和InputStream一模一样的
        // 缓冲字节输入流流是需要基于一个字节输入流来进行实例化的
        // 在这里,BufferedInputStream构造方法中的InputStream对象,只是用来做当前的对象的实例化,在使用结束的时候,理论上来讲,是需要关闭的
        // 实际在使用中,使用结束后,只需要关闭BufferedInputStream即可。
        try (BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("file\\day26\\source"))) {
            // 1. 实例化一个字节数组
            byte[] array = new byte[1024];
            // 2. 声明一个整型变量,用来记录每次读取了多少个字节数据
            int length = 0;
            // 3. 循环读取
            while ((length = bufferedInputStream.read(array)) != -1) {
                // 4. 将读取到的数据转成字符串输出到控制台
                String msg = new String(array, 0, length);
                System.out.println(msg);
            }
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
}

 

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

/*
 * @Description BufferedOutputStream
 */
public class BufferedOutputStreamTest {
    public static void main(String[] args) {
        // 1. 实例化一个缓冲字节输出流对象
        try (BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("file\\day26\\target")))  {
            // 2. 将数据写入到输出流中
            bufferedOutputStream.write("hello world".getBytes());
            bufferedOutputStream.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.1.3. 缓冲字符流

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

/**
 * @Description
 */
public class BufferedReaderTest {
    public static void main(String[] args) {
        // 借助一个字符流,实例化一个缓冲字符输入流
        try (BufferedReader bufferedReader = new BufferedReader(new FileReader("file\\day26\\src"))) {
            // 从流中读取数据
            char[] array = new char[100];
            int length = 0;
            while ((length = bufferedReader.read(array)) != -1) {
                System.out.print(new String(array, 0, length));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

 

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

/**
 * @Description
 */
public class BufferedWriterTest {
    public static void main(String[] args) {
        // 借助一个字符输出流,实例化一个缓冲字符输出流对象
        try (BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("file\\day26\\dst"))) {
            bufferedWriter.write("hello world");
            bufferedWriter.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.1.4. 缓冲流中的特殊方法

BufferedReader 类中多了一个方法 readLine()

  • 意义: 读取缓冲流中的一行数据, 可以逐行读取。 一直到读取到的数据是null, 表示数据读取完了, 没有下一行数据了。
  • 注意事项: readLine() 是逐行读取, 但是, 只能读取到一行中的内容, 并不能读取走换行符。
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

/*
 * @Date 2020/4/26
 * @Description
 */
public class BufferedReaderSpecial {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("file\\day26\\src"))) {
            // 1. 定义一个字符串,用来接收每一行读取到的数据
            String line = "";
            // 2. 循环读取数据
            while ((line = reader.readLine()) != null) {
                // 3. 将读取到的数据输出
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

BufferedWriter 类中多了一个方法 newLine()

  • 意义: 无参的方法, 写一个换行符。
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

/**
 * @Description
 */
public class BufferedWriterSpecial {
    public static void main(String[] args) {
        try (BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("file\\day26\\dst"))) {
            bufferedWriter.write("hello world");
            bufferedWriter.newLine();
            bufferedWriter.write("你好,世界");
            bufferedWriter.newLine();
            bufferedWriter.write("end");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

使用缓冲字符流进行文件的拷贝

import java.io.*;

/**
 * @Description 使用缓冲字符流实现文本文件的拷贝
 */
public class BufferedCopy {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("file\\day26\\src"));
             BufferedWriter writer = new BufferedWriter(new FileWriter("file\\day26\\destination"))) {
            String line = "";
            while ((line = reader.readLine()) != null) {
                writer.write(line);
                writer.newLine();
            }
            writer.flush();
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }

3.2. Scanner类

3.2.1. 简介

这个类, 并不是一个IO流。 是一个扫描器, 这个类最主要的作用, 是从一个文件中或者从一个流中浏览数据。 在这个类中封装了若干个方法, 方便了数据的读取。

3.2.2. API

注意事项

这里nextLine和BufferedReader中的readLine都可以读取一行数据。 但是区别在于: 结束条件不同。

  • BufferedReader: 如果读取到的数据是null, 说明没有下一行数据了。
  • Scanner: 如果没有下一行了,再去读取,会出现异常。 所以, 此时的结束条件是 hasNextLine() 为false。
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
import java.util.regex.Pattern;

/**
 * @Description Scanner类的方法
 */
public class ScannerTest {
    public static void main(String[] args) {
        // 其实,Scanner在使用结束之后,也是需要进行关闭的。 调用close方法。
        try (Scanner scanner = new Scanner(new File("file\\day26\\src"))) {
            // 读取文件中的内容
            while (scanner.hasNextLine()) {
                System.out.println(scanner.hasNextLine());
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

3.3. 标准输入输出流

3.3.1. 简介

标准输入流: http://System.in : 连接了程序和控制台。 读取控制台中的内容。

标准输出流: System.out : 连接了程序和控制台。 将程序中的内容输出到控制台。

3.3.2. 标准输入流

import java.io.BufferedInputStream;
import java.io.IOException;
import java.util.Scanner;

/**
 * @Description 标准输入流
 */
public class SystemInTest {
    public static void main(String[] args) {
        try (BufferedInputStream bis = new BufferedInputStream(System.in)) {
            byte[] array = new byte[128];
            int length = 0;
            while ((length = bis.read(array)) != -1) {
                String str = new String(array, 0, length);
                System.out.println(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.3.3. 标准输出流

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;

/**
 * @Description 标准输出流
 */
public class SystemOutTest {
    public static void main(String[] args) {
        PrintStream original = System.out;
        // PrintStream: 是一个打印流,可以将数据输出到指定位置。
        try (PrintStream ps = new PrintStream(new FileOutputStream("file\\day26\\logs", true))) {
            // ps.println("hello world!");
            // 重定向标准输出流
            System.setOut(ps);

            System.out.println("123");
        }
        catch (IOException e) {
            e.printStackTrace();
        } finally {
            System.setOut(original);
        }

        System.out.println("你好");

        // System.out;      标准输出流地址
        // System.out -> ps
    }
}

3.4. 转换流

3.4.1. 为什么要用转换流

在进行文件读取的时候, 如果项目采用的字符集和文件的字符集不同,会出现乱码的情况。

3.4.2. 输入流

import java.io.*;

/**
 * @Description 转换流
 *      转换输入流:可以以指定的字符集读取某一个文件中的数据
 *      转换输出流:可以以指定的字符集把数据写入到某一个文件
 */
public class TransforeTest {
    public static void main(String[] args) {
        read();
    }
    private static void read() {
        // 当前的项目是 utf-8, 读取的文件是 GBK
        // 如果需要以指定的字符集进行文件的读取,需要使用 InputStreamReader(InputStream inputStream, String charsetName)
        try (InputStreamReader reader = new InputStreamReader(new FileInputStream("file\\day26\\src"), "GBK")) {
            char[] array = new char[128];
            int length = 0;
            while ((length = reader.read(array)) != -1) {
                System.out.println(new String(array, 0, length));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

 

3.4.3. 输出流

import java.io.*;

/**
 * @Description 转换流
 *      转换输入流:可以以指定的字符集读取某一个文件中的数据
 *      转换输出流:可以以指定的字符集把数据写入到某一个文件
 */
public class TransforeTest {
    public static void main(String[] args) {
        write();
    }

    private static void write() {
        // 以指定的字符集写数据
        try (OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream("file\\day26\\dst", true), "GBK")) {
            writer.write("hello world");
            writer.write("你好,世界");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.5. 对象流

3.5.1. 简介

ObjectInputStream、 ObjectOutputStream, 主要是用来做对象的序列化和反序列化的。

  • 序列化: 将内存中的某个对象, 以文件的形式保存到本地。
  • 反序列化: 将本地保存的某一个文件, 信息读取出来, 存到某一个对象中。
序列化、 反序列化, 是对象的持久化存储的一种常用手段。

3.5.2. 注意事项

  • 所有的要序列化到本地的类的对象, 类必须实现 java.io.Serilizable 接口。
  • 如果需要序列化多个文件到本地, 尽量不要序列化到一个文件中。 如果需要序列化多个文件到本地, 通常采用的方式, 是村集合。 将多个对象存入一个集合中, 将这个集合序列化到本地。

3.5.3. 示例代码

import java.io.*;

/**
 * @Description
 */
public class Test {
    public static void main(String[] args) {
        load();
    }

    /**
     * 反序列化
     */
    private static void load() {
        try(ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("file\\day26\\person"))) {
            // 读取文件中的数据
            Object obj = inputStream.readObject();

            if (obj instanceof Person) {
                Person xiaoming = (Person)obj;
                System.out.println(xiaoming);
            }

        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    /**
     * 序列化
     */
    private static void save() {
        // 实例化一个Person对象
        Person xiaoming = new Person("xiaoming", 12, 100);

        // 序列化对象
        try (ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("file\\day26\\person"))) {
            // 序列化
            outputStream.writeObject(xiaoming);
            outputStream.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.6. Properties

3.6.1. 简介

Properties也不是一个IO流, 是一个集合。 是Hashtable的子类。

使用Properties主要是为了描述程序中的属性列表文件。 有时候, 我们会将一些比较简单的项目的配置信息, 以 .properties 格式的文件进行存储。 可以使用Properties对象读写 .properties 文件。

3.6.2. 示例代码

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

/**
 * @Description
 */
public class Program {
    public static void main(String[] args) {
        // 1. 实例化一个Properties对象
        Properties properties = new Properties();

        // 2. 加载一个 .properties 文件中的数据
        try {
            properties.load(new FileReader("file\\day27\\my.properties"));
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 3. 遍历
        System.out.println(properties);

        // 4. 键值对的增删改查
        //    由于这个类是Map的实现类,因此在Map集合中定义的所有的方法,它都有。
        //    但是,对于Properties类的来说,增删改查基本上不用从Map中继承到的方法。
        //    因为,从Map集合中继承下来的方法,键和值都是Object类型的。
        // 4.1. 可以在集合中新增一个键值对,也可以修改集合中的存在的键值对。
        properties.setProperty("userlevel", "12");
        properties.setProperty("password", "ABCDEFG");

        // 4.2. 通过键,获取值
        String level = properties.getProperty("userlevel");
        String id = properties.getProperty("userid", "123");

        System.out.println(properties);

        // 5. 将内存中的数据,同步到文件中
        try {
            properties.store(new FileWriter("file\\day27\\my.properties"), "hello");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
展开阅读全文
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值