20200803（IO流）

一.File类

1.File类的构造方法

1.File（String pathname）：用于指定的文件路径构建文件
2.File（String dir， String subpath):在指定目录下创建文件名的文件
3.File（File parent，String path）：根据一个文件对象和一哥字文件构造文件对象

2.File的常用方法

1.boolean exists（）：测试文件参数是否存在
2.String getAbsolutePath（）：返回此对象表示的文件的绝对路径
3.String getName（）：返回此对象表示的文件的名称
4.String getParent（）：返回此File对象的路径名的上一级，如果路径名没有上一级，则返回null
5.boolean delete（）：删除此对象指定的文件
6.boonlean createNewFile（）：创建空文件，不创建文件夹
7.boonlean isDirectory（）：测试File对象是否是目录
8.boolean mkdir（）：创建一个目录，它的路径名由当前File对象指定
9.boolean mkdirs（）：创建包括父目录的目录

3.使用File类操作文件和目录

1.引入File类
2.构造一个文件对象：File file=new File（“text.txt”）；
3.利用File类的方法访问文件或者目录属性

二.流（Stream)

1.含义

是指一连串流动的字符，是以先进先出的方式方式和接收数据的通道

2.字节输入流InputStream

常用方法

1.int read（）：从输入流读取下一个字节数据
2.int read（byte[]b）:将读取的数据存储到数组b中，返回实际读取到的字节数
3.int read（byte[]b,int off,int len）:从off开始保存长度len的字节到数组b中
void close：关闭输入流

读文本文件（使用FileInputStream）

步骤：
1.导入相关类
2.构建一个文件输入流对象：
InputStream fileObject=new FileInputStream（“text.txt”）
3.利用文件输入流的方法读取文本文件的数据：
fileObject.available（）；//可读取的字节数
fileObject.read（）;//读取文件的数据
4.关闭文件输入流对象：fileObject.close（）；

3.字节输出流OutoutStream

常用方法

1.void write（int c）：将指定的字节数据写入输出流
2.void write（byte[]buf）:将数组buf中的所有字节写入输出流
3.void write（byte[]b,int off,int len）：将字节数组中从off开始长度为len的字节输出到输出流
4.void close（）：关闭输出流

写文本文件（使用FileOutputStream）

步骤：
1.导入相关类
2.构建一个文件输出流对象：
OutputStream fos=new FileOutputStream（“text.txt”,true）
true:表示可追加
3.利用文件输出流的方法把数据写入文本文件中：
String str=“好好学习java”；
byte[]words=str.getBytes();
fos.write(words,0,words.length)
4.关闭文件输出流：
fos.close()

import java.io.*;

/**
 * @author Oldhu
 * @date @Date 2020/8/4
 * @des
 */
public class TestStreamReader {
    public static void main(String[] args) throws IOException {
        FileInputStream fis=new FileInputStream(
                "C:\\Users\\86157\\Desktop\\1\\2.txt");
        InputStreamReader isr=new InputStreamReader(fis,"UTF-8");
        char[]c=new char[fis.available()];
        isr.read(c);
        System.out.println(c);
    }
}

4.字符输入流Reader

BufferedReader和FileReader步骤
1.引入相关类
2.构造一个BufferedReader对象：
FileReader fr=new FileReader（“test.txt”）；
BufferedReader br=new BufferedReader（fr）；
3.读取数据：
br.readLine();//读入一行数据，返回字符串
4.关闭相关的流对象
br.close();
fr.close();

5.字符输出流Writer

BufferedWriter和Filewriter步骤：
1.引入相关类
2.构造一个BufferedWriter对象
FileWriter fw=new FileWriter（“test.txt”）;
BufferedWriter bw=new BufferedWriter(fw);
3.写文本文件：
bw.write(“你好呀”);
bw.newLine();
4.相关流的清空和关闭：
bw.flush();//刷新缓冲区
bw.close();
fw.close();

