java高级语言 - I/O 流04 缓冲流

最新推荐文章于 2021-09-15 17:56:12 发布
最新推荐文章于 2021-09-15 17:56:12 发布
阅读量110 收藏
点赞数 1
分类专栏： javase 文章标签： stream buffer
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40617873/article/details/106566805
版权

缓冲流

作用：提高流读取和写入（文件处理）的效率

处理非文本文件：

​ BufferedInputStream

​ BufferedOutputStream

​ BufferedReader

​ BufferedWriter

缓冲流复制文件

package com.io.readerwriter;

import org.junit.Test;

import java.io.*;

// test bufferStream
public class Demo06 {

    //
    @Test
    public void  BufferedStreamTest(){
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            // 1. create file
            File srcFile = new File("/Users/pz/Desktop/screen.png");
            File destFile = new File("/Users/pz/Desktop/screen_copy.png");
            //  2. create stream
            //  2.1 create node stream
            FileInputStream fis = new FileInputStream(srcFile);
            FileOutputStream fos = new FileOutputStream(destFile);
            //  2.2 create buffered stream
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);
            // 3. read and write
            byte[] buffer = new byte[10];
            int len;
            while((len = bis.read(buffer))!=-1){
                bos.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 4. close stream
            // order: close outer stream first, then close inner stream
            if(bos!=null){
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(bis!=null){
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                // inner streams closed when outer streams closed
                // fos.close();
                // fis.close();
            }
        }
    }
}

缓冲流复制文件速度

package com.io.readerwriter;

import org.junit.Test;

import java.io.*;

public class Demo07 {

    public void copyFileWithBuffered(String srcPath,String destPath){
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            // 1. create file
            File srcFile = new File(srcPath);
            File destFile = new File(destPath);
            //  2. create stream
            //  2.1 create node stream
            FileInputStream fis = new FileInputStream(srcFile);
            FileOutputStream fos = new FileOutputStream(destFile);
            //  2.2 create buffered stream
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);
            // 3. read and write
            byte[] buffer = new byte[1024];
            int len;
            while((len = bis.read(buffer))!=-1){
                bos.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 4. close stream
            // order: close outer stream first, then close inner stream
            if(bos!=null){
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(bis!=null){
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                // inner streams closed when outer streams closed
                // fos.close();
                // fis.close();
            }
        }
    }
    @Test
    public void testCopyFileWithBuffered(){
        long start = System.currentTimeMillis();
        String srcPath = "/Users/pz/Desktop/study/usc_record/GMT20200323-222726_20201_inf__640x360.mp4";
        String destPath = "/Users/pz/Desktop/study/usc_record/copy.mp4";
        copyFileWithBuffered(srcPath,destPath);
        long end = System.currentTimeMillis();
        System.out.println("cost time: "+(end-start));
    }
}
// cost time: 2108
// compare with Demo5: cost 7102

处理文本文件

BufferedReader

BufferedWriter

package com.io.readerwriter;

import org.junit.Test;

import java.io.*;

// test buffered reader and buffered writer to copy text file
public class Demo08 {
    @Test
    public void testBufferedReaderBufferedWriter(){
        BufferedReader br = null;
        BufferedWriter bw = null;

        try {
            // create file and stream
            br = new BufferedReader(new FileReader(new File("src/com/io/hello.txt")));
            bw = new BufferedWriter(new FileWriter(new File("src/com/io/hello_copy.txt")));

            // read and write
            // way 1
//            char[] cbuf = new char[1024];
//            int len;
//            while((len = br.read(cbuf))!=-1){
//                bw.write(cbuf,0,len);
//            }

            // way 2
            String data;
            while((data = br.readLine())!=null){
                // 1.
                //bw.write(data+"\n"); // data中不包含换行符
                // 2.
                bw.write(data);
                bw.newLine(); // 提供换行的操作
            }


        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(bw!=null){
                // close stream
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(br!=null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
节点流（或文件流）方法缓冲流（处理流的一种）方法
FileInputStreamread(byte[] buffer)BufferedInputStreamread(byte[] buffer)
FileOutputStreamwrite(byte[] buffer,0,len)BufferedOutputStreamWrite(byte[] buffer,0,len)/flush()
FileReaderread(char[] chuff)BufferedReaderread(char[] cbuf)
FileWriterwrite(char[] chuff,0,len)BufferedWriterwrite(char[] cbuf,0,len)/flush
  1. Create file
  2. create stream
  3. read and write data
  4. close stream

练习

图片加密

hint：

int b = 0;
while((b = fis.read())!=-1){
  fos.write(b^5);
}

package com.io.readerwriter;

import org.junit.Test;

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

public class Demo09 {
    // picture encryption
    @Test
    public void test1(){
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream("/Users/pz/Desktop/screen.png");
            fos = new FileOutputStream("/Users/pz/Desktop/screen_2.png");
            byte[] buffer = new byte[20];
            int len;
            while((len=fis.read(buffer))!=-1){
                // modify byte array
                for (int i = 0; i < len; i++) {
                    buffer[i] = (byte)(buffer[i]^5);
                }
                fos.write(buffer,0,len);
            }
        } 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();
                }
            }
        }
    }
    // decrypt
    @Test
    public void test2(){
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream("/Users/pz/Desktop/screen_2.png");
            fos = new FileOutputStream("/Users/pz/Desktop/screen_3.png");
            byte[] buffer = new byte[20];
            int len;
            while((len=fis.read(buffer))!=-1){
                // modify byte array
                for (int i = 0; i < len; i++) {
                    buffer[i] = (byte)(buffer[i]^5);
                }
                fos.write(buffer,0,len);
            }
        } 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();
                }
            }
        }
    }
}

