IO类（详解）

体系

1.File类

1.1概念

*是java.io包中的一个类

*File类的对象可表示文件/目录，还可对文件/目录的属性进行操作，如：文件名等。

//在当前目录创建一个与tm.txt文件名相关的对象
File f1=new File("tm.txt");
//指明详细路径及文件名，可以用双斜杠"\\"或反斜杠"/"
File f2=new File("E:/java/tm.txt");
//指明详细路径及目录名，使用双斜杠"\\"
File f2=new File("E:\\java");

1.2File类的常用方法

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

public class Demo2 {
    public static void main(String[] args) {
        //File f2=new File("H:/demo");//无H盘
        File f2=new File("E:/demo");
        /*if(!f2.exists()){
            try {
                f2.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
                System.out.println("文件创建失败");
            }
        }*/
        System.out.println(f2.delete());//删除文件，成功返回true；否则返回false
    }
}

import java.io.File;

public class Demo3 {
    public static void main(String[] args) {
        File f2=new File("E:/demo/a/b");
        f2.mkdir();//单极文件夹
        f2.mkdirs();//双级文件夹
        f2.delete();//删除时，文件必须为空
        File[] fs=f2.listFiles();
        for(File f:fs){
            System.out.println(f);
            f.delete();
        }
        f2.delete();
    }
}

2.IO流

从数据流编码格式上划分为

● 字节流

字节流中常用类 字节输入流 InputStream FileInputStream 字节输出流OutputStream FileOutputStrea m.

● 字符流

字符流中常用类 字符输入流 Reader 字符输出流 Write r

3.输入流、输出流

3.1输入、输出的概念

*输入（input）：将电脑硬盘的数据读到程序中、

*输出（output）：从程序往外部写数据，即进行数据的write操作

3.2输入流、输出流

● 输入流：往程序中读叫输入流。 ● 输出流：从程序中往外写叫输出流 .

InputStream和OutputStream的子类都是字节流,字节处理单元为1字节。

Reader和Writer的子类都是字符流 主要处理字符或字符串 ，字符流处 理单元为1个字符。

4.节点流、处理流

4.1节点流

直接操作文件、字符串等。如：

FileInputStream

FileOutputStream

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

public class Demo5 {
    public static void main(String[] args) throws IOException {
        /*
        节点流操作
         */
        String mes="你好";
        FileOutputStream out=new FileOutputStream("D:/demo.txt");
        out.write(mes.getBytes());
        FileInputStream in=new FileInputStream("D:/demo.txt");
        byte[] b=new byte[20];
        int length=in.read(b);
        String mess=new String(b,0,length);


    }
}

4.2处理流

又为包装流。如：

BufferedInputStream

BufferedOutputStream

DataInputStream

DataOutputStream

ObjectInputStream

ObjectOutputStream

import java.io.*;

public class Demo4 {
    /*
    FileInputStream  FileOutputStream 直接操作文件，节点流
    内部带缓冲数组的包装处理流
    BufferedInputStream  BufferedOutputStream 流对象，属于包装流/处理流
     */
    public static void main(String[] args) throws IOException {
        FileInputStream in=new FileInputStream("E:/feige.exe");
        BufferedInputStream bin=new BufferedInputStream(in);

        FileOutputStream out=new FileOutputStream("F:/feige.exe");
        //BufferedOutputStream bout=new BufferedOutputStream(out);//8192
        BufferedOutputStream bout=new BufferedOutputStream(out,2048);

        byte[] b=new byte[1024*10];
        int length=0;
        while((length=bin.read())!=-1){
            bout.write(b,0,length);
        }
        bin.close();
        bout.flush();//刷新缓存区
        bout.close();
    }
}

import java.io.*;

public class Demo6 {
    public static void main(String[] args) throws IOException {
        /*
        处理流操作
         */
        String mes="你好呀！";
        FileOutputStream out=new FileOutputStream("D:/demo.txt");
        DataOutputStream dout=new DataOutputStream(out);
        dout.writeUTF(mes);
        FileInputStream in=new FileInputStream("D:/demo.txt");
        DataInputStream din=new DataInputStream(in);
        String mess=din.readUTF();
        System.out.println(mess);
    }
}

