文件操作

1、File类概述
2、File类的常用API
- File类的判断文件类型、获取文件信息功能
- 创建文件、删除文件功能
- 遍历文件夹
- 文件搜索
3、字符集
- 常见字符集
- 字符集的编码、解码操作
4、IO流分类
5、字节流的使用
- 文件字节输入流
- 文件字节输出流
- 文件拷贝
6、字符类的使用
- 文件字符输入流
- 文件字符输出流
7、缓冲流
- 字节缓冲流使用
- 字符缓冲流
8、转换流
- 字符输入转换流
- 字符输出转换流
9、序列化对象
- 对象序列化
- 对象反序列化
10、打印流
11、Properties
12、IO框架

1、File类概述

File类在包java.io.File下，代表操作系统的文件对象（文件、文件夹）
File类提供了：定位文件，获取文件本身的信息、删除文件、创建文件（文件夹）等功能

File类创建对象

名称	说明
public File(String pathname)	根据文件路径创建对象
public File(String parent,String child)	从父路径名字符串和子路径名字字符串创建文件对象
public File(File parent,String child)	根据父路径对应文件对象和子路径名字字符串创建对象

File对象可以定位文件和文件夹
File封装的对象仅仅是一个路径名，这个路径可以是存在的，也可以是不存在的

Demo

package file;

import java.io.File;

public class FileDemo1 {
    public static void main( String[] args ) {
        // 1.创建File对象（指定文件的路径）
        File f = new File("D:\\ABC\\123.jpeg");
        long size = f.length();//文件的字节大小
        System.out.println(size);

        // 2.File创建对象，支持绝对路径和支持相对路径
        File f2= new File("file-io-app/src/data.txt");
        System.out.println(f2.length());

        // 3.File创建对象，可以是文件也可以是文件夹
        File f3 = new File("D:\\ABC");
        System.out.println(f3.exists());
    }
}

运行结果
在这里插入图片描述

2、File类的常用API

File类的判断文件类型、获取文件信息功能

名称	说明
public boolean isDirectory()	测试此抽象路径名表示的File是否为文件夹
public boolean isFile()	测试此抽象路径名表示的File是否为文件
public boolean exists()	测试此抽象路径名表示的File是否存在
public String getAbsolutePath()	返回此抽象路径名的绝对路径名字符串
public String getPath()	将此抽象路径名转换为路径名字符串
public String getName()	返回由此抽象路径名表示的文件或文件夹的名称
public long lastModfied()	返回文件最后修改的时间毫秒值

Demo

package file;

import java.io.File;
import java.text.SimpleDateFormat;

public class FileDemo2 {
    public static void main( String[] args ) {
        // 1.绝对路径创建一个文件对象
        File f1 = new File("D:\\ABC\\123.jpeg");

        // 2.获取它的绝对路径
        System.out.println(f1.getAbsolutePath());

        // 3.获取文件定义的时候使用的路径
        System.out.println(f1.getAbsolutePath());

        // 4.获取文件的名称，带后缀
        System.out.println(f1.getName());

        // 5.获取文件的大小，字节个数
        System.out.println(f1.length());

        // 6.获取文件的最后修改时间
        long time = f1.lastModified();
        System.out.println("最后修改时间"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(time));

        // 7.判断是文件还是文件夹
        System.out.println(f1.isFile());
        System.out.println(f1.isDirectory());
    }
}

运行结果
在这里插入图片描述

创建文件、删除文件功能

名称	说明
public boolean createNewFile()	创建一个新的空文件
public boolean mkdir()	只能创建一级文件夹
public boolean mkdirs()	可以创建多级文件夹
public boolean delete()	删除由此抽象路径名表示的文件或空文件夹

delete方法直接删除不走回收站
delete方法默认只能删除空文件夹

Demo

package file;

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

