Java的IO流：字符流 和 字节流

最新推荐文章于 2023-01-30 11:15:26 发布
最新推荐文章于 2023-01-30 11:15:26 发布
阅读量242 收藏
点赞数 1
分类专栏： Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuDong1109/article/details/115070133
版权

IO流

I（Input 输入）/ O（Output 输出）流，是Java中用来传输数据的方式。

一、划分

按照流向：

  • 输入流：从文件 读数据 到内存
  • 输出流：从内存 写数据 到文件

按照操作：

  • 字符流：以字符为单位操作数据
    • Reader：字符输入流的顶层抽象类
      • FileReader：普通的字符输入流
      • BufferedReader：高效的字符输入流（字符缓冲输入流）
    • Writer：字符输出流的顶层抽象类
      • FileWriter：普通的字符输出流
      • BufferedWriter：高效的字符输出流（字符缓冲输出流）
  • 字节流：以字节为单位操作数据
    • InputStream：字节输入流的顶层抽象类
      • FileInputStream：普通的字节输入流
      • BufferedInputStream：高效的字节输入流（字节缓冲输入流）
    • OutputStream：字节输出流的顶层抽象类
      • FileOutputStream：普通的字节输出流
      • BufferedOutputStream：高效的字节输出流（字节缓冲输出流）

二、File类

文件，文件夹，一个File对象代表磁盘上的某个文件或文件夹

2.1 构造方法

  • File(String pathname)
  • File(String parent, String child)
  • File(File parent, String child)
File file1 = new File("D:/abc/1.txt");
System.out.println("file1: " + file1);

File file2 = new File("D:/abc/", "1.txt");
System.out.println("file2: " + file2);

File file3 = new File("D:/abc/");
File file4 = new File(file3, "1.txt");
System.out.println("file4: " + file4);

2.2 成员方法

  • 创建功能：如果不存在就创建，返回true；否则就不创建，返回false

    • createNewFile()：创建文件
    • mkdir()：创建单级目录
    • mkdirs()：创建目录
    File file5 = new File("F:/abc/2.txt");
boolean flag1 = file5.createNewFile();
System.out.println("flag1: " + flag1);

File file6 = new File("F:/a");
boolean flag2 = file6.mkdir();
System.out.println("flag2: " + flag2);

File file7 = new File("F:/b/c");
boolean flag3 = file7.mkdirs(); // 也可以创建单级目录
System.out.println("flag3: " + flag3);

  • 判断功能：

    • isDirectory()：判断File对象是否为目录
    • isFile()：判断File对象是否为文件
    • exists()：判断File对象是否存在
    File file8 = new File("F:/a/b");
System.out.println("判断file8是否为文件夹：" + file8.isDirectory());
System.out.println("判断file8是否为文件：" + file8.isFile());
System.out.println("判断file8是否存在：" + file8.exists());

  • 获取功能：

    • getAbsolutePath()：获取绝对路径

      绝对路径：以盘符开头的路径，例如D:/1.txt

    • getPath()：获取文件的相对路径

      相对路径：一般是相对于当前项目的路径而言，例如1.txt

    • getName()：获取文件名

    File file1 = new File("lib/3.txt");
file1.createNewFile();

String path1 = file1.getAbsolutePath();
System.out.println("绝对路径：" + path1);

String path2 = file1.getPath();
System.out.println("相对路径：" + path2);

String name = file1.getName();
System.out.println("文件名称：" + name);
    • list()：获取指定目录下所有文件（夹）的名称数组
    • listFile()：获取指定目录下所有文件（夹）的File数组
    File file2 = new File("lib");

String[] names = file2.list();
System.out.println("lib目录下的文件（夹）名称如下：");
for (String s : names) {
	System.out.println(s);
}

File[] files = file2.listFiles();
System.out.println("lib目录下的文件（夹）数组如下：");
for (File file : files) {
	System.out.println(file);
}

