Java 流(Stream)、文件(File)和IO

最新推荐文章于 2024-04-27 14:12:29 发布
最新推荐文章于 2024-04-27 14:12:29 发布
阅读量28 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46047285/article/details/133006601
版权

IO流

输入流用于从源读取数据，输出流用于向目标写数据。
下图是一个描述输入流和输出流的类层次图。

1.File类

1.1 File类概述和构造方法

File类介绍

  • 它是文件和目录路径名的抽象表示
  • 文件和目录是可以通过File封装成对象的
  • 对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在的，也可以是不存在的。将来是要通过具体的操作把这个路径的内容转换为具体存在的
方法名说明
File(String pathname)通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例
File(String parent, String child)从父路径名字符串和子路径名字符串创建新的 File实例
File(File parent, String child)从父抽象路径名和子路径名字符串创建新的 File实例

File类的构造方法

import java.io.File;
public class FileDemo01 {
    public static void main(String[] args) {
        File file1 = new File("G:\\JavaEE\\file01.txt");
        System.out.println(file1);
        File file2 = new File("G:\\JavaEE", "file02.txt");
        System.out.println(file2);
        File file3 = new File("G:\\JavaEE");
        File file4 = new File(file3, "file03.txt");
        System.out.println(file4);
    }
}

运行结果

G:\JavaEE\file01.txt
G:\JavaEE\file02.txt
G:\JavaEE\file03.txt

1.2 File类创建功能

public boolean createNewFile() throws IOException当且仅当具有该名称的文件尚不存在时，原子地创建一个由该抽象路径名命名的新的空文件。
public boolean mkdir()创建由此抽象路径名命名的目录。
public boolean mkdirs()创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录。
public class FileDemo02 {
    public static void main(String[] args) throws IOException {
        //需求1：我要在G:\\JavaEE2021目录下创建一个文件file01.txt
        File file1 = new File("G:\\JavaEE2021\\file01.txt");
        System.out.println(file1.createNewFile());
        //需求2：我要在G:\\JavaEE2021目录下创建一个目录JavaEE
        File file2 = new File("G:\\JavaEE2021\\JavaEE");
        System.out.println(file2.mkdir());
        //需求3：我要在G:\\JavaEE2021目录下创建一个多级目录JavaWEB\\HTML
        File file3 = new File("G:\\JavaEE2021\\JavaWEB\\HTML");
        System.out.println(file3.mkdirs());;

    }
}

1.3 File类判断和获取功能

File类的判断和获取功能：
  public boolean isDirectory()：测试此抽象路径名表示的File是否为目录
  public boolean isFile()：测试此抽象路径名表示的File是否为文件
  public boolean exists()：测试此抽象路径名表示的File是否存在

  public String getAbsolutePath()：返回此抽象路径名的绝对路径名字符串
  public String getPath()：将此抽象路径名转换为路径名字符串
  public String getName()：返回由此抽象路径名表示的文件或目录的名称

  public String[] list()：返回此抽象路径名表示的目录中的文件和目录的名称字符串数组
  public File[] listFiles()：返回此抽象路径名表示的目录中的文件和目录的File对象数组
public class FileDemo04 {
    public static void main(String[] args) {
        //创建一个File对象
        File f = new File("G:\\JavaEE2021\\file01.txt");

        System.out.println(f.isDirectory());
        System.out.println(f.isFile());
        System.out.println(f.exists());

        System.out.println(f.getAbsolutePath());
        System.out.println(f.getPath());
        System.out.println(f.getName());
        System.out.println("--------");
			
       File f2 = new File("G:\\JavaEE2021");

        String[] strArray = f2.list();
        for (String str : strArray) {
            System.out.println(str);
        }
        System.out.println("--------");

        File[] fileArray = f2.listFiles();
        for (File file : fileArray) {
            if (file.isFile()) {
                System.out.println(file.getName());
            }
        }
    }
}