public class FileDemo3 {
    public static void main( String[] args ) throws IOException {
        File f1 = new File("file-io-app/src/data.txt");
        // 1.创建文件，创建成功返回true
        System.out.println(f1.createNewFile());

        // 2.mkdir创建一级目录
        File f2 = new File("D:\\ABC\\abc");
        System.out.println(f2.mkdir());

        // 3.mkdirs创建多级目录
        File f3 = new File("D:\\ABC\\1\\2\\3");
        System.out.println(f3.mkdirs());

        // 4.删除文件或者空文件夹
        System.out.println(f1.delete());
        File f4 = new File("D:\\ABC\\1\\2\\3\\test.txt");
        System.out.println(f4.delete());


        // 5.只能删除空文件，不能删除非空文件夹
        File f5 = new File("D:\\ABC");
        System.out.println(f5.delete());

    }
}

遍历文件夹

名称	说明
public String[] list()	获取当前目录下所有的“一级文件夹名”到一个字符数组中去返回
public File[] listFiles()	获取当前所有的“一级文件对象”到一个文件对象数组中去（`重点`）

listFiles方法注意事项

当调用者不存在时，返回null
当调用者是一个文件时，返回null
当调用者是一个空文件夹时，返回一个长度为0的数组
当调用者是一个用内容的文件夹时，将里面所有文件和文件夹的路径放在File数组中返回
当调用者是一个有隐藏文件的文件夹时，将里面所有文件和文件夹的路径放在File数组中返回，包含隐藏内容

文件搜索

需求：文件搜索，从D：盘中，搜出dea64.exe文件名称并输出绝对路径
分析：

先定位出一级文件对象
遍历全部一级文件对象，判断是否为文件
如果是文件，判断是否是自己想要的
如果是文件夹，需要继续递归进去重复上诉过程

Demo

package file;

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

public class FileDemo5 {
    public static void main( String[] args ) {
        searchFile(new File("D:/"),"dea64.exe");
    }

    /**
     * 搜索某个目录下的全部文件，找到我们想要的文件
     * @param dir       被搜索的文件名称
     * @param fileName  被搜索的文件名称
     */
    public static void searchFile( File dir,String fileName){
        // 判断dir是否为文件夹
        if(dir!=null && dir.isDirectory()){
            // 提取当前目录下的一级文件对象
            File[] files = dir.listFiles();

            //判断是否存在一级文件对象
            if (files != null&& files.length>0){
                for (File file : files) {
                    // 判断当前的一级对象是文件还是文件夹
                    if (file.isFile()){
                        if(file.getName().contains(fileName)){
                            System.out.println("找到了："+file.getAbsolutePath());

                        }
                    }else if(file.isDirectory()){
                        // 是文件夹，递归查找
                        searchFile(file,fileName);
                    }

                }
            }


        }else{
            System.out.println(dir.getAbsolutePath()+ "---------搜索的不是文件夹，不支持");
        }
    }
}

运行结果
在这里插入图片描述

3、字符集

常见字符集

字符集基础

计算机底层不可以直接存储字符的，计算机底层只能存储二进制
二进制是可以转换成十进制的
结论:计算机底层可以表示十进制编号，计算机可以给人类字符进行编号存储，这套编号规则就是字符集

ASCII字符集

ASCII：包含了数字、英文、符号
ASCII使用一个字节存储一个字符，一个字节时八位，总共可以表示128个字符信息，对于英文，数字来说是够用的

GBK

Windows系统默认的码表，兼容ASCII码表，也包含了几万个汉字，并支持繁体汉字一级部分日韩文字
注意：GBK是中国的码表，一个中文以两个字节的形式存储。但不包含世界上所有国家的文字

Unicode码表

unicode（又称同一码，万国码，单一码）：是计算机科学领域里的一项业界字符编码标准
容纳世界上大多数国家的所有常见字符和符号
由于Unicode会先通过UTF-8，UTF-16以及UTF-32的编码变成二进制后再存储到计算机，其中最为常见的就是UTF-8

注意

Unicode是万国码，以UTF-8编码后一个中文一般以三个字节的形式存储
UTF-8也要兼容ASCII编码表
技术人员都应该使用UTF-8的字符集编码
编码前和编码后的字符集需要一致，否则会出现中文乱码

字符集的编码、解码操作

API

名称	说明
byte[] getBytes	使用平台的默认字符集将该String编码为一些列字节，将结果存储到新的字节数组中
byte[] getBytes(String charsetName)	使用指定的字符集将该String编码为一系列字节，奖结果存储到新的字节数组中
String(byte[] bytes)	通过使用平台默认字符集解码指定的字节数组来构造新的String
String(byte[] bytes,String charsetName)	通过指定的字符集解码指定的字节数组来构造新的String

