I/O框架

InputStream：字节输入流
方法名	解释
public int read(){}	从输入流读取数据的下一个字节。
public int read(byte[] b ){}	从输入流读取一些字节数，并将它们存储到缓冲区 b。
public int read(byte[] b ,int off,int len){}	从输入流读取最多 len字节的数据到一个字节数组。

OutputStream：字节输出流
方法名	解释
public void write(int n){}	将指定的字节写入此输出流。
public void write(byte[] b ){}	将 b.length字节从指定的字节数组写入此输出流。
public void write(byte[] b ,int off,int len){}	从指定的字节数组写入 len个字节，从偏移 off开始输出到此输出流。

（2）文件字节流

①FileInputStream

public int read(byte[] b ){} //从流中读取多个字节，将读到内容存入b数组，返回实际读到的字节数；如果达到文件的尾部，则返回-1。

import java.io.FileInputStream;

/**
 * 演示FileInputStream的使用
 * 文件字节输入流
 */
public class demo01 {
    public static void main(String[] args) throws Exception{
        //1.创建FileInputStream,并指定文件路径
        FileInputStream fis=new FileInputStream("C:\\aaa.txt");
        

        //2.读取文件
        //fis.read();
        //2.1  单个字节读取
       /* System.out.println("=====2.1  单个字节读取=====");
        int data=0;
        while ((data= fis.read())!=-1){
            System.out.println((char) data);
        }

        */

        //2.2  一次读取多个字节
        System.out.println("=====2.2  一次读取多个字节=====");
        byte[] buf=new byte[3];
        int count=0;
        while ((count=fis.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
        

        //3.关闭
        fis.close();
        System.out.println();
        System.out.println("执行完毕");
    }
}

②FileOutputStream

public void write(byte[] b ){} //一次写多个字节，将b数组中所有字节，写入输出流。

import java.io.FileOutputStream;

/**
 * 演示FileOutputStream的使用
 * 文件字节输出流
 */
public class demo02 {
    public static void main(String[] args) throws Exception{
        //1.创建文件字节输出流对象
        FileOutputStream fos=new FileOutputStream("C:\\bbb.txt");
        //若在路径后面加上，ture，则会再后面继续添加，若没加，则会一直覆盖原有内容

        //2.写入文件
        fos.write(97);
        fos.write('g');
        fos.write('h');

        String string="  helloworld";
        fos.write(string.getBytes());

        //3.关闭
        fos.close();
        System.out.println("执行完毕");

    }
}

③字节复制

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

/**
 * 使用文件字节流实现文件的复制
 */
public class demo03 {
    public static void main(String[] args) throws Exception{
        //1.创建流
        //1.1文件字节输入流
        FileInputStream fis=new FileInputStream("C:\\001.png");

        //1.2文件字节输出流
        FileOutputStream fos=new FileOutputStream("C:\\002.png");

        //2、一边读一边写
        byte[] buf=new byte[1024];
        int count =0;
        while((count= fis.read(buf))!=-1){
            fos.write(buf,0,count);
        }
        //3、关闭
        fis.close();
        fos.close();
        System.out.println("复制完毕");

    }
}

（3）字节缓冲流

缓冲流：BufferedInputStream / BufferedOutputStream

提高IO效率，减少访问磁盘的次数；
数据存储在缓冲区中，flush是将缓存区的内容写入文件中，也可以直接close。

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

/**
 * 使用字节流缓冲流读取
 * BufferedInputStream
 */

public class demo04 {
    public static void main(String[] args) throws Exception{
        //1.创建BufferedInputStream
        FileInputStream fis=new FileInputStream("C:\\aaa.txt");
        BufferedInputStream bis=new BufferedInputStream(fis);

        //2.读取
        /*int data=0;
        while((data=bis.read())!=-1){
            System.out.print((char)data);
        }
         */
        //或者

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

        //3.关闭
        bis.close();
    }
}

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

/**
 * 使用字节流缓冲流写入文件
 * BufferedOutputStream
 */
public class demo05 {
    public static void main(String[] args) throws Exception{
        //1、创建字节输出缓冲流
        FileOutputStream fos=new FileOutputStream("C:\\buffer.txt");
        BufferedOutputStream bos=new BufferedOutputStream(fos);

        //2、写入文件
        for(int i=0;i<10;i++){
            bos.write("helloworld\r\n".getBytes());//写入了8k的缓冲区
            bos.flush();//刷新到硬盘
        }


        //3、关闭（内部调用flush方法）
        bos.close();
    }
}

4.对象流

（1）对象流：ObjectOutputStream / ObjectInputStream

增强了缓冲区功能
增强了读写8种基本数据类型和字符串功能
增强了读写对象的功能：

① readObject() 从流中读取一个对象

② writeObject（object obj）向流中写入一个对象

（2）使用流传输对象的过程称为序列化、反序列化。

（3）要求：

序列化的类必须要实现 Serializable 接口
序列化的类中的对象属性要求实现 Serializable 接口
序列化版本号ID，保证序列化的类和反序列化的类是同一个类
使用transient（瞬间的）修饰属性，这个属性不能序列化
静态属性不能序列化（static)
序列化多个对象，可以借用集合来实现

import java.io.Serializable;

//学生类
public class Student implements Serializable {//实现接口，只是为了标志可以序列化
    private static final long serialVersionUID = -3918831492241416351L;  //serialVersionUID：序列化版本号ID
    private String name;
    private int age;

