大数据必学Java基础（七十）：不要用字符流去操作非文本文件

举报
Lansonli 发表于 2022/10/05 10:52:26 2022/10/05
【摘要】 不要用字符流去操作非文本文件文本文件：.txt .java .c .cpp -- 建议使用字符流操作非文本文件：.jpg、 .mp3 、 .mp4、.doc 、.ppt -- 建议使用字节流操作利用try-catch-finally处理异常方式package com.lanson.io01;import java.io.*;/** * @author : Lansonli */public ...

不要用字符流去操作非文本文件

文本文件：

.txt .java .c .cpp -- 建议使用字符流操作

非文本文件：

.jpg、 .mp3 、 .mp4、.doc 、.ppt -- 建议使用字节流操作

利用try-catch-finally处理异常方式

package com.lanson.io01;

import java.io.*;

/**
 * @author : Lansonli
 */
public class Test04 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args)  {
        //1.有一个源文件
        File f1 = new File("d:\\Test.txt");
        //2.有一个目标文件：
        File f2 = new File("d:\\Demo.txt");
        //3.搞一个输入的管 怼到源文件上：
        FileReader fr = null;
        FileWriter fw = null;
        try {
            fr = new FileReader(f1);
            //4.搞一个输出的管，怼到目标文件上：
            fw = new FileWriter(f2);

            //5.开始动作：
            char[] ch = new char[5];
            int len = fr.read(ch);
            while(len!=-1){
                String s = new String(ch,0,len);
                fw.write(s);
                len = fr.read(ch);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //6.关闭流：(关闭流的时候，倒着关闭，后用先关)
            try {
                if(fw!=null){//防止空指针异常
                    fw.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

            try {
                if(fr!=null){
                    fr.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

        }

    }
}


一、FileInputStream读取文件中内容

1、读取文本文件

package com.lanson.io02;

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

/**
 * @author : Lansonli
 */
public class Test01 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) throws IOException {
        //功能：利用字节流将文件中内容读到程序中来：
        //1.有一个源文件：
        File f = new File("D:\\Test.txt");
        //2.将一个字节流这个管 怼  到 源文件上：
        FileInputStream fis = new FileInputStream(f);
        //3.开始读取动作
        /*
        细节1：
        文件是utf-8进行存储的，所以英文字符 底层实际占用1个字节
        但是中文字符，底层实际占用3个字节。

        细节2：
        如果文件是文本文件，那么就不要使用字节流读取了，建议使用字符流。

        细节3：
        read()读取一个字节，但是你有没有发现返回值是 int类型，而不是byte类型？
        read方法底层做了处理，让返回的数据都是“正数”
        就是为了避免如果字节返回的是-1的话，那到底是读入的字节，还是到文件结尾呢。
         */
        int n = fis.read();
        while(n!=-1){
            System.out.println(n);
            n = fis.read();
        }
        //4.关闭流：
        fis.close();

    }
}

2、利用字节流读取非文本文件（一个字节一个字节的读取）

package com.lanson.io02;

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

/**
 * @author : Lansonli
 */
public class Test02 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) throws IOException {
        //功能：利用字节流将文件中内容读到程序中来：
        //1.有一个源文件：
        File f = new File("D:\\LOL.jpg");
        //2.将一个字节流这个管 怼  到 源文件上：
        FileInputStream fis = new FileInputStream(f);
        //3.开始读取动作
        int count = 0;//定义一个计数器，用来计读入的字节的个数
        int n = fis.read();
        while(n!=-1){
            count++;
            System.out.println(n);
            n = fis.read();
        }
        System.out.println("count="+count);
        //4.关闭流：
        fis.close();

    }
}


3、利用字节类型的缓冲数组

package com.lanson.io02;

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

/**
 * @author : Lansonli
 */
public class Test03 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) throws IOException {
        //功能：利用字节流将文件中内容读到程序中来：
        //1.有一个源文件：
        File f = new File("D:\\LOL.jpg");
        //2.将一个字节流这个管 怼  到 源文件上：
        FileInputStream fis = new FileInputStream(f);
        //3.开始读取动作
        //利用缓冲数组：（快递员的小车）
        byte[] b = new byte[1024*6];
        int len = fis.read(b);//len指的就是读取的数组中的有效长度
        while(len!=-1){
            //System.out.println(len);
            for(int i = 0;i<len;i++){
                System.out.println(b[i]);
            }
            len = fis.read(b);
        }
        //4.关闭流：
        fis.close();

    }
}