1.4 File类的删除功能

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

        //需求1：在当前模块目录下创建java.txt文件
        File f1 = new File("myFile\\java.txt");
      //  f1.mkdirs();
        System.out.println(f1.createNewFile());
        //需求2：删除当前模块目录下的java.txt文件
        System.out.println(f1.delete());
        System.out.println("--------");

        //需求3：在当前模块目录下创建itcast目录
        File f2 = new File("myFile\\itcast");
        System.out.println(f2.mkdir());
        //需求4：删除当前模块目录下的itcast目录
        System.out.println(f2.delete());
        System.out.println("--------");

        //需求5：在当前模块下创建一个目录itcast,然后在该目录下创建一个文件java.txt
        File f3 = new File("myFile\\itcast");
        System.out.println(f3.mkdir());
        File f4 = new File("myFile\\itcast\\java.txt");
        System.out.println(f4.createNewFile());
        //需求6：删除当前模块下的目录itcast
        System.out.println(f4.delete());
        System.out.println(f3.delete());
    }
}

1.5 递归遍历目录

给定一个路径(...)，通过递归完成遍历该目录下所有内容，并把所有文件的绝对路径输出在控制台

public class DiGuiDemo02 {
    public static void main(String[] args) {
        File file = new File("G:\\JavaEE2021");
        getSrcFile(file);
    }
    public static void getSrcFile(File srcFile){
        File[] files = srcFile.listFiles();
        if(files != null){
            for (File file : files) {
                if(file.isDirectory()){
                    getSrcFile(file);
                }else{
                    System.out.println(file.getAbsolutePath());
                }

            }
        }
    }
}

2.IO流

  • IO流介绍

    • IO：输入/输出(Input/Output)
    • 流：是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输
    • IO流就是用来处理设备间数据传输问题的。常见的应用：文件复制；文件上传；文件下载

  • IO流的分类

    • 按照数据的流向
      • 输入流：读数据
      • 输出流：写数据
    • 按照数据类型来分
      • 字节流
        • 字节输入流
        • 字节输出流
      • 字符流
        • 字符输入流
        • 字符输出流

  • IO流的使用场景

    • 如果操作的是纯文本文件，优先使用字符流
    • 如果操作的是图片、视频、音频等二进制文件。优先使用字节流
    • 如果不确定文件类型，优先使用字节流。字节流是万能的流

2.1 字节流写数据

  • 字节流抽象基类

    • InputStream：这个抽象类是表示字节输入流的所有类的超类
    • OutputStream：这个抽象类是表示字节输出流的所有类的超类
    • 子类名特点：子类名称都是以其父类名作为子类名的后缀

  • 字节输出流

    • FileOutputStream(String name)：创建文件输出流以指定的名称写入文件

  • 使用字节输出流写数据的步骤

    • 创建字节输出流对象(调用系统功能创建了文件，创建字节输出流对象，让字节输出流对象指向文件)
    • 调用字节输出流对象的写数据方法
    • 释放资源(关闭此文件输出流并释放与此流相关联的任何系统资源)

  • 示例代码

public class FileOutputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        File file = new File("myFileOutputStream\\file.txt");
        FileOutputStream fos = new FileOutputStream(file);
       /**
        *  做了三件事情：
        *   A:调用系统功能创建了文件
        *   B:创建了字节输出流对象
        *   C:让字节输出流对象指向创建好的文件
        * */
      fos.write(97);
      fos.close();
    }
}

2.2 字节流写数据的三种方式

方法名说明
void write(int b)将指定的字节写入此文件输出流 一次写一个字节数据
void write(byte[] b)将 b.length字节从指定的字节数组写入此文件输出流 一次写一个字节数组数据
void write(byte[] b, int off, int len)将 len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流 一次写一个字节数组的部分数据
public class FileOutputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream(new File("myFileOutputStream\\fos.txt"));
        fos.write(97);
        fos.write(98);
        fos.write(99);

        byte[] bys={97,98,99,100,101};
        fos.write(bys);

        byte[] bytes = "abcde".getBytes();
        fos.write(bytes);

        fos.write(bys,1,3);

        fos.close();
    }
}

字节流写数据的两个小问题

1.字节流写数据如何实现换行

windows:\r\n

linux:\n

mac:\r

2.字节流写数据如何实现追加写入

public FileOutputStream(String name,boolean append)

创建文件输出流以指定的名称写入文件。如果第二个参数为true ，则字节将写入文件的末尾而不是开头

示例代码

public class FileOutputStreamDemo03 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        FileOutputStream fos = new FileOutputStream(new File("fos.txt"), true);
        //写数据
        for (int i = 0; i < 10; i++) {
            fos.write("你好，世界".getBytes());
            fos.write("\r\n".getBytes());
        }
        //释放资源
        fos.close();
    }
}

