字节流和字符流的文件读写操作

最新推荐文章于 2024-09-16 18:42:01 发布
最新推荐文章于 2024-09-16 18:42:01 发布
阅读量1.4k 收藏 6
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lintiyan/article/details/90112665
版权

1.乱码问题

问题：当从本地磁盘里读取.txt文件到控制台时，如果本地文件有中文，则控制台会显示乱码；

原因：本地文件是默认采用ANSI编码来进行编码的，而我们的ide采用的编码默认是UTF-8（可以采用System.getProperties().list(System.out),查看file.encoding属性的值得到自己ide默认编码。编码和解码不是同一个自然会有乱码；

解决：用notepade++将.txt文件采用utf-8重新编码即可。

2.字节流和字符流的文件读取实例

package mybatistest.file_transport;

import org.junit.Test;

import java.io.*;

public class FileImport {

    /**
     * 字节流
     * 一次读取一个字节到控制台
     */
    @Test
    public void test01() {
        File file = new File("e:\\a.txt");
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(file);
            int read = -1;
            while ((read = fis.read()) != -1) {
                System.out.print((char) read);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 字节流
     * 一次读取一个固定数组
     */
    @Test
    public void test02() {
        File file = new File("e:\\a.txt");
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(file);
            byte[] bytes = new byte[1024];
            int read = -1;
            StringBuilder sb = new StringBuilder();
            while ((read = fis.read(bytes)) != -1) {
                sb.append(new String(bytes, 0, read));
            }

            System.out.println(sb.toString());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 字节流
     * 一次读取整个文件
     */
    @Test
    public void test03() {
        File file = new File("F:\\a.txt");
        FileInputStream fis = null;

        try {
            fis = new FileInputStream(file);
            byte[] bytes = new byte[fis.available()];
            fis.read(bytes);

            System.out.println(new String(bytes));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }


    /**
     * 字节流
     * 一次写一个字节
     */
    @Test
    public void test04() {
        File target = new File("f:\\a.txt");
        FileOutputStream fos = null;
        try {
            String str = "白日依山尽，黄河入海流。欲穷千里目，更上一层楼";
            byte[] bytes = str.getBytes();
            fos = new FileOutputStream(target);
            for (int i = 0; i < bytes.length; i++) {
                fos.write(bytes[i]);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 字节流
     * 一次写一个固定数组
     */
    @Test
    public void test05() {
        File file = new File("f:\\a.txt");
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(file);
            byte[] bytes = new byte[1024];
            String str = "白日依山尽，黄河入海流。欲穷千里目，更上一层楼";
            byte[] source = str.getBytes();

            for (int i = 0; i <= source.length / bytes.length; i++) {
                if (i == source.length / bytes.length) {
                    fos.write(source, bytes.length * i, source.length);
                } else {
                    fos.write(source, bytes.length * i, bytes.length * (i + 1));
                }
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 字节流
     * 一次全写入
     */

    @Test
    public void test06() {
        File file = new File("f:\\a.txt");
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(file);
            String str = "白日依山尽，黄河入海流。欲穷千里目，更上一层楼";
            fos.write(str.getBytes());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }


    /**
     * 字符流
     * 一次读取一个字符
     */

    @Test
    public void test07() {
        File file = new File("e:\\a.txt");
        FileReader fr = null;
        try {
            fr = new FileReader(file);
            int read = -1;
            while ((read = fr.read()) != -1) {
                System.out.print((char) read);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 字符流
     * 一次读取一个固定数组
     */
    @Test
    public void test08() {
        File file = new File("e:\\a.txt");
        FileReader fr = null;
        try {
            fr = new FileReader(file);
            char[] chars = new char[1024];
            int read = -1;
            StringBuilder sb = new StringBuilder();
            while ((read = fr.read(chars)) != -1) {
                sb.append(new String(chars, 0, read));
            }
            System.out.println(sb.toString());

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 字符流
     * 一次写一个字符
     */
    @Test
    public void test09() {
        File file = new File("f:\\a.txt");
        FileWriter fw = null;
        try {
            fw = new FileWriter(file);
            String str = "白日依山尽，黄河入海流。欲穷千里目，更上一层楼";
            char[] chars = str.toCharArray();
            for (int i = 0; i < chars.length; i++) {
                fw.write(chars[i]);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 字符流
     * 一次写一个字符数组
     */
    @Test
    public void test10() {
        File file = new File("f:\\a.txt");
        FileWriter fw = null;
        try {
            fw = new FileWriter(file);
            char[] chars = new char[1024];
            String str = "白日依山尽，黄河入海流。欲穷千里目，更上一层楼";
            char[] source = str.toCharArray();
            printCharArray(source);
            for (int i = 0; i <= source.length / chars.length; i++) {
                if (i == source.length / chars.length) {
                    fw.write(source, chars.length * i, source.length);
                } else {
                    fw.write(source, chars.length * i, chars.length * (i + 1));
                }
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 字符流
     * 一次全部写入
     */
    @Test
    public void test11() {
        File file = new File("f:\\a.txt");
        FileWriter fw = null;
        try {
            fw = new FileWriter(file);
            String str = "白日依山尽，黄河入海流。欲穷千里目，更上一层楼";
            char[] chars = str.toCharArray();

            fw.write(chars);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 字节流
     * 将文件e:a.txt复制到f:a.txt
     * 一次读写一个字节
     */
    @Test
    public void test12() {
        File source = new File("e:\\a.txt");
        File target = new File("f:\\a.txt");

        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream(source);
            fos = new FileOutputStream(target);

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

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fos.flush();
                fis.close();
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 字节流
     * 将文件e:a.txt复制到f:a.txt
     * 一次读写一个字节数组
     */
    @Test
    public void test13() {
        File source = new File("e:\\a.txt");
        File target = new File("f:\\a.txt");
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream(source);
            fos = new FileOutputStream(target);

            byte[] bytes = new byte[1024];
            int read = -1;
            while ((read = fis.read(bytes)) != -1) {
                fos.write(bytes, 0, read);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fos.flush();
                fis.close();
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 字节流
     * 将文件e:a.txt复制到f:a.txt
     * 一次全部读写
     */
    @Test
    public void test14() {
        File source = new File("e:\\a.txt");
        File target = new File("f:\\a.txt");

        FileInputStream fis = null;
        FileOutputStream fos = null;

        try {
            fis = new FileInputStream(source);
            fos = new FileOutputStream(target);

            byte[] bytes = new byte[fis.available()];
            int read = fis.read(bytes);
            fos.write(bytes, 0, read);

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fos.flush();
                fos.close();
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 字符流
     * * 将文件e:a.txt复制到f:a.txt
     * * 一次读写一个字符
     */
    @Test
    public void test15() {
        File source = new File("e:\\a.txt");
        File target = new File("f:\\a.txt");
        FileReader fr = null;
        FileWriter fw = null;

        try {
            fr = new FileReader(source);
            fw = new FileWriter(target);
            int read = -1;
            while ((read = fr.read()) != -1) {
                fw.write(read);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fw.flush();
                fw.close();
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 字符流
     * * 将文件e:a.txt复制到f:a.txt
     * * 一次读写一个字符数组
     */
    @Test
    public void test16() {
        File source = new File("e:\\a.txt");
        File target = new File("f:\\a.txt");
        FileReader fr = null;
        FileWriter fw = null;

        try {
            fr = new FileReader(source);
            fw = new FileWriter(target);
            char[] chars = new char[1024];
            int read = -1;
            while ((read = fr.read(chars)) != -1) {
                fw.write(chars);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fw.flush();
                fw.close();
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public void printCharArray(char[] chars) {
        if (chars != null) {
            for (int i = 0; i < chars.length; i++) {
                System.out.print(chars[i]);
            }
        }
    }

    @Test
    public void test(){
        System.getProperties().list(System.out);
    }
}

 

lintiyan
关注
字节流和字节顺序(用于序列化和反序列化)
game_helloworld的博客
04-10 3817
介于要设计游戏服务器和客户端逻辑，现在需要普及一下我在代码中用到的一些数据结构，这一篇讲一下字节流--- ByteStream。 字节流就是自己实现的一个数据存储区，可对基础数据和其他特定数据进行序列化和反序列化。用与玩家数据或者其他服务器数据的落地保存。也可用于客户端和服务器,、服务器和服务器之间的通信。里面也添加了对字节顺序的处理逻辑。如果是通信的数据包可以启动字节顺序转换。 需要注意的一点是我对输入的每一个元素只拷贝元素内容，没有存储其类型，所以在字节流输出的时候没有办法做类型校验，这样对于结构经
c语言文件读写字符流及字节流,C++中输入输出流及文件流操作笔记
weixin_34245159的博客
05-17 2796
1、流的控制 iomanip在使用格式化I/O时应包含此头文件。stdiostream用于混合使用C和C + +的I/O机制时，例如想将C程序转变为C++程序2、类继承关系ios是抽象基类，由它派生出istream类和ostream类， iostream类支持输入输出操作，iostream类是从istream类和ostream类通过多重继承而派生的类类ifstream继承了类istream，类of...
Java IO学习笔记（三）：字节流与字符流
weixin_30402343的博客
12-11 231
先来看一下流的概念： 在程序中所有的数据都是以流的方式进行传输或保存的，程序需要数据的时候要使用输入流读取数据，而当程序需要将一些数据保存起来的时候，就要使用输出流完成。 程序中的输入输出都是以流的形式保存的，流中保存的实际上全都是字节文件。 字节流与字符流 在java.io包中操作文件内容的主要有两大类：字节流、字符流，两类都分为输入和输出操作。在字节流中输出数据主要是使用OutputS...
[JAVA]介绍怎样在Java中通过字节字符流实现文件读取与写入
最新发布
2301_79757798的博客
09-16 1185
File类是java.io包下代表与平台无关的文件和目录，程序中操作文件和目录，都可以通过File类来完成。通过这个File对象，可以进行一系列与文件相关的操作，比如判断文件是否存在，获取文件属性，读取文件内容，写入文件内容，新建，删除，重命名文件和目录。运行结果显示：运行结果显示：通过File对象对文件本身的操作，比如实现了对于文件的创建，文件的删除等等，但是对文件的内容，作为File对象它是无能为力不能进行操作的，我们只能通过字节字符流实现文件读取与写入1.字节输入流读取二进制文件。
使用字节流和字符流对文件进行操作
a805814077的博客
08-10 1925
本文较详细的讲解了使用字节流和字符流对文件进行写入、读取、复制的操作
Java字节流与字符流读写文件
热门推荐
蜗牛学习笔记
12-11 1万+
  字节流读写 Java中文件读写有多种方式，但有一种读写方式可以处理任何场景的文件读写，就是字节流的读写。 package com.main.stream; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; i...
字节流，字符流读取文件中的内容
fight_man8866的博客
06-19 2414
  一、使用字节流读取import java.io.File;  import java.io.FileInputStream;  import java.io.FileNotFoundException;  import java.io.IOException;  import java.io.InputStream;    public class Test08 {        public...
Java字符流和字节流对文件操作的区别
09-01
Java的IO流是Java语言处理输入输出操作的重要组成...总的来说，Java的字符流和字节流在文件操作上各有其优势，开发者应根据实际需求选择合适的流类型。了解并熟练掌握这两种流，对于进行高效、准确的文件操作至关重要。
详解JAVA 字节流和字符流
08-19
Java字节流和字符流是Java I/O流处理中非常基础且重要的概念，它们是用于文件读写操作的两大类型。...在选择使用字节流还是字符流时，需要根据文件的类型和操作的需求来决定，以确保处理过程中的效率和正确性。
python字节流和字符流_字符流与字节流
weixin_39548787的博客
12-04 2332
[一]写在前面简单总结一下分别用(一直混淆的)字节流or字符流读写文件。[二]字节流2.1 字节流介绍程序中的输入输出都是以流的形式保存的(输入流or输出流),流中保存的实际上全都是字节(一个字节等于一个Byte占8个bit)文件。Java提供了OutputStream、InputStream两个专门操作字节流的类。知识补充1：计算机能存储的唯一东西就是 bytes,为了在计算机中存储东西,我们首...
java读写文件，字节与字符的读写
weixin_33937499的博客
12-11 183
读文件的各种方式：1、FileInputStreamreader=newFileInputStream(file);//字节流2、Readerreader=newFileReader(file);//字符流，继承InputStreamReader，默认的系统编码格式3、InputStreamReaderreader=newInputStreamRead...
分别使用(字符流)和(字节流)对文件进行读写操作
韩世雷 程序员专栏
04-08 1万+
一.使用(字符流)对文件进行读写操作/* * 使用字符流对文件进行读写操作 */ import java.io.BufferedReader; import java.io.FileInputStream; import java.io.InputStreamReader; import java.io.PrintWriter; public class T04 { public stati
字节与字符的方式读写文件
haiyang2017的博客
11-07 834
字节与字符的区别： 区别：字节是存储容量的基本单位，1字节=8个二进制位。 字符是指字母、数字、汉字和各种符号。 联系： 一个字符在计算机中用若干个字节的二进制数表示，英文字符1个字节，中文字符2个字节。 处理字节流的抽象类： InputStream ：是字节输入流的所有类的超类，子类,如FileInputStream。 read()：读取单个字节。 OutputStream：是字节输出流的所有类...
字节流和字符流简单操作
qq_42721085的博客
07-21 1204
常用的I/O流： 1.字节流： /** * 输出字节流--写操作 * * @param filePath */ public static void fileOutputStreamTest(String filePath) { FileOutputStream fos = null; try { fos = new FileOutputStream(filePath); Str
字节流与字符流 与其常用操作
蹊源的奇思妙想的博客
08-10 2149
字节流与字符流 字节流 占一个字节，8位。 用于：视频、图像、音频等类容 IntputStream输入流 （OutputStream输出流） //都可以向上转型 InputStream子类 数据源类型 ByteArrayInputStream 包含一个内存缓冲区，字节从中取出。 FileInputStream 从文件中获得字节。 ObjectInputStream 用来恢复被序列...
字符读写文件流
wojiaxiaohuang2014的博客
01-16 566
字符读写文件流
字节流和字符流到底怎么用
qq_39286701的博客
10-25 1043
首先说明什么是流，流，可以想象为数据中的流水，水管里面流动的水，按顺序流出来。使用流进行数据文件的读写可以称之为流式读写，与之对比的是随机读写。流式读写也代表着顺序读写，比如一个word文档，只有按里面保存的数据顺序读出来才能还原里面的内容。你不可能先随便从某个字节开始读，一定是怎么存怎么读。因此对于一个流来说，如果想要获取文件中的第5个字节，那么你也只能先把前4个字节读出来，才能获取到第5个字节。对应的是随机读写就是可以从任意读取文件中的某一个位置的字节。 从字面意思上来理解，读取一个.mp4文件得用字节
129.(字节流、字符流)对文件进行读写操作
Away_D的博客
08-03 568
public class Main{ public static void main(String[] args) throws Exception{ String value="中国风\n"; String value2="a 中国风\n"; PrintWriter pw=new PrintWriter("temp.txt","UTF-8"); pw.write(value
Java文件操作实战：字节流与字符流读写
本文档将深入探讨Java中的文件操作，主要包括通过字节流（InputStream）和字符流（Reader）进行文件读取的方法。 首先，我们来看`readFileByBytes`方法，它用于按字节逐个读取文件内容。这个方法首先创建一个`File`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值