IO流基础知识

IO流

1. IO流概述

IO流是什么？

  • IO：input 和 output

  • 输入输出流的意思：

    • Java程序进行数据传输的管道，流就是管道的意思

    • 流：Stream

    • 输入流：把数据传到程序中

    • 输出流：把数据从程序中输出

  • 现实网络操作中有没有进行数据输入输出的操作？

    有，以后台服务器为例。

    • 例如上网注册信息的时候，对图片信息的上传 ------上传 ------输入到程序中 输入流
    • 从网上下载数据的时候，也是数据的传输： ------下载 ------输出的操作

2. IO流的分类

分类方式

  1. 按照流的方向进行分类（以内存作为参照物）：

    • 往内存中去，叫做输入（Input）或者读（Read）
    • 从内存中出来，叫做输出（Output）或者写（Write）

  2. 按照读取数据方式不同进行分类：

    • 按照字节方式读取数据：一次读取1byte（8bit）。万能流：什么类型的文件都能读取。包括：文本文件，图片，声音文件，视频文件
    • 按照字符方式读取数据：一次读取一个字符，这种六是为了方便读取普通文本文件而存在的，不能读取：图片，声音，视频等文件，只能读取纯文本文件，连word文件都无法读取。
  • 综上：输入流、输出流； 字节流、字符流

3. Java IO流的四大家族

名称 IO类别
InputStream 字节输入流
OutputStream 字节输出流
Reader 字符输入流
Writer 字符输出流

以上4大家族的首领都是抽象类 (abstract class)

所有的流都实现了：

​ java.io.Closeable接口，都是可关闭的，都有close()方法。

​ 流毕竟是一个管道，这个是内存和硬盘之间的通道，用完之后一定要关闭，不然会耗费（占用）很多资源。养成好习惯，用完流一定要关闭。

所有的输出流都实现了：

​ java.io.Flushable接口，都是可刷新的，都有flush()方法

​ 养成好习惯，输出流在最终输出之后，一定要记得flush()

​ 刷新一下。这个刷新表示将通道/管道当中剩余未输出的数据强行输出完（清空管道！）

​ 注意：如果没有flush()可能会导致丢失数据。

注意：以Stream结尾的都是字节流，以Reader/Writer结尾的都是字符流

4. java.io包下需要掌握的流有16个

  • 文件专属流

    1. java.io.FileInputStream

      package com.cao.io;

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

