JavaSE-IO流

IO概述

Input：将磁盘或硬盘、键盘等数据读入到内存

Output：从内存输出到磁盘、硬盘等

File类

文件和目录的抽象表示

构造方法

File(String pathname) #通过将给定的路径名的字符串转换成一个抽象路径名创建一个新的 File实例
File(URI uri) #通过将给定的 file: URI到一个抽象路径名创建一个新的 File实例

常用方法

boolean createNewFile()  #自动创建一个新的空文件命名的抽象路径名的当且仅当该文件不存在
boolean delete()  #删除文件或目录的路径名表示的抽象
boolean exists()  #检查文件或目录是否存在这种抽象路径名记
boolean isDirectory()  #测试文件是否通过这种抽象路径名表示是一个目录
boolean isFile()  #测试文件是否通过这种抽象路径名表示的是一种正常的文件
String[] list()  #返回的字符串在该目录下的抽象路径名的文件和目录命名为数组
File[] listFiles()  #返回表示抽象路径名的目录中的文件的路径名表示抽象的数组
String getAbsolutePath()  #返回此抽象路径名的绝对路径名的字符串
boolean mkdir()  #创建该目录下的抽象路径名命名
boolean mkdirs()  #创建该目录下的抽象路径名命名，包括任何必要的但不存在父目录

FileInputStream类

FileInputStream是读取原始字节的图像数据流

构造方法

FileInputStream(File file) #打开一个连接到一个实际的文件创建一个 FileInputStream，文件在文件系统的 File对象 file命名

常用方法

int read()  #从这个输入流读取一个字节的数据
int read(byte[] b)  #读到 b.length从输入流到字节数组数据字节
int read(byte[] b, int off, int len)  #读到 len从输入流到字节数组数据字节

FileInputStreamDemo类

package com.File.util;

import java.io.File;
import java.io.FileInputStream;
/*
 * @author Administrator
 * @version 1.0
 */