三、字符流

字符流只能拷贝纯文本文件！

3.1 字符输入流：Reader

  1. 创建字符输入流对象FileReader
  2. 读取数据
  3. 释放资源

例子1：一次读取一个字符

public class ReaderDemo {
    public static void main(String[] args) throws IOException {
        // 1.创建字符输入流对象
        Reader reader = new FileReader("lib/3.txt");

        // 2.读取数据
        /*
            2.1 reader.read()，到文件中读取一个字符
            2.2 ch = reader.read()，将读取到的字符赋值给变量ch
            2.3 (ch = reader.read()) != -1，用读取到的字符（变量）和 -1 进行比较，若文件已经读完，会返回 -1
         */
        int ch;
        while ((ch = reader.read()) != -1) {
            System.out.println(ch);
        }

        // 3.释放资源
        reader.close();
    }
}

例子2：一次读取一个字符数组

public class ReaderDemo {
    public static void main(String[] args) throws IOException {
        // 1.创建字符输入流对象
        Reader reader = new FileReader("lib/3.txt");

        // 2.读取数据
        /*
            2.1 reader.read(chs)，到文件中读取若干字符到字符数组 chs中
            2.2 len = reader.read(chs)，将读取到的有效字符数量赋值给变量 len
            2.3 (len = reader.read(chs)) != -1，用读取到的字符数量（变量）和 -1 进行比较，若文件已经读完，会返回 -1
         */
        char[] chs = new char[3];
        int len;
        while ((len = reader.read(chs)) != -1) {
            String s = new String(chs,0,len);
            System.out.println(s);
        }

        // 3.释放资源
        reader.close();
    }
}

3.2 字符输出流：Writer

  1. 创建字符输出流对象FileWriter

  2. 写入数据

    void write(int ch); // 一次写一个字符

    void write(char[] chs, int index, int len); //一次写一个字符数组

    void write(String str); //一次写一个字符串

  3. 释放资源

public class WriterDemo {
    public static void main(String[] args) throws IOException {
        // 1.创建字符输出流对象
        Writer writer = new FileWriter("lib/3.txt");

        // 2.写入数据
        // 2.1一次写入一个字符
        writer.write("好");

        // 2.2一次写入一个字符数组，起始 和 长度
        char[] chars = {'华','南','农','业','大','学'};
        writer.write(chars,1,2);

        // 2.3一次写入一个字符串
        writer.write("信息与计算科学");
        
        // 3.释放资源
        writer.close();
    }
}

3.3 字符流拷贝：Reader + Writer

  1. 创建字符输入流对象，关联数据源文件
  2. 创建字符输出流对象，关联目的地文件
  3. 定义变量，用于记录读取到的内容
  4. 循环读取，将读取到的内容赋值给变量
  5. 将读取到的数据写入到 目的地文件中
  6. 释放资源

例子1：一次拷贝一个字符

public class CopyDemo {
    public static void main(String[] args) throws IOException {
        // 1. 创建字符输入流对象，关联数据源文件
        FileReader fr = new FileReader("lib/1.txt");
        // 2. 创建字符输出流对象，关联目的地文件
        FileWriter fw = new FileWriter("lib/3.txt");
        // 3. 定义变量，用于记录读取到的内容
        int ch;
        // 4. 循环读取，将读取到的内容赋值给变量
        while ((ch = fr.read()) != -1) {
            // 5. 将读取到的数据写入到 目的地文件中
            fw.write(ch);
        }
        // 6. 释放资源
        fr.close();
        fw.close();
    }
}

例子2：一次拷贝一个字符数组

