目的：

文件操作也是十分重要的，学习文件有关的知识和函数调用，如当需要保存数据的信息，不会随着程序结束而结束时，可使用文件进行保存，当需要时对文件进行读取即可，此外学习数据的输出和输入的原理有助于了解文件的数据传递。

技术：

1.I / O流：

I / O 流
流的方法：参考的是自己的内存空间
输出流：从内存空间将数据写到外部设备（磁盘硬盘光盘）
输入流：将外部数据写到内存中
流：统一管理数据的写入和读取
输出流：OutputStream开发者只需要将内存里面的数据写到流里面
输入流：InputStream 从流里面读取数据
输出流：OutputStream字节流 Writer字符流
输入流：InputStream字节流 Reader字符流
I/O流对象不属于内存对象需要自己关闭
OutputStream和InputStream都是抽象类不能直接使用

    FileOutputStream/FileInputStream       //字节流
    ObjectOutputStream/ObjectInputStream
    WriterOutputStream/ReaderInputStream   //字符流

2.文件操作：

（1）.文件的创建：

文件创建，需提供创建的具体路径即可，然后定义一个文件类型的对象：

         //创建文件 完整路径
        String path = "E:\\JavaStudy\\JavaXuexi\\src\\main\\java\\day8";
        //path/1.text
        File file = new File("".concat("\\1.tFext"));

同时为防止创建出错，需做抛出异常处理：
public class Myclass {
public static void main(String[] args) throws IOException, ClassNotFoundException {

    //创建文件 完整路径
    String path = "E:\\JavaStudy\\JavaXuexi\\src\\main\\java\\day8";
    //path/1.text
    File file = new File("".concat("\\1.text"));

    //判断是否存在
    if(file.exists() == false){
        //不存在就创建
        file.createNewFile();
    }

}
，在main函数后接上 throws IOException,谁调用这个main函数谁来处理I/O异常。

（2）.文件的写入：

流的方法：参考的是自己的内存空间
输出流：从内存空间将数据写到外部设备（磁盘硬盘光盘）
输入流：将外部数据写到内存中

        //向文件写入数据
        //1.创建输出流对象
        FileOutputStream fos = new FileOutputStream(file);

        //2.调用write方法写入
        byte[] text = {'1','2','3','4'};
        fos.write(text);

        //3.操作完毕需要关闭stream对象
        fos.close();

        //向文件写入数据-字符流
        FileWriter fw = new FileWriter(file);

        char[] name = {'安','卓','开','发'};
        fw.write(name);

        fw.close();

文件运行完后需要自己释放。

（3）.文件读取：

        //读取内容
        FileInputStream fis = new FileInputStream(file);

        byte[] name = new byte[12];
        fis.read(name);
        fis.close();

        System.out.println(new String(name));

        FileReader fr = new FileReader(file);

        char[] book = new char[4];
        int count = fr.read(book);

        fr.close();
        System.out.println(count+" "+ new String(book));

（4）.向文件中存入一个对象：

向文件里面存一个对象
序列化 serializable
保存对象必须实现Serializable
如果对象内部还有属性变量是其他类的对象
这个类也必须实现Seriablizable接口
eg：定义Person类和Dog类时类名后添加: implements Serializable

import java.io.Serializable;

public class Person implements Serializable {

    public String name;
    public int age;
    public Dog dog;
}

class Dog implements Serializable{
    String name;
}

进行存入：

        Dog dog1 = new Dog();
        dog1.name = "wangcai";

        Person xw = new Person();
        xw.age = 18;
        xw.name = "xiaowang";
        xw.dog = dog1;

        OutputStream os = new FileOutputStream(file);     //多态
        ObjectOutputStream oos = new ObjectOutputStream(os);
        oos.writeObject(xw);
        oos.close();

        //从文件里面读取一个对象
        InputStream is = new FileInputStream(file);
        ObjectInputStream ois = new ObjectInputStream(is);
        Person person = (Person)ois.readObject();

        ois.close();
        System.out.println(person.name+" "+person.age+" "+person.dog.name);

（5）.将一个文件拷贝到另外一个位置：