public class FileInputStreamTest {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("E:\\JavaStudy\\notes\\tempfile.txt");
            // 准备一个byte数组
            byte[] buffer = new byte[4];
            int len;
            while((len = fis.read(buffer)) != -1){
                System.out.print(new String(buffer,0,len));
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

    2. java.io.FileOutputStream

      package com.cao.io;

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

public class FileOutputStreamTest {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try {
            // 若文件不存在，就创建该文件
            fos = new FileOutputStream("tempfile4",true); //true:以追加方式写入
            String str = "I am so proud of you!";
            byte[] strBytes = str.getBytes();
            fos.write(strBytes);
            fos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

    3. java.io.FileReader

      package com.cao.io;

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

/**
 * 文件字符流,此种流只适用于读取普通的文本文件
 */
public class FileReaderTest {
    public static void main(String[] args) {
        FileReader fr = null;
        try {
            fr = new FileReader("tempfile4");
            char[] chars = new char[4];
            int len = 0;
            while((len = fr.read(chars)) != -1){
                System.out.println(new String(chars,0,len));
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fr != null) {
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

    4. java.io.FileWriter

      package com.cao.io;

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

public class FileWriterTest {
    public static void main(String[] args) {
        FileWriter fw = null;
        try {
            fw = new FileWriter("fileWrite",true);
            char[] chars = {'d','d','g','y'};
            fw.write(chars);
            fw.write("老当益壮，宁移白首之心；穷且益坚，不坠青云之志！");
            fw.write('\n');
            fw.write("Hello world");
            fw.write("Hello world");
            fw.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fw != null) {
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

  • 转换流：（将字节流转换成字字符流）

    1. java.io.InputStreamReader
    2. java.io.OutputStreamWriter

  • 缓冲流专属

    1. java.io.BufferedInputStream
    2. java.io.BufferedOutputStream
    3. java.io.BufferedReader
    4. java.io.BufferedWriter

  • 数据流专属

    1. java.io.DataInputStream
    2. java.io.DataOutputStream

  • 标准输出流

    1. java.io.PrintWriter
    2. java.io.PrintStream（掌握）

  • 对象专属流

    1. java.io.ObjectInputStream（掌握）
    2. java.io.ObjectOutputStream（掌握）

5. 文件复制

  • 使用FileInputStream + FileOutputStream 完成文件的复制，复制的过程应该是一边读一边写。使用这种方法，文件类型随意。

    package com.cao.io;

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

public class CopyTest {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream("源文件路径");
            fos = new FileOutputStream("目的路径");

            byte[] buffer = new byte[1024 * 1024];  //每次复制1M大小
            int len = 0;
            while((len = fis.read(buffer)) != -1){
                // 一边读一边写
                fos.write(buffer,0,len);
            }
            fos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

6. java.io.File 类

  1. File类和四大家族无关，没有文件读写功能。
  2. File对象代表着什么：文件名 和 目录路径名 的表示形式，一个File对象可以是目录，也可以是文件。她只是一个路径名的抽象表示形式

一些常用的方法：

MethodName Meaning
new File("pathname") 创建文件对象 pathname:文件目录
exists() 判断文件或者目录是否存在
createNewFile() 以文件形式创建文件
mkdir() 以目录形式创建
mkdirs() 以多重目录形式创建（a/b/c/d）
getParent() 获取目标路径的父路径（上一级目录）
getAbsolutePath() 获取文件/目录的绝对路径
getName() 获取文件名
isDirectory() 判断是否为目录
isFile() 判断是否为文件
lastModified() 获取文件最后一次修改的时间(毫秒数)
length() 获取文件大小（字节）
listFiles() 获取当前目录下的所有子目录/文件

案例：将E盘目录拷贝到F盘

package com.cao.io;

import java.io.*;

public class CopyDirectory {
    public static void main(String[] args) {
        // 拷贝源
        File srcFile = new File("E:\\qqFiles");;
        // 拷贝目标
        File destFile = new File("F:\\");;
        // 调用方法拷贝
        copy(srcFile,destFile);

    }

    /**
     * 拷贝目录
     * @param srcFile   源路径
     * @param destFile  目标路径
     */
    private static void copy(File srcFile, File destFile) {
        if(srcFile.isFile()){
            // srcFile如果是文件，则递归结束
            FileInputStream fis = null;
            FileOutputStream fos = null;
            try {
                fis = new FileInputStream(srcFile);
                String path = (destFile.getAbsolutePath().endsWith("\\") ? destFile.getAbsolutePath() : destFile.getAbsolutePath() + "\\") + srcFile.getAbsolutePath().substring(3);
                fos = new FileOutputStream(path);
                byte[] bytes = new byte[1024 * 1024];
                int len = 0;
                while((len = fis.read(bytes)) != -1){
                    fos.write(bytes,0,len);
                }
                fos.flush();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (fos != null) {
                    try {
                        fos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (fis != null) {
                    try {
                        fis.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            return;
        }
        File[] files = srcFile.listFiles();
        for (File file : files) {
            if(file.isDirectory()){
                String srcDir = file.getAbsolutePath();
                String destDir = (destFile.getAbsolutePath().endsWith("\\") ? destFile.getAbsolutePath() : destFile.getAbsolutePath() + "\\") + srcDir.substring(3);
                File newFile = new File(destDir);
                if(!newFile.exists()){
                    newFile.mkdirs();
                }
            }
            // 递归调用
            copy(file, destFile);
        }
    }
}
posted on 2021-01-26 17:59  caoshikui  阅读(101)  评论(0)    收藏  举报