public class CopyDemo {
    public static void main(String[] args) throws IOException {
        // 1. 创建字符输入流对象，关联数据源文件
        FileReader fr = new FileReader("lib/1.txt");
        // 2. 创建字符输出流对象，关联目的地文件
        FileWriter fw = new FileWriter("lib/3.txt");
        // 3. 定义变量，用于记录读取到的内容
        char[] chs = new char[1024];
        int len;
        // 4. 循环读取，将读取到的内容赋值给变量，将读取到的有效字符数量赋值给变量 len
        while ((len = fr.read(chs)) != -1) {
            // 5. 将读取到的数据写入到 目的地文件中
            fw.write(chs,0,len);
        }
        // 6. 释放资源
        fr.close();
        fw.close();
    }
}

3.4 字符缓冲流拷贝

  1. 创建字符缓冲输入流对象，关联数据源文件

    new BufferedReader(Reader reader);

  2. 创建字符缓冲输出流对象，关联目的地文件

    new BufferedWriter(Writer writer);

    字符缓冲流自带缓冲区，大小为8192个字符，即16KB

  3. 定义变量，用于记录读取到的内容

  4. 循环读取，将读取到的内容赋值给变量

  5. 将读取到的数据写入到 目的地文件中

  6. 释放资源

public class CopyDemo {
    public static void main(String[] args) throws IOException {
        // 1.创建字符缓冲输入流对象，关联数据源文件
        FileReader fr = new FileReader("lib/1.txt");
        BufferedReader br = new BufferedReader(fr);

        // 2.创建字符缓冲输出流对象，关联目的地文件
        FileWriter fw = new FileWriter("lib/3.txt");
        BufferedWriter bw = new BufferedWriter(fw);

        // 3.定义变量，用于记录读取到的内容
        int len;

        // 4.循环读取，将读取到的内容赋值给变量
        while ((len = br.read()) != -1) {
            // 5.将读取到的数据写入到 目的地文件中
            bw.write(len);
        }

        // 6.释放资源
        bw.close();
        fw.close();
        br.close();
        fr.close();
    }
}

一次读取写一行：

一次读取一行数据并返回读取到的内容，读不到就返回null

public String readLine(){};

根据当前操作系统给出对应的换行符

public void newLine(){};

操作系统换行符
windows\r\n
mac\r
unix\n
public class CopyDemo {
    public static void main(String[] args) throws IOException {
        // 1.创建字符缓冲输入流对象，关联数据源文件
        BufferedReader br = new BufferedReader(new FileReader("lib/1.txt"));
        // 2.创建字符缓冲输出流对象，关联目的地文件
        BufferedWriter bw = new BufferedWriter(new FileWriter("lib/3.txt"));

        // 3.定义变量，用于记录读取到的内容
        String str;
        // 4.循环读取，将读取到的内容赋值给变量
        while ((str = br.readLine()) != null) {
            // 5.将读取到的数据写入到 目的地文件中
            bw.write(str);
            // 注意换行
            bw.newLine();
        }

        // 6.释放资源
        bw.close();
        br.close();
    }
}

四、字节流

拷贝纯文本文件使用字符流，拷贝其他==（图片、音频、视频等）==使用字节流

4.1 字节流拷贝

InputStream + OutputStream

  1. 创建字节输入流对象FileInputStream，关联数据源文件
  2. 创建字节输出流对象FileOutputStream，关联目的地文件
  3. 定义变量，用于记录读取到的内容
  4. 循环读取，将读取到的内容赋值给变量
  5. 将读取到的数据写入到 目的地文件中
  6. 释放资源

例子1：一次拷贝一个字节

public class CopyDemo {
    public static void main(String[] args) throws IOException {
        // 1.创建字节输入流对象，关联数据源文件
        FileInputStream fis = new FileInputStream("lib/a.jpg");
        // 2.创建字节输出流对象，关联目的地文件
        FileOutputStream fos = new FileOutputStream("lib/b.jpg");

        // 3.定义变量，用于记录读取到的内容
        int by;
        // 4.循环读取，将读取到的内容赋值给变量
        while ((by = fis.read()) != -1) {
            // 5.将读取到的数据写入到 目的地文件中
            fos.write(by);
        }

        // 6.释放资源
        fos.close();
        fis.close();
    }
}