  long start = System.currentTimeMillis();
        //将一个文件拷贝到另外一个位置
        //1.源文件路径
        String sourcePath = "C:/Users/DELL/Desktop/1.png";
        //2.目标文件路径
        String desPath = "E:/JavaStudy/JavaXuexi/src/main/java/day8/1.png";
        //3.图片 字节
        FileInputStream fis = new FileInputStream(sourcePath);
        FileOutputStream fos = new FileOutputStream(desPath);

        byte[] in = new byte[1024];

        while (true) {
            int count = fis.read(in);
            if (count != -1){
                //读取到内容了
                //将这一次读取的内容写入到目标文件
                fos.write(in, 0, count);
            }else{
                break;
            }
        }
        fis.close();
        fos.close();

        long end = System.currentTimeMillis();
        System.out.println(end-start);

当拷贝大型文件时，考略效率可使用BufferedOutputStream进行优化：

  long start = System.currentTimeMillis();
        //1.源文件路径
        String sourcePath = "C:/Users/DELL/Desktop/1.png";
        //2.目标文件路径
        String desPath = "E:/JavaStudy/JavaXuexi/src/main/java/day8/2.png";

        //输入流
        InputStream is = new FileInputStream(sourcePath);
        BufferedInputStream bis = new BufferedInputStream(is);

        //输出流
        OutputStream os = new FileOutputStream(desPath);
        BufferedOutputStream bos = new BufferedOutputStream(os);

        byte[] in = new byte[1024];
        int count;
        while((count = bis.read(in)) != -1){
            bos.write(in,0,count);
        }
        bis.close();
        bos.close();

        long end =System.currentTimeMillis();

        System.out.println(end-start);

实际编程：

要求：

图案解锁
文件写入文件读取
第一次运行：
设置密码：6位
从终端一次输入一个整数
确认密码
设置过了 3次错误的机会
检查密码：相同提示解锁成功不同就提示密码不一致重新输入

1.创建FileOperation类：

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

public class FileOperation {

    public static final String PATH = "/Users/pengxiaodong/Desktop/day1/java/src/main/java/day8/Demo/pwd.txt";
    String password;

    public static final FileOperation instance = new FileOperation();

    private FileOperation(){
        try {
            load();
        }catch (IOException e){
            System.out.println("");
        }
    }

    public void load() throws IOException {
        FileInputStream fis = new FileInputStream(PATH);

        byte[] pwd = new byte[4];

        int count = fis.read(pwd);

        if (count == -1){
            password = null;
        }else{
            password = new String(pwd);
        }
        fis.close();
    }

    public void save(String password){
        try {
            FileOutputStream fos = new FileOutputStream(PATH);
            fos.write(password.getBytes());
            fos.close();
        } catch (IOException e){
            System.out.println("");
        }
    }
}

2.实现：

public class Myclass {
    public static void main(String[] args) throws IOException {


            boolean logined =false;

            //判断是否已经登录
            String password = FileOperation.instance.password;
            if (password != null){
                logined = true;
            }

            //提示用户操作
            String alert;
            if (logined) {
                alert = "请输入密码";
            } else {
                alert = "请设置密码";
            }
            System.out.println(alert);

            String firt = null;
            int wrongTime = 3;
            while (wrongTime > 0) {
                //接收用户输入
                Scanner scanner = new Scanner(System.in);
                String inputPassword = scanner.next();

                //判断操作
                if (logined) {
                    //已经登陆过 直接比较
                    if (password.equals(inputPassword)) {
                        System.out.println("解锁成功");
                        break;
                    } else {
                        System.out.println("解锁失败 请重新输入");
                        wrongTime--;
                    }
                }else{
                    //没有登陆过 在设置密码
                    //判断是设置密码的第一次还是第二次
                    if (firt == null){
                        //第一次  保存第一次输入的密码
                        firt = inputPassword;
                        System.out.println("请确认密码 ");
                    }else{
                        //第二次 比较两次输入的密码是否相同
                        if (firt.equals(inputPassword)){
                            System.out.println("设置密码成功");
                            //保存设置的密码
                            FileOperation.instance.save(firt);
                            break;
                        }else{
                            System.out.println("两次密码不一致 请重新设置密码:");
                            firt = null;
                            wrongTime--;
                        }
                    }


                }
                scanner.nextLine();
            }
    }
}

感想：

愉快的假期刚开始就结束了，期间主要是对这几天讲的知识点进行复习，理解归纳，这也是一种十分有效的学习方法哦。

文件I/O流2019-08-15