    public Student() {
    }

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

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

/**
* 使用ObjectOutputStream实现对象的序列化（即写入操作）
* 要求：
* (1)序列化的类必须要实现 Serializable 接口
* (2)序列化的类中的对象属性要求实现 Serializable 接口
* (3)序列化版本号ID，保证序列化的类和反序列化的类是同一个类
* (4)使用transient（瞬间的）修饰属性，这个属性不能序列化
* (5)静态属性不能序列化（static)
* (6)序列化多个对象，可以借用集合来实现
*/
public class demo06 {
    public static void main(String[] args) throws Exception {
        //1、创建对象流
        FileOutputStream fos=new FileOutputStream("C:\\stu.bin");
        ObjectOutputStream oos=new ObjectOutputStream(fos);

        //2、序列化（写入操作）
        Student zhangsan=new Student("张三",55);
        Student krystal=new Student("郑秀晶",28);
        Student jessica=new Student("郑秀妍",34);
        //写入多个对象
        ArrayList<Student> list=new ArrayList<>();
        list.add(zhangsan);
        list.add(krystal);
        list.add(jessica);
        oos.writeObject(list);
        oos.flush();

        //3、关闭
        oos.close();
        System.out.println("序列化完毕");
    }
}

import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.util.ArrayList;


/**
* 使用ObjectInputStream实现对象的反序列化（读取重构对象）
*
*/
public class demo07 {
    public static void main(String[] args) throws Exception{
        //1、创建对象流
        FileInputStream fis=new FileInputStream("C:\\stu.bin");
        ObjectInputStream ois=new ObjectInputStream(fis);

        //2、反序列化（读取文件）

        /*单个输出
Student s=(Student)ois.readObject();
*/
        //集合输出
        ArrayList<Student> list=(ArrayList<Student>)ois.readObject();

        //3、关闭
        ois.close();
        System.out.println("反序列化完毕");
        //System.out.println(s.toString());
        System.out.println(list.toString());
    }
}

5.字符流

（1）字符编码

注意：当编码方式和解码方式不一致时，会出现乱码

字符编码	备注
ISO-8859-1	ASCII码、西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号
UTF-8	针对Unicode码表的可变长度字符编码
GB2312	简体中文
GBK	简体中文扩充
BIG5	台湾、繁体中文

（2）字符流的父类（抽象类）

Reader：字符输入流

①public int read( ){ }

②public int read(char[ ] c){ }

③public int read(char[ ] b ,int off, int len){ }

Writer：字符输出流

①public int write(int n){ }

②public int write(String str){ }

③public int write(char[ ] c){ }

(3)文件字符流

FileReader：

①public int read(char[ ] c) // 从流中读取多个字符，把读到内容存入c数组，返回实际读到的字符数；如果达到文件的尾部，则返回-1.

import java.io.FileReader;
/**
 * 使用FileReader读取文件
 */
public class demo09 {
    public static void main(String[] args)throws Exception {
        //1.创建FileReader 文件字符输入流
        FileReader fr=new FileReader("C:\\demo08.txt");
        //2.读取
        //2.1 单个字符读取
        /*
        int data=0;
        while((data=fr.read())!=-1){  //读取的是字符
            System.out.print((char)data);
        }
         */
        //2.2 多个字符读取
        char[] buf=new char[1024];
        int count=0;
        while((count= fr.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
        //3.关闭
        fr.close();
    }
}

FileWriter：

①public int write(String str) // 一次写多个字符，将b数组中的所有字符，写入输出流。

import java.io.FileWriter;

/**
 * 使用FileWriter写入文件
 */
public class demo10 {
    public static void main(String[] args) throws Exception{
        //1.创建FileWrite 对象
        FileWriter fw=new FileWriter("C:\\demo10.txt");
        //2.写入
        for(int i=0;i<3;i++){
            fw.write("jessica is krystal sister,乐海永远在一起\n");
            fw.flush();//刷新
        }
        //3.关闭
        fw.close();
        System.out.println("写入完毕");

    }
}

FileReader和FileWriter复制文本文件

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

/**
 * 使用FileReader和FileWriter复制文本文件
 * 使用字节流可以复制任意文件
 * 使用字符流只能复制文本文件，不能复制图片或二进制文件
 */


public class demo11 {
    public static void main(String[] args) throws Exception {
        //1.创建FileReader 和FileWriter
        FileReader fr =new FileReader("C:\\Users\\Administrator\\Desktop\\JAVA\\code\\src\\IOdemo\\demo10.txt");
        FileWriter fw =new FileWriter("C:\\Users\\Administrator\\Desktop\\JAVA\\code\\src\\IOdemo\\demo11.txt");
        //2.读写
        int data =0;
        while((data=fr.read())!=-1){
            fw.write(data);
        }
        //3.关闭
        fr.close();
        fw.close();
        System.out.println("复制完毕！");
    }
}

（4）字符缓冲流

缓冲流：BufferedReader / BufferedWriter

①高效读写

②支持输入换行符

③可一次写一行、读一行

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

/**
 * 使用字符缓冲流读取文件
 * BufferedReader
 */
public class demo12 {
    public static void main(String[] args) throws Exception{
        //1.创建缓冲流 BufferedReader
        FileReader fr=new FileReader("C:\\demo10.txt");
        BufferedReader br=new BufferedReader(fr);
        //2.读取
        //2.1 第一种方式
        /*
        char[] buf = new char[1024];
        int count =0;
        while((count= br.read(buf))!=-1){
            System.out.print(new String (buf,0,count));
        }
         */
        //2.2第二种方式，一行一行的读
        String line=null;
        while((line= br.readLine())!=null){
            System.out.println(line);
        }

        //3.关闭
        br.close();
    }
}

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

/**
 * 使用BufferedWriter的使用
 */
public class demo13 {
    public static void main(String[] args) throws Exception{
        //1.创建BufferedWriter对象
        FileWriter fw=new FileWriter("C:\\demo13.txt");
        BufferedWriter bw=new BufferedWriter(fw);
        //2.写入
        for(int i=0;i<2;i++){
            bw.write("A Cat with rode for you");
            bw.newLine();//写入一个换行符   windows ：\r\n   linux: \n
            bw.write("送给你一个带着玫瑰的猫咪");
            bw.newLine();
            bw.flush();
        }
        //3.关闭
        bw.close();
        System.out.println("写入完毕");
    }
}

6.打印流

PrintWriter：

①封装了print（）/println（）方法。支持写入后换行

②支持数据原样打印

import java.io.PrintWriter;

/**
 * 演示PrintWriter的使用
 */
public class demo14 {
    public static void main(String[] args) throws Exception{
        //1.创建打印流
        PrintWriter pw=new PrintWriter("C:\\demo14.txt");
        //2.打印
        pw.println(97);
        pw.println(true);
        pw.println(3.14);
        pw.println('a');
        pw.flush();
        //3.关闭
        pw.close();
        System.out.println("打印完毕");
    }
}

7.转换流

桥转换流：InputStreamReader / OutputStreamWriter
可将字节流转换为字符流
可设置字符的编码方式

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

/**
 * 使用InputStreamReader读取文件，指定使用的编码
 */
public class demo15 {
    public static void main(String[] args) throws Exception{
        //1.创建InputStreamReader对象
        FileInputStream fis =new FileInputStream("code/src/IOdemo/demo15.txt");
        InputStreamReader isr=new InputStreamReader(fis,"utf-8");

        //2.读取文件
        int data =0;
        while((data= isr.read())!=-1){
            System.out.print((char)data);
        }
        //3.关闭
        isr.close();

    }
}

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

/**
 * 使用OutputStreamWriter写入文件，使用指定的编码
 *
 */
public class demo16 {
    public static void main(String[] args) throws Exception{
        //1、创建OutputStreamWriter对象
        FileOutputStream fos=new FileOutputStream("code/src/IOdemo/demo15.txt");
        OutputStreamWriter osw=new OutputStreamWriter(fos,"utf-8");

        //2.写入文件
        for(int i=0;i<2;i++){
            osw.write("jessica is krystal's sister!\n");
            osw.write("They love each other forever!\n");
            osw.flush();
        }
        //3.关闭
        osw.close();
        System.out.println("写入成功");
    }
}

二、File类

1、概念：代表物理盘符中的一个文件或者文件夹

2、方法：

createNewFile( ): 创建一个新文件
mkdir( )：创建一个新目录
delete( ) : 删除文件或空目录
exists( ): 判断File对象所对象所代表的的对象是否存在
getAbsolutePath( ): 获取文件的绝对路径
getName( ) : 取得名字
getParent( ): 获取文件/目录所在的目录
isDirectory( ): 是否是目录
isFile( ) : 是否是文件
length( ) : 获取文件的长度
listFiles( ): 列出目录中的所有内容
renameTo( ): 修改文件名为

import com.sun.org.apache.xerces.internal.util.DraconianErrorHandler;

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

/**
 * File类的使用
 * （1）分隔符
 * （2）文件操作
 *  (3)文件夹操作
 *
 */
public class demo17 {
    public static void main(String[] args) throws Exception {
        //separator();
        //fileOpe();
        directoryOpe();
    }

    //(1)分隔符
    public static void separator() throws Exception{
        System.out.println("路径分隔符" + File.pathSeparator);
        System.out.println("名称分隔符" + File.separator);
    }
    //(2)文件操作
    public  static void fileOpe()throws Exception{
        //1.创建文件 createNewFile()
        File file = new File("C:\\demo17.txt");
        //System.out.println(file.toString());
        if(!file.exists()){ //判断是否存在
            boolean b=file.createNewFile();
            System.out.println("创建结果："+b);
        }

        //2.删除文件
        //2.1直接删除
        //System.out.println("删除结果为："+file.delete());

        //2.2使用jvm退出时来删除
        /*
        file.deleteOnExit();
        Thread.sleep(3000);
        */

        //3.获取文件信息
        System.out.println("获取文件的绝对路径："+file.getAbsoluteFile());
        System.out.println("获取路径："+file.getPath());
        System.out.println("获取文件名称：" + file.getName());
        System.out.println("获取父目录：" + file.getParent());
        System.out.println("获取文件的长度：" + file.length());
        System.out.println("文件创建时间：" + new Date(file.lastModified()).toLocaleString());
        //4.判断
        System.out.println("是否可写："+file.canWrite());
        System.out.println("是否可读："+file.canRead());
        System.out.println("是否是文件："+file.isFile());
        System.out.println("是否隐藏:"+file.isHidden());

    }
    //(3)文件夹操作
    public static  void directoryOpe()throws Exception{
        //1.创建文件夹
        File dir=new File("d:\\aaa\\bbb\\ccc\\ddd");
        System.out.println(dir.toString());
        if(!dir.exists()){
            //dir.mkdir();//只能创建单级目录
            System.out.println("创建结果"+dir.mkdirs());//可以创建多级目录
        }
        //2.删除文件夹
        //2.1直接删除
        //System.out.println("删除结果为："+dir.delete());//只删除最底层目录，且只删除空目录

        //2.2使用jvm退出时来删除
        /*
        dir.deleteOnExit();
        Thread.sleep(3000);
        */

        //3.获取文件夹信息
        System.out.println("获取绝对路径："+dir.getAbsoluteFile());
        System.out.println("获取路径："+dir.getPath());
        System.out.println("获取目录名称：" + dir.getName());
        System.out.println("获取父目录：" + dir.getParent());
        System.out.println("目录创建时间：" + new Date(dir.lastModified()).toLocaleString());
        //4.判断
        System.out.println("是否是文件夹："+dir.isDirectory());
        System.out.println("是否隐藏:"+dir.isHidden());

        //5.遍历文件夹
        File dir2=new File("C:\\Users");
        String[] files = dir2.list();
        System.out.println("===================================");
        for(String string : files){
            System.out.println(string);
        }
    }
}

3.FileFilter接口

（1）public interface FileFilter

boolean accept (File pathname)

(2)注意：

当调用File类中的listFiles（）方法时，支持传入FileFilter接口接口实现类，对获取文件进行过滤，只有满足条件的文件的才可出现在listFiles（）的返回值中。

import java.io.File;

/**
 * 案例1 ：递归遍历文件夹
 * 案例2 : 递归删除文件夹
 */
public class anli01 {
    public static void main(String[] args) {
        //listDir(new File("D:\\12\\aaa"));
        deleteDir(new File("D:\\12\\aaa"));
    }
    //案例1 ：递归遍历文件夹
    public static void listDir(File dir){
        File[] files1=dir.listFiles();
        System.out.println(dir.getAbsoluteFile());
        if(files1!=null&&files1.length>0){
            for(File file:files1){
                if(file.isDirectory()){
                    listDir(file);//递归
                }else{
                    System.out.println(file.getAbsoluteFile());
                }
            }
        }
    }
    //案例2 : 递归删除文件夹
    public static void deleteDir(File dir){
        File[] files2=dir.listFiles();
        System.out.println(dir.getAbsoluteFile());
        if(files2!=null&&files2.length>0){
            for(File file1:files2){
                if(file1.isDirectory()){
                    deleteDir(file1);
                    }else{
                    //删除文件
                    System.out.println(file1.getAbsoluteFile()+"删除："+file1.delete());
                }
            }
        }
        System.out.println(dir.getAbsoluteFile()+"删除："+dir.delete());
    }
}

4.补充：Properties

（1）Properties：属性集合

（2）特点：

1.存储属性名和属性值
2.属性名和属性值都是字符串类型
3.没有泛型
4.和流有关

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.util.Properties;
import java.util.Set;

/**
 * 演示Properties集合的使用
 */
public class anli02 {
    public static void main(String[] args) throws Exception{
        //1.创建集合
        Properties ppt=new Properties();
        //2.添加数据
        ppt.setProperty("username","krystal");
        ppt.setProperty("age","24");
        ppt.setProperty("lovr's food","beef");
        ppt.setProperty("sister","jessica");
        ppt.setProperty("friend","amber");
        System.out.println(ppt.toString());
        //3.遍历
        //3.1-----keySet-----
        //3.2-----entrySet-----
        //3.3-----StringPropertyNames()-----
        Set<String > pronames=ppt.stringPropertyNames();
        for(String pro:pronames){
            System.out.println(pro+"======="+ppt.getProperty(pro));
        }
        //4.和流有关的方法
        //-------------list方法-------------
        PrintWriter pw=new PrintWriter("code/src/IOdemo/anli02.txt");
        ppt.list(pw);
        pw.close();

        //-------------store方法（保存）-------------
        FileOutputStream fos=new FileOutputStream("code/src/IOdemo/anli02.properties");
        ppt.store(fos,"zhushi");
        fos.close();
        //-------------load方法（加载）-------------
        Properties properties2=new Properties();
        FileInputStream fis=new FileInputStream("code/src/IOdemo/anli02.properties");
        properties2.load(fis);
        fis.close();
        System.out.println(properties2.toString());
    }
}