Java IO流

最新推荐文章于 2024-01-27 16:24:57 发布

ISWWC

最新推荐文章于 2024-01-27 16:24:57 发布

阅读量386

点赞数

分类专栏： Java SE 文章标签： iostream

本文链接：https://blog.csdn.net/weixin_41836784/article/details/117160745

版权

Java SE 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

文章目录

一、概述

I:Input
O:Output
通过IO可以完成硬盘上文件的读和写
流的分类：
- 按流的方向（以内存为参照物）：
  - 输入流：往内存中去，叫做输入（Input）/读（Read）
  - 输出流：从内存中出来，叫做输出（Output）/写（Write）
- 按读取数据方式
  - 字节流：按照字节的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制位。这种流比较万能，能够读取各种类型的文件。包括文本文件、图片、声音文件、视频文件等…
  - 字符流：按照字符的方式读取数据，一次读取一个字符，这种流是为了方便读取普通文本文件而存在，只能读取纯文本文件，连word文件都无法读取。Win上英文字符占一个字节，中文字符占两个字节
Java中的流都在java.io.*;下，类名以Stream结尾的都是字节流，以Reader/Writer结尾的都是字符流，以下是四大流
- Java.io.InputStream 字节输入流（抽象类）
- Java.io.OutputStream 字节输出流（抽象类）
- Java.io.Reader 字符输入流（抽象类）
- Java.io.Writer 字符输出流（抽象类）
- Tips1：抽象类使用abstract class定义，不能实例化对象，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样，抽象类必须被继承，才能被使用。
- Tips2：所有的流都实现了：java.io.Closeable接口，都是可以关闭的，都有close（）方法。流是内存与硬盘之间的管道，使用结束之后需要进行关闭，否则会耗费（占用）系统资源
- Tips3：所有的输出流都实现了java.io.Flushable接口，都是可刷新的，都有flush（）方法；输出流在最终输出完毕之后，需要flush（）刷新一下，表示将通道/管道中剩余未输出的数据强行输出完毕（清空管道）。反之，可能会导致丢失数据
java.io之下的重要的16个流
- 文件专属：
  - java.io.FileInputStream
  - java.io.FileOutputStream
  - java.io.FileReader
  - java.io.FileWriter
- 转换流（将字节流转换为字符流）：
  - java.io.InputStreamReader
  - java.io.OutputStreamWriter
- 缓冲流专属
  - java.io.BufferedReader
  - java.io.BufferedWriter
  - java.io.BufferedInputStream
  - java.io.BufferedOutputStream
- 数据流专属
  - java.io.DataInputStream
  - java.io.DataOutputStream
- 标准输出流
  - java.io.PrintWriter
  - java.io.PrintStream
- 对象专属流
  - java.io.ObjectInputStream
  - java.io.ObjectOutputStream

二、文件字节输入流FileInputStream

文件字节输入流，任何类型的文件都可以采用这个流来进行读取
字节的方式，完成输入操作，完成读的操作（从硬盘到内存）

