1.文件基础知识

流向内存的为输入流，从内存流出的为输出流

文件流：文件在程序中是以流的形式来操作的

流：就是数据在数据源(文件)和程序(内存)之间经历的路径

输入流：数据从数据源(文件)到程序(内存)的路径

输出流：数据从程序(内存)到数据源(文件)的路径

常用的文件操作

创建文件的三种方式（只学一种即可）

package learn;

import java.io.File;
import java.io.IOException;

public class learn01 {
    /**
     * 文件创建
     * @param args
     */
    public static void main(String[] args) {
        create01();
        create02();
        create03();
    }
    //方式1，new File(String pathname)
    public static void create01(){
        //创建一个file对象，相当于在内存中创建了一个文件对象
        File file=new File("E:\\java_learn\\file\\src\\main\\java\\learn\\news1.txt");
        try {
            //通过createNewFile()方法才会在磁盘真正创建该文件
            file.createNewFile();
            System.out.println("文件1创建成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //方式2，new File(File parent,String child)
    public static void create02(){
        File parentFile=new File("E:\\java_learn\\file\\src\\main\\java\\learn\\");
        File file=new File(parentFile,"news2.txt");
        try {
            file.createNewFile();
            System.out.println("文件2创建成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //方式3，new File(String parent,String child)
    public static void create03(){
        //创建一个file对象，相当于在内存中创建了一个文件对象
        File file=new File("E:\\java_learn\\file\\src\\main\\java\\learn\\","news3.txt");
        try {
            //通过createNewFile()方法才会在磁盘真正创建该文件
            file.createNewFile();
            System.out.println("文件3创建成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

获取文件相关信息

package learn;

import java.io.File;

public class learn02 {
    /**
     * 文件信息
     * @param args
     */
    public static void main(String[] args) {
        info();
    }
    //获取文件信息
    public static void info(){
        //先创建文件对象
        File file=new File("E:\\java_learn\\file\\src\\main\\java\\learn\\news1.txt");
        //调用相应方法得到对应信息
        //getName、getAbsolutePath、 getParent、 length、 exists、 isFile、isDirectory
        System.out.println(file.getName());
        System.out.println(file.getAbsolutePath());
        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());
    }
}

目录操作

package learn;

import java.io.File;

public class learn03 {
    /**
     * 目录操作
     * @param args
     */
    public static void main(String[] args) {
        m1();
        m2();
        m3();
    }
    //判断news1是否存在，执行删除操作
    public static void m1(){
        String filepath="E:\\java_learn\\file\\src\\main\\java\\learn\\news1.txt";
        File file=new File(filepath);
        if(file.exists()){
            if(file.delete()){
                System.out.println(filepath+"删除成功");
            }else{
                System.out.println(filepath+"删除失败");
            }
        }else{
            System.out.println("该文件不存在");
        }
    }
    //判断E:\java_learn\file\src\main\java\learn\kk目录是否存在，存在执行删除操作，否则提示不存在
    public static void m2(){
        String filepath="E:\\java_learn\\file\\src\\main\\java\\learn\\kk";
        File file=new File(filepath);
        if(file.exists()){
            if(file.isDirectory()){
                if(file.delete()){
                    System.out.println(filepath+"删除成功");
                }else{
                    System.out.println(filepath+"删除失败");
                }
            }else{
                System.out.println("该文件不是目录");
            }

        }else{
            System.out.println("该目录不存在");
        }
    }
    //判断E:\java_learn\file\src\main\java\learn\kk目录是否存在，存在就提示已存在，否则创建
    public static void m3(){
        String filepath="E:\\java_learn\\file\\src\\main\\java\\learn\\kkk";
        File file=new File(filepath);
        if(file.exists()){
            System.out.println(filepath+"存在");
        }else{
            System.out.println("该目录不存在，创建该目录");
            if(file.mkdirs()){//创建一级目录用mkdir(),创建多级目录用mkdirs().
                System.out.println("该目录创建成功");
            }else{
                System.out.println("该目录创建失败");
            }
        }
    }
}

IO流类图

IO流原理及流的分类

InputStream、OutputStream、Reader、Writer都是抽象类，不能直接实例化，只能通过子类创建实例对象

输入输出流就相当于一个外卖小哥，文件中的数据就相当于物流中心的商品，文件中的数据需要一个传递者(通道)来就行传输，此处的传递者就是流。

IO流常用类

InputStream（字节输入流）

InputStream抽象类是所有类字节输入流的超类

常用子类：

FileInputStream 文件输入流

BufferedInputStream 缓冲字节输入流

ObjectInputStream 对象字节输入流

FileInputStream文件输入流

package learn;

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

/**
 * 演示FileInputStream的使用(字节输入流  文件-->程序)
 */
public class learn04 {
    public static void main(String[] args) {
        f1();
        f2();
    }

    /**
     * 单个字节读取，效率低
     */
    public static void f1(){
        String filePath="E:\\java_learn\\file\\src\\main\\java\\learn\\ceshi1.txt";
        int readData=0;
        FileInputStream fileInputStream=null;
        try {
            //创建FileInputStream对象,用于读取文件
            fileInputStream = new FileInputStream(filePath);
            //如果返回-1，表示读取完毕
            while((readData = fileInputStream.read())!=-1){
                System.out.print((char)readData);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * 使用read(byte[] b)优化
     */
    public static void f2(){
        String filePath="E:\\java_learn\\file\\src\\main\\java\\learn\\ceshi1.txt";
        int readLen=0;
        FileInputStream fileInputStream=null;
        byte[] buf=new byte[8];//尝试一次读取8个字节
        try {
            //创建FileInputStream对象,用于读取文件
            fileInputStream = new FileInputStream(filePath);
            //如果返回-1，表示读取完毕
            //如果读取正常，返回实际读取的字节数
            while((readLen = fileInputStream.read(buf))!=-1){
                System.out.print(new String(buf,0,readLen));//显示，偏移量off==0，偏移量前的数据默认为NULL值
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

使用read(byte[] b)即可，一次读取字节数自定。

注：一个个读取时，读取返回的int类型说明：是字符的ascii码，比如a–97，b–98。

byte数组读取，返回值是一次读取的最大字节数，

OutputStream(字节输出流)

FileOutputStream文件输出流

在目录已经存在的前提下，如果待写入的文件不存在，会创建文件写入

package learn;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

/**
 * 演示FileOutputStream
 */
public class learn05 {
    public static void main(String[] args) {
        f1();
    }
    public static void f1(){
        String filePath="E:\\java_learn\\file\\src\\main\\java\\learn\\ceshi3.txt";
        FileOutputStream fileOutputStream=null;
        String s="fsefsf";
        byte[] bytes = s.getBytes();
        try {
            //fileOutputStream = new FileOutputStream(filePath);//该创建方式写入内容会覆盖原来的内容
            fileOutputStream=new FileOutputStream(filePath,true);//写入内容追加到文件末尾
            //写入一个字节
            //fileOutputStream.write('a');
            fileOutputStream.write(bytes);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

文件拷贝

package learn;

import java.io.*;

public class learn06 {
    public static void main(String[] args) {
        //完成文件拷贝，将某某图片拷贝到该目录下
        copy();
        copy02();
    }

    private static void copy() {
        String filepath1="E:\\重邮\\截图\\14c2e7ab3e4c58c498c427de8b5ffa68.jpg";
        String filepath2="E:\\java_learn\\file\\src\\main\\java\\learn\\image\\image1.jpg";
        FileInputStream fileInputStream=null;
        FileOutputStream fileOutputStream=null;
        int len=0;
        //定义一个字节数组，提高读取效果
        byte[] buf=new byte[1024];
        try {
            fileInputStream = new FileInputStream(filepath1);
            fileOutputStream=new FileOutputStream(filepath2);
            while((len=fileInputStream.read(buf))!=-1){
                //一边读一边写
                fileOutputStream.write(buf,0,len);//一定要使用这个方法
                //fileOutputStream.write(buf);//使用该方法，如果最后只剩不到1024个字节的数据，还是会读入1024个，文件损失。
            }
            System.out.println("copy ok~");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
    private static void copy02() {
        String filepath1="E:\\重邮\\截图\\14c2e7ab3e4c58c498c427de8b5ffa68.jpg";
        String filepath2="E:\\java_learn\\file\\src\\main\\java\\learn\\image\\image2.jpg";
        FileInputStream fileInputStream=null;
        FileOutputStream fileOutputStream=null;
        int len=0;
        try {
            fileInputStream = new FileInputStream(filepath1);
            fileOutputStream=new FileOutputStream(filepath2);
            while((len=fileInputStream.read())!=-1){
                fileOutputStream.write(len);//尝试了一下单个读取
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

就使用字节数组来读，效率更高。

文件字符流

FileReader & FileWriter

package learn;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/**
 * 字符流
 *
 */
public class learn07 {
    public static void main(String[] args) {
       /* f1();
        f2();*/
        f3();
    }

    /**
     * 读一个字符
     */
    private static void f1() {
        String filepath="E:\\java_learn\\file\\src\\main\\java\\learn\\txt\\ceshi1.txt";
        FileReader fr=null;
        int ch=0;
        try {
            fr=new FileReader(filepath);
            while((ch=fr.read())!=-1){
                System.out.print((char)ch);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if(fr!=null) {
                    fr.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 将字符读入数组
     */
    private static void f2() {
        String filepath="E:\\java_learn\\file\\src\\main\\java\\learn\\txt\\ceshi1.txt";
        FileReader fr=null;
        int len=0;
        char[] c=new char[8];
        try {
            fr=new FileReader(filepath);
            while((len=fr.read(c))!=-1){
                System.out.print(new String(c,0,len));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if(fr!=null) {
                    fr.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * 单个字符写文件
     */
    public static void f3(){
       String filepath="E:\\java_learn\\file\\src\\main\\java\\learn\\txt\\ceshi2.txt";
        FileWriter fw=null;
        char[] chars={'a','b','c'};
        try {
            fw=new FileWriter(filepath);
            //write(int):写入单个字符
            fw.write('D');
            //write(char[]):写入指定数组
            fw.write(chars);
            //write(char[],off,len):写入指定数组的指定部分
            fw.write(chars,1,2);
            //write (string):写入整个字符串
            String s="动画设计";
            fw.write(s);
            //write(string,off,len):写入字符串的指定部分
            fw.write(s,2,2);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {//对于FileWriter，一定要关闭流，或者flush才能真正的把数据写入到文件
            try {
                if(fw!=null){
                    fw.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

close()的作用，在其源码中发现其对数据进行了写操作

private void writeBytes() throws IOException {
    bb.flip();
    int lim = bb.limit();
    int pos = bb.position();
    assert (pos <= lim);
    int rem = (pos <= lim ? lim - pos : 0);

        if (rem > 0) {
    if (ch != null) {
        if (ch.write(bb) != rem)
            assert false : rem;
    } else {
        out.write(bb.array(), bb.arrayOffset() + pos, rem);
    }
    }
    bb.clear();
    }

此处才真正将数据写入文件中，相当于一个flush()+关闭

节点流和处理流

注意：

BufferedReader & BufferedWriter源码：

其中有Reader & Writer属性,意思是BufferedReader & BufferedWriter都可以都可以封装一个节点流，这个节点流是任意的，只要是Reader & Writer的子类，那么在对数据进行读写时，就可以通过处理流（包装流）对已存在的流进行包装以提供更强大的读写功能

处理流设计模式

就是利用其内部的抽象基类（InputStream、OutputStream、Reader、Writer）属性实现不同子类方法的调用，丰富子类方法，就可以丰富包装类功能，包装类本身还具有些方法。

BufferedReader & BufferedWriter

在底层会直接关闭我们包装的流

package learn;

import java.io.*;

public class Buffered_R_W {
    public static void main(String[] args) {
        f1();
        f2();
    }

    private static void f1() {
        String filePath="E:\\java_learn\\file\\src\\main\\java\\learn\\txt\\ceshi1.txt";
        BufferedReader br=null;
        char[] chars=new char[10];
        int len=0;
        try {
            br=new BufferedReader(new FileReader(filePath));
            /*while((len=br.read(chars))!=-1){
                System.out.print(new String(chars,0,len));
            }*/
            //按行读取
            String line;//按行读取，效率高
            while((line=br.readLine())!=null){
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    private static void f2() {
        String filePath="E:\\java_learn\\file\\src\\main\\java\\learn\\txt\\ceshi2.txt";
        BufferedWriter bw=null;
        try {
            bw=new BufferedWriter(new FileWriter(filePath));
            //bw=new BufferedWriter(new FileWriter(filePath,true));//追加
            bw.write("ggggytfhg");
            //建议插入一个和系统相关的换行
            bw.newLine();
            //关闭外层流即可,传入的new FileWriter(filepath),会在底层关闭
            bw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Buffered拷贝

package learn;

import java.io.*;

public class Buffered_R_W_Copy {
    public static void main(String[] args) {
        copy1();
    }

    private static void copy1() {

        //BufferedReader和BufferedWriter是对字符操作，不要去操作二进制文件，可能会造成文件损坏

        String filepath1="E:\\java_learn\\file\\src\\main\\java\\learn\\txt\\ceshi1.txt";
        String filepath2="E:\\java_learn\\file\\src\\main\\java\\learn\\txt\\ceshi2.txt";
        BufferedReader br=null;
        BufferedWriter bw=null;
        try {
            br=new BufferedReader(new FileReader(filepath1));
            bw=new BufferedWriter(new FileWriter(filepath2));
            String line=null;
            //按行读写
            while((line=br.readLine())!=null){
                bw.write(line);
                bw.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                bw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

Buffered字节处理流

BufferedInputStream和BufferedOutputStream

和BufferedReader一样，也是使用的修饰器模式，唯一不同的是抽象基类属性是从其父类FilterInputStream、FilterOutputStream继承而来

BufferedInputStream在创建时，会创建一个内部缓冲区数组

BufferedOutputStream是字节流，实现缓冲的输出流，可以将多个字节写入底层的输出流中，而不必对每次字节写入调用底层系统。

字节处理流拷贝文件

package learn;

import java.io.*;

/**
 * 演示BufferedOutputStream和BufferedInputStream的使用
 * 可以实现二进制文件的拷贝，当然，文本文件也可以
 */
public class Buffered_IS_OS {
    public static void main(String[] args) {
        copy1();
    }

    private static void copy1() {
        String filePath1="E:\\java_learn\\file\\src\\main\\java\\learn\\image\\image1.jpg";
        String filePath2="E:\\java_learn\\file\\src\\main\\java\\learn\\image\\image4.jpg";
        BufferedInputStream bis=null;
        BufferedOutputStream bos=null;
        byte[] byt=new byte[1024];
        int len=0;
        try {
            bis=new BufferedInputStream(new FileInputStream(filePath1));
            bos=new BufferedOutputStream(new FileOutputStream(filePath2));
            while((len=bis.read(byt))!=-1){
                bos.write(byt,0,len);
            }
            System.out.println("copy ok~");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                bis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                bos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

对象处理流

**重点：序列化和反序列化

package learn;

import java.io.*;

/**
 * 完成ObjectOutputStream的使用，完成数据的序列化
 */
public class Serializable_test {
    public static void main(String[] args) {
        f1();
        f2();
    }

    private static void f1() {
        //序列化后，保存的文件格式不是纯文本的，而是按照他的格式来保存的
        String filePath="E:\\java_learn\\file\\src\\main\\java\\learn\\txt\\data.dat";
        ObjectOutputStream oos=null;
        try {
            oos=new ObjectOutputStream(new FileOutputStream(filePath));
            //序列化数据到data.dat中
            oos.writeInt(100);//int -> Integer(实现了 Serializable 接口)
            oos.writeBoolean(true);//boolean -> Boolean(实现了 Serializable 接口)
            oos.writeChar('a');
            oos.writeDouble(9.5);
            oos.writeUTF("测试");//String
            //自定义类对象
            oos.writeObject(new Cat("猫",10));//会抛出没有序列化的异常
            System.out.println("写入成功");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                oos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static void f2(){
        String filePath="E:\\java_learn\\file\\src\\main\\java\\learn\\txt\\data.dat";
        ObjectInputStream ois=null;
        try {
            ois=new ObjectInputStream(new FileInputStream(filePath));
            //读取
            //读取(反序列化)的顺序需要和你保存数据(序列化)的顺序一致，否则会出现异常
            System.out.println(ois.readInt());
            System.out.println(ois.readBoolean());
            System.out.println(ois.readChar());
            System.out.println(ois.readDouble());
            System.out.println(ois.readUTF());
            //cat的编译类型是Object，运行类型是Cat
            Object cat=ois.readObject();
            System.out.println("class="+cat.getClass());
            System.out.println("cat信息="+cat);//底层 Object -> Cat

            //注意，此处有一个特别重要的细节：
            //如果我们希望调用Cat的方法，需要向下转型
            //需要我们将Cat类的定义拷贝到可以引用的位置
            Cat cat2= (Cat) cat;
            System.out.println(cat2.getName());
            
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }finally {
            try {
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

//如果需要序列化某个类对象，必须实现Serializable接口
    static class Cat implements Serializable{
        private String name;
        private int age;

        public Cat() {
        }

        public Cat(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 "Cat{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
}

使用细节

标准输入输出流

package learn;

import java.io.PrintStream;

public class In_Out {
    public static void main(String[] args) {
        //System 类的属性 public static final InputStream in = null;
        //System.in 的编译类型 InputStream
        //System.in 运行类型 BufferedInputStream
        //表示标准输入  键盘
        System.out.println(System.in.getClass());
        //System 类的属性  public static final PrintStream out = null;
        //System.out 的编译类型 PrintStream
        //System.out 运行类型 PrintStream
        //表示标准输出  显示器
        System.out.println(System.out.getClass());
    }
}

转换流

InputStreamReader & OutputStreamWriter

将字节流转换成字符流

transformation(转型)

默认情况下，读取文件按照utf-8编码，如果文本文件不是utf-8编码，就会出现乱码，因为使用字节流可以指定读取的编码格式，但是效率低，所以出现了转换流，即字符流的效率+字节流的指定编码格式

转换流是字符流

package learn.transformation;

import java.io.*;
import java.nio.charset.StandardCharsets;

public class Tr_In_Out {
    public static void main(String[] args) {
        //f1();
        f2();
    }

    /**
     * 使用InputStreamReader转换流解决中文乱码问题
     * 将字节流FileInputStream转换成字符流 InputStreamReader,指定编码gbk/utf-8
     */
    private static void f1() {
        String filePath="E:\\java_learn\\file\\src\\main\\java\\learn\\txt\\ceshi4.txt";
        BufferedReader br=null;
        try {
            br=new BufferedReader(new InputStreamReader(
                    new FileInputStream(filePath), "gbk"));
            String line=null;
            while((line=br.readLine())!=null){
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * OutputStreamWriter
     */
    public static void f2(){
        String filePath="E:\\java_learn\\file\\src\\main\\java\\learn\\txt\\ceshi4.txt";
        BufferedWriter bw=null;
        String charSet="utf-8";
        try {
            bw=new BufferedWriter(new OutputStreamWriter(
                    new FileOutputStream(filePath),charSet));
            bw.write("hi,很大声接电话");
        }catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                bw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

打印流

PrintStream 和 PrintWriter

打印流只有输出流，没有输入流

package learn;

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintStream;
import java.io.PrintWriter;

public class Print_ {
    public static void main(String[] args) throws IOException {
        //f1();
        f2();
    }

    /**
     * 字节打印流
     * @throws IOException
     */
    private static void f1() throws IOException {
        PrintStream out=System.out;
        out.print("test");
        out.write("测试".getBytes());
        out.close();
        //重定向输出设备到文件
        //源码：public static void setOut(PrintStream out) {
        //        checkIO();
        //        setOut0(out);//native方法，修改了out
        //    }
        System.setOut(new PrintStream("E:\\java_learn\\file\\src\\main\\java\\learn\\txt\\ceshi3.txt"));
        System.out.println("再度测试");
    }

    /**
     * 字符打印流
     */
    private static void f2() throws IOException {
        PrintWriter pw=new PrintWriter(System.out);
        pw.print("ceshi");
        pw.close();

        PrintWriter pw1=new PrintWriter(new FileWriter("E:\\java_learn\\file\\src\\main\\java\\learn\\txt\\ceshi3.txt"));
        pw1.print("字符打印流测试");
        pw1.close();//flush+关闭流
    }
}

字符打印流可包装Writer、OutputStream，可打印至文件File

Properties

配置文件的读写操作

package learn.properties_;

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

public class Properties01 {
    public static void main(String[] args) throws IOException {
        //使用Properties类来读取jdbc.properties文件
        //创建Properties对象
        Properties properties=new Properties();
        //加载指定配置文件
        properties.load((new FileReader("E:\\java_learn\\file\\src\\jdbc.properties")));
        //把k-v显示控制台
        properties.list(System.out);
        //根据key获取对应值
        String user = properties.getProperty("jdbc.user");
        System.out.println(user);
    }
}

package learn.properties_;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;

public class properties02 {
    public static void main(String[] args) throws IOException {
        f1();
    }

    private static void f1() throws IOException {
        //使用Properties类来创建配置文件，修改配置文件内容
        Properties properties=new Properties();
        //如果该文件没有key，就创建，有就修改
        /*
        Properties父类是Hashtable，底层是Hashtable ，核心方法
        
            public synchronized V put(K key, V value) {
                // Make sure the value is not null
                if (value == null) {
                    throw new NullPointerException();
                }

                // Makes sure the key is not already in the hashtable.
                Entry<?,?> tab[] = table;
                int hash = key.hashCode();
                int index = (hash & 0x7FFFFFFF) % tab.length;
                @SuppressWarnings("unchecked")
                Entry<K,V> entry = (Entry<K,V>)tab[index];
                for(; entry != null ; entry = entry.next) {
                    if ((entry.hash == hash) && entry.key.equals(key)) {
                        V old = entry.value;
                        entry.value = value;//如果存在就修改
                        return old;
                    }
                }

                addEntry(hash, key, value, index);//不存在就新建
                return null;
            }
        */
        properties.setProperty("charset","utf-8");
        properties.setProperty("user","汤姆");//注意保存时，是中文的unicode码值
        properties.setProperty("pwd","8888");
        //将k-v存储在文件中即可
        properties.store(new FileOutputStream("src\\jdbc2.properties"),null);
        System.out.println("ok~");
    }
}

new NullPointerException();
}

            // Makes sure the key is not already in the hashtable.
            Entry<?,?> tab[] = table;
            int hash = key.hashCode();
            int index = (hash & 0x7FFFFFFF) % tab.length;
            @SuppressWarnings("unchecked")
            Entry<K,V> entry = (Entry<K,V>)tab[index];
            for(; entry != null ; entry = entry.next) {
                if ((entry.hash == hash) && entry.key.equals(key)) {
                    V old = entry.value;
                    entry.value = value;//如果存在就修改
                    return old;
                }
            }

            addEntry(hash, key, value, index);//不存在就新建
            return null;
        }
    */
    properties.setProperty("charset","utf-8");
    properties.setProperty("user","汤姆");//注意保存时，是中文的unicode码值
    properties.setProperty("pwd","8888");
    //将k-v存储在文件中即可
    properties.store(new FileOutputStream("src\\jdbc2.properties"),null);
    System.out.println("ok~");
}

}