Demo

package charset;


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

public class Test {
    public static void main( String[] args ) throws UnsupportedEncodingException {
        // 1.编码：把文字转换成字节（使用指定的编码）
        String name ="小吴在敲Bug";
        byte[] bytes = name.getBytes("GBK");
        System.out.println(bytes.length);
        System.out.println(Arrays.toString(bytes));

        // 2.解码：把字节转换成对应的中文形式（编码前 和 解码后的字符集必须一致）
        String rs = new String(bytes,"GBK");
        System.out.println(rs);
    }
}

运行结果
在这里插入图片描述

4、IO流分类

IO流也称为输入、输出流，就是用来读写数据的

I表示intput，是数据从硬盘文件读入到内存的过程，称之输入，负责读
O表示output，是内存程序的数据从内存写出到硬盘文件的过程，称之输出，负责写

字节输入流：以内存为基准，来自硬盘文件/网络中的数据以字节的形式读入到内存中去的流称为字节输入流
字节输出流：以内存为基准，把内存中的数据以字节写出到磁盘文件或者网络中去的流称为字节流
字符输入流：以内存为基准，来自磁盘文件/网络中的数据以字符的形式读入到内存中去的流称为字符输入流

5、字节流的使用

文件字节输入流

FileInputStream

作用：以内存为基准，把磁盘文件中的数据以字节的形式读取到内存中去

构造器

名称	说明
public FileInputStream(File file)	创建字节输入流管道与源文件对象接通
public FileInputStream(String pathname)	创建字节输入流管道与源文件路径接通

API

名称	说明
public int read()	每次读取一个字节返回，如果字节已经没有可读的返回-1
public int read(byte[] buffer)	每次读取一个字节数组返回，如果字节已经没有可读的返回-1

读取一个字节Demo

package byte_stream;

import java.io.FileInputStream;
import java.io.InputStream;

public class FileInputStreamDemo1 {
    public static void main( String[] args ) throws Exception {
        // 1.创建一个文件字节输入流管道与文件接通
        InputStream is = new FileInputStream("file-io-app\\src\\data.txt");

        // 2.读取一个字节返回
        /*int b1 = is.read();
        System.out.println(b1);*/

        //定义一个变量记录每次读取的字节
        int b;
        while ((b=is.read())!=-1){
            System.out.print((char) b);
        }
    }
}

每次读取多个字节Demo

package byte_stream;

import java.io.FileInputStream;
import java.io.InputStream;

public class FileInputStreamDemo2 {
    public static void main( String[] args ) throws Exception {
        // 1.创建一个文件字节输入流管道与文件接通
        InputStream is = new FileInputStream("file-io-app\\src\\data.txt");

        // 2.定义一个字节数组，用于读取字节数组
        /*byte[] buffer = new byte[3];
        int len = is.read(buffer);
        System.out.println("读取了几个字节："+len);
        // 读多少倒多少
        String rs = new String(buffer,0,len);
        System.out.println(rs);*/

        // 3.使用循环读取
        byte[] buffer = new byte[3];
        int len;    //记录每次读取的字节数
        while ((len=is.read(buffer))!=-1){
            // 读多少倒多少
            String rs = new String(buffer,0,len);
            System.out.print(rs);
        }
    }
}

文件字节输出流

作用：以内存为基准，把内存中的数据以字节的形式写出到磁盘文件中去的流

构造器