2.3 字节流写数据异常处理

异常处理格式

try-catch-fifinally

try{
  可能出现异常的代码; 
}
catch(异常类名 变量名){
  异常的处理代码; 
}
finally{
  执行所有清除操作; 
}

fifinally特点

被fifinally控制的语句一定会执行，除非JVM退出

示例代码

/*
    字节流写数据加入异常处理
 */
public class FileOutputStreamDemo04 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        FileOutputStream fos = null;

        try {
            File file = new File("myByteStream");
            file.mkdir();
            fos = new FileOutputStream("myByteStream\\fos.txt", true);
            
            //写数据
            for (int i = 0; i < 10; i++) {
                fos.write("hello".getBytes());
                fos.write("\r\n".getBytes());
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
           if(fos != null)
               try {
                   fos.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
        }
    }
}

2.4 字节流读数据

  • 字节输入流

    • FileInputStream(String name)：通过打开与实际文件的连接来创建一个FileInputStream ，该文件由文件系统中的路径名name命名

  • 字节输入流读取数据的步骤

    • 创建字节输入流对象

    • 调用字节输入流对象的读数据方法

    • 释放资源

2.5.1一次读一个字节字符数据

public class FileInputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("myByteStream/fos.txt");
        int file = 0;
        while((file=fis.read())!=-1){
            System.out.print((char)file);
        }
        fis.close();
    }
}

2.5.2一次读一个字节数组数据

public class FileInputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("fos.txt");
        byte[]bytes = new byte[1024];
        int file = 0;
        while((file=fis.read(bytes))!=-1){
            System.out.print(new String(bytes,0,file));
        }
        fis.close();
    }
}

2.6 复制

实现步骤

复制文本文件，其实就把文本文件的内容从一个文件中读取出来(数据源)，然后写入到另一个文件中(目

的地)

数据源：

fis.txt --- 读数据 --- InputStream --- FileInputStream

目的地：

fos.txt --- 写数据 --- OutputStream --- FileOutputStream

2.6.1复制文本

public class CopyTxtDemo {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream(new File("fis.txt"));
        FileOutputStream fos = new FileOutputStream(new File("fos.txt"));

        int fileCopy=0;
        while((fileCopy=fis.read())!=-1){
            fos.write(fileCopy);
        }
        System.out.println("finish");

        fos.close();
        fis.close();
    }
}

2.6.2 复制图片

public class CopyJpgDemo {
    public static void main(String[] args)throws IOException {
        FileInputStream fis = new FileInputStream("image01.jpg");
        FileOutputStream fos = new FileOutputStream("image02.jpg");
        int length;
        byte[]buf = new byte[1024];
        while ((length=fis.read(buf))!=-1){
            fos.write(buf,0,length);
        }
        fos.close();
        fis.close();
    }
}

2.6.3 复制视频

public class CopyJpgDemo {
    public static void main(String[] args)throws IOException {
        FileInputStream fis = new FileInputStream("张艺兴-Jorke.mp4");
        FileOutputStream fos = new FileOutputStream("copy张艺兴-Jorke.mp4");
        int length;
        byte[]buf = new byte[1024];
        while ((length=fis.read(buf))!=-1){
            fos.write(buf,0,length);
        }
        fos.close();
        fis.close();
    }
}

3.字节缓冲流

  • 字节缓冲流介绍

    • BufffferOutputStream：该类实现缓冲输出流。 通过设置这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用
    • BufffferedInputStream：创建BufffferedInputStream将创建一个内部缓冲区数组。 当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节

  • 构造方法

方法名说明
BufferedOutputStream(OutputStream out)创建字节缓冲输出流对象
BufferedInputStream(InputStream in)创建字节缓冲输入流对象

3.1 字节流读写文本

public class BufferStreamDemo {
    public static void main(String[] args) throws IOException {
        BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream("fos.txt"));
        for (int i = 0; i < 10; i++) {
            fos.write("你好,世界\n".getBytes());
        }
        fos.close();
        //读数据
        BufferedInputStream fis = new BufferedInputStream(new FileInputStream("fos.txt"));
        int length = 0;
      //方式一
        /*while((length = fis.read())!=-1){
            System.out.print((char)length);
        }*/

