IO流_3_文件复制+buffered缓冲流

CXY_1274511216

已于 2023-05-26 15:44:47 修改

阅读量90

点赞数

文章标签： java c++ android

于 2023-05-19 14:54:58 首次发布

本文链接：https://blog.csdn.net/CXY_1274511216/article/details/130759300

版权

1：IO流的文件复制

1.1：语法

利用输入输出流进行数据的拿取和存取

package com.File_demo;

import java.io.*;

public class FileCopy {

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

        InputStream inputStream = new FileInputStream("D:\\飞思培训\\FileTest\\11.txt");

        OutputStream outputStream = new FileOutputStream("D:\\飞思培训\\FileTest\\12.txt");

        int len = 0 ;
        while((len = inputStream.read())!=-1){
            outputStream.write(len);
        }

        outputStream.close();
        inputStream.close();

    }
}

1.2：字节流

FileInputStream+FileOutputStream进行数据的读取和存取

package cn.sz.gl.test05;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class Test {

	public static void copyFileByStream(File source, File target) {
		// 判断源文件是否存在，如果不存在，就退出程序
		if (!source.exists()) {
			System.out.println("源文件不存在,程序退出");
			System.exit(0);
		}
		// target.getParentFile()表示用来获取目标对象的父目录对象
		// 如果目标文件路径不存在，就创建
		if (!target.getParentFile().exists()) {
			target.getParentFile().mkdirs();
		}

		InputStream is = null;
		OutputStream os = null;

		try {
			// 准备输入流
			is = new FileInputStream(source);
			// 准备输出流
			os = new FileOutputStream(target);
			// 准备一个数组，用来存放读写的数据
			byte[] b = new byte[1024];
			int len = 0;
			// read(b)实现读取操作，数据存入b数组，返回读取长度给len，当所有内容都读取完毕，len=-1
			while ((len = is.read(b)) != -1) {
				// 实现写的操作
				os.write(b, 0, len);
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (is != null) {
					is.close();
				}
				if (os != null) {
					os.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

	}

	public static void main(String[] args) {
		File source = new File("D:\\java\\Java高级\\myfile\\a.txt");
		File target = new File("D:\\java\\Java高级\\myfile\\b.txt");
		copyFileByStream(source, target);
	}
}

1.3：字符流

package cn.sz.gl.test05;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

public class Test {

	public static void copyFileByWriter(File source, File target) {
		// 判断源文件是否存在
		if (!source.exists()) {
			System.out.println("源文件不存在，程序退出");
			System.exit(0);
		}

		// 判断目标文件路径是否存在，不存在就创建
		if (!(target.getParentFile().exists())) {
			target.getParentFile().mkdirs();
		}

		Reader reader = null;
		Writer writer = null;
		try {
			reader = new FileReader(source);
			writer = new FileWriter(target);
			char c[] = new char[1024];
			int len = 0;
			while ((len = reader.read(c)) != -1) {
				writer.write(c, 0, len);
			}
			writer.flush();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				// 多个资源需要关闭时，原则上应该是先开的后关
				if (writer != null) {
					writer.close();
				}
				if (reader != null) {
					reader.close();
				}
			} catch (IOException e) {
				e.printStackTrax`ce();
			}
		}
	}

	public static void main(String[] args) {
		File source = new File(
				"D:\\java\\Java高级\\myfile\\a.txt");
		File target = new File(
				"D:\\java\\Java高级\\myfile\\b.txt");
		copyFileByWriter(source, target);
	}
}

2：缓冲流(处理流)-Buffered

缓冲流是建立在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写的效率，还增加了一些新的方法。

JDK提供四种缓冲流：

BufferedInputStream 可以对任何的InputStream流进行包装

BufferedOutputStream 可以对任何的OutputStream流进行包装

BufferedReader 可以对任何的Reader流进行包装

BufferedWriter 可以对任何的Writer流进行包装

注意：

对于缓冲输出流，写出的数据会先缓存在内存缓冲区中，关闭此流前要用flush()方法将缓存区的数据立刻写出。

关闭过滤流时，会自动关闭缓冲流包装的所有底层流。

2.1：字节缓冲流

字节缓冲分输入缓冲和输出缓冲。

1、缓冲字节输入流：BufferedInputStream。BufferedInputStream为另一个输入流添加一些功能，即缓冲输入以及支持mark 和reset 方法的能力。

2、缓冲字节输出流：BufferedOutputStream。输出字节时，先把要输出的字节输出到缓冲区，当手动调用flush()方法或者缓冲区满或者流关闭时才会把数据输出到结点流。

3、字节缓冲输入流的缓冲区默认大写为8k字节。也可以指定缓冲区大小

package com.File_demo;

import java.io.*;

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

//        使用缓冲流，来拷贝
        FileInputStream fileInputStream = new FileInputStream("D:\\飞思培训\\FileTest\\11.txt");
//        缓冲流
        BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);

        FileOutputStream fileOutputStream = new FileOutputStream("D:\\飞思培训\\FileTest\\12.txt");
//        字节缓冲流
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
//        开始时间
        long start =System.currentTimeMillis();
        int len = 0 ;
//        每次拿取的字节数量
        byte[] b=new byte[1024];
        while((len = bufferedInputStream.read(b))!=-1){
            bufferedOutputStream.write(b,0,len);
        }
//        结束时间
        long end = System.currentTimeMillis();
        System.out.println(end - start);
        bufferedOutputStream.close();
        bufferedInputStream.close();

    }
}

2.2：字符缓冲流

字符缓冲分输入缓冲和输出缓冲。

1、 BufferedReader 从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。 mark和 reset方法。新增了readLine()方法用于一次读取一行字符串(以‘\r’或‘\n’认为一行结束)。

2、 BufferedWriter 将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。

3、字符缓冲输入流的缓冲区默认大写为8k个字符。也可以指定缓冲区大小。

package com.File_demo;

import java.io.*;

public class BufferedReaderStream1 {

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

        BufferedReader bufferedReader = null ;
        BufferedWriter bufferedWriter = null ;

        try {
            //创建字符流对象
            Reader reader = new FileReader("File/src/1.txt");
            //利用字符流对象转化为缓冲流对象
             bufferedReader = new BufferedReader(reader);
 			//创建字符流对象
            Writer writer = new FileWriter("File/src/2.txt");
            //利用字符流对象转化为缓冲流对象
             bufferedWriter = new BufferedWriter(writer);
			//创建数组，用来读取数据
            char[] c = new char[1024] ;
            int len = 0 ;
            //每次读取1024个字符，若读取的len=-1就没有数据
            while((len=bufferedReader.read(c))!=-1){
                System.out.println(new String(c,0,len));
                bufferedWriter.write(c,0,len);
            }

        }  catch (Exception e) {
            e.printStackTrace();
        } finally {
            //最后进行关闭流
            if(bufferedReader!=null){
                bufferedReader.close();
            }
            if (bufferedWriter!=null){
                bufferedWriter.close();
            }
        }
    }
}

3、总结

文件复制就是利用了我们的IO流这点毋庸置疑

缓冲流的使用大大增加了我们IO流传输的速度，使用缓冲数组以后，整体的读取，写入效率提升很大。降低了CPU通过内存访问硬盘的次数。提高效率，降低磁盘损耗。

但是-----这里需要注意的是，所有的缓冲流都没有任何的读取，写入文件能力，这里都需要对应的输入流和输出流来提供对应的能力。在创建缓冲流流对象时，需要传入对应的输入流对象和输出流对象。底层就是提供了一个默认大小的缓冲数组，用于提高效率。

4、建议采纳

如有建议或者错误请私信我进行修改，感谢！！！

CXY_1274511216

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
IO流_3_文件复制+buffered缓冲流

文件复制就是利用了我们的IO流这点毋庸置疑缓冲流的使用大大增加了我们IO流传输的速度，使用缓冲数组以后，整体的读取，写入效率提升很大。降低了CPU通过内存访问硬盘的次数。提高效率，降低磁盘损耗。但是-----这里需要注意的是，所有的缓冲流都没有任何的读取，写入文件能力，这里都需要对应的输入流和输出流来提供对应的能力。在创建缓冲流流对象时，需要传入对应的输入流对象和输出流对象。底层就是提供了一个默认大小的缓冲数组，用于提高效率。4、
复制链接

扫一扫