018IO流

I/O流

文件字节输入流 FileInputStream

package com.stream;

import java.io.FileInputStream;

/**
 * 文件输入流
 * FileInputStream
 */
public class Demo01 {
    public static void main(String[] args) throws Exception {
        FileInputStream fileInputStream = new FileInputStream("d:\\File.txt");

        //单个字节读取
        System.out.println("单个字节===================");
//        int data = 0;
//
//        while ((data = fileInputStream.read()) != -1) {
//            System.out.print((char) data);
//        }

        //多个字节读取
//        System.out.println("多个字节===================");
//        byte[] bytes = new byte[3];
//
//        int read = fileInputStream.read(bytes);
//        System.out.println(read);
//        System.out.println(new String(bytes));
//
//        int read1 = fileInputStream.read(bytes);
//        System.out.println(read1);
//        System.out.println(new String(bytes));
//
//        fileInputStream.close();
//        System.out.println("执行完毕");

        //多个字节 循环读取
        byte[] bytes = new byte[1024];
        int count = 0;

        while ((count = fileInputStream.read(bytes)) != -1) {
            System.out.println(new String(bytes,0,count));
        }

    }
}

文件字节输出流 FileOutputStream

package com.stream;

import java.io.FileOutputStream;

/**
 * 文件输出流的使用
 * FileOutputStream
 */
public class Demo02 {
    public static void main(String[] args) throws Exception {
        FileOutputStream fileOutputStream = new FileOutputStream("d:\\FileOutputStream.txt", true);

//        fileOutputStream.write(97);
//        fileOutputStream.write('b');
//        fileOutputStream.write('c');

        String string = "Hello World";
        fileOutputStream.write(string.getBytes());

        fileOutputStream.close();
    }
}

文件的拷贝（输入流读取–>输出流写出）

package com.stream;

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


/**
 * 输入输出流进行copy
 */
public class Demo03 {
    public static void main(String[] args) throws Exception {
        FileInputStream fileInputStream = new FileInputStream("d:\\t1.png");

        FileOutputStream fileOutputStream = new FileOutputStream("d:\\t2.png");

        byte[] bytes = new byte[1024];
        int count = 0;

        while ((count = fileInputStream.read(bytes)) != -1) {
            fileOutputStream.write(bytes, 0 , count);
        }

        fileInputStream.close();
        fileOutputStream.close();
    }
}

字节缓冲流输入 BufferedInputStream

package com.stream.Buffered;

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

/**
 * @ClassName Demo01
 * @Description 字节缓冲流输入
 * @Author AOA
 * @Date 2021/1/13 14:31
 * Version 1.0
 **/
public class Demo01 {
    public static void main(String[] args) throws Exception {
        FileInputStream fileInputStream = new FileInputStream("d:\\File.txt");
        BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);

//        int date = 0;
//
//        while ((date = bufferedInputStream.read()) != -1) {
//            System.out.print((char)date);
//        }

        byte[] bytes = new byte[10];

        int count = 0;

        while ((count = fileInputStream.read(bytes)) != -1) {
            System.out.print(new String(bytes, 0, count));
        }

        bufferedInputStream.close();
        fileInputStream.close();
    }
}

字节缓冲流输出 BufferedOutputStream

package com.stream.Buffered;

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

/**
 * @ClassName Demo02
 * @Description 字节缓冲流 输出 BufferedOutputStream
 * @Author AOA
 * @Date 2021/1/13 15:07
 * Version 1.0
 **/
public class Demo02 {
    public static void main(String[] args) throws Exception {
        //创建字符缓冲流
        FileOutputStream fileOutputStream = new FileOutputStream("d:\\buffered.txt", true);
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);

        //写入
        for (int i = 0; i < 2; i++) {
            bufferedOutputStream.write("Hello Worled\r\n".getBytes());//写入缓冲区
            bufferedOutputStream.flush();//刷新，从缓冲区写入硬盘
        }
        //关闭字节缓冲流，close()里面自带flush()方法
        bufferedOutputStream.close();
    }
}
```

## 对象输出流 ObjectOutputStream (序列化) 过滤流

```java
package com.stream.ObjectStream;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;

/**
 * @ClassName Demo01
 * @Description ObjectOutputStream对象输出流，序列化操作
 * 注意事项：
 * (1)序列化类需要实现Serializable接口
 * (2)序列化类中的对象属性也要求实现Serializable接口
 * (3)序列化版本号：确保序列化的类和反序列化的类是同一个类
 * (4)使用transient修饰的对象属性，无法被序列化
 * (5)静态属性无法被序列化
 * (6)序列化多个对象使用集合
 * @Author AOA
 * @Date 2021/1/13 15:52
 * Version 1.0
 **/