        //读数据
      //方式二
        byte []bytes = new byte[1024];
        while((length = fis.read(bytes))!=-1){
          //防止乱码
            System.out.println(new String(bytes,0,length, "UTF-8"));
        }
        fis.close();
    }
}

3.2 字节流复制视频

  • 实现步骤

    • 根据数据源创建字节输入流对象

    • 根据目的地创建字节输出流对象

    • 读写数据，复制视频

    • 释放资源

      四种方式实现复制视频，并记录每种方式复制视频的时间
  1:基本字节流一次读写一个字节             
  2:基本字节流一次读写一个字节数组          
  3:字节缓冲流一次读写一个字节             
  4:字节缓冲流一次读写一个字节数组

      实现代码：

import java.io.*;

public class CopyAviDemo {
    public static void main(String[] args) throws IOException {
        //记录开始时间
        long startTime = System.currentTimeMillis();

        //复制视频
        // method01();
        //method02();
        //method03();
        method04();
        //记录结束时间
        long endTime = System.currentTimeMillis();
        System.out.println("共耗时：" + (endTime - startTime) + "毫秒");
    }

    //    1:基本字节流一次读写一个字节
    public static void method01() throws IOException {
        FileInputStream fis01 = new FileInputStream("张艺兴-Jorke.mp4");
        FileOutputStream fos01 = new FileOutputStream("Jorke01.mp4");
        int length;
        while ((length = fis01.read()) != -1) {
            fos01.write(length);
        }
        fos01.close();
        fis01.close();
    }

    //    2:基本字节流一次读写一个字节数组
    public static void method02() throws IOException {
        FileInputStream fis02 = new FileInputStream("张艺兴-Jorke.mp4");
        FileOutputStream fos02 = new FileOutputStream("Jorke02.mp4");
        int length = 0;
        byte[] bytes = new byte[1024];
        while ((length = fis02.read(bytes)) != -1) {
            fos02.write(bytes, 0, length);
        }
        fos02.close();
        fis02.close();
    }

    //    3:字节缓冲流一次读写一个字节
    public static void method03() throws IOException {
        BufferedInputStream fis03 = new BufferedInputStream(new FileInputStream("张艺兴-Jorke.mp4"));
        BufferedOutputStream fos03 = new BufferedOutputStream(new FileOutputStream("Jorke03.mp4"));
        int length = 0;

        while ((length = fis03.read()) != -1) {
            fos03.write(length);
        }
        fos03.close();
        fis03.close();
    }

    //    4:字节缓冲流一次读写一个字节数组
    public static void method04() throws IOException {
        BufferedInputStream fis04 = new BufferedInputStream(new FileInputStream("张艺兴-Jorke.mp4"));
        BufferedOutputStream fos04 = new BufferedOutputStream(new FileOutputStream("Jorke04.mp4"));
        int length = 0;
        byte[] bytes = new byte[1024];
        while ((length = fis04.read(bytes)) != -1) {
            fos04.write(length);
        }
        fos04.close();
        fis04.close();
    }
}

4.字符流

  • 字符流的介绍

    • 由于字节流操作中文不是特别的方便，所以Java就提供字符流
    • 字符流 = 字节流 + 编码表

  • 中文的字节存储方式

    • 用字节流复制文本文件时，文本文件也会有中文，但是没有问题，原因是最终底层操作会自动进行字节拼接成中文，如何识别是中文的呢？
    • 汉字在存储的时候，无论选择哪种编码存储，第一个字节都是负数

4.1 编码表

  • 什么是字符集

    • 是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等
    • 计算机要准确的存储和识别各种字符集符号，就需要进行字符编码，一套字符集必然至少有一套字符编码。
    • 常见字符集有ASCII字符集、GBXXX字符集、Unicode字符集等

  • 常见的字符集

  • ASCII字符集：

    • lASCII：是基于拉丁字母的一套电脑编码系统，用于显示现代英语，主要包括控制字符(回车键、退格、换行键等)和可显示字符(英文大小写字符、阿拉伯数字和西文符号)
    • 基本的ASCII字符集，使用7位表示一个字符，共128字符。ASCII的扩展字符集使用8位表示一个字符，共256字符，方便支持欧洲常用字符。是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等

  • GBXXX字符集：

    • GBK：最常用的中文码表。是在GB2312标准基础上的扩展规范，使用了双字节编码方案，共收录了21003个汉字，完全兼容GB2312标准，同时支持繁体汉字以及日韩汉字等

  • Unicode字符集：

    • UTF-8编码：可以用来表示Unicode标准中任意字符，它是电子邮件、网页及其他存储或传送文字的应用中，优先采用的编码。互联网工程工作小组(IETF)要求所有互联网协议都必须支持UTF-8编码。它使用一至四个字节为每个字符编码
    • 编码规则：
      • 128个US-ASCII字符，只需一个字节编码
      • 拉丁文等字符，需要二个字节编码
      • 大部分常用字(含中文)，使用三个字节编码
      • 其他极少使用的Unicode辅助字符，使用四字节编码