//使用 FileInputStream读取文件
public class FileInputStreamTest {
    public static void main(String[] args) {
        //IO流需要进行异常的处理

        //1.创建文件字节输入流对象
        //需要文件路径（绝对路径或相对路径(从当前位置作为起点开始查找，即IDEA的工程根目录)）作为初始化参数，且需要进行异常处理
        FileInputStream fis=null;
        try {
             fis = new FileInputStream("文件路径");//参数也可以是File类型

             //2.1开始进行数据读取——读取单个字符
            //int readData = fis.read();//从不指向开始，调用read（）一次，指针向前移动一位，并返回当前位上的字节本身。当到达文件末尾没有数据时，则返回-1
            //System.out.println(readData);

            //2.2使用循环读取整个文档,每次读取单个字符
            //int readData2=0;
            //while ((readData2=fis.read())!=-1){
                //System.out.println(readData2);
            //}

            //2.3采用byte数组，一次读取多个字符。最多读取数组.length个字节
            //准备一个4个长度的byte数组
            byte[] bytes = new byte[4];
            int readCount=0;
            while ((readCount=fis.read(bytes))!=-1){//返回值readCount是读到的字节数量，若到文件末尾无字节，则返回值为-1
                //3.将字节byte数组转换成字符串
                //String(byte[] bytes, int offset, int length),通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的 String。
                String data = new String(bytes, 0, readCount);
                //读取是采用新字节覆盖旧字节的方式，若读到末尾占不满byte数组，则部分旧字节仍存在,固需要截掉重复部分
                System.out.print(data);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //在finally语句当中确保流的关闭
            if (fis != null) {//避免空指针异常
                //关闭流的前提：流不是空，流是null的时候没必要关闭。
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

FileInputStream类常用方法：
- int available（）:返回流当中剩余的没有读到的字节数量；也可以开始时，作为总字节数量返回。
```
//用法
 byte[] bytes = new byte[fis.available()];//但这种方式不适用于太大的文件，因为byte[]数组不能太大
```
long skip（long n）:跳过几个字节不读取
```
//举例如下
fis.skip(5);
```

三、文件字节输出流FileOutputStream

//使用FileOutputStream写出数据
public class FileOutputStreamTest {
    public static void main(String[] args) {
        FileOutputStream fos=null;
        try {
            //构造方法第一个参数是文件的路径，文件不存在时，会自动新建
            //Tips：默认是原文件内容进行清空，再重新写
            //若构造方法传参数时，第二个参数，传true，则在文件内容末尾进行追加
            fos= new FileOutputStream("/Users/wwc/Desktop/a.txt",true);

            //要写入的数据1
            byte[] bytes={97,98,99,100};
            //要写入的数据2
            String s="Hello World!";
            byte[] bs = s.getBytes();

            //写出数据
            fos.write(bytes);//abcd
            fos.write(bs);
            //写出一部分数据
            fos.write(bytes,0,2);

            //写完数据之后，需要刷新
            fos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

四、字节流的文件拷贝

使用FileInputStream+FileOutputStream完成文件拷贝
拷贝的过程是一边读，一边写
字节流进行文件拷贝，文件类型不限定。

public class Copy {
    public static void main(String[] args) {
        FileInputStream fis=null;
        FileOutputStream fos=null;
        try {
            //创建一个输入流对象
            fis=new FileInputStream("/Users/wwc/Desktop/a.txt");
            //创建一个输出流对象
            fos=new FileOutputStream("/Users/wwc/Desktop/StudyBasic/b.txt");

            //边读边写
            byte[] bytes=new byte[1024*1024];//1MB（一次最多拷贝1MB）
            int readCount=0;
            while ((readCount=fis.read(bytes))!=-1){
                fos.write(bytes,0,readCount);
            }

            //写完刷新一下
            fos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //同时使用多个流，越晚打开的流，越早关闭，异常建议分开try，catch
            if (fos == null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fis == null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

五、文件字符输入流FileReader

只能读取普通文本，读取文本内容，较为方便快捷

public class FileReaderTest {
    public static void main(String[] args) {
        FileReader reader=null;
        try {
            //创建文件字符输入流
            reader=new FileReader("/Users/wwc/Desktop/a.txt");
            //开始读
            char[] chars=new char[4];
            int readCount=0;
            while ((readCount=reader.read(chars))!=-1){
                System.out.print(new String(chars,0,readCount));
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
//其余常用方法功能均与FileInputStream一致

六、文件字符输出流FileWriter

只能输出普通文本(能用记事本编辑的都是，与后缀无关，不一定是txt)

public class FileWriterTest {
    public static void main(String[] args) {
        FileWriter out=null;
        try {
            //创建文件字符输出流对象
            //第二个参数传true，则为不清空追加写法
            out=new FileWriter("/Users/wwc/Desktop/a.txt");

            //开始写
            char[] chars={'你','好','世','界'};
            String str="HelloWorld!";
            out.write(chars);//参数可以是char[]数组
            out.write(chars,0,2);//截位输入
            out.write(str);//参数也可以是String

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

七、字符流的文件拷贝

只能拷贝普通文本文件

public class Copy {
    public static void main(String[] args) {
        FileReader in=null;
        FileWriter out=null;
        try {
            //创建字符输入流对象
            in=new FileReader("/Users/wwc/Desktop/a.txt");
            //创建字符输出流对象
            out=new FileWriter("/Users/wwc/Desktop/StudyBasic/b.txt");

            //开始写
            char[] chars=new char[1024*512];//一个字符是两个字节，因此这里也是1MB
            int readCount=0;
            while ((readCount=in.read(chars))!=-1){
                out.write(chars,0,readCount);
            }

            //写完刷新一下
            out.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

八、BufferedReader

带有缓冲区的字符输入流，使用该流时，不需要自定义char数组/byte数组，自带缓冲

public class BufferedReaderTest {
    public static void main(String[] args) {
        FileReader reader = null;
        BufferedReader br = null;
        try {
            reader = new FileReader("/Users/wwc/Desktop/a.txt");
            //构造方法参数为一个流对象，该参数称为节点流
            //外部负责包装的这个流，叫做包装流/处理流
            br = new BufferedReader(reader);

            //开始读
            String s = null;
            while ((s = br.readLine()) != null) {//一次读一行，不读取换行符，无需准备缓冲数组
                System.out.println(s);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (br != null) {
                //使用包装流，只需要关闭最外层的包装流即可，节点流会自动关闭
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

九、BufferedWriter

带有缓冲的字符输出流

public class BufferedWriterTest {
    public static void main(String[] args) {
        FileWriter reader = null;
        BufferedWriter out =null;
        try {
            //创建文件字符输出流对象
            reader = new FileWriter("/Users/wwc/Desktop/a.txt");
            //创建带缓冲区的字符输出流对象
            out=new BufferedWriter(reader);

            //写数据，不赘述了

            //刷新
            out.flush();

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (out != null) {
                try {
                    //包装流关闭最外层即可
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

BufferedInputStream、BufferedOutputStream用法基本与前述一致，固不在赘述

十、转换流InputStreamReader

public class BufferedReaderTest {
    public static void main(String[] args) throws IOException {
        //字节流
        FileInputStream fis = new FileInputStream("/Users/wwc/Desktop/a.txt");
        
        //通过转换流转换（）
        //此处fis是节点流，reader是包装流
        InputStreamReader reader = new InputStreamReader(fis);
        
        //这个构造方法只能传一个字符流，不能传字节流
        //此处reader是节点流，br是包装流
        BufferedReader br = new BufferedReader(reader);
        
        //读数据，就不赘述了
        
        //关闭最外层即可
        br.close();
    }
}

OutputStreamWriter用法类似，也不再过多赘述了

十一、数据字节输出流DataOutputStream与数据字节输入流DataInputStream

这个流可以将数据连同数据类型一并写入文件/读取，因此该文件并非普通文档，记事本无法打开
DataOutputStream写出的文件只能用DataInputStream并且要按写入顺序进行读取，读写顺序需要一致

//数据字节输出流DataOutputStream
public class DataOutputStreamTest {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        DataOutputStream dos=null;
        try {
            //创建节点流
            fos = new FileOutputStream("/Users/wwc/Desktop/a.txt");
            dos = new DataOutputStream(fos);

            //写数据
            byte b=100;
            short s=200;
            int i=300;
            long l=400L;
            float f=3.0F;
            double d=3.14;
            boolean sex=false;
            char c='a';
            dos.writeByte(b);
            dos.writeShort(s);
            dos.writeInt(i);
            dos.writeLong(l);
            dos.writeFloat(f);
            dos.writeDouble(d);
            dos.writeBoolean(sex);
            dos.writeChar(c);

            //输出流刷新
            dos.flush();

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (dos != null) {
                try {
                    //关闭最外层的包装流，节点流自动关闭
                    dos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

//数据字节输入流DataInputStream
public class DataInputStreamTest {
    public static void main(String[] args) {
        FileInputStream fis = null;
        DataInputStream dis=null;
        try {
            fis = new FileInputStream("/Users/wwc/Desktop/a.txt");
            dis = new DataInputStream(fis);

            //开始读
            byte b=dis.readByte();
            short s=dis.readShort();
            int i=dis.readInt();
            long l=dis.readLong();
            float f=dis.readFloat();
            double d=dis.readDouble();
            boolean sex=dis.readBoolean();
            char c=dis.readChar();

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (dis != null) {
                try {
                    dis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

十二、标准输出流PrintStream

默认输出到控制台
可以用于书写日志框架/日志工具

//测试PrintStream用法
public class PrintStreamTest {
    public static void main(String[] args) throws FileNotFoundException {
        //联合写
        System.out.println("");

        //分开写
        PrintStream ps = System.out;
        ps.println("");

        //标准输出流不需要手动close（）关闭

        //System类中常用的方法与属性
        //System.gc();
        //System.currentTimeMillis();
        //System.exit(0);
        //System.arraycopy(...);

        //改变输出的方向,不再指向控制台，而是指向"log"文件
        PrintStream printStream = new PrintStream(new FileOutputStream("log"));
        //修改输出方向，将输出方向修改到"log"文件
        System.setOut(printStream);
        //重新输出 
        System.out.println("");
    }
}

//封装一个日志工具
public class Logger {
    public static void log(String msg) {
        try {
            //指向一个日志文件
            PrintStream out = new PrintStream(new FileOutputStream("log.txt", true));
            //改变输出方向
            System.setOut(out);
            //获取系统当前时间
            Date nowTime = new Date();
            //格式化日期时间
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
            String strTime = sdf.format(nowTime);
            
            System.out.println(strTime+":"+msg);
            
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

十三、File类

File类不能完成文件的读和写，而是代表文件和目录路径名的抽象表示形式，如C：\Drivers
File是一个路径名的抽象表示形式
File类常用方法

public class FileTest {
    public static void main(String[] args) throws IOException {
        //创建File类对象
        File f1 = new File("/Users/wwc/Desktop");
        //判断是否存在
        f1.exists();

        //若文件不存在，则以文件形式创建出来
        if(!f1.exists()){
            f1.createNewFile();
        }

        //若文件不存在，则以目录形式创建出来
//        if(!f1.exists()){
//             f1.mkdir();//只创建一级目录，若中间的多级目录都不存在，则不创建
//        }

        //若文件不存在，则以多重目录形式创建出来
//        if(!f1.exists()){
//             f1.mkdirs();//创建多重目录，即使中间的多级目录不存在，也会一直创建到有为止
//       }

        //获取文件的父路径方式一
        f1.getParent();
        //获取文件的父路径方式二
        File parentFile = f1.getParentFile();
        parentFile.getAbsolutePath();

        //获取绝对路径
        f1.getAbsolutePath();

        //获取文件名
        f1.getName();

        //判断是否是目录
        f1.isDirectory();

        //判断是否文件
        f1.isFile();

        //获取文件最后一次修改时间
        long haomiao=f1.lastModified();//返回值为从1970年到现在的总毫秒数
        //时间格式化
        Date time = new Date(haomiao);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
        String strTime = sdf.format(time);
        System.out.println(strTime);

        //获取文件大小
        f1.length();

        //获取当前目录下的所有子文件
        File[] files = f1.listFiles();
    }
}

十四、目录拷贝

import java.io.*;

public class CopyAll {

    public static void main(String[] args) {
        //拷贝源
        File srcFile = new File("/Users/wwc/Desktop/tes");
        //拷贝目标
        File destFile = new  File("/Users/wwc/Desktop/Test");
        //调用拷贝方法
        copyDir(srcFile,destFile);

    }

    public static void copyDir(File srcFile,File destFile) {
        //判断是否是文件
        if(srcFile.isFile()){
            //拷贝源于拷贝目标的路径
            String strDir=srcFile.getAbsolutePath();
            String destDir=destFile.getAbsolutePath()+strDir.substring(18);
            System.out.println(destDir);
            //边读边写
            FileInputStream in = null;
            FileOutputStream out=null;

            try {
                in = new FileInputStream(strDir);
                out = new FileOutputStream(destDir);

                byte[] bytes=new byte[1024*1024];//一次复制1MB
                int readCount=0;
                while ((readCount=in.read(bytes))!=-1){
                    out.write(bytes,0,readCount);
                }

                //输出完后，刷新一下
                out.flush();

            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (out != null) {
                    try {
                        out.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (in != null) {
                    try {
                        in.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            return;
        }

        //若是目录，则获取源目录下面的子目录
        File[] files = srcFile.listFiles();

        for (File file:files) {
            if(file.isDirectory()){
                //拷贝源子目录路径
                String strDir=file.getAbsolutePath();
                //拷贝目标子目录路径
                String destDir=destFile.getAbsolutePath()+strDir.substring(18);
                //在拷贝目标中创建对应文件夹
                File newFile = new File(destDir);
                if(!newFile.exists()){
                    newFile.mkdirs();
                }
            }
          //使用递归进行调用
            copyDir(file,destFile);
        }
    }
}

十五、对象流ObjectInputStream 与ObjectOutputStream

java.io.ObjectInputStream 反序列化
java.io.ObjectOutputStream 序列化
序列化（Serialize）：将内存中的Java对象的数据状态信息放置到硬盘文件上，即将对象按序号切块，转换为可以存储或传输的形式的过程，将传输对象当前状态存储到临时或持久性存储区（硬盘上）
反序列化（DeSerialize）：通过从存储区（硬盘）中读取或反序列化对象的状态，恢复到内存中，重新创建该对象，即组装对象
Serializable接口：参与序列化和反序列化的类型必须实现Serializable接口，该接口是一个标志性接口，其内无任何代码，起到标识作用。标识是给JVM识别参考的，识别到该标志性接口，会自动默认生成一个序列化版本号
- Java语言中区分类的机制：1.通过类名进行对比（类名包括报名）；2.通过序列版本号进行区分（同名但不同内容的类也可以通过此进行区分）；
- 但当对象数据进行序列化后，再修改类，则重新编译后序列化版本号则会发生改变，导致无法读取先前的序列化对象数据；因此应当给该类提供一个固定不变的序列化版本号
- 序列化版本号：
```
//在实现了Serializable接口的类中，手动提供序列化版本号
//如：
private static final long serialVersionUID=1234566L;
//也可以使用IDEA生成
```
- 此时可以通过在实现了Serializable的类上，点击类名，进行快捷键alt+回车/option+回车生成。

//序列化

//测试类
public class Test {
    public static void main(String[] args) {
        //创建Java对象
        Student s = new Student(1111, "zhansan");
        ObjectOutputStream oos=null;
        //序列化
        try {
            //创建序列化流
            oos = new ObjectOutputStream(new FileOutputStream("/Users/wwc/Desktop/a.txt",true));
            //序列化对象
            oos.writeObject(s);

            //输出完刷新一下
            oos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (oos != null) {
                try {
                    //关闭流
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

Serializable是标志性接口，其内没有任何的方法
//实体类
class Student implements Serializable {
    private int no;
    private String name;

    public Student() {
    }

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

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
  
  @Override
    public String toString() {
        return "Student{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }
}

//反序列化  
public class Tesst {
    public static void main(String[] args) {
        ObjectInputStream ois=null;
        //反序列化
        try {
             ois = new ObjectInputStream(new FileInputStream("/Users/wwc/Desktop/a.txt"));
             //开始反序列化，读
            Object obj = ois.readObject();//默认使用Object接收，可进行强制类型转换
            //反序列化回来的对象，通过重写后的toString方法进行打印输出
            System.out.println(obj);//此为多态 


        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (ois != null) {
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

//实体类同上，不过多赘述

一次性序列化多个对象：将对象放到集合当中，序列化集合，否则直接存多个对象会导致报错；集合与存在集合中的类对象都需要实现Serializable接口
transient：若不希望类中的某个属性被序列化，可以加此关键字；如private transient String name;

十六、IO+Properties

Properties是一个Map集合，key和value都是String类型，是专门用于存放属性的配置文件的一个类。
通过IO流将userinfo中的数据加载到Properties对象中

//userinfo
username=admin
password=root

public class PropertiesTest {
    public static void main(String[] args) throws Exception {
        //新建一个输入流对象
        FileReader reader = new FileReader("src/userinfo");

        //新建一个Map集合
        Properties pro = new Properties();
        //通过流将数据加载到Map集合中，其中=号左边作为key，右边作为value
        pro.load(reader);
        //通过key获取value
        pro.getProperty("username");
        System.out.println(pro.getProperty("username"));
    }
}

配置文件：程序中经常发生变化的信息不要书写到Java程序当中，因为改动代码要重新编译，重新部署，重启服务器，而是应当书写到配置文件中；
属性配置文件：形如key=value或key:value的配置文件称为属性配置文件， Java中建议以.properties结尾，但非必须。其中，#号是注释，若key重复则会自动报错