public class Demo01 {
    public static void main(String[] args) throws Exception{
        //对象流
        FileOutputStream stream = new FileOutputStream("d:\\stu.bin");
        ObjectOutputStream outputStream = new ObjectOutputStream(stream);

        Student s1 = new Student("张三", 18);
        Student s2 = new Student("李四", 20);

        //写入
//        outputStream.writeObject(s1);
        ArrayList<Student> list = new ArrayList<>();

        list.add(s1);
        list.add(s2);

        outputStream.writeObject(list);

        outputStream.flush();

        //关闭
        outputStream.close();
        System.out.println("序列化完毕");
    }
}
```

## 对象输入流 ObjectInputStream (反序列化) 过滤流

```java
package com.stream.ObjectStream;

import java.io.FileInputStream;
import java.io.ObjectInputStream;

/**
 * @ClassName Demo02
 * @Description TODO
 * @Author AOA
 * @Date 2021/1/13 16:18
 * Version 1.0
 **/
public class Demo02 {
    public static void main(String[] args) throws Exception{
        //创建对象流
        FileInputStream f = new FileInputStream("d:\\stu.bin");
        ObjectInputStream inputStream = new ObjectInputStream(f);

        //读取对象，(反序列化)
//        Object o = inputStream.readObject();

        Object o = inputStream.readObject();

        System.out.println(o.toString());

        //关闭
        inputStream.close();
        System.out.println("反序列化完毕");
    }
```

## 字符输入流 FileReader

```java
package com.stream.FileReader;

import java.io.FileReader;

/**
 * @ClassName Demo01
 * @Description 字符输入流 FileReader
 * @Author AOA
 * @Date 2021/1/14 16:11
 * Version 1.0
 **/
public class Demo01 {
    public static void main(String[] args) throws Exception {
        //创建字符流
        FileReader fileReader = new FileReader("d:\\work\\hello.txt");

        //读取
        //单个字符读取
//        int data = 0;
//        while ((data = fileReader.read()) != -1) {
//            System.out.print((char) data);
//        }

        //多个字符读取

        char[] chars = new char[1024];
        int count = 0;
        while ((count = fileReader.read(chars)) != -1) {
            System.out.println(new String(chars, 0 , count));
        }

        //关闭
        fileReader.close();
    }
}
```

## 字符输出流 FileWriter

```java
package com.stream.FileReader;

import java.io.FileWriter;

/**
 * @ClassName Demo02
 * @Description FileWriter 字符输出流
 * @Author AOA
 * @Date 2021/1/14 16:49
 * Version 1.0
 **/
public class Demo02 {
    public static void main(String[] args) throws Exception{
        //创建
        FileWriter fileWriter = new FileWriter("d:\\work\\write.txt");

        //写出
        for (int i = 0; i < 3; i++) {
            fileWriter.write("你好吗？\r\n");
            fileWriter.flush();
        }

        //关闭
        fileWriter.close();
    }
}
```

## 字符流 FileReader 和 FileWriter 复制文本文件

```java
package com.stream.FileReader;

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

/**
 * @ClassName Demo03
 * @Description
 * (1)FileWriter和Fileeader只能复制文本文件，不可以复制字节文件和二进制文件
 * (2)使用字节流可以复制任意文件
 * @Author AOA
 * @Date 2021/1/15 14:22
 * Version 1.0
 **/
public class Demo03 {
    public static void main(String[] args) throws IOException {
        //创建字符流
        FileReader fileReader = new FileReader("d:\\work\\write.txt");
        FileWriter fileWriter = new FileWriter("d:\\work\\write2.txt");

        //复制
        int data = 0;

        while ((data = fileReader.read()) != -1) {
            fileWriter.write(data);
        }

        //关闭
        fileReader.close();
        fileWriter.close();
        System.out.println("复制完毕");
    }
}
```

## 字符缓冲流 BufferedReader 一行一行的读取文件

```java
package com.stream.FileReader;

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

/**
 * @ClassName Demo04
 * @Description 字符缓冲流额读取 BufferedReader
 * @Author AOA
 * @Date 2021/1/15 15:17
 * Version 1.0
 **/
public class Demo04 {
    public static void main(String[] args) throws Exception{
        //创建字符缓冲流
        FileReader fileReader = new FileReader("d:\\work\\write.txt");
        BufferedReader bufferedReader = new BufferedReader(fileReader);

        // 读取
        // 单个读取
//         char[] chars = new char[1024];
//         int count = 0;
//         while ((count = bufferedReader.read(chars)) != -1) {
//             System.out.print(new String(chars, 0, count));
//         }

        //一行一行的读取

        String line = null;
        while ((line = bufferedReader.readLine()) != null) {
            System.out.println(line);
        }
        
        // 关闭
        bufferedReader.close();
    }
}
```

## 字符缓冲流 BufferedWriter 输出

```java
package com.stream.FileReader;

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

/**
 * @ClassName Demo05
 * @Description 使用字符缓冲流输出 BufferedWriter
 * @Author AOA
 * @Date 2021/1/15 15:43
 * Version 1.0
 **/
public class Demo05 {
    public static void main(String[] args) throws Exception {
        //创建字符缓冲流
        FileWriter fileWriter = new FileWriter("d:\\work\\BufferedWriter.txt");
        BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);