例子2：一次拷贝一个字节数组

public class CopyDemo {
    public static void main(String[] args) throws IOException {
        // 1.创建字节输入流对象，关联数据源文件
        FileInputStream fis = new FileInputStream("lib/b.jpg");
        // 2.创建字节输出流对象，关联目的地文件
        FileOutputStream fos = new FileOutputStream("lib/c.jpg");

        // 3.定义变量，用于记录读取到的内容
        byte[] bys = new byte[2048];
        int len;
        // 4.循环读取，将读取到的内容赋值给变量，将读取到的有效字符数量赋值给变量 len
        while ((len = fis.read(bys)) != -1) {
            // 5.将读取到的数据写入到 目的地文件中
            fos.write(bys,0,len);
        }

        // 6.释放资源
        fos.close();
        fis.close();
    }
}

4.2 字节缓冲流拷贝

  1. 创建字节缓冲输入流对象，关联数据源文件

    new BufferedInputStream(InputStream is);

  2. 创建字节缓冲输出流对象，关联目的地文件

    new BufferedOutputStream(OutputStream os);

    字节缓冲流自带缓冲区，大小为8192个字节，即8KB

  3. 定义变量，用于记录读取到的内容

  4. 循环读取，将读取到的内容赋值给变量

  5. 将读取到的数据写入到 目的地文件中

  6. 释放资源