public class FileInputStreamDemo {
    public static void main(String[] args){
        File file = new File("C:\\Users\\Administrator\\Desktop\\134.txt");
        FileInputStream fis = null;
        int len= 0;
        String str = "";
        byte[] bytes1 = new byte[10];
        byte[] bytes2 = new byte[1024];
        try {
            fis = new FileInputStream(file);
            //单个字节读取
            while ((len = fis.read())!= -1){
                System.out.println("ASCII的值："+len+"；字符值："+(char)len);
            }
            //全部字节读取(字节数组大小足够小)
            while ((len = fis.read(bytes1)) != -1){
                String s = new String(bytes1, 0, len);
                str += s;
            }
            System.out.println(str);
            //全部字节读取(字节数组大小足够大)
            while ((len = fis.read(bytes2)) != -1){
                System.out.println(new String(bytes2,0, bytes2.length));
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        finally {
            if (fis != null){
                try {
                    fis.close();
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }
    }
}

FileOutputStream类

FileOutputStream是写作的原始字节的图像数据流

构造方法

FileOutputStream(File file) #创建一个文件输出流写入指定的 File对象表示的文件
FileOutputStream(File file, boolean append) #创建一个文件输出流写入指定的 File对象表示的文件

常用方法

void write(int b)  #将指定的字节写入该文件输出流中
void write(byte[] b)  #写 b.length字节从指定的字节数组来此文件输出流
void write(byte[] b, int off, int len)  #写 len字节指定字节数组中的起始偏移 off此文件输出流
void flush()  #刷新输出流，使缓存数据被写出来

FileReader类

FileReader是读取字符流

构造方法

FileReader(File file) #创建一个新的 FileReader，给予 File读

常用方法

int read()  #从这个输入流读取一个字符的数据
int read(char[] b)  #读到 b.length从输入流到字符数组数据字符
int read(char[] b, int off, int len)  #读到 len从输入流到字符数组数据字符

FileReaderDemo类

package com.File.util;

import java.io.File;
import java.io.FileReader;
/*
 * @author Administrator
 * @version 1.0
 */
public class FileReaderDemo {
    public static void main(String[] args){
        File file = new File("C:\\Users\\Administrator\\Desktop\\134.txt");
        FileReader fr = null;
        int len = 0;
        char[] c1 = new char[10];
        char[] c2 = new char[1024];
        String s = "";
        try {
            fr = new FileReader(file);
            //单个字符来读取
            while ((len = fr.read()) != -1){
                System.out.println((char)len);
            }
            //全部字符读取(字符组数大小小于文件的字符大小)
            while ((len= fr.read(c1)) != -1){
               String str = new String(c1, 0, len);
                s += str;
            }
            System.out.println(s);
            //全部字符读取(字符数组大小足够大)
            while ((len = fr.read(c2)) != -1){
                System.out.println(c2);
            }
            while ((len = fr.read(c2)) != -1){
                System.out.println(new String(c2, 0, len));
            }
        }catch (Exception e){
            e.printStackTrace();
        } finally {
            if (fr != null){
                try {
                    fr.close();
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }
    }
}

FileWriter类

FileWriter是书写字符流

构造方法

FileWriter(File file) #构建了一个文件对象FileWriter对象
FileWriter(File file, boolean append) #构建了一个文件对象FileWriter对象

常用方法

void write(int b)  #将指定的字符写入该文件输出流中
void write(char[] b)  #写 b.length字节从指定的字符数组来此文件输出流
void write(char[] b, int off, int len)  #写 len字符指定字符数组中的起始偏移 off此文件输出流
void flush()  #刷新输出流，使缓存数据被写出来

InputStreamReader类

InputStreamReader是桥从字节流字符流

构造方法

InputStreamReader(InputStream in) #创建一个inputstreamreader使用默认字符集
InputStreamReader(InputStream in, String charsetName) #创建一个inputstreamreader使用指定的字符集

常用方法

int read()  #读取单个字符
int read(char[] cbuf, int offset, int length)  #将字符读入一个数组的一部分

BufferedReader类

从一个字符输入流中读取文本，缓冲字符，以便提供字符、数组和行的有效读取

构造方法

BufferedReader(Reader in) #创建一个使用默认大小输入缓冲区的缓冲字符输入流
BufferedReader(Reader in, int sz) #创建一个使用指定大小的输入缓冲区的缓冲字符输入流

常用方法

int read()  #读取单个字符
int read(char[] cbuf, int off, int len)  #将字符读入一个数组的一部分
String readLine()  #读一行文本

OutputStreamWriter类

outputstreamwriter是桥从字符流的字节流

构造方法

OutputStreamWriter(OutputStream out) #创建一个outputstreamwriter使用默认的字符编码
OutputStreamWriter(OutputStream out, String charsetName) #创建一个outputstreamwriter使用指定的字符集

常用方法

void write(int c)  #写一个字符
void write(char[] cbuf, int off, int len)  #写入一个字符数组的一部分
void write(String str, int off, int len)  #写入字符串的一部分
void flush()  #冲流

BufferedWriter类

将文本写入到字符输出流中，缓冲字符，以便提供对单个字符、数组和字符串的有效写入

构造方法

BufferedWriter(Writer out) #创建一个使用默认大小输出缓冲区的缓冲字符输出流
BufferedWriter(Writer out, int sz) #创建一个新的缓冲字符输出流，该流使用给定大小的输出缓冲区

常用方法

void write(int c)  #写一个字符
void write(char[] cbuf, int off, int len)  #写入一个字符数组的一部分
void write(String s, int off, int len)  #写入字符串的一部分
void newLine()  #写行分隔符

实现文件的复制

package com.File.util;

import java.io.*;

/*
 * @author Administrator
 * @version 1.0
 */
public class FileCopyDemo {
    //主函数
    public static void main(String[] args) {
        //初始化File对象
        File file1 = new File("C:\\Users\\Administrator\\Desktop\\134.txt");
        File file2 = new File("C:\\Users\\Administrator\\Desktop\\10.txt");
        //初始化FileReader和FileWriter对象
        FileReader fileReader = null;
        FileWriter fileWriter = null;
        //初始化BufferedReader和BufferedWriter对象
        BufferedReader bufferedReader = null;
        BufferedWriter bufferedWriter = null;
        //定义一个String类型的变量
        String temp = "";
        //确定复制的源文件和目标文件
        try {
            //获取复制文件的初始时间
            long begin = System.currentTimeMillis();
            //实例化FileReader和FileWriter
            fileReader = new FileReader(file1);
            fileWriter = new FileWriter(file2,true);
            //实例化BufferedReader和BufferedWriter
            bufferedReader = new BufferedReader(fileReader);
            bufferedWriter = new BufferedWriter(fileWriter);
            //读取每一行文本
            while ((temp = bufferedReader.readLine()) != null){
                bufferedWriter.write(temp);
                bufferedWriter.newLine();
                bufferedWriter.flush();
            }
            //获取复制文件的最终时间
            long end = System.currentTimeMillis();
            System.out.println("复制文件共花了" + (end - begin) + "ms");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileReader != null){
                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fileWriter != null){
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bufferedReader != null){
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bufferedWriter != null){
                try {
                    bufferedWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

序列化与反序列化

序列化：把对象转换为字节序列的过程

反序列化：把把字节恢复为对象的过程

ObjectOutputStream类（序列化）

构造方法

ObjectOutputStream() #提供完全重新实现的子类对象不需要分配的私有数据只是用于实现对象的方式
ObjectOutputStream(OutputStream out) #创建一个对象写入到指定的输出流

常用方法

void write(byte[] buf)  #写入一个字节数组
void write(byte[] buf, int off, int len)  #写入字节数组的字节数
void write(int val)  #写一个字节
void writeObject(Object obj)  #写入指定的对象的对象

Student类

package com.File.util;

import java.io.Serializable;

/*
 * @author Administrator
 * @version 1.0
 */
//对类进行序列化，首先实现Serializable接口
public class Student implements Serializable {
    //定义成员变量
    private String name;
    private char sex;
    //无参构造方法
    public Student(){

    }
    //有参构造方法
    public Student(String name,char sex){
        this.name = name;
        this.sex = sex;
    }

    public String getName() {
        return name;
    }

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

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }
    public String toString(String name,char sex){
        return "[" + this.name + "," + this.sex + "]";
    }
}

ObjectStreamDemo类

package com.File.util;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

/*
 * @author Administrator
 * @version 1.0
 */
public class ObjectStreamDemo {
    //主函数
    public static void main(String[] args) {
        //初始化Student对象
        Student student = new Student("邓一",'男');
        //初始化File对象
        File file = new File("C:\\Users\\Administrator\\Desktop\\student");
        //初始化FileOutputStream
        FileOutputStream fileOutputStream = null;
        //初始化ObjectOutputStream
        ObjectOutputStream objectOutputStream = null;
        //实例化FileOutputStream
        try {
            fileOutputStream = new FileOutputStream(file);
            objectOutputStream = new ObjectOutputStream(fileOutputStream);
            objectOutputStream.writeObject(student);
            objectOutputStream.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileOutputStream != null){
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (objectOutputStream != null){
                try {
                    objectOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

ObjectInputStream类（序列化）

构造方法

ObjectInputStream()  #为子类，完全重新实现了ObjectInPutStream没有分配私有数据只是用于实现对象输入流的方式
ObjectInputStream(InputStream in)  #创建一个对象输入流读取从指定的输入流

常用方法

int read()  #读取一个字节的数据
int read(byte[] buf, int off, int len)  #读入一个字节数组
Object readObject()  #从对象输入流对象

ObjectStreamDemo类

package com.File.util;

import java.io.*;

/*
 * @author Administrator
 * @version 1.0
 */
public class ObjectStreamDemo1 {
    //主函数
    public static void main(String[] args) {
        //初始化File对象
        File file = new File("C:\\Users\\Administrator\\Desktop\\student");
        //初始化FileInputStream
        FileInputStream fileInputStream = null;
        //初始化ObjectInputStream
        ObjectInputStream objectInputStream = null;
        try {
            //实例化FileInputStream
            fileInputStream = new FileInputStream(file);
            //实例化ObjectInputStream
            objectInputStream = new ObjectInputStream(fileInputStream);
            //向下转型
            Student student = (Student) objectInputStream.readObject();
            System.out.println(student.getName());
            System.out.println(student.getSex());
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (fileInputStream != null){
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (objectInputStream != null){
                try {
                    objectInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}