IO字节流，高效字节流BufferedInputStream/BufferedOutputStream，单级/多级文件夹的复制

最新推荐文章于 2023-04-22 16:04:01 发布
原创 最新推荐文章于 2023-04-22 16:04:01 发布 · 342 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#java
本文是2020.5.24的课堂笔记，主要探讨了Java中的IO流，包括输入流和输出流的概念，重点讲解了FileOutputStream和FileInputStream的使用，以及如何进行文件复制。特别是BufferedInputStream和BufferedOutputStream的运用，展示了它们在提高文件读写效率上的优势。同时，文章还介绍了如何进行单级和多级文件夹的复制操作。

2020.5.24 课堂笔记

IO流

  1. 用来处理设备之间的数据传输。

  2. 分为：输入流和输出流

  3. 字节流：可以操作任意类型的文件(图片，音频等等)

    字符流：只能操作文本文件。

FileOutPutStream

  1. 创建一个文件输出流，来关联一个文件，当关联的文件不存在，就会创建文件。

  2. 往文件中写入数据：

    • write(int b):一次写入一个字节，如果超过字节范围，就会丢弃掉部分数据。

    • write(byte [] a):一次写入一个字节数组

    • write((byte [] a,int start,int length):一次写入字节数组的一部分

    • 怎么覆盖原文件，或者在源文件后面添加？在使用输出流构造方法时，

      FileOutputStream out = new FileOutputStream(“c.txt”,true);true在文件后面添加，否则覆盖。

package org.westos.demo0524.IO; 
 
/*Author:LH
CreatTime:2020.05.26.19:39*/

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

public class Test2 {
    public static void main(String[] args) throws IOException {
        FileInputStream in = new FileInputStream("b.txt");
//        每次将输出的数据添加到文档的尾部
        FileOutputStream out = new FileOutputStream("c.txt",true);
        byte[] bytes = new byte[1024 * 8];
        in.read(bytes);
        out.write(bytes);
//        要将换行符变成字节输入
        String s2="\r\n";
        byte[] bytes2 = s2.getBytes();
        in.read(bytes2);
        out.write(bytes2);
        String s="你是谁呀";
        byte[] bytes1 = s.getBytes();
        in.read(bytes1);
        out.write(bytes1);
        in.read(bytes2);
        out.write(bytes2);
        in.close();
        out.close();
    }
}
  1. 流使用完毕，要释放资源。close()方法。
    • 释放资源的原因：通知系统释放管理的文件资源。让IO流对象变成垃圾等待回收器回收
  2. 写入过程中：换行“\r\n”.注意将换行符变成字节数据

流的异常处理

  1. 异常不建议抛出去，而要自己处理，通过try …catch捕捉处理。
  2. 在异常处理中可以做一写逻辑，不仅是打印异常信息。

FileInputStream

  1. 概念：从文件中读取数据。如果读取不到有效的字节就会返回-1

  2. 输入流关联的文件不存在，就会报错。

  3. 构造方法和方法

    • 构造方法：

      FileInputStream(File file)：创建一个输入流，传入一个File file。

      FileInputStream(String name)：创建一个输入流，传入一个String name。

    • 方法：

      close()：关闭文件输入流并释放资源

      read()：文件的读入，从此输入流中读取一个数据字节。

      read(byte[] b)：从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。

      read(byte[] b, int off, int len)：从此输入流中将最多 len 个字节的数据读入一个 byte 数组中，其实位置从off开始。

  4. 流使用完毕，要释放资源。close()方法。

    • 注意：释放资源的位置和释放资源时的空指针异常

文件的复制

模板复制代码：

package org.westos.demo0524.IO;

import java.io.*;

/*Author:LH
CreatTime:2020.05.26.16:48*/
//复制文件
//步骤一：创建字节输入，输出流，输入输出流中封装要复制的文件的路径和名称
//步骤二：封装完，采用一次读取一个字节数组，这样会比较快。
//步骤三:创建字节数组，建议一次读取和写入8KB
//步骤四：将文件读入字节数组
//步骤五：将字节数组的字节，写入到文件中
//注意：建议自己捕捉和处理错误,输入输出对象关闭时，要判断是否为空
public class Test {
    public static void main(String[] args) {
        File file = new File("b.txt");
        File file1 = new File("c.txt");
        FileInputStream in = null;
        byte[] bytes = new byte[1024 * 8];
        try {
            in = new FileInputStream(file);
            in.read(bytes);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        FileOutputStream out = null;
        try {
            out = new FileOutputStream(file1);
            out.write(bytes);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
//            资源释放，放在finally里面，不管try有没有执行都会执行自己的语句
            try {
//            如果刚进去进捕捉到错误，没有创建输入，输出流就会空指针
//            此处就不用关闭，如果关闭就会报错--NullPointerException
                if (in != null) {
                    in.close();
                }
                if (out != null) {
                    out.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

BufferedInputStream/BufferedOutputStream

  1. 高效的输入输出流，它自身维护一个数组充当缓冲。字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多，因此Java在设计时也考虑了这种方法，
  2. 所以提供了字节缓冲区流BufferedInputStream/BufferedOutputStream
  3. 字节缓冲区流自身维护了一个字节数组，因此编程者提供字节数组读写和一个字节读取速度差不多。

代码：字节流和高效字节流一次读取字节数组和一次读取一个字节的时间对比

package org.westos.demo0524.IO; 
 
/*Author:LH
CreatTime:2020.05.27.11:24*/

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
//使用字节流读取视频文件
//一次读取一个字节
public class Test6 {
    public static void main(String[] args) throws IOException {
        FileInputStream in = new FileInputStream("C:\\Users\\LH\\Desktop\\b2.mp4");
        FileOutputStream out = new FileOutputStream("C:\\Users\\LH\\Desktop\\b4.mp4");
        int len=0;
        long time1 = System.currentTimeMillis();
        while ((len=in.read())!=-1){
           out.write(len);
       }
        long time2 = System.currentTimeMillis(); //耗时68591
        System.out.println(time2-time1);
        in.close();
        out.close();
    }
}
2.package org.westos.demo0524.IO; 
 
/*Author:LH
CreatTime:2020.05.27.10:26*/

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

//使用字节IO流复制视频文件
public class Test3 {
    public static void main(String[] args) throws IOException {
        FileInputStream in = new FileInputStream("C:\\Users\\LH\\Desktop\\a1.mp4");
        FileOutputStream out = new FileOutputStream("C:\\Users\\LH\\Desktop\\a2.mp4");
        //一次读取一个8KB
        byte[] bytes = new byte[1024 * 8];
        int len = 0;
//返回当前时间的毫秒值
        long time1 = System.currentTimeMillis();
        while ((len = in.read(bytes)) != -1) {
            out.write(bytes, 0, len);
        }
        long time2 = System.currentTimeMillis(); //耗时37
        System.out.println(time2 - time1);
        in.close();
        out.close();
    }
}
3.package org.westos.demo0524.IO;

import java.io.*;

/*Author:LH
CreatTime:2020.05.27.10:42*/
//使用高效字节流复制视频
//一个字节一个字节复制
public class Test4 {
    public static void main(String[] args)throws IOException {
        BufferedInputStream in = new BufferedInputStream(new FileInputStream("C:\\Users\\LH\\Desktop\\b2.mp4"));
        BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream("C:\\Users\\LH\\Desktop\\b2副本.mp4"));
        long time1= System.currentTimeMillis();
        int read = 0;
        while ((read=in.read())!=-1){
            out.write(read);
        }
        long time2 = System.currentTimeMillis(); //耗时173
        System.out.println(time2-time1);
        in.close();
        out.close();
    }
}
4.package org.westos.demo0524.IO; 
 
/*Author:LH
CreatTime:2020.05.27.11:07*/
//使用高效字节流复制视频
//一次读取8KB
import java.io.*;

public class Test5 {
    public static void main(String[] args) throws IOException {
        BufferedInputStream in = new BufferedInputStream(new FileInputStream("C:\\Users\\LH\\Desktop\\b2.mp4"));
        BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream("C:\\Users\\LH\\Desktop\\b3副本.mp4"));
        byte[] bytes = new byte[1024 * 8];
        int len=0;
        long time1 = System.currentTimeMillis();
        while ((len=in.read(bytes))!=-1){
           out.write(bytes,0,len);
       }
        long time2 = System.currentTimeMillis(); //耗时34
        System.out.println(time2-time1);
        in.close();
        out.close();
    }
}
多级文件夹的复制
package org.westos.demo0524.IO; 
 
/*Author:LH
CreatTime:2020.05.27.22:36*/
import java.io.*;
//复制多级文件夹
//1.先将目标文件夹封装在File类中
//2.再将目的路径封装在File类中。并判断文件夹是否存在。不存在就创建一个
//3.获取创建完的路径。
//4.判断文件一级目录中是否含有文件夹，除文件夹的其他文本复制到封装好的目的路径中
//5.是文件夹的获取文件夹名字，将下一级路径封装在下级File类中，将文件夹的File类对象和下级路径的File类对象传到方法中，使用递归方法，继续分析复制文件。
public class MyTest3 {
    public static void main(String[] args) throws IOException {
//        封装目标文件夹
        File file = new File("G:\\kk");
//        封装目的路径。
        File file1 = new File("C:\\Users\\LH\\Desktop\\kk");
        copyFile(file, file1);
    }

    public static void copyFile(File f1, File f2) throws IOException {
//        判断目的路径下是否包含目标文件夹
        if (!f2.exists()) {
            f2.mkdirs();    //不包含就创建一个
        }
//        获取创建完成的目的文件夹的绝对路径。
        File absoluteFile = f2.getAbsoluteFile();
        File[] files = f1.listFiles();
//        判断文件夹中是否包含文件夹
        for (File file : files) {
            if (file.isDirectory()) {
//                是文件夹，就获取文件夹的名称
                String name = file.getName();
//                封装新的目的文件夹路径
                File newAbsoluteFile = new File(absoluteFile, name);
//                使用递归，继续分析下级文件夹
                copyFile(file, newAbsoluteFile);
            } else {
//                不是文件夹，就是用字节流赋值文件。
                String name = file.getName();
                File finalFile = new File(f2, name);
                byte[] bytes = new byte[1024 * 8];
                int len = 0;
                FileInputStream in = new FileInputStream(file);
                FileOutputStream out = new FileOutputStream(finalFile);
                while ((len = in.read(bytes)) != -1) {
                    out.write(bytes);
                }
//                最终赋值完毕，关闭资源。
                in.close();
                out.close();
            }
        }

    }
}
单级文件夹的复制
package org.westos.demo0526; 
 
/*Author:LH
CreatTime:2020.05.27.17:54*/

import java.io.*;

/*需求: 复制D:\\course这文件夹到E:\\course
        - 分析:
        - a: 封装D:\\course为一个File对象
        - b: 封装E:\\course为一个File对象,然后判断是否存在,如果不存在就是创建一个目录
        - c: 获取a中的File对应的路径下所有的文件对应的File数组
        - d: 遍历数组,获取每一个元素,进行复制
        - e: 释放资源*/
public class Test3 {
    public static void main(String[] args) throws IOException {
        File file = new File("G:\\javase");
        File file1 = new File("C:\\Users\\LH\\Desktop\\bb");
        boolean b = file1.exists();
        System.out.println("有没有文件夹："+b);
        if (!b){
            boolean b1 = file1.mkdirs();
            System.out.println("创建成功与否："+b1);
        }
        File[] name = file.listFiles();
        for (File file2 : name) {
            String name1 = file2.getName();
            File finalFile = new File(file1, name1);
            copyFile(file2,finalFile);
        }
    }
    public static void copyFile(File f1,File f2) throws IOException {
        BufferedReader in = new BufferedReader(new FileReader(f1));
        BufferedWriter out = new BufferedWriter(new FileWriter(f2));
        char[] chars = new char[1000];
        int len=0;
        while ((in.read(chars))!=-1){
            out.write(chars);
            out.flush();
        }
        out.close();
        in.close();
    }
}
java合并多个文件的两种方式
qq_33716306的博客
03-12 1万+
在java多个线程下载文件或处理较大文件是可能会切分成多个文件，处理完成后需要合并成一个文件。Java中合并子文件最容易想到的就是利用BufferedStream进行读写。利用BufferedStream合并多个文件public static boolean mergeFiles(String[] fpaths, String resultPath) { if (fpaths == nul...
java将多个文件写入到一个文件流中再有规律的取出_编写java程序，往一个txt文件里写入学生的基本信息，然后再读出这些信息并打印出来，最后把该文件拷贝到指...
weixin_39613839的博客
02-25 454
满意答案azonyb2014.02.18采纳率：59%等级：12已帮助：13223人import java.io.BufferedInputStream;import java.io.BufferedOutputStream;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOExc...
java：文件写入BufferedOutputStream写入字节和PrintWriter写入字符
彭世瑜的博客
04-22 771
【代码】java：文件写入BufferedOutputStream写入字节和PrintWriter写入字符。
Java 文件读取和写入多个对象
大家好~我是SP_FA~
12-05 4199
在开始整理文件读取和写入对象之前，先回顾一下文件读取和写入的内容： 1. 字符流： 传输过程中，传输数据的最基本单位是字符的流 通过 BufferedReader 读取文件内容： public static void readFile() throws IOException { Path path = Paths.get("data.txt"); BufferedReader reader = Files.newBufferedReader(path); String lineContent = r
API进阶第二天
qq_44949668的博客
03-29 362
JAVA IO 1.java io可以让我们用标准的读写操作来完成对不同设备的读写数据工作. 2.java将IO按照方向划分为输入与输出,参照点是我们写的程序(内存). 3.输入(读):用来读取数据的,是从外界到程序(内存)的方向,用于获取数据. 4.输出(写):用来写出数据的,是从程序(内存)到外界的方向,用于发送数据. 5.java将IO比喻为"流",即stream,就像"电流","水流"一样,是以同一个方法顺序移动的过程,只不过这里流动的是字节(二进制数据),所以在IO中有输入流和输出流之分,我们理解
IO流:常见输入输出流：文件输入输出流，字符转换流；复制文件或多级文件夹；
y_Engineer的博客
07-25 1431
文章目录IO流一.概述及分类二、字节输入输出流1、文件输入流(FileInputStream)常用方法2、文件输出流(FileOutputStream)常用方法3、使用文件输入输出流进行文件的复制方式一：一次读一个字节，写一个字节（效率低，一般不使用）方式二：一次读写一个字节数组（效率高）4、流的异常处理5、高效(通过内部缓冲区实现)的文件输入输出流复制文件方式三 :使用高效的文件输入输出流三、字...
Java的IO流实现复制多级目录文件
GYT0313
08-13 544
1. 源目录 2. 代码 package com.gyt; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.File; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; /...
IO【字节流、高效流】
weixin_30718391的博客
01-13 112
微信公众号：菜鸟永恒第11天 IO流今日内容介绍 字节流 缓冲流今日学习目标 能够使用字节输出流写出数据到文件 能够使用字节输入流读取数据到程序 能够理解读取数据read(byte[])方法的原理 能够使用字节流完成文件的复制 能够使用字节缓冲流读取数据到程序 能够使用字节缓冲流写出数据到文件 能够完成单级文件夹...
java-IO流中复制单击目录以及使用递归的方式复制多级目录小结
smiletomyself的专栏
02-03 1264
文件的复制大概分为五种方式，如果是文本文档可以使用字节流复制，也可以使用字符流复制 如果是复制目录，由于目录中可以存放各种类型的文件，所以最好使用字节流的方式，因为字节流可以操作包括图片、语音、视屏等各种类型的文件进行复制 一、如果是单级目录： 1.首先创建文件目录 2.遍历出源文件内容 3.创
IO流——BufferedOutputStream构造方法为什么不创建一个具体的文件或者文件路径，而是传递一个OutputStream对象呢？
LuM523的博客
12-03 792
BufferedOutputStream构造方法为什么不创建一个具体的文件或者文件路径，而是传递一个OutputStream对象呢？ 答案：字节缓冲区流仅仅提供缓冲区，这个是为IO流的高效而设计的 。但是真正的读写操作还是要靠基本的流对象实现。就如同喝水时的水杯一样，一滴一滴水喝会觉得很慢，但是给一个水杯，将水存储到水杯中，一次性就可以喝很多水了。但是水杯只是一个媒介，最终还是需要喝的这个动作去完...
BufferedOutputStream深入分析
自律使我自由
10-13 2412
FileOutputStream和BufferedOutputStream都提供了一系列的将数据写入文件的方式，并且我们都知道BufferedOutputStream要比直接使用FileOutputStream写入速度要快，本文通过案例实际演示一下两者的区别。 代码准备 public class BufferFile { public static void main(String[] args) { //每次向文件中写入一个8字节的数组 byte[] bytes
使用JAVA的ZipOutputStream时，在zip文件中出现多层目录
08-30 792
ZIP文件由ZipEntry和实际的data组成，一个entry对应一个datazipOutputStream.putNextEntry(new ZipEntry(filename));此处的filename不要包含该file的本地路径，只需要简单的文件名即可，如果添加了路径，在zip文件里就会显示多层目录。当然如果你想显示多层目录的话，也可以在这儿设置
java文件缓冲流BufferedOutputStream
weixin_46672808的博客
01-17 1030
package IO; import java.io.BufferedOutputStream; import java.io.File; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.OutputStream; /*缓存的目的 解决在写文件时候，频繁的操作文件带来的性能影响 BufferedOutputStream 内部默认
java文件操作使用buffer_java使用BufferedOutputStream写文件
weixin_30444573的博客
02-24 980
2014-05-19 06:30:01阅读( 2229 )下面代码演示如何使用BufferedOutputStream类写文件。使用BufferedOutputStream类写文件，需要先将字符串转换为字节数组，然后再写入。import java.io.BufferedOutputStream;import java.io.FileNotFoundException;import java.io....
JavaIO流遇到的一个坑（FileOutputStream找不到文件）
weixin_42795208的博客
01-12 6186
所以，必须要先用mkdirs();方法创建多级目录，然后再用file.createNewFile()方法.FileOutputStream会自动创建文件，但是如果是多级目录，就创建不了并且报错。所以，必须要先创建文件夹，之后才能用FileOutputStream。这里注意createNewFile()方法也不能创建多级目录的文件。在读取zip文件时，如果有中文名称的文件夹，会报错。此时，只需要修改一下字符编码就好了.
Java中BufferedInputStream和BufferedOutputStream基本使用详解
热门推荐
刘先森
10-03 5万+
BufferedInputStream的使用 BufferedInputStream:缓冲字节输入流，是一个高级流(处理流)，与其他低级流配合使用。 构造方法//创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。创建一个内部缓冲区数组并将其存储在 buf 中,该buf的大小默认为8192。 public BufferedInputStream(Inpu
FileOutPutStream自动创建文件相关
houlai_houlai的博客
12-11 8292
目录 mkdir 、 mkdirs区别 关于自动创建文件的问题 mkdir 、 mkdirs区别 mkdir只能创建一层目录，而mkdirs可以创建多层 //第a种： 什么都没创建 // File saveFile = new File("/a/b/c/","a.txt");// File saveFile = new File("/a/b/c/a.txt"); // saveFile.mkdir(); //第b.
Java之浅析BufferedInputStream和BufferedOutputStream的高效原理
一名小白的进阶之路
01-27 3439
/*普及：计算机中内存的访问速度（运算效率）比硬盘的访问速度（运算效率）要高得多*/ 在代码中使用BufferedInputStream和BufferedOutputStream能够提高数据的传输效率原因如下： ①当只使用FileInputStream和FileOutputStream进行数据复制时，每次FileInputStram从数据源（硬存）中读取一个字节，然后交给b，再把b给Fil...
Java使用BufferedInputStream和BufferedOutputStream类进行文件(音乐)复制
Of_the的博客
07-31 5434
Java使用BufferedInputStream和BufferedOutputStream类进行文件(音乐)复制 BufferedInputStream 为另一个输入流添加一些功能，即缓冲输入以及支持 mark 和 reset 方法的能力。在创建 BufferedInputStream 时，会创建一个内部缓冲区数组。在读取或跳过流中的字节时，可根据需要从包含的输入流再次填充该内部缓冲区，一次填...
BufferedOutputStream复制文件
Hello Worle
02-24 484
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("E:\\JavaWeb\\web10\\src\\B.txt")); BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\JavaWeb\...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值