获取文本上每个字符出现的次数

hint：遍历文本的每一个字符，字符及字符出现的次数保存着Map中， 将Map 中的数据写入文件

package com.io.readerwriter;

import org.junit.Test;

import java.io.*;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

// word count
// 遍历文本的每一个字符
// 字符出现的次数存在 Map中
// Map<Character,Integer> map = new HashMap<>();
// map.put('a',12);
// 把 Map 中的数据写入文件
public class Demo10 {
    @Test
    public void testWordCount(){
        FileReader fr = null;
        BufferedWriter bw = null;
        try {
            Map<Character,Integer> map = new HashMap<>();
            fr = new FileReader("src/com/io/hello.txt");

            int c = 0;
            while((c = fr.read())!=-1){
                // int back to char
                char ch = (char)c;
                if(map.get(ch)==null){
                    map.put(ch,1);
                }else{
                    map.put(ch,map.get(ch)+1);
                }
            }
            bw = new BufferedWriter(new FileWriter("src/com/io/output.txt"));
            // traversal map and write data
            Set<Map.Entry<Character,Integer>> entrySet = map.entrySet();
            for(Map.Entry<Character,Integer> entry:entrySet){
                switch (entry.getKey()){
                    case ' ':
                        bw.write("space = "+entry.getValue());
                        break;
                    case '\t':
                        bw.write("tab = "+entry.getValue());
                        break;
                    case '\r':
                        bw.write("return = "+entry.getValue());
                        break;
                    case '\n':
                        bw.write("line break = " +entry.getValue());
                        break;
                    default:
                        bw.write(entry.getKey()+"="+entry.getValue());
                        break;
                }
                bw.newLine();
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fr!=null){
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(bw!=null){
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
ShakeSharkPP
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基础深化和提高-IO流技术学习大全
11-11
另外，Java还提供了一些高级的流类，如缓冲流、对象流、数据流等，它们在底层字节流和字符流的基础上提供了更多的功能和便利。 除了基本的文件和网络I/O之外，Java的NIO（New I/O）技术也是I/O流领域的重要发展。...
php操作base64编码转pdf文件,Pdf与Base64编码之间的转换
weixin_29903043的博客
03-25 1197
Base64编码转换为pdfpublic static void base64StringToPdf(String base64Content,String filePath){BASE64Decoder decoder = new BASE64Decoder();BufferedInputStream bis = null;FileOutputStream fos = null;Buffered...
Pdf与Base64编码之间的转换
热门推荐
路漫漫，水迢迢
08-03 4万+
在我们的工作有时候我们需要将图片或者pdf文件转换为Base64编码，然后从服务器端下载传输到本地，在这里我列举下两者之间的转换方法： Base64编码转换为pdf：/** * Description: 将base64编码内容转换为Pdf * @param base64编码内容，文件的存储路径（含文件名） * @Author fuyuwei * Creat
缓冲流BIS和BOS
风火一回，一生不毁
08-29 906
BufferOutStream：缓冲输出流，其内部维护一个
2021-09-15 IO流FOS FIS BOS BIS详解
抱住小羊的卷卷
09-15 526
一、IO流 Java标准IO流： in输入，out输出 java将IO比喻为“流”，即Stream。就像生活中的“电流”，“水流”一样，它是以同一个方向顺序移动的过程，只不过这里流动的是二进制数据。 我们可以理解它们是连接程序与另一端的“管道”，用于获取和发送数据到另一端。 二、IO流的分类： 1、根据数据的流向：输入流和输出流 输入流：从外界到程序，用来读取数据。 输出流：从程序到外界，用来写出数据。 2、根据流的操作单位：字节流和字符流 字节流：以字节为单位读写数据。 字符流：以字符
第四十八讲 I/O流——常用IO流(数据流和内存操作流)
李阿昀的博客
11-30 2149
数据流 数据流是操作基本数据类型的流，分为数据输入流和数据输出流。下面分别来对它们进行介绍。 数据输入流 概述 数据输入流DataInputStream允许应用程序以与机器无关方式从底层输入流中读取基本Java数据类型。应用程序可以使用数据输出流写入稍后由数据输入流读取的数据。 数据输出流 概述 数据输出流DataOutputStream允许应用程序以适当方式将基本Java数据类型写入输出流中。然...
JAVA_API1.6文档（中文）
04-12
javax.imageio.stream Java Image I/O API 的一个包，用来处理从文件和流中产生的低级别 I/O。 javax.management 提供 Java Management Extensions 的核心类。 javax.management.loading 提供实现高级动态加载的类...
java jdk-api-1.6 中文 chmd
03-22
javax.imageio.stream Java Image I/O API 的一个包，用来处理从文件和流中产生的低级别 I/O。 javax.management 提供 Java Management Extensions 的核心类。 javax.management.loading 提供实现高级动态加载的类...
java api最新7.0
10-26
javax.imageio.stream Java Image I/O API 的一个包，用来处理从文件和流中产生的低级别 I/O。 javax.management 提供 Java Management Extensions 的核心类。 javax.management.loading 提供实现高级动态加载的类。...
Java 1.6 API 中文 New
10-26
javax.imageio.stream Java Image I/O API 的一个包，用来处理从文件和流中产生的低级别 I/O。 javax.management 提供 Java Management Extensions 的核心类。 javax.management.loading 提供实现高级动态加载的类。...
HDFS客户端操作（win10）
weixin_38023225的博客
09-10 613
搭建开发环境 1）拷贝编译后的hadoop jar包到非中文路径 hadoop源码编译参考：https://blog.csdn.net/weixin_38023225/article/details/100576751 也可直接下载：https://download.csdn.net/download/weixin_38023225/11692985 2）配置HADOOP_HOME环境变量...
文件读写小程序
08-08 466
package service; import bean.User;/** *  * 功能接口 * */public interface UserFaoif {    void addUser(User u);     User getUser();}    package service; import java.io.
jav常用类-时间处理相关类
shake_shark_pp
05-29 3378
时间处理相关类 https://www.bilibili.com/video/BV1bW411o7TJ?p=9 1970年1月1日00:00:00为基准时间，度量单位为毫秒 long now = System.currentTimeMillis(); public class Demo00 { public static void main(String[] args) { Date d = new Date(2000); System.out.println
java集合-set练习题
shake_shark_pp
06-01 1841
练习题 TreeSet练习 题目：定义一个Employee类，该类包含：private 成员变量 name age birthtday,其中birthday为MyDate类的对象。并为每一个属性定义 getter, setter 方法，并重写toString方法输出name age birthday MyDate类包含： private 成员变量 year month day，并为每一个属性定义getter,setter方法 创建该类的5个对象，并把这些对象放入TreeSet集合中 分别按照以下两种方式对
Java高级语言 - GUI 04 swing 窗口 面板 弹窗 按钮 单选框 复选框
shake_shark_pp
06-08 313
Swing 窗口 面板 Jframe package com.swing.jframe; import javax.swing.*; import java.awt.*; public class JFrameDemo01 { public static void main(String[] args) { new MyJFrame2().init(); } } class MyJFrame2 extends JFrame{ public void init(){
java多线程 05 线程同步方法 CopyOnWriteArrayList 死锁 lock锁 synchronized
shake_shark_pp
06-16 268
线程同步 并发：多个线程操作同一个资源 线程同步 – 等待机制 形成条件：队列｜锁机制 synchronized 解决线程安全性 同步方法 synchronized 关键字 包括两种用法：synchronized 方法和 synchronized 块 synchronized 方法控制对“对象”的访问，每个对象对应一把锁，每个 synchronized 方法都必须获得调用该方法的对象的锁才能执行，否则线程会堵塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行 若
java实现简单计算器-switch scanner method
shake_shark_pp
05-24 233
java实现简单计算器 scanner实现用户多次输入数据 import java.util.Scanner; public class ScannerTest { public static void main(String[] args) { Scanner sc = new Scanner(System.in); String str=null; while(!(str=sc.nextLine()).equals("exit")){//当输入的数据是exit退出输入 System.ou
java流程控制02-顺序结构 03-选择结构
shake_shark_pp
05-23 208
顺序结构 sequential structure java的基本结构 ----> A -----> B -----> 他是任何一个算法都离不开的一种基本算法结构 选择结构 If 单选择结构 grammer： if (bool expression){ // the code will be executed if bool expression is true } example package com.zepei.struct; import java.util.Scanner;
java使用I/O流完成文件复制
最新发布
09-03
### 回答1： 在 Java 中使用 I/O 流复制文件可以使用如下的代码： ...无论使用字节流还是字符流，Java中的I/O流都提供了方便的方法来实现文件复制。通过以上的代码示例，我们可以轻松地完成文件复制操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值