        //写入
        for (int i = 0; i < 10; i++) {
            bufferedWriter.write("你好吗？");
            bufferedWriter.newLine();
            bufferedWriter.flush();
        }

        //关闭
        bufferedWriter.close();
    }
}
```

## 转换流 InputStreamReader 读取

```java
package com.stream.StreamReader;

import java.io.FileInputStream;
import java.io.InputStreamReader;

/**
 * @ClassName Demo01
 * @Description 转换流 将字节流 读到内存 变为字符流
 * 使用指定的编码格式
 * @Author AOA
 * @Date 2021/1/15 21:07
 * Version 1.0
 **/
public class Demo01 {
    public static void main(String[] args) throws Exception{
        //转换流需要传入字节流
        FileInputStream fileInputStream = new FileInputStream("d:\\work\\hello.txt");

        //创建转换流
        InputStreamReader reader = new InputStreamReader(fileInputStream, "UTF-8");

        //读取
        int data = 0;
        while ((data = reader.read()) != -1) {
            System.out.print((char) data);
        }

        //关闭
        reader.close();
    }
}
```

## 转换流 OutputStreamReader 写出

```java
package com.stream.StreamReader;

import java.io.FileOutputStream;
import java.io.OutputStreamWriter;

/**
 * @ClassName Demo02
 * @Description 转换流 OutputStreamReader 将字符流 存入 硬盘 变 字节流
 * @Author AOA
 * @Date 2021/1/15 21:40
 * Version 1.0
 **/
public class Demo02 {
    public static void main(String[] args) throws Exception{
        FileOutputStream fileOutputStream = new FileOutputStream("d:\\work\\OutputStreamWriter");
        //创建转换流
        OutputStreamWriter writer = new OutputStreamWriter(fileOutputStream, "gbk");

        //输出
        for (int i = 0; i < 5; i++) {
            writer.write("年后\r\n");
            writer.flush();
        }

        //关闭
        writer.close();
    }
}
```

## File文件类 获取文件信息

```java
package com.stream.File;

import java.io.File;
import java.util.Date;

/**
 * @ClassName Demo01
 * @Description File文件操作类
 * (1)分隔符
 * (2)文件操作
 * (3)文件夹操作
 * @Author AOA
 * @Date 2021/1/16 15:05
 * Version 1.0
 **/
public class Demo01 {
    public static void main(String[] args) throws Exception{
        separator();
        fileope();
        directoryOpe();
    }

    public static void separator() {
        System.out.println("路径分隔符:" + File.pathSeparator);
        System.out.println("名称分隔符:" + File.separator);
    }

    public static void fileope() throws Exception{
        //创建文件
        File file = new File("d:\\work\\file.txt");

        if (!file.exists()) {
            boolean newFile = file.createNewFile();
            System.out.println(newFile);
        } else {
            System.out.println("文件已存在");
        }

        //删除文件

        //正常删除文件

//        boolean delete = file.delete();
//        System.out.println("是否删除文件:" + delete);

        //jvm退出时删除文件

//        file.deleteOnExit();
//        Thread.sleep(5000);

        //获取文件消息

        System.out.println("文件名字:" + file.getName());
        System.out.println("文件路径:" + file.getPath());
        System.out.println("文件绝对路径:" + file.getAbsolutePath());
        System.out.println("文件父目录:" + file.getParent());
        System.out.println("文件长度:" + file.length());
        System.out.println("文件创建时间:" + new Date(file.lastModified()).toLocaleString());

        //判断
        System.out.println("是否能写:" + file.canWrite());
        System.out.println("是否是隐藏的:" + file.isHidden());
        System.out.println("是否是文件:" + file.isFile());
    }

