第八节 Java IO流

java IO简介

Java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。

Java.io 包中的流支持很多种格式，比如：基本类型、对象、本地化字符集等等。

Java输入输出流

IO的分类
1. java.io包中阻塞型IO
2. java.nio包中的非阻塞型IO——>new IO

IO类
1. 流式部分——>IO的主体
2. 非流式部分——>辅助流式部分

文件操作

class FileOpreator{
    public static void main(String[] args) throws IOException {

        //获取文件或者文件夹引用
        File file = new File("D:/百度脑图/abc");
        //创建文件
        file.createNewFile();

        //创建文件夹
        new File("D:/百度脑图/新建文件夹").mkdirs();

        //获取文件列表
        File[] files = new File("D:/百度脑图").listFiles();
        for (int i = 0; i < files.length; i++) {
            System.out.println(files[i].getName());
        }
    }
}

字节流

class FileCopy{
    /**
     * 使用字节流，单字节复制
     */
    public static void byteStreamCopy(String src,String des) throws IOException {
        FileInputStream inputStream = new FileInputStream(new File(src));
        FileOutputStream outputStream = new FileOutputStream(new File(des));
        int value=0;
        while ((value=inputStream.read())!=-1){//获取字节
            outputStream.write(value);
        }
        inputStream.close();
        outputStream.close();
        System.out.println("单字节复制成功!");
    }
    /**
     * 使用字节流，字节数组复制
     */
    public static void bytesStreamCopy(String src,String des) throws IOException {

        FileInputStream inputStream = new FileInputStream(new File(src));
        FileOutputStream outputStream = new FileOutputStream(new File(des));

        byte[] bytes = new byte[1024];
        int len;
        while((len=inputStream.read(bytes))!=-1){
            outputStream.write(bytes,0,len);
        }
        inputStream.close();
        outputStream.close();
        System.out.println("字节数组复制成功");
    }
}

字符流

public FileCopy{
 /**
     * 字符流复制，单个字符复制
     * 字符流不能拷贝流媒体，因为，字符流是先读取字节，然后转码，再输出，转码之后就不是媒体文件了。
     */
    public static void charStreamCopy(String src,String des) throws IOException {

        FileWriter fileWriter = new FileWriter(new File(des));
        FileReader fileReader = new FileReader(new File(src));
        int value;
        while ((value = fileReader.read()) != -1) {
            fileWriter.write(value);
            fileWriter.flush();
        }
        fileReader.close();
        fileWriter.close();
    }
    /**
     * 使用字符流复制，数组复制
     */
    public static void charsStreamCopy(String src,String des) throws IOException {
        FileReader fileReader = new FileReader(new File(src));
        FileWriter fileWriter = new FileWriter(new File(des));
        int len;
        char[] chars=new char[1024];
        while((len=fileReader.read(chars))!=-1){
            fileWriter.write(chars,0,len);
        }
        fileReader.close();
        fileWriter.close();


    }
}

字符流和字节流总结

package java基础;

import java.io.*;

public class 文件复制 {
    public static void main(String[] args) {
        String src="D:\\百度脑图\\Java语言编程\\JavaIO.png";
        String des="D:\\百度脑图\\JavaIO.png";
        //单字节复制
//        try {
//            FileCopy.byteStreamCopy(src,des);
//        } catch (IOException e) {
//            e.printStackTrace();
//        }
        //字节数组赋值
//        try {
//            FileCopy.bytesStreamCopy(src,des);
//        } catch (IOException e) {
//            e.printStackTrace();
//        }
    //单字符复制
        try {
            FileCopy.charStreamCopy(src,des);
        } catch (IOException e) {
            e.printStackTrace();
        }
        //字符数组复制
        try {
            FileCopy.charsStreamCopy(src,des);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}


class FileCopy{
    /**
     * 使用字节流，单字节复制
     */
    public static void byteStreamCopy(String src,String des) throws IOException {
        FileInputStream inputStream = new FileInputStream(new File(src));
        FileOutputStream outputStream = new FileOutputStream(new File(des));
        int value=0;
        while ((value=inputStream.read())!=-1){//获取字节
            outputStream.write(value);
        }
        inputStream.close();
        outputStream.close();
        System.out.println("单字节复制成功!");
    }
    /**
     * 使用字节流，字节数组复制
     */
    public static void bytesStreamCopy(String src,String des) throws IOException {

        FileInputStream inputStream = new FileInputStream(new File(src));
        FileOutputStream outputStream = new FileOutputStream(new File(des));

        byte[] bytes = new byte[1024];
        int len;
        while((len=inputStream.read(bytes))!=-1){
            outputStream.write(bytes,0,len);
        }
        inputStream.close();
        outputStream.close();
        System.out.println("字节数组复制成功");
    }

    /**
     * 字符流复制，单个字符复制
     * 字符流不能拷贝流媒体，因为，字符流是先读取字节，然后转码，再输出，转码之后就不是媒体文件了。
     */
    public static void charStreamCopy(String src,String des) throws IOException {

        FileWriter fileWriter = new FileWriter(new File(des));
        FileReader fileReader = new FileReader(new File(src));
        int value;
        while ((value = fileReader.read()) != -1) {
            fileWriter.write(value);
            fileWriter.flush();
        }
        fileReader.close();
        fileWriter.close();
    }
    /**
     * 使用字符流复制，数组复制
     */
    public static void charsStreamCopy(String src,String des) throws IOException {
        FileReader fileReader = new FileReader(new File(src));
        FileWriter fileWriter = new FileWriter(new File(des));
        int len;
        char[] chars=new char[1024];
        while((len=fileReader.read(chars))!=-1){
            fileWriter.write(chars,0,len);
        }
        fileReader.close();
        fileWriter.close();


    }
}

文件压缩

class FileZip{
    /**
     * 单个文件压缩
     */
    public static void singleFileZip(File srcFile,File desZipFile) throws IOException {
        //获取文件输入流
        FileInputStream inputStream = new FileInputStream(srcFile);
        //获取压缩文件输出流
        ZipOutputStream zipOutputStream = new ZipOutputStream(new FileOutputStream(desZipFile));
        //向文件中写入条目
        zipOutputStream.putNextEntry(new ZipEntry(srcFile.getName()));
        //写入文件
        byte[] bytes = new byte[1024];
        int len;
        while((len=inputStream.read(bytes))!=-1){
            zipOutputStream.write(bytes,0,len);
        }
        System.out.println("单文件压缩完成");
        inputStream.close();
        zipOutputStream.close();


    }

    /**
     * 多个文件压缩
     */
    public static void filesZip(File[] srcFiles, File zipFile) throws IOException {
        ZipOutputStream outputStream = new ZipOutputStream(new FileOutputStream(zipFile));

        for (int i = 0; i < srcFiles.length; i++) {
            FileInputStream inputStream = new FileInputStream(srcFiles[i]);

            //为压缩文件添加条目
            outputStream.putNextEntry(new ZipEntry(srcFiles[i].getName()));

            byte[] bytes = new byte[1024];
            int len;
            while((len=inputStream.read(bytes))!=-1) {
                outputStream.write(bytes, 0, len);
            }
            outputStream.closeEntry();
            inputStream.close();
        }
        System.out.println("压缩完成。");
        outputStream.close();

    }

    /**
     * 文件夹及其文件压缩
     */
    public static void singleDirFileZip(File srcDir,File zipFile) throws IOException {
        File[] files = srcDir.listFiles();
        for (int i = 0; i < files.length; i++) {
            filesZip(files,zipFile);
        }
    }

    /**
     * 多个文件夹组合压缩
     */
    public static void dirsFileZip() throws IOException {


    }

}