public class TestReader {
    public static void main(String[] args) throws IOException {
        File f=new File("C:\\Users\\86157\\Desktop\\1\\2.txt");
        FileReader fr=new FileReader(f);
        char[]c=new char[(int)f.length()];
        fr.read(c);//把文件的内容读到char数组中
        System.out.println(c);
        String s=readFile("C:\\Users\\86157\\Desktop\\1\\2.txt");
        System.out.println(s);
    }
    public static String readFile(String path){
        File f=new File(path);
        FileReader fr=null;
        String str=null;
        try{
            fr=new FileReader(f);
            char[]c=new char[(int)f.length()];
            fr.read(c);
            str=new String(c);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try{
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return str;
    }
}

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

/**
 * @author Oldhu
 * @date @Date 2020/8/4
 * @des
 */
public class TestWriter {
    public static void main(String[] args) {
        String s="djjsjsdj";
        writerFile(s,"C:\\Users\\86157\\Desktop\\1\\a.txt",false);
    }
    public static void writerFile(String str,String path, boolean isAppend){
        File f=new File(path);
        //char[]c=str.toCharArray();
        FileWriter fw=null;
                try{
                    fw=new FileWriter(f,isAppend);
                    fw.write(str);
                } catch (IOException e) {
                    e.printStackTrace();
                }finally {
                    try{
                        fw.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
    }
}

6.二进制文件的读

使用字节流DataInputStream步骤
1.引入相关类
2.构造一个数据输入流对象：
FileInputStream fis=new FileInputStream(“qianxi.jpg”);
DataInputStream dis=new DataInputStream(fis);
3.读出二进制文件中的数据：
dis.readInt();//读出来的是整数
4.关闭数据输入流：
dis.close（）；

7.二进制文件的写

使用字节流DataOutputStream步骤
1.引入相关类
2.构造一个数据输入流对象
FileOutputStream outFile=new FileOutputStream(“C:\Users\86157\Desktop\1\haha.png”);
DataOutputStream out=new DataOutputStream(outFile);
3.利用数据输出流把数据写入二进制文件
out.write（1）；
4.关闭数据输出流：
out.close（）；

import java.io.*;

/**
 * @author Oldhu
 * @date @Date 2020/8/4
 * @des
 */
public class TestDataIO {
    public static void main(String[] args) throws IOException {
        FileInputStream fis=new FileInputStream("C:\\Users\\86157\\Desktop\\1\\2\\qianxi.jpg");
        DataInputStream dis=new DataInputStream(fis);
        FileOutputStream outFile=new FileOutputStream("C:\\Users\\86157\\Desktop\\1\\haha.png");
        DataOutputStream out=new DataOutputStream(outFile);
        int tmp;
        while((tmp=dis.read())!=-1){
            out.write(tmp);
        }
        out.close();
        outFile.close();
        dis.close();
        fis.close();
        copyData("C:\\Users\\86157\\Desktop\\1\\2\\qianxi.jpg","C:\\Users\\86157\\Desktop\\1\\haha.png");


    }
    public static void copyData(String fromPath,String targetPath){
        FileInputStream fis=null;
        DataInputStream dis=null;
        FileOutputStream fos=null;
        DataOutputStream dos=null;
        try{
            fis=new FileInputStream(fromPath);
            dis=new DataInputStream(fis);
            fos=new FileOutputStream(targetPath);
            dos=new DataOutputStream(fos);
            int tmp = 0;
            while((tmp=dis.read())!=-1){
                dos.write(tmp);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

三.序列化

使用对象流读写对象信息

1.使用对象输出流（ObjectOutputStream）

步骤：
1.引入相关类
2.创建类，实现Serializable接口：
public class Student implements java.io.Serializable
3.创建输出流对象
FileOutputStream fos=new FileOutputStream(“obj.txt”);
ObjectOutputStream oos=new ObjectOutputStream(fos);
4.调用writeObject（）方法将对象写入文件
oos.writeObject(stu);
5.关闭对象输出流
oos.close();
fos.close();

2.反序列化：使用对象输入流（ObjectInputStream）

步骤：
1.引入相关类
2.创建对象输入流
FileInputStream fis=new FileInputStream(“obj.txt”);
ObjectInputStream ois=new ObjectInputStream(fis);
3.调用readObject（）方法读取对象：
Object o=ois.readObject();
4.关闭对象输入流
ois.close（）；

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

/**
 * @author Oldhu
 * @date @Date 2020/8/4
 * @des  可序列化，对象流=高级流
 */
public class SerializaableObj {
    public static void main(String[] args) throws FileNotFoundException {
        FileOutputStream fos=new FileOutputStream("obj.txt");
        ObjectOutputStream oos=null;
        try{
            //创建ObjectOutputStream输出流
            oos=new ObjectOutputStream(fos);
            Student stu=new Student("安娜",30,"女",new Date());

            //对象序列化，写入输出流
            oos.writeObject(stu);
            System.out.println(stu);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(oos!=null){
                try {
                    oos.close();
                    fos.close();

                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        try{
            FileInputStream fis=new FileInputStream("obj.txt");
            ObjectInputStream ois=new ObjectInputStream(fis);
            Object o=ois.readObject();
            System.out.println(o);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}