名称	说明
public FileOutputStream(File file)	创建字节输出流管道与源文件对象接通
public FileOutputStream(File file,boolean append	创建字节输出流管道与源文件对象接通，可追加数据
public FileOutputStream(String filepath)	创建字节输出流管道与源文件路径接通
public FileOutputStream(String filepath,boolean append	创建字节输出流管道与源文件路径接通，可追加数据

常用API

名称	说明
public void write(int a)	写一个字节出去
public void write(byte[] buffer)	写一个字节数组出去
public void write(byte[] buffer,int pos ,int len)	写一个字节数组的一部分出去

Demo

package byte_stream;

import java.io.FileOutputStream;
import java.io.OutputStream;

public class FileOutputStreamDemo1 {
    public static void main( String[] args ) throws Exception {
        // 1.创建一个文件字节输出流管道与目标文件接通
        OutputStream os = new FileOutputStream("file-io-app/src/out1.txt");

        // 2.写数据出去
        // 写一个字节出去
        os.write('a');

        /*os.flush(); // 写数据，刷新数据，可以继续使用
        os.close(); //关闭资源*/

        // 写一个字节数组出去
        byte[] buffer1 = {'x','i','a','o','w','u'};
        os.write(buffer1);

        // 写一个字节数组的一部分出去
        byte[] buffer2 = {'\n','x','i','a','o','w','u'};
        os.write(buffer2,0,5);
    }
}

文件拷贝

需求

把某个视频复制到其他目录下的 “b.mp4”

思路

根据数据源创建字节输入流对象
根据目的地创建字节流输出对象
读写数据，复制视频
释放资源

Demo

package byte_stream;

import java.io.*;

public class CopyDemo1 {
    public static void main( String[] args ) {
        InputStream is = null;
        OutputStream os = null;
        try {
            // 1.创建一个字节输入流管道与原视频接通
            is = new FileInputStream("D:\\Download\\video\\学习经验.mp4");

            // 2.创建一个字节输出流与目标文件接通
            os = new FileOutputStream("D:/ABC/b.mp4");

            // 3.定义字节输出转移数据
            byte[] buffer = new byte[1024];
            int len;    //记录每次读取的字节数
            while ((len = is.read(buffer)) != -1) {
                os.write(buffer, 0, len);
            }
            System.out.println("复制完成");

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 4.关闭流
            try {
                if (os != null) os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (is != null) is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

6、字符类的使用

文件字符输入流

作用：以内存为基准，把磁盘文件中的数据以字符的形式读取到内存中去

构造器

构造器	说明
public FileReader(File file)	创建字符输入流管道与源文件对象接通
public FileReader(String pathName)	创建字符输入流管道与源文件路径接通

API

名称	说明
public int read()	每次读取一个字符返回，如果字符已经没有可读的放回-1
public int read(char[] buffer]	每次读取一个字符数组，返回读取的字符个数，如果字符已经没有可读的返回-1

一次读入一个字符Demo

package char_stream;

import java.io.FileReader;
import java.io.Reader;

public class FileReaderDemo1 {
    public static void main( String[] args ) throws Exception {
        // 目标：每次读取一个字符
        // 1.创建一个字符输入流管道与源文件接通
        Reader fr = new FileReader("D:\\Download\\java\\api-app\\file-io-app\\src\\data.txt");

        // 2.读取一个字符返回，没有可读的字符返回-1
        /*int code = fr.read();
        System.out.println((char)code);*/

        // 3.使用循环读取字符
        int code;
        while((code=fr.read())!=-1){
            System.out.print((char) code);
        }

    }
}

一次读入多个字符Demo

package char_stream;

import java.io.FileReader;
import java.io.Reader;

public class FileReaderDemo2 {
    public static void main( String[] args ) throws Exception {
        // 1.创建一个字符输入流管道与源文件接通
        Reader fr = new FileReader("D:\\Download\\java\\api-app\\file-io-app\\src\\data.txt");

        // 2.用循环，每次读取一个字符数组的数据
        char[] buffer = new char[1024];
        int len;
        while ((len = fr.read(buffer)) != -1) {
            String rs = new String(buffer, 0, len);
            System.out.print(rs);
        }
    }
}

文件字符输出流

作用：以内存为基准，把内存中的数据以字符的形式写出到磁盘文件中去的流

构造器

名称	方法
public FileWriter(File file)	创建字符输出流管道与源文件对象接通
public FileWriter(File file,boolean append)	创建字符输出流管道与源文件对象接通，可追加数据
public FileWriter(String filePath)	创建字符输出流管道与源文件对象接通
public FileWriter(String filePath,boolean append)	创建字符输出流管道与源文件对象接通，可追加数据

API

名称	说明
void write(int c)	写一个字符
void write(char[] cbuf)	写一个字符数组
void write(char[] cbuf,int off,int len)	写入字符数组的一部分
void write(String str)	写入一个字符串
void write(String str,int off,int len)	写一个字符串的一部分
void write(int c)	写一个字符

Demo

package char_stream;

import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.OutputStream;
import java.io.Writer;

public class FileWriterDemo1 {
    public static void main( String[] args ) throws Exception {
        // 1.创建一个文件字符输出流管道与目标文件接通
        Writer fw = new FileWriter("file-io-app/src/out2.txt");

        // 2.写数据出去
        // 写一个字符出去
        fw.write('小');
        fw.write('吴');
        fw.write("在敲Bug");

        // 写一个字符数组出去
        char[] chars = "小吴在敲Bug".toCharArray();
        fw.write(chars);

        // 写一个字符数组的一部分出去
        fw.write(chars,0,2);

        fw.close();

    }
}

7、缓冲流

缓冲流也称为高效流，或者高级流

作用：缓冲流自带缓冲区、可以提高原始字节流、字符流读写数据的性能

字节缓冲流使用

字节缓冲输入流 自带了 8KB ，以后我们直接从缓冲池读取数据，所以性能比较好
字节缓冲输出流 自带了 8KB ，数据就直接写入到缓冲池中去，写数据性能极高

构造器

名称	说明
public BufferedInputStream(InputStream is)	可以把低级的字节输入流包装成一个高级的缓冲字节输入流管道，从而提高字节输入流读取数据的性能
public BufferedOutputStream(OutputStream os)	可以把低级的字节输出流包装成一个高级的缓冲字节输出流，从而提高写数据的性能

Demo

package byte_buffer;

import java.io.*;

public class ByteBufferDemo1 {
    public static void main( String[] args ) {
        try (   //try(会自动释放资源)
                // 1.创建一个字节输入流管道与原视频接通
                InputStream is = new FileInputStream("D:\\Download\\video\\学习经验.mp4");
                //把原始的字节输入流包装成高级的缓冲字节输入流
                InputStream bis = new BufferedInputStream(is);

                // 2.创建一个字节输出流与目标文件接通
                OutputStream os = new FileOutputStream("D:/ABC/bos.mp4");
                //把原始的字节输出流包装成高级的缓冲字节输出流
                OutputStream bos = new BufferedOutputStream(os);
        ) {
            
            // 3.定义字节输出转移数据
            byte[] buffer = new byte[1024];
            int len;    //记录每次读取的字节数
            while ((len = bis.read(buffer)) != -1) {
                bos.write(buffer, 0, len);
            }
            System.out.println("复制完成");

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

字符缓冲流

字符缓冲输入流：BufferedReader
作用：提高字符输入流读取数据的性能，除此之外多了按照行读取数据的功能
字符缓冲输出流：BufferedWriter
作用：提高字符输出流写数据的性能，除此之外多了行换功能

构造器

名称	说明
public BufferedReader(Reader r)	可以把低级的字符输入流包装成一个高级的缓冲字符输入流管道，从而提高字符输入流数据的性能
public BufferedWriter(Writer w)	可以把低级的字符输出流包装成一个高级的缓冲字符输出流管道，从而提高字符输出流写数据的性能

新增API

名称	说明
public String readLine()	读取一行数据放回，如果读取完毕，无行可读返回null
public void newLine()	换行操作

Demo

package char_buff;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class BufferedReaderDemo1 {
    public static void main( String[] args ) {
        try (
                // 1.创建一个字符输入流管道与源文件接通
                Reader fr = new FileReader("D:\\Download\\java\\api-app\\file-io-app\\src\\data.txt");
                BufferedReader br = new BufferedReader(fr);
                ){


            // 2.用循环，每次读取一个字符数组的数据
            /*char[] buffer = new char[1024];
            int len;*/
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);       //按照行度注意要换行
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

8、转换流

字符流直接读取文本内容：必须文件和代码编码一致才不会乱码

字符输入转换流

字符输入转换流：InputStreamReader，可以把原始的字节流按照指定编码转换成字符输入流

构造器

名称	说明
public InputStreamReader(InputStream is)	可以把原始字节流按照代码默认编码转换成字符输入流
public InputStreamReader(InputStream is,String charset	可以把原始的字节流按照指定的编码转换成字符输入流，这样字符流中的字符就不乱码了

Demo

package transfer_stream;

import java.io.*;

public class InputStreamReaderDemo1 {
    public static void main( String[] args ) {
        // 代码：UTF-8 文件 GBK 会乱码
        try (
                // 1.提取GBK文件的原始字节流
                InputStream is = new FileInputStream("D:\\ABC\\test.txt");

                // 2.把原始字节流转换成字符输入流
                Reader isr = new InputStreamReader(is, "GBk");      //以指定的GBK编码转换成字符输入流

                BufferedReader br = new BufferedReader(isr);
        ) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

字符输出转换流

字符输出转换流：OutputStreamWriter，可以把字节输出流按照指定编码转换成字符输出流

名称	说明
public OutputStreamWriter(OutputStream os)	可以把原始的字节输出流按照代码默认编码转换成字符输出流
public OutputStreamWriter(OutputStream os,String charset)	可以把原始的字节输出流按照指定编码转换成字符输出流

Demo

package transfer_stream;

import java.io.*;

public class OutputStreamWriterDemo2 {
    public static void main( String[] args ) throws Exception {
        // 1.定义一个字节输出流
        OutputStream os = new FileOutputStream("file-io-app/src/out03.txt");

        // 2.把原始的字节输出流转换成字符输出流
        Writer osw = new OutputStreamWriter(os,"GBK");

        // 3.把低级的字符输出流包装成高级的缓冲输出流
        BufferedWriter bw = new BufferedWriter(osw);

        bw.write("小吴在敲Bug");
        bw.close();
    }
}

9、序列化对象

对象序列化

作用：以内存为基准，把内存中的对象存储到磁盘文件中去，称为对象序列化
使用到的流是对象字节输出流：ObjectOutputStream

构造器

名称	说明
public ObjectOutputStream(OutputStream out)	把低级字节输出流包装成高级的对象字节输出流

API

名称	说明
public final void writeObject(Object obj)	把对象写出去到对象序列化流的文件中去

Demo

实体类：需要实现Serializable接口

transient：表示这个属性不参加序列化
```
private transient String passWord;
```

声明版本

//声明序列化版本号
//序列化的版本号必须一致才不会出错
private static final long serioVersionUid = 1;

package serializable;

import java.io.Serializable;

public class Student implements Serializable {
    private String name;
    private String loginName;
    private String passWord;
    private int age;

    public Student( ) {
    }

    public Student( String name, String loginName, String passWord, int age ) {
        this.name = name;
        this.loginName = loginName;
        this.passWord = passWord;
        this.age = age;
    }

    public String getName( ) {
        return name;
    }

    public void setName( String name ) {
        this.name = name;
    }

    public String getLoginName( ) {
        return loginName;
    }

    public void setLoginName( String loginName ) {
        this.loginName = loginName;
    }

    public String getPassWord( ) {
        return passWord;
    }

    public void setPassWord( String passWord ) {
        this.passWord = passWord;
    }

    public int getAge( ) {
        return age;
    }

    public void setAge( int age ) {
        this.age = age;
    }

    @Override
    public String toString( ) {
        return "Student{" +
                "name='" + name + '\'' +
                ", loginName='" + loginName + '\'' +
                ", passWord='" + passWord + '\'' +
                ", age=" + age +
                '}';
    }
}

Demo

package serializable;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

public class ObjectOutputStreamdemo1 {
    public static void main( String[] args ) throws Exception {
        // 1.创建学生对象
        Student s = new Student("小吴", "xiaowu", "123456", 21);

        // 2.对象序列化：使用对象字节输出流包装字节输出流管道
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("file-io-app/src/obj.txt"));

        // 3.直接调用序列化方法
        oos.writeObject(s);

        // 4.释放资源
        oos.close();

        System.out.println("序列化完成了");
    }
}

对象反序列化

使用到的流是对象字节输入流：ObjectInputStream
作用：以内存为基准，把存储到磁盘文件中去的对象数据，称为反序列化

构造器

名称	说明
public ObjectInputStream(InputStream out)	把低级字节输入流包装成高级的对象字节输入流

API

名称	说明
public Object readObject()	把存储到磁盘文件中去的对象数据恢复成内存中的对象返回

Demo

package serializable;

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

public class ObjectInputStreamDemo1 {
    public static void main( String[] args ) throws Exception {
        // 1.创建对象字节输入流管道包装低级的字符输入流管道
        ObjectInputStream is = new ObjectInputStream(new FileInputStream("file-io-app/src/obj.txt"));

        // 2.调用对象字节输入流的反序列化方法
        Student s = (Student) is.readObject();

        System.out.println(s);
    }
}

10、打印流

作用：打印流可以实现方便、高效的打印数据到文件中去。 打印流一般是是指：PrintStream，PrintWriter两个类
可以实现打印什么数据就是什么数据

PrintStream

构造器	说明
public PrintStream(OutputStream os)	打印流直接通向字节输出流管道
public PrintStream(File f)	打印流直接通向文件对象
public PrintStream(String filePath)	打印流直接通向文件路径

方法	说明
public void print(Xxx xx)	打印任意类型的数据出去

Demo

package printstream;

import java.io.PrintStream;

public class PrintDemo1 {
    public static void main( String[] args ) throws Exception {
        // 1.创建一个打印流对象
        PrintStream ps =new PrintStream("file-io-app/src/ps.txt","Utf-8");

        ps.println(97);
        ps.println(true);
        ps.println("小吴在敲Bug");
        ps.close();
    }
}

PrintWriter

构造器	说明
public PrintWriter(OutputStream os)	打印流直接通向字节输出流管道
public PrintWriter(Writer w)	打印流直接通向字符输出流管道
public PrintWriter(file f)	打印流直接通向文件对象
public PrintWriter(String filePath)	打印流直接通向文件路径

方法	说明
public void print(Xxx xx)	打印任意类型的数据出去

11、Properties

其实就是一个Map集合，但是我们一般不会当集合使用，因为HashMap更好用
Properties代表的是一个属性文件，可以把自己对象中的键值对信息存入到一个属性文件中去
属性文件：后缀是.properties结尾的文件，里面的内容都是key=Value，后续做系统配置信息

API

构造器	说明
void load(InputStream inStream	从字节流读取属性列表(键和元素对)
void load(Reader reader)	从输入字符流肚饿去属性列表(键和元素对)
void store(OutputStream out,String comments)	将此属性列表(键和元素对)写入此Properties表中，以适合于使用load(InputStream)方法的格式写入字节流
void store(Writer writer,String comments)	将此属性列表(键和元素对)写入此Properties表中，以适合使用load(Reader)方法的格式写入输出字符流
public Object setPropertyy(String key,String value)	保存键值对(put)
public String getProperty(String key)	使用此属性列表中指定的键搜索属性值(get)
public Set stringPropertyNames()	所有键的名称的集合(keySet)

Demo1

package properties;

import java.io.FileWriter;
import java.util.Properties;

public class PropertiesDemo1 {
    public static void main( String[] args ) throws Exception {
        // 需求，使用Properties把键值对信息存入到属性文件中去
        Properties properties = new Properties();
        properties.setProperty("admin","123456");
        properties.setProperty("xiaowu","xiaowu");
        properties.setProperty("windows","1433223");

        System.out.println(properties);

        properties.store(new FileWriter("file-io-app/src/user.properties"),"this is users!");

    }
}

Demo2

package properties;

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

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

        //加载属性文件中键值对数据到属性对象properties中去
        properties.load(new FileReader("file-io-app/src/user.properties"));

        System.out.println(properties);

        String admin = properties.getProperty("admin");
        System.out.println(admin);
    }
}

12、IO框架

commons-io是Apache开源基金组织提供的一组有关IO操作的类库，可以提高IO功能开发效率
commons-io工具包提供了很多有关io操作的类。有两个主要的类FileUtils，IOUtils

FileUtils常用API

方法名	说明
String readFileToString(File file,String encoding)	读取文件中的数据，返回字符串
void copyFile(File srcFilee,File destFile)	复制文件
void copyDirectoryToDirectory(File srcDir,File destDir)	复制文件夹