5.字符流

字符流只能读取纯文本文件。

每次读取单位为一个字符，utf-8编码表中，一个汉字由3个字节组成。

计算机所有数据的存储以字节为单位。

字符输入流父类：Reader

InputStreamReader是转换流，将字节按照编码表转为字符；

FileReader 文件输入字符流。

字符输出流父类：Writer

OutputStreamWriter是转换流，将字符转为字节；

FileWriter 文件输出字符流。

缓冲字符流

BufferedReader 缓冲字符输入流

BufferedWriter 缓冲字符输出流

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

public class Demo2 {
    public static void main(String[] args) throws IOException {
        FileReader reader=new FileReader("E:/demo1.txt");
        FileWriter writer=new FileWriter("F:/demo2.txt");
        char[] c=new char[10];
        int length=0;
        while((length=reader.read(c))!=-1){
            System.out.println(length);
            writer.write(c,0,length);
        }
        reader.close();
        writer.close();
    }
}

pimport java.io.*;

public class Demo3 {
    public static void main(String[] args) throws IOException {
        FileReader reader=new FileReader("E:/demo.txt");
        BufferedReader bufferedReader=new BufferedReader(reader);

        FileWriter writer=new FileWriter("F:/demo.txt",true);//true 可以不让下一次的内容覆盖当前内容
        BufferedWriter bufferedWriter=new BufferedWriter(writer);
        String line=null;
        while((line=bufferedReader.readLine())!=null){
            bufferedWriter.write(line);//一次写出一个字符串
            bufferedWriter.newLine();//换行符
        }
        bufferedReader.close();
        bufferedWriter.close();
    }
}

6.print流

只做输出没有输入，打印流分为字节打印流和字符打印 流

PrintWriter： 字符打印流 print方法可打印各类型数据。

在javaweb项目中,服务器端向客户端响应数据以打印流的方式响应 。

7.对象输入输出流/对象序列化

对象寿命随程序的终止而终止，有时需将对象信息保存，在需要时恢复，将其持久化。

对象的输出流/对象序列化:ObjectOutputStream

将指定对象写进文件。

用readObject（）方法直接读取一个对象。

当一个类的对象需被序列化时，该类要实现Serializable接口，

实现后，隐式在类中生产一个不重复的序列化编号，该编号会在类被修改后随之改变，重新生成一个编号，

这在反序列化时可能会出现问题，对象和类不能对应。

我们可以显示生成一个序列化编号，即使类信息发生变化，也不改变。

private static final long serialVersionUID = -5669977830036777084L;

当属性不需要被序列化时，用transient修饰。

对象输入流/对象反序列化：ObjectInputStream

将指定的已序列化好的文件读出。

用writeObject()方法直接将对象保存到输出流。

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


public class Car implements Serializable {

   
    private static final long serialVersionUID = -5669977830036777084L;

    private transient int num;
    private String name;
    private String color;
    public Car(int num,String name){
        this.num=num;
        this.name=name;
    }

    @Override
    public String toString() {
        return "Car{" +
                "num=" + num +
                ", name='" + name + '\'' +
                '}';
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {
         //对象序列化
       /* FileOutputStream fos = new FileOutputStream("F:/t.tmp");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        Car car=new Car(10,"奔驰");
        //不是所有类的对象都可被序列化到文件中
        oos.writeObject(car);
        oos.close();
        */

        FileInputStream fis = new FileInputStream("F:/t.tmp");
        ObjectInputStream ois = new ObjectInputStream(fis);
        Car car =(Car)ois.readObject();//反序列化，也是Java中创建对象的一种方式
        System.out.println(car);//Car{num=0, name='奔驰'}
        ois.close();
    }

}

//若没有显示生成序列化编号，运行后会有以下错误
Exception in thread "main" java.io.InvalidClassException: com.albb.javaIO.Car; local class incompatible: stream classdesc serialVersionUID = -6599522886150976569, local class serialVersionUID = -1072406244132866035