    public static void directoryOpe() throws Exception{
        //创建文件夹
        File file = new File("d:\\work\\aa\\bb");

        if (!file.exists()) {
//            file.mkdir();//单级目录
            System.out.println("新建文件夹结果:" + file.mkdirs());//多级目录
        } else {
            System.out.println("文件夹已存在");
        }
        //删除文件夹

        //正常删除
//        boolean delete = file.delete();
//        System.out.println("删除文件夹结果:" + delete);

        //JVM退出时删除
//        file.deleteOnExit();
//        Thread.sleep(5000);


        //获取文件夹信息

        System.out.println("文件夹的绝对路径:" + file.getAbsolutePath());
        System.out.println("文件夹的路径:" + file.getPath());
        System.out.println("文件夹的父路径:" + file.getParent());
        System.out.println("文件夹的名字:" + file.getName());
        System.out.println("文件夹的生成时间:" + new Date(file.lastModified()).toLocaleString() );

        //判断

        System.out.println("文件夹是否是隐藏的" + file.isHidden());
        System.out.println("是否是文件夹" + file.isDirectory());

        //遍历文件夹

        File file1 = new File("d:\\work");

//        String[] list = file1.list();   //只有文件名
        File[] files = file1.listFiles(); //还有路径

        for (File file2 : files) {
            System.out.println(file2);
        }
    }
}
```

## 递归文件夹

```java
package com.stream.File;

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

/**
 * @ClassName ListFiles
 * @Description (1)递归遍历文件夹 (2)递归删除文件夹
 * @Author AOA
 * @Date 2021/1/19 17:37
 * Version 1.0
 **/
public class ListFiles {
    public static void main(String[] args) {
        //ListDir(new File("d:\\work\\aa"));
        DelectDir(new File("d:\\work\\aa"));
    }

    public static void ListDir(File dir) {
        System.out.println(dir.getAbsolutePath());

        File[] files = dir.listFiles();

        if (files != null && files.length > 0) {
            for (File file : files) {
                if (file.isDirectory()) {
                    ListDir(file);
                } else {
                    System.out.println(file.getAbsolutePath());
                }
            }
        }
    }

    public static void DelectDir(File dir) {
        File[] files = dir.listFiles();

        if (files != null && files.length > 0) {
            for (File file : files) {
                if (file.isDirectory()) {
                    DelectDir(file);
                } else {
                    System.out.println(file.getName() + "被删除了" + file.delete());
                }
            }
        }

        System.out.println(dir.getName() + "被删除了" + dir.delete());
    }
}
```

## Properties的使用

```java
package com.stream.File;

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

/**
 * @ClassName Demo02
 * @Description Properties属性:的使用
 * @Author AOA
 * @Date 2021/1/19 19:35
 * Version 1.0
 **/
public class Demo02 {
    private PrintWriter printWriter;

    public static void main(String[] args) throws Exception{
        Properties properties = new Properties();

        properties.setProperty("username", "张三");
        properties.setProperty("age", "20");

        System.out.println(properties);

        //遍历
        //keySet()
        System.out.println("==========keySet==========");
        Set<Object> objects = properties.keySet();

        for (Object object : objects) {
            System.out.println(object + ":" + properties.get(object));
        }

        //entrySet()
        System.out.println("==========entrySet==========");
        Set<Map.Entry<Object, Object>> entries = properties.entrySet();
        for (Map.Entry<Object, Object> entry : entries) {
            System.out.println(entries);
        }

        //stringPropertiesName
        System.out.println("==========stringPropertyNames==========");
        Set<String> strings = properties.stringPropertyNames();

        for (String string : strings) {
            System.out.println(string + ":" + properties.getProperty(string));
        }

        //和流有关的方法
        //-------------list方法-------------

        PrintWriter printWriter = new PrintWriter("d:\\work\\print.txt");
        properties.list(printWriter);
        printWriter.close();

        PrintStream printStream = new PrintStream("d:\\work\\print1.txt");
        properties.list(printStream);
        printStream.close();

        //-------------store方法 保存-------------

//        FileOutputStream fileOutputStream = new FileOutputStream("d:\\work\\print.properties");
//        properties.store(fileOutputStream, "Hello World!!");
//        fileOutputStream.close();

//        FileWriter fileWriter = new FileWriter("d:\\work\\print1.properties");
//        properties.store(fileWriter, "Hello");
//        fileWriter.close();

        //-------------load方法 读取-------------
        System.out.println("========load.fileInputStream=======");
        FileInputStream fileInputStream = new FileInputStream("d:\\work\\print.properties");
        Properties properties1 =  new Properties();
        properties1.load(fileInputStream);
        System.out.println(properties1);
        fileInputStream.close();

        System.out.println("========load.fileReader=======");
        FileReader fileReader = new FileReader("d:\\work\\print1.properties");
        properties1.load(fileReader);
        System.out.println(properties1);
        fileReader.close();

    }
}
```