package IO.Test01;

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

public class FileOutPutStream02 {
    public static void main(String[] args) throws IOException {
        //创建文件输出对象
        FileOutputStream fileOutputStream = new FileOutputStream("D:\\Test01\\InputStreamTest01");
        byte a = 10;
        fileOutputStream.write(a);
        byte[] bytes = {1, 2, 3, 4};
        fileOutputStream.write(bytes);
        
        fileOutputStream.write(bytes, 1, 2);//bytes数组，索引从1开始，存入2个长度
    }
}

package IO.Test01;

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

public class FileOutputStream03 {
    public static void main(String[] args) throws IOException {
        //1.创建文件输出流对象
        FileOutputStream fileOutputStream = new FileOutputStream("D:\\Test01\\InputStreamTest01.txt");
        //2.写出内容
        byte[] bytes ={97,98,99,100,101};
        fileOutputStream.write(bytes);
        //加入换行符 getBytes()能够在字符串转为byte类型
        fileOutputStream.write("\r\n".getBytes());
        //存入bytes数组，索引从off开始，存入len个长度
        fileOutputStream.write(bytes,1,3);
        fileOutputStream.write("\r\n".getBytes());
        //3.关闭流
        fileOutputStream.close();
    }
}

package IO.Test01;

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

public class FileOutputStream04 {
    public static void main(String[] args) {
        //1.创建对象
        FileOutputStream fileOutputStream = null;
        try {
            File file = new File("D:\\Test01\\InputStreamTest01.txt");
            //第一次捕获异常
            fileOutputStream = new FileOutputStream(file，true);//也可以直接写路径，但是船舰File对象好处是，可以进行非空判断
            if (file != null && file.length() >= 0) {
                //2.写数据
                String str = "energy in my heart";
                //3.将字符串转为字节类型数组 调用getbytes()方法
                 fileOutputStream.write(str.getBytes());//第二次捕获异常
            }


        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileOutputStream.close();//第三次捕获异常
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

package IO.Test01;

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

public class FileOutputStream04 {
    public static void main(String[] args) {
        //1.创建对象
        FileOutputStream fileOutputStream = null;
        try {
            File file = new File("D:\\Test01\\InputStreamTest01.txt");
            //第一次捕获异常
            fileOutputStream = new FileOutputStream(file,true);//也可以直接写路径，但是船舰File对象好处是，可以进行非空判断
            if (file != null && file.length() >= 0) {
                //2.写数据
                String str = "energy in my heart";
                //3.将字符串转为字节类型数组 调用getbytes()方法
                 fileOutputStream.write(str.getBytes());//第二次捕获异常
            }


        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileOutputStream.close();//第三次捕获异常
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

package IO.Test01;

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

public class FileInputStream01 {
    public static void main(String[] args) {
        FileInputStream fileInputStream = null;
        try {
            //第一次捕获异常
            fileInputStream = new FileInputStream("D:\\Test01\\InputStreamTest01.txt");
            
            //实例1
            int read = fileInputStream.read();//第二次捕获异常，捕获第一个字节，然后使索引加1
            System.out.println((char) read);//是的read输出为char型
            //最佳使用方法while循环遍历
            int len;
            while ((len = fileInputStream.read()) != -1) {
                System.out.println(len);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileInputStream.close();//第三次捕获异常
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

package IO.Test01;

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

public class FileInputStream02 {
    public static void main(String[] args) {
        FileInputStream fileInputStream = null;//输入
        FileOutputStream fileOutputStream = null;//输出
        try {
            fileInputStream = new FileInputStream("D:\\Test01\\InputStreamTest01.txt");//输入
            fileOutputStream = new FileOutputStream("D:\\Test01\\InputStreamTest02.txt");//输出
//            byte[] bytes = {97, 98, 99};
//            int read = fileInputStream.read(bytes);//read(byte[] b)返回读取到的字节数
//            System.out.println(read);//3
//            System.out.println(fileInputStream.read());//100，读取的第四个字节，每次跨国len个字节，len为byte[]的长度

            //文件之间的拷贝
            byte[] bytes = new byte[1024];//1024b=1kb
            int len;
            // int read(byte[] b) : 一次读一个字节组数据(通常数组长度为1024)，把数据封装到参数b中，返回值为本次读取到的字节个数，b默认值为0
            while ((len = fileInputStream.read(bytes)) != -1) {//fileInputStream.read(bytes)会将得到的数据封装到bytes中
                fileOutputStream.write(bytes, 0, len);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileOutputStream.close();
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

package IO.BufferedOutStream;

import java.io.*;

public class BufferedOutputStream01 {

    public static void main(String[] args) {
        //创建 字节缓冲流对象
        BufferedOutputStream bos = null;
        BufferedInputStream bis = null;
        try {
            bos = new BufferedOutputStream(new FileOutputStream("D:\\Test01\\InputStreamTest01.txt"));
            bis = new BufferedInputStream(new FileInputStream("D:\\Test01\\InputStreamTest01.txt"));
            //实现对拷操作
            byte[] bytes = new byte[1024];
            int len;
            while ((len = bis.read(bytes)) != -1) {
                //将数据写出到file文件中
                bos.write(bytes, 0, len);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                bis.close();
                bos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

package Homework.IO;

import java.io.*;
import java.nio.file.Files;

//把一个文件夹目录   拷贝到项目模块目录下。（要求：文件夹及其子文件全部拷贝）

//尝试使用缓冲流完成这个copy操作。
public class Demo03 {
    public static void main(String[] args) throws IOException {
        File srcFile = new File("D:\\Test01");
        File destFile = new File("D:\\IOTest");
        create(srcFile, destFile);
    }

    public static void create(File srcFile, File destFile) throws IOException {
        //创建输入输出流
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        File[] files = srcFile.listFiles();//获取源路径下的所有路径名
        for (File file : files) {//循环遍历源路径下的所有一级文件
            if (file.isDirectory()) {
                String name = srcFile.getName();//获取目标名
                File file2 = new File(destFile.getPath() + File.separator + file.getName());//防止拒绝访问
                if (!file2.exists()) {//判断该文件夹是否存在
                    //如果不存在则创建该文件夹
                    file2.mkdir();
                    //递归调用该方法，继续复制
                    create(file, file2);
                }
            } else {
                //如果不是文件夹，则复制文件
                try {//创建输入输出流
                    File newFile = new File(destFile.getPath() + File.separator + file.getName());//防止拒绝访问
                    bis = new BufferedInputStream(new FileInputStream(file));
                    bos = new BufferedOutputStream(new FileOutputStream(newFile));
                    //写数据
                    int len;
                    byte[] bytes = new byte[1024];
                    while ((len = bis.read(bytes)) != -1) {
                        bos.write(bytes);
                    }
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                } finally {
                    try {
                        bos.flush();
                        bos.close();
                        bis.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }


            }

        }
    }
}

package ReaderAndWirter;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class Code_Learn {
    public static void main(String[] args) throws UnsupportedEncodingException {
      //编码byte[] getBytes(String charsetName)
        String str = "小黑子树枝666";//想要输入的值
        byte[] bytes = str.getBytes();//将想要输入的值转换为字节类型，存入字节数组，UTF-8默认编码格式，一个中文三个字节
        System.out.println(Arrays.toString(bytes));//输出bytes集合，中文会变成负数
        //[-27, -80, -113, -23, -69, -111, -27, -83, -112, -26, -96, -111, -26, -98, -99, 54, 54, 54]

        byte[] bytes1 = str.getBytes("UTF-8");//抛出异常，UnsupportedEncodingException
        System.out.println(Arrays.toString(bytes1));
        //[-27, -80, -113, -23, -69, -111, -27, -83, -112, -26, -96, -111, -26, -98, -99, 54, 54, 54]

        byte[] gbks = str.getBytes("GBK");//GBK中，一个中文两个字节
        System.out.println(Arrays.toString(gbks));
        //[-48, -95, -70, -38, -41, -45, -54, -9, -42, -90, 54, 54, 54]

      //解码String(byte[] bytes, String charsetName)
        String str1 = new String(bytes);
        System.out.println(str1);//默认编码 UTF-8
        //小黑子树枝666

        String str2 = new String(bytes, "GBK");
        System.out.println(str2);//默认编码 UTF-8,用GBK去解码，会出现乱码
        // 灏忛粦瀛愭爲鏋�666

    }
}

package ReaderAndWirter;

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

public class ReadAndWrite01 {
    public static void main(String[] args) {
        //创建字符输入流对象
        FileReader fileReader = null;
        FileWriter fileWriter = null;


        try {
            fileReader = new FileReader("src/ikun");
            fileWriter = new FileWriter("src/abc.txt");//没有文件的话，会先创建
            //开始读取 写入文件
            int len;
            while ((len=fileReader.read())!=-1){
                fileWriter.write(len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //关流
            try {
                fileWriter.close();
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }
}

package ReaderAndWirter;

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

public class ReaderAndWriter01 {
    public static void main(String[] args) throws IOException {//本示例代码直接抛出异常
        FileWriter fileWriter = null;
        fileWriter = new FileWriter("src/a");
        char[] chars = {97, 98, 99, 100};
        String str = "ikun";
        fileWriter.write(98);// void write(int c)
        fileWriter.write(chars);//void write(char[] cbuf)
        fileWriter.write(chars, 1, 2);//void write(char[] cbuf, int off, int len)
        fileWriter.write("98");//void write(String str)
        fileWriter.write(str);//void write(String str, int off, int len)
        fileWriter.flush();
        fileWriter.close();
    }
}

package ReaderAndWirter;

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

public class ReaderAndWriterTest01 {
    public static void main(String[] args) {
        //1.创建扫描器 键盘录入 用户名密码
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入用户名：");
        String username = scanner.next();
        System.out.println("请输入密码：");
        String password = scanner.next();

        //2.创建 输出流 将用户数据存入本地文件夹中
        FileWriter fw = null;
        try {
            fw = new FileWriter("src/abc.txt");
            byte[] bytes = new byte[1024];
            fw.write("username："+username);
            fw.write("\r\n");
            fw.write("password："+password);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fw.flush();
                fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

package Buffered;

import java.io.*;
/*构造方法：
 * BufferedWriter(Writer out)
 * void newLine()：写一行行分隔符，行分隔符字符串由系统属性定义

 * BufferedReader(Reader in)
 * public String readLine() ：读一行文字。 结果包含行的内容的字符串，不包括任何行终止字符，如果流的结尾已经到达，则为null
 */

public class BufferedReaderAndWriter {
    public static void main(String[] args) {
        //创建缓冲流字符输入流/输出流
        BufferedReader bufferedReader = null;
        BufferedWriter bufferedWriter = null;
        try {
            bufferedReader = new BufferedReader(new FileReader("src/a"));
            bufferedWriter = new BufferedWriter(new FileWriter("src/aaaa"));
            //普通方法
//            int len;
//            while ((len = bufferedReader.read()) != -1) {
//                bufferedWriter.write(len);
//            }
            String line;
            while ((line = bufferedReader.readLine()) != null) {//public String readLine()
                bufferedWriter.write(line);//写一行数据
                bufferedWriter.newLine();//换行

            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                bufferedWriter.flush();
                bufferedWriter.close();
                bufferedReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

package ReaderAndWirter;

import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Demo01 {
    public static void main(String[] args) {
        //创建输入和输出流对象
        BufferedWriter bw = null;
        BufferedReader br = null;
        //创建集合，便于排序
        ArrayList<String> arrayList = new ArrayList<>();
        try {
            br = new BufferedReader(new FileReader("src/a"));
            bw = new BufferedWriter(new FileWriter("src/a", true));//添加true使得写文件时，不会清空文件夹的内容
            //读取数据
            String line;
            while ((line = br.readLine()) != null) {
                //取出数据 添加到集合中 并排序
                arrayList.add(line);
                // bw.write(line);

            }
            //对集合中的元素 完成排序
            Collections.sort(arrayList, new Comparator<String>() {//Collections.sort(list,Comparator<String>())自定义集合排序方式
                @Override
                public int compare(String o1, String o2) {
                    return o1.hashCode() - o2.hashCode();//利用哈希值进行比较
                }
            });
            System.out.println("排序后：" + arrayList);//打印集合内容

              //将集合中的内容写入到文件夹中
/*            for (String s : arrayList) {
                bw.write(s);
                bw.newLine();
            }
*/
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                br.close();
                bw.flush();
                bw.close();

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

package ObjectManipilationStream;

import java.io.Serializable;

//学生对象
public class Students implements Serializable {
    private String name;
    private int age;

    @Override
    public String toString() {
        return "Students{" +
                "name='" + name + '\'' +
                ", 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;
    }

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

package ObjectManipilationStream;

import java.io.*;

/*
 * 对象操作流 用来操作对象
 * 1. 对象输入流 将对象从文件中读取出来 反序列化过程
 * 2. 对象输出流 将对象保存到文件中 序列化的过程
 * 序列化： 将对象保存到磁盘
 * 反序列化：将对象从磁盘中取出
 *
 * 前提条件：在向文件中存储对象时，必须将类实现序列化接口
 * */
public class ObjectManipulationStream01 {
    public static void main(String[] args) {
        ObjectOutputStream oos = null;
        ObjectInputStream ois = null;
        try {
            //1.创建输入输出流
            ois = new ObjectInputStream(new FileInputStream("src/ObjectManipilationStream/Object01"));
            oos = new ObjectOutputStream(new FileOutputStream("src/ObjectManipilationStream/Object01"));
            //2.写数据
            Students s1 = new Students("撒旦", 98);
            oos.writeObject(s1);//形参为对象类型
            //读数据
            Students s2 = (Students) ois.readObject();//强制类型转换才可以用Students接收
            System.out.println(s2);//Students{name='撒旦', age=98}
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        } finally {

            try {
                ois.close();
                oos.flush();
                oos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
}

package ObjectManipilationStream;

import IO.Demo01.Student;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.Date;

public class ObjectManipulationStream02 {
    public static void main(String[] args) throws IOException {
        //创建
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("src/a"));
        //写
        oos.writeInt(123);//注意方法名
        oos.writeObject(new Date());
        oos.writeObject(new Students("小黑子", 666));
        //关
        oos.flush();
        oos.close();
    }
}

package ObjectManipilationStream;

import java.io.Serializable;

//学生对象
/*生成serialVersionUID两种方法
 * 1.死值 private static final long serialVersionUID = 42l;
 * 2.系统生成
 * */
public class Students implements Serializable {
    //写一个死值
    private static final long serialVersionUID = 42l;
    //serialVersionUID = -6439917428245416448
    private String name;
    private int age;
    private String sex;//二次修改后增添的值
    
    @Override
    public String toString() {
        return "Students{" +
                "name='" + name + '\'' +
                ", 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;
    }

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

package ObjectManipilationStream;

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

public class ObjectManipulationStream03 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("src/a"));
        Students s2 = (Students) ois.readObject();
        System.out.println(s2);
        ois.close();
    }
    /*
    Exception in thread "main" java.io.InvalidClassException: ObjectManipilationStream.Students;
    local class incompatible: stream classdesc serialVersionUID = -6439917428245416448(存储时的序列化ID), local class serialVersionUID = -8371228507770588511(修改后新的序列化ID)二者不相同，程序报错
    at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:699)
    at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:2028)
    at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1875)
    at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:2209)
    at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1692)
    at java.io.ObjectInputStream.readObject(ObjectInputStream.java:508)
    at java.io.ObjectInputStream.readObject(ObjectInputStream.java:466)
    at ObjectManipilationStream.ObjectManipulationStream03.main(ObjectManipulationStream03.java:11)
    */
}

package Properties;

import java.util.Properties;
import java.util.Set;

/*Properties作为Map集合实现增删改查
* 只能存储字符串的
* Object setProperty(String key, String value)	设置集合的键和值，都是String类型，底层调用 Hashtable方法 put
* String getProperty(String key)	使用此属性列表中指定的键搜索属性
* Set<String> stringPropertyNames()	从该属性列表中返回一个不可修改的键集，其中键集其对应的值是字符串
* */
public class Properties01 {
    public static void main(String[] args) {
        Properties properties = new Properties();//{age=18, name=小黑子, sex=男}
        //增
        properties.setProperty("name","小黑子");
        properties.setProperty("age","18");
        properties.setProperty("sex","男");
        //删
        Object name = properties.remove("name");//{age=18, sex=男}
        System.out.println(name);//张三 删除键，返回的是键对应的值
        //改
        properties.setProperty("age","19");//{age=19, sex=男} 键名不能重复
        //查
        Set<Object> set = properties.keySet();//获取键，但是没法获取值,因为keySet返回类型为Object
        for (Object o : set) {//只有键名，没有值
           // System.out.println(o);
        }

        Set<String> set1 = properties.stringPropertyNames();//从该属性列表中返回一个不可修改的键集，其中键，及其对应的值是字符串
        for (String s : set1) {//获取值
            String value = properties.getProperty(s);
            System.out.println("Key:"+s+"Value"+"\t"+value);
        }

        System.out.println(properties);
    }
}

package Properties;

import java.io.*;
import java.util.Properties;
import java.util.Set;

/*
* void load(InputStream inStream)	从输入字节流读取属性列表（键和元素对）
void load(Reader reader)	从输入字符流读取属性列表（键和元素对）
void store(Writer writer, String comments)	将此属性列表（键和元素对）写入此 Properties表中，以适合使用 load(Reader)方法的格式写入输出字符流
*Properties通产用来读取，properties后缀的文件，称之为java中的配置文件
*
* */
public class Properties02 {
    public static void main(String[] args) throws IOException {
        //创建Properties 集合对象
        Properties properties = new Properties();
        properties.setProperty("ikun01","树枝666");
        properties.setProperty("ikun02","食不食油饼");
        properties.setProperty("ikun03","香精监狱");
        properties.setProperty("ikun04","香翅捞饭");
        System.out.println(properties);//{ikun=香翅捞饭}
        //{ikun04=香翅捞饭, ikun03=香精监狱, ikun02=食不食油饼, ikun01=树枝666}
        //创建输入流
        FileInputStream fis = new FileInputStream("src/Prop.properties");
        //加载
        properties.load(fis);
        System.out.println(properties);
        //{ikun04=香翅捞饭, ikun03=香精监狱, ikun02=食不食油饼, ikun01=树枝666}

        //将properties集合中的内容存储到配置文件中 以下创建的为字节流 想要存储汉字需要字符流
        properties.store(new FileOutputStream("src/Prop.properties"),"abc");//comments为备注，会自动在文件中生成‘#comments’，还会自动生成时间备注

        Set<String> set = properties.stringPropertyNames();
        for (String s : set) {
            String value = properties.getProperty(s);
            System.out.println("Key:"+s+"Value"+"\t"+value);
        }
        /*
        Key:ikun04Value	香翅捞饭
        Key:ikun1Value	123
        Key:ikun03Value	香精监狱
        Key:ikun02Value	食不食油饼
        Key:ikun01Value	树枝666
        Key:ikun2Value	246
*/
        
    }
}

package Properties;

import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.Properties;

/*
* - 案例需求
xx.properties:
jdbc.username=root
jdbc.password=1234
  在Properties文件中手动写上用户名密码,读取到集合中,将该数据封装成用户对象,写到本地文件.
- 实现步骤
  - 创建Properties集合,将本地文件中的数据加载到集合中.
  - 获取集合中的键值对数据,封装到用户对象中.
  - 创建序列化流对象,将用户对象序列化到本地文件中.
* */
public class Properties03 {
    public static void main(String[] args) throws IOException {
        //创建properties集合对象
        Properties properties = new Properties();
        //2.存储内容
        properties.setProperty("jdbc.username", "rppt");
        properties.setProperty("jdbc.password", "1234");
        //根据键名 获取值 存入对象中
        User user = new User();
        user.setUsername(properties.getProperty("jdbc.username"));
        user.setPassword(Integer.parseInt(properties.getProperty("jdbc.password")));
        //将对象存入到文件中 对象流要注意实现接口
        ObjectOutputStream oos= new ObjectOutputStream(new FileOutputStream("src/jdbc.properties"));
        oos.writeObject(user);
        //3.读取集合内容 写入到配置文件中 创建字符流
        FileWriter fw = new FileWriter("src/jdbc.properties");
        properties.store(fw, "jdbc");
        //关闭流
        oos.flush();
        oos.close();
        fw.close();
    }
}

package Properties;

import java.io.*;
import java.util.*;

/*
 * 案例：使用字符缓冲流读取user.txt中用户名和密码
 * 需求：读取用户名和密码，判断用户输入数据是否正确
 * 步骤：
 * 用户通过控制台输入数据
 * 读取文件内容，进行数据撕裂获取username, password
 * 比较用户输入数据是否正确
 */
public class Demo02 {
    public static void main(String[] args) throws IOException {//为了减少代码行数，本示例代码选择直接抛出异常
        //定义限制次数
        int time=3;
        //创建扫描器，获取用户输入数据
        Scanner scanner = new Scanner(System.in);
        while (true){//循环输入用户名和密码
            //输入用户名
            System.out.println("请输入用户名：");
            String username = scanner.next();
            //输入密码
            System.out.println("请输入密码：");
            String password = scanner.next();
            if (getTarget(username,password)==1){
                System.out.println("登陆成功");
                break;
            }else if (getTarget(username,password)==0){
                --time;
                System.out.println("密码错误，您当前还有"+time+"次输入次数");
            }else{
                System.out.println("用户名不存在");
            }
            if (time==0){
                break;
            }

        }
    }

    //创建方法，判断用户输入是否在本地中存在
    public static int getTarget(String username, String password) throws IOException {
        //比较次数结果
        int size = 0;
        //创建properties操作流
        Properties properties = new Properties();
        //创建字符缓冲流，获取保存的用户名和密码
        BufferedReader bf = new BufferedReader(new FileReader("src/ProtertiesTest.protetties"));
        //加载
        properties.load(bf);
        //对properties获取的值存入到集合中
        Set<String> set = properties.stringPropertyNames();
        //循环判断用户输入是否正确
        for (String s : set) {
            size++;
            if (s.equals(username)) {//判断用户名是否正确
                if (properties.getProperty(s).equals(password)) {//密码正确
                    return  1;
                }
            } else if (s.equals(username) && !properties.getProperty(s).equals(password))//密码不正确
            {
                return 0;
            }
                if (size == set.size()) {//未找到相关用户名
                    return -1;
                }
        }
        return -1;
    }
}