二、FileInputStream、FileOutputStream完成非文本文件的复制

1、读入一个字节，写出一个字节

package com.lanson.io02;

import java.io.*;

/**
 * @author : Lansonli
 */
public class Test04 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) throws IOException {
        //功能：完成图片的复制：
        //1.有一个源图片
        File f1 = new File("d:\\LOL.jpg");
        //2.有一个目标图片：
        File f2 = new File("d:\\LOL2.jpg");
        //3.有一个输入的管道 怼 到 源文件：
        FileInputStream fis = new FileInputStream(f1);
        //4.有一个输出的管道 怼到  目标文件上：
        FileOutputStream fos = new FileOutputStream(f2);
        //5.开始复制：（边读边写）
        int n = fis.read();
        while(n!=-1){
            fos.write(n);
            n = fis.read();
        }
        //6.关闭流：(倒着关闭流，先用后关)
        fos.close();
        fis.close();


    }
}


2、利用缓冲字节数组

package com.lanson.io02;

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

/**
 * @author : Lansonli
 */
public class Test05 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) throws IOException {
        //功能：完成图片的复制：
        //1.有一个源图片
        File f1 = new File("d:\\LOL.jpg");
        //2.有一个目标图片：
        File f2 = new File("d:\\LOL2.jpg");
        //3.有一个输入的管道 怼 到 源文件：
        FileInputStream fis = new FileInputStream(f1);
        //4.有一个输出的管道 怼到  目标文件上：
        FileOutputStream fos = new FileOutputStream(f2);
        //5.开始复制：（边读边写）
        //利用缓冲数组：
        byte[] b = new byte[1024*8];
        int len = fis.read(b);
        while(len!=-1){
            fos.write(b,0,len);
            len = fis.read(b);
        }
        //6.关闭流：(倒着关闭流，先用后关)
        fos.close();
        fis.close();


    }
}


三、缓冲字节流(处理流) -- BufferedInputStream ,BufferedOutputStream

1、读入一个字节，写出一个字节

2、 利用缓冲字节数组

3、利用缓冲区

想要完成上面的效果，单纯的靠FileInputStream、FileOutputStream是不可以完成的，这个时候就需要功能的加强。 这个加强就需要引入新的流（在FileInputStream、FileOutputStream外面再套一层流）：BufferedInputStream ,BufferedOutputStream -- 处理流

4、代码

package com.lanson.io02;

import java.io.*;

/**
 * @author : Lansonli
 */
public class Test06 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) throws IOException {
        //1.有一个源图片
        File f1 = new File("d:\\LOL.jpg");
        //2.有一个目标图片：
        File f2 = new File("d:\\LOL2.jpg");
        //3.有一个输入的管道 怼 到 源文件：
        FileInputStream fis = new FileInputStream(f1);
        //4.有一个输出的管道 怼到  目标文件上：
        FileOutputStream fos = new FileOutputStream(f2);
        //5.功能加强，在FileInputStream外面套一个管：BufferedInputStream:
        BufferedInputStream bis = new BufferedInputStream(fis);
        //6.功能加强，在FileOutputStream外面套一个管：BufferedOutputStream:
        BufferedOutputStream bos = new BufferedOutputStream(fos);

        //7.开始动作 ：
        byte[] b = new byte[1024*6];
        int len = bis.read(b);
        while(len!=-1){
            bos.write(b,0,len);
           /* bos.flush(); 底层已经帮我们做了刷新缓冲区的操作，不用我们手动完成：底层调用flushBuffer()*/
            len = bis.read(b);
        }

        //8.关闭流：
        //倒着关：
        //如果处理流包裹着节点流的话，那么其实只要关闭高级流（处理流），那么里面的字节流也会随之被关闭。
        bos.close();
        bis.close();
        /*fos.close();
        fis.close();*/
    }
}
【版权声明】本文为华为云社区用户原创内容，转载时必须标注文章的来源（华为云社区）、文章链接、文章作者等基本信息， 否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱： cloudbbs@huaweicloud.com
Java 大数据
  • 点赞
  • 收藏
  • 关注作者

评论（0）

0/1000
抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认 取消

加入云驻计划，成为创作者

  • 华为云周边好礼
  • 免费体验产品
  • 特殊身份标识
  • 线下官方门票
  • 内部专家零距离
  • 与10000+优质创作者共同成长
立即加入