public class CopyDemo {
    public static void main(String[] args) throws IOException {
        // 1.创建字节缓冲输入流对象，关联数据源文件
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("lib/a.jpg"));
        // 2.创建字节缓冲输出流对象，关联目的地文件
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("lib/d.jpg"));

        // 3.定义变量，用于记录读取到的内容
        int len;
        // 4.循环读取，将读取到的内容赋值给变量
        while ((len = bis.read()) != -1) {
            // 5.将读取到的数据写入到 目的地文件中
            bos.write(len);
        }

        // 6.释放资源
        bos.close();
        bis.close();
    }
}
Java IO流常用字节字符流原理解析
08-19
Java IO流中的字节流和字符流是两个基本的流类型，字节流用于对文件、网络等进行读写操作，而字符流用于对文本文件、网络等进行读写操作。了解Java IO流的原理和实现，可以帮助我们更好地使用Java IO流来进行文件、...
java读取txt每一行_java读取文件中的每一行
weixin_32243309的博客
02-12 4206
import java.io.BufferedInputStream;import java.io.BufferedReader;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.IOException;import java.io.InputStreamReader;public ...
Java--文件读写三 之 普通字节流一次读写一行
weixin_39772200的博客
08-03 543
import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; public class MyFileInputStream { public static void main(String[] args) throws IOException { //1、创建普通字节流读对象，指定源文件路径 FileInputStream fis = new
字节流一次读取一行数据?
weixin_45216092的博客
03-31 3489
字节流一次读取一行数据? 观察图可发现是可以实现字节流一次读取一行的。 测试1：无中文 BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("G:\\a.txt"))); String str = null; while ((str = br.read...
io流 java每次读一行,Java复习之IO流（下）
weixin_42629522的博客
03-12 1070
上一篇文章中，我们在提到 IO 流的概念时说到 IO 流分为两大类，一个是字节流，我们已经在上一篇文章中做了复习，而本篇文章的 IO流复习就从另一大类字符流来开始。什么是字符流上一篇文章中我们说过字符流一般只能操作的是存文本数据，而字节流可以操作很多类型数据(文本，图片，音频，视频等)字符流是可以直接读写字符的IO流计算机中存储的是字节数据，字符流读取字符，就要先读取到字节数据, 然后转为字符。当...
StreamTool 字节流保存，字节流读取下一行，读取流
张文光的博客
04-25 396
StreamTool 字节流保存，字节流读取下一行，读取流 在读取流的过程中，有时会不确定是否是字节流或者是字符流，统一用字节流读取，然后对流进行处理： public class StreamTool { /** * 将字节流保存到文件中 * @param file * @param data * @throws Exception
java 字节流和字符流的区别详解
08-25
Java 字节流和字符流的区别详解 Java 中的字节流和字符流是两种不同的输入 / 输出流，它们之间的区别是非常重要的。在本文中，我们将详细介绍 Java 中的字节流和字符流的区别，并通过示例代码来演示它们的使用。 ...
详解JAVA 字节流和字符流
08-19
Java字节流和字符流是Java I/O流处理中非常基础且重要的概念，它们是用于文件读写操作的两大类型。Java字节流主要包括InputStream和OutputStream两个基类及其子类，字符流则包括Reader和Writer两个基类及其子类。 ...
详解Java中字符流与字节流的区别
09-02
根据处理的数据单位，Java提供了两种主要类型的流：字符流和字节流。这两种流在处理数据时有显著的区别，尤其是在处理文本数据和二进制数据时。 1. 什么是流 流在Java中是一个抽象概念，它描述了数据如何从一个地方...
Java中的字节流文件读取教程（一）
08-27
主要给大家介绍了关于Java中字节流文件读取的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用java具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java中对于字节流的读取方式
08-06
NULL 博文链接：https://qing-gee.iteye.com/blog/2074683
Java字节流数据逐行读取(readLine)
07-25
Java字节流数据逐行读取(readLine)
1.转换流基本用法（三个练习）2.利用字节流读取数据 读一行且不出现乱码
最新发布
m0_67911983的博客
01-30 108
1.转换流基本用法（三个练习）2.利用字节流读取数据 读一行且不出现乱码
IO流---基础 （附相对路径）
weixin_47198217的博客
08-04 780
Io流、绝对、相对路径
I/O流的学习（二）---字符流
cangerwjd的博客
05-21 201
计算机如何存储中文的?        当前平台默认编码集 :GBK 一个中文两个字节 第一个字节:一定是负数 第二个字节:一般是负数,可能也会是正数,不会影响的结果.public class StringDemo { public static void main(String[] args) { //定义一个字符串 String str = "你好" ;//[-60, -29...
Java IO流精讲下
12-10
本门课程深入浅出的讲解了JavaIO流中的高级部分内容，主要内容有：l  LineNumberReader流l  数据输入输出流（DataInputStream和DataOutputStream）l  内存操作流            字节内存操作流 ByteArrayInputStream ByteArrayOutputStream             字符内存操作流 CharArrayReader CharArrayWrite                    字符串内存操作流 StringReader  StringWriterl  打印流（PrintStream 和 PrintWriter）l  标准输入输出流(System.in 和 System.out)l  随机访问流（RandomAccessFile）l  合并流(SequenceInputStream)l  序列化流和反序列化流(ObjectOutputStream/ObjectInputStream)l  Properties （集合+IO流）
java 字节流和字符流
m0_62472348的博客
07-19 1333
I/O流的分类I/O流按照数据类型分为字节流和字符流，其中字节流可以操作所有类型的文件包括音频视频和图片，而字符流只能操作纯文本文件，如java文件，txt文件等。而按照流向来分的话分为输入流和输出流缓冲输入流缓冲输入流的目的就是加快字节流或者字符流的传输效率，在传输视频、音频等较大文件时可以更好的体现出它的作用。...
Java从一个输入流每次读取一行：BufferedReader.readLine()
热门推荐
Zhang Phil
02-24 4万+
假设该输入流从一个文件中获取，然后每次读取一行输出，直到读取完毕。用Java IO中的BufferedReader的readLine()，“顾名思义，读取一行”实现： import java.io.BufferedReader; import java.io.FileInputStream; import java.io.InputStream; import java.io.InputStre
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值