4.2 字符串中的编码解码问题

方法说明
byte[] getBytes()使用平台的默认字符集将该 String编码为一系列字节
byte[] getBytes(String charsetName)使用指定的字符集将该 String编码为一系列字节
String(byte[] bytes)使用平台的默认字符集解码指定的字节数组来创建字符串
String(byte[] bytes, String charsetName)通过指定的字符集解码指定的字节数组来创建字符串
package com.itheima_01;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class StringDemo {
    public static void main(String[] args) throws UnsupportedEncodingException {
        //定义一个字符串
        String s = "青春";
        System.out.println(Arrays.toString(s.getBytes()));
        System.out.println(Arrays.toString(s.getBytes("UTF-8")));
        System.out.println(Arrays.toString(s.getBytes("GBK")));
        System.out.println(Arrays.toString(s.getBytes("ASCII")));

        System.out.println(new String(s.getBytes()));
        System.out.println(new String(s.getBytes("UTF-8")));
        System.out.println(new String(s.getBytes("GBK")));
        System.out.println(new String(s.getBytes("ASCII")));
    }
}

控制台输出

[-23, -99, -110, -26, -104, -91]
[-23, -99, -110, -26, -104, -91]
[-57, -32, -76, -70]
[63, 63]
青春
青春
�ഺ
??

4.3 字符流中的编码解码问题

字符流抽象基类

  • Reader：字符输入流的抽象类
  • Writer:字符输出流的抽象类

字符流中和编码解码问题相关的两个类

  • InputStreamReader：是从字节流到字符流的桥梁

    • 它读取字节，并使用指定的编码将其解码为字符
    • 它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集

  • OutputStreamWriter：是从字符流到字节流的桥梁

    • 是从字符流到字节流的桥梁，使用指定的编码将写入的字符编码为字节
    • 它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集

构造方法

方法名 说明 
InputStreamReader(InputStream in) 使用默认字符编码创建InputStreamReader对象

InputStreamReader(InputStream in,Stringchatset)使用指定的字符编码创建InputStreamReader对象

OutputStreamWriter(OutputStream out)使用默认字符编码创建OutputStreamWriter对象

OutputStreamWriter(OutputStream out,Stringcharset)使用指定的字符编码创建OutputStreamWriter对象
public class FileInputStreamDemo {
    public static void main(String[] args) throws IOException {
        //写数据
        OutputStreamWriter osw01 = new OutputStreamWriter(new FileOutputStream("fos.txt", true));
        OutputStreamWriter osw02 = new OutputStreamWriter(new FileOutputStream("fos.txt", true), "GBK");
        osw01.write("岁月静好，现世安稳\n");
        osw02.write("我不喜欢这世界，我只喜欢你\n");
        osw01.close();
        osw02.close();
        //读数据
        InputStreamReader isr01 = new InputStreamReader(new FileInputStream("fos.txt"));
        InputStreamReader isr02 = new InputStreamReader(new FileInputStream("fos.txt"), "GBK");
        int length = 0;
        while ((length = isr01.read()) != -1) {
            System.out.print((char) length);
        }

        char[] ch = new char[1024];
        while ((length = isr02.read(ch)) != -1) {
            System.out.println(new String(ch, 0, length));
        }
        isr01.close();
        isr02.close();
    }
}

4.4 字符流写数据的5种方式

  • 写数据
方法说明
void write(int c)写一个字符
void write(char[] cbuf)写入一个字符数组
void write(char[] cbuf, int off, int len)写入字符数组的一部分
void write(String str)写一个字符串
void write(String str, int off, int len)写一个字符串的一部分
  • 刷新和关闭的方法
方法说明
flush()刷新流，之后还可以继续写数据
close()关闭流，释放资源，但是在关闭之前会先刷新流。一旦关闭，就不能再写数据
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
public class OutputStreamWriterDemo {
    public static void main(String[] args) throws IOException {
        OutputStreamWriter ows1 = new OutputStreamWriter(new FileOutputStream("fos.txt", true));
        OutputStreamWriter ows2 = new OutputStreamWriter(new FileOutputStream("fos.txt", true));
        OutputStreamWriter ows3 = new OutputStreamWriter(new FileOutputStream("fos.txt", true));
        OutputStreamWriter ows4 = new OutputStreamWriter(new FileOutputStream("fos.txt", true));
        OutputStreamWriter ows5 = new OutputStreamWriter(new FileOutputStream("fos.txt", true));
        int c = 97;
        for (int i = 0; i < 10; i++) {
            ows1.write(c + i);
            ows1.write(" ");
        }
        char[] ch2 = {'J', 'a', 'v', 'a', 'E', 'E'};
        ows2.write(ch2);
        char[]ch3={'S','t','u','d','y','J', 'a', 'v', 'a', 'E', 'E'};
        ows3.write(ch3,0,7);
        String s4="疯狂学Java";
        ows4.write(s4);
        String s5="我不喜欢这世界，我只喜欢你";
        ows5.write(s5,3,6);

        ows5.close();
        ows4.close();
        ows3.close();
        ows2.close();
        ows1.close();
    }
}

4.5 字符流读数据的2种方式

方法名说明
int read()一次读一个字符数据
int read(char[] cbuf)一次读一个字符数组数据
public class InputStreamReaderDemo {
    public static void main(String[] args) throws IOException {
        InputStreamReader fis = new InputStreamReader(new FileInputStream("fis.txt"));
        int length=0;
        //一次读一个字符数据
        while ((length=fis.read())!=-1){
            System.out.print((char)length);
        }
        char[]buf=new char[1024];
        //一次读一个字符数组数据
        while ((length=fis.read(buf))!=-1){
            System.out.print(new String(buf,0,length));
        }
        fis.close();
    }
}

4.6 字符缓冲流

  • 字符缓冲流介绍
    • BufferedWriter：将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，可以指定缓冲区大小，或者可以接受默认大小。默认值足够大，可用于大多数用途
    • BufferedReader：从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取，可以指定缓冲区大小，或者可以使用默认大小。 默认值足够大，可用于大多数用途
  • 构造方法
方法名说明
BufferedWriter(Writer out)创建字符缓冲输出流对象
BufferedReader(Reader in)创建字符缓冲输入流对象
public class BufferedStreamDemo01 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("fis.txt"));

        //一次读取一个字符数据
        int ch;
        while ((ch = br.read()) != -1) {
            System.out.print((char) ch);
        }

        //一次读取一个字符数组数据
        char[] chs = new char[1024];
        int len;
        while ((len = br.read(chs)) != -1) {
            System.out.print(new String(chs, 0, len));
        }

        br.close();

    }

}

4.7 字符缓冲流特有功能

  • 方法介绍

BufferedWriter：

方法说明
void newLine()写一行行分隔符。 行分隔符字符串由系统属性line.separator定义，并不一定是单个换行符('\ n')字符。

BufferedReader：

方法说明
String readLine()读一行文字。 结果包含行的内容的字符串，不包括任何行终止字符如果流的结尾已经
public class BufferedStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //创建字符缓冲输出流
        BufferedWriter bw = new BufferedWriter(new FileWriter("fis.txt"));
        //写数据
        for (int i = 0; i < 10; i++) {
            bw.write("hello" + i);
//            bw.write("\r\n");
            bw.newLine();
            bw.flush();
        }
        //释放资源
        bw.close();
        //创建字符缓冲输入流
        BufferedReader buf = new BufferedReader(new FileReader("fis.txt"));
        //public String readLine()：读一行文字。
        String line;
        while ((line = buf.readLine()) != null) {
            System.out.println(line);
        }
        buf.close();
    }
}

5.I O流小结

  • 字节流

  • 字符流

晚风花间寺中人
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java Stream、File、IO.pdf
07-23
使用 Java Stream 可以方便地进行过滤、映射、排序和聚合等操作。下面是一个简单的示例： 该示例将一个整数列表中的偶数筛选出来，并将它们加起来。 List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); int ...
Java文件io-stream-file教程
08-23
Java文件io-stream-file教程
Java IO流.docx
09-12
本文整理了 Java 流(Stream)、 输入/输出IO 和 文件(File) 的相关内容，对文件内容的读写方法作了详细的介绍，对磁盘上的文件创建，删改，查询等方法也作了介绍。
方法引用, Stream流，File类 , 递归 ，字节流.md
08-25
关于一些java的流处理
01【File类】.html
07-19
Java文件流知识点梳理总结，IO文件流，包含了File类、缓冲流、字节流、字符流、转换流等
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 428
都是符合我们的预期的。
string模拟实现
m0_73969414的博客
04-23 1516
c++中string的模拟实现，面试必会知识点
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 682
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
Lambda表达式特点
weixin_57763462的博客
04-24 633
**API 设计**：Lambda 表达式鼓励使用函数式接口的设计模式，这改变了 Java 库的设计，例如 `java.util.function` 包下的一系列函数式接口。- **函数式编程**：Lambda 表达式引入了函数式编程的理念，使得 Java 更接近于函数式编程语言，如 Scala 和 Clojure。- **并发编程**：Lambda 表达式与 Java 8 新增的 Stream API 结合使用，可以简化并发编程，特别是与集合的操作相关。
第5 章 Consul服务注册与发现
a13763926743的博客
04-22 788
consul官网地址。
MSE实现全链路灰度实践
云计算、数据库、大数据、深度学习、NLP、Python
04-24 244
待更新。
Mybatis-动态SQL
weixin_43866613的博客
04-24 816
Mybatis的xml映射文件，以及动态SQL的应用
迭代器模式
LuckFairyLuckBaby的博客
04-23 579
迭代器模式(Iterator),提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。
Java | 冒泡排序算法实现
yingzix688的博客
04-24 730
题目描述 编写一个Java程序，实现冒泡排序算法。程序需要能够接收一个整型数组作为输入，并输出排序后的数组。 冒泡排序是一种简单的排序算法，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
安装和部署maven
weixin_44014460的博客
04-21 257
maven本地部署和集成到jenkins详细步骤
埃氏筛选-判断素数
最新发布
qq_45706306的博客
04-27 84
筛选：从最小的质数2开始，将它的所有倍数标记为合数（非质数），即把 isshushu 数组中对应索引位置的值设置为 true。计数：在筛选过程中，每当遇到一个未被标记为合数的数（即 isshushu 数组中对应值为 false 的数），则它就是一个质数，增加质数计数器 count 的值。返回结果：当所有小于 n 的数都经过筛选后，返回质数计数器 count 的值，即小于 n 的质数数量。通过这种方式，代码能够高效地找出并计算给定范围内质数的数量，避免了逐一检查每个数是否为质数的低效方法。
【Java--数据结构】提升数据处理速度！深入理解Java中的顺序表机制
2301_80898480的博客
04-24 574
如有错误，欢迎指出~
深入理解Java NIO：原理、应用与实战详解
suqieer的博客
04-24 934
BIO（Blocking I/O），即传统的阻塞式I/O模型，其特点是程序在进行读写操作时会一直阻塞，直到操作完成。这种模式简单易用，但在高并发场景下容易导致线程资源浪费，因为每个连接都需要一个独立的线程来处理，当连接数增多时，系统资源消耗急剧增大。NIO（Non-blocking I/O），非阻塞式I/O模型，它允许单个线程管理多个通道（Channel），并通过选择器（Selector）监控这些通道上的事件。
Maven基础篇1
m0_52474839的博客
04-22 306
项目2需要用到项目3需要将项目三作为资源配置到项目二也就是dependecy中加入项目三的gav两点注意事项：使用项目三，直接将其gav添加到依赖中，使用项目三，项目三不能感知到，自己有相关资源依赖传递：就是自己使用的资源如果是jar包，那么jar资源使用的依赖自己也可以使用就像上图那样一层一层的传递下去；依赖传递分为：直接依 赖，间接依赖。
使用io流下载文件 Java
05-13
使用 Java 下载文件可以使用以下代码： ```java import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.net.URL; public class FileDownload { public static ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值