java 常用IO流梳理，持续更新...

已于 2022-05-08 17:01:26 修改
阅读量438 收藏 1
点赞数
分类专栏： IO 文章标签： java
于 2022-05-08 11:50:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bo_wei/article/details/124630028
版权

定义

JavaIO流，是一种计算机用语。主要是用于处理数据的传输。

背景

I/O 流众多，在学习I/O流时，流与流之间关系理不清楚，什么场景下该选择使用什么样的流？成为了难点，因此，文本根据笔者的学习情况，梳理了常用的几种流

流的分类

按方向划分：

  • 输入流 和 输出流

按处理的数据单位划分：

  • 字节流 和 字符串

按功能划分：

  • 节点流 和 处理流

四大抽象类

类定义说明
InputStream字节输入流，特点：凡是继承它的子类，类命名均以 InputStream 结尾，都是字节输入流
OutputStream字节输出流，特点：凡是继承它的子类，类命名均以 OutputStream 结尾，都是字节输出流
Reader字符输入流，特点：凡是继承它的子类，类命名均以 Reader 结尾 ，都是字符输入流
Writer字符输出流，特点：凡是继承它的子类，类命名均以 Writer 结尾，都是字符输出流

生活场景类比计算机输入输出流操作

抽水机抽水到水塔的A区：相当于输入流 InputStram
水塔对水进行消毒、过滤、净化后装入水塔B区：相对于对输入流里的数据写入到输出流
水塔将B区的净化水供给到居民家里：相当于将输出流进行输出
在这里插入图片描述

浅谈文件拷贝过程内存中的对象

在这里插入图片描述

常用流说明

字节流

FileInputStream 对文件操作的字节输入流
  • 构造方法
构造器方法说明
FileInputStream(File file)有参构造器，传入 File 对象
FileInputStream(String name)有参构造器，传入文件的路径（含文件名）
  • 常用方法
返回类型方法方法说明
intread()从该文件字节输入流中读取 下一个字节，并返回 该字节 对应的 整型数值，且游标自动指向下一个字节的位置
intread(byte[] b)从该文件字节输入流读取最多 b.length 个字节的数据放入 字节数组b，并返回读取到的字节个数
intread(byte[] b, int off, int len)从该文件字节输入流读取最多 len 个字节的数据放入 字节数组b，并返回读取到的字节个数
voidclose()关闭此文件字节输入流并释放与流相关联的任何系统资源
  • 代码演示
package com.wei.java.basic.io;

import java.io.FileInputStream;

/**
 * @author: wei
 * @date 2022/5/7 10:36
 * 说明：
 **/
public class FileInputStream_my {
    public static void main(String[] args) {
        String filePath = "D:\\IdeaProjects\\my-study\\java-basic\\java-basic-begin\\src\\main\\resources\\io\\text_01.txt";
        try (
                FileInputStream fis = new FileInputStream(filePath);
        ) {
            // .read() 读取一个字节，并返回
            int byteInt = fis.read();
            System.out.println(byteInt +" -> " + (char)byteInt);

            // .read(bytes)，每次只从流中读取2个字节，UTF-8编码，一个汉字占3个字节
            byte[] bytes = new byte[2];
            int len;
            while ((len = fis.read(bytes)) != -1){
                // new String() 强行将一个汉字的 2 个字节转为字符串，会乱码
                System.out.print(new String(bytes));
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
FileOutputStream 对文件操作的字节输出流
  • 构造方法
构造器方法说明
FileOutputStream(File file)有参构造器，传入 File 对象，创建文件输出流以写入到指定的 File对象表示的文件
FileOutputStream(File file, boolean append)有参构造器，传入 File 对象，创建文件输出流以写入到指定的 File对象表示的文件，append参数控制覆盖或追加数据到文件，true-追加，false-覆盖，默认false
FileOutputStream(String name)有参构造器，传入文件的路径+文件名，将数据输出到指定的文件
FileOutputStream(String name, boolean append)有参构造器，传入文件的路径+文件名，将数据输出到指定的文件，append参数控制覆盖或追加数据到文件，true-追加，false-覆盖，默认false
  • 常用方法
返回类型方法方法说明
voidwrite(int b)将一个字节 的 整型数字，写入该文件字节输出流
voidwrite(byte[] b)将 b.length 个字节从 字节数组b 写入该文件字节输出流
voidwrite(byte[] b, int off, int len)将 字节数组b中，从 偏移量off 开始的 len个字节 数据，写入到该文件字节输出流
voidclose()关闭此文件字节输出流并释放与流相关联的任何系统资源，不需要close()，数据也会输出到磁盘
  • 代码演示
package com.wei.java.basic.io;

import java.io.FileInputStream;
import java.io.FileOutputStream;

/**
 * @author: wei
 * @date 2022/5/7 10:36
 * 说明：
 **/
public class FileOutputStream_my {
    public static void main(String[] args) {
        String filePath = "D:\\IdeaProjects\\my-study\\java-basic\\java-basic-begin\\src\\main\\resources\\io\\text_01.txt";
        String outFilePath = "D:\\IdeaProjects\\my-study\\java-basic\\java-basic-begin\\src\\main\\resources\\io\\out_01.txt";
        try (
                FileInputStream fis = new FileInputStream(filePath);
                FileOutputStream fos = new FileOutputStream(outFilePath);
        ) {
            // fos.write(bytes, 0, len);  不需要flush()，数据也写到磁盘了
            byte[] bytes = new byte[2]; // 数组设2，只为调试
            int len;
            while ((len = fis.read(bytes)) != -1) {
                fos.write(bytes, 0, len);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
ByteArrayInputStream 对字节数组操作的字节输入流
  • 构造方法
构造器方法说明
ByteArrayInputStream(byte[] buf)有参构造， 传入字节数组
  • 常用方法
返回类型方法方法说明
intread()从该字节数组输入流中读取 下一个字节，并返回 该字节 对应的 整型数值
intread(byte[] b)从该字节数组输入流读取最多 b.length 个字节的数据放入 字节数组b，并返回读取到的字节个数
intread(byte[] b, int off, int len)从该字节数组输入流读取最多 len 个字节的数据放入 字节数组b，并返回读取到的字节个数
voidclose()关闭 ByteArrayInputStream没有任何效果，该流中的方法仍可以在流关闭后调用，而不生成IOException
  • 代码演示
package com.wei.java.basic.io;

import java.io.ByteArrayInputStream;
import java.io.IOException;

/**
 * @author: wei
 * @date 2022/5/8 13:38
 * 说明：
 **/
public class ByteArrayInputStream_my {
    public static void main(String[] args) throws IOException {
        byte[] bytes = "wddd".getBytes();
        ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
        int byteInt = bais.read();
        System.out.println((char)byteInt);
        // close() 不会起作用
        bais.close();

        int byteInt2 = bais.read();
        System.out.println((char)byteInt2);

        byte[] buff = new byte[2];
        int read = bais.read(buff);
        System.out.println(new String(buff));
    }
}
ByteArrayOutputStream 对字节数组操作的字节输出流
  • 构造方法
构造器方法说明
ByteArrayOutputStream()无参构造器
  • 常用方法
返回类型方法方法说明
voidwrite(int b)将一个字节 的 整型数字，写入该字节数组输出流
voidwrite(byte[] b, int off, int len)将 字节数组b中，从 偏移量off 开始的 len个字节 数据，写入到该字节数组输出流
byte[]toByteArray()将字节数组输出流中的数据，转为新的字节数组，并返回该新的字节数组的完整数据
StringtoString(String charsetName)将字节数组输出流中的数据转换为字符串，并指定编码类型
voidclose()关闭 ByteArrayOutputStream 没有任何效果，该流中的方法可以在流关闭后调用，而不生成IOException
  • 代码演示
package com.wei.java.basic.io;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

/**
 * @author: wei
 * @date 2022/5/8 13:38
 * 说明：
 **/
public class ByteArrayOutputStream_my {
    public static void main(String[] args) throws IOException {
        byte[] bytes = "qwertyuiopa我的观点".getBytes();
        ByteArrayInputStream bais = new ByteArrayInputStream(bytes);

        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        int byteInt = bais.read();
        System.out.println((char) byteInt);

        // close() 不会起作用
        bais.close();

        byte[] buff = new byte[2];
        int len;
        while ((len = bais.read(buff)) != -1) {
            baos.write(buff, 0, len);
        }

        // close() 也是不起作用的
        baos.close();
        baos.flush();

        // 转数组
        byte[] resultBytes = baos.toByteArray();
        System.out.println(new String(resultBytes));
        // 转字符串
        String resultStr = baos.toString("utf-8");
        System.out.println(resultStr);
    }
}
BufferedInputStream 带缓冲区的字节输入流
  • 构造方法
构造器方法说明
BufferedInputStream(InputStream in)有参构造器，传入 InputStream 对象
  • 常用方法
返回类型方法方法说明
intread()从该带缓冲区的字节输入流中读取 下一个字节，并返回 该字节 对应的 整型数值
intread(byte[] b)从该带缓冲区的字节输入流读取最多 b.length 个字节的数据放入 字节数组b，并返回读取到的字节个数
intread(byte[] b, int off, int len)从该带缓冲区的字节输入流读取最多 len 个字节的数据放入 字节数组b，并返回读取到的字节个数
voidclose()关闭此带缓冲区的字节输入流并释放与流相关联的任何系统资源
  • 代码演示
package com.wei.java.basic.io;

import java.io.BufferedInputStream;
import java.io.FileInputStream;

/**
 * @author: wei
 * @date 2022/5/7 21:25
 * 说明：
 **/
public class BufferedInputStream_my {
    public static void main(String[] args) {
        String filePath = "D:\\IdeaProjects\\my-study\\java-basic\\java-basic-begin\\src\\main\\resources\\io\\text_01.txt";
        try (
                FileInputStream fis = new FileInputStream(filePath);
                BufferedInputStream bis = new BufferedInputStream(fis);
        ) {
            // .read() 读取一个字节，并返回
            int byteInt = bis.read();
            System.out.println(byteInt +" -> " + (char)byteInt);

            // fis 流已经传入 bis 流，并且已经开始读取 bis 流后，再从 fis 流里读取，是读取不到数据的
            byte[] temp = new byte[3];
            int fisReadByteInt = fis.read(temp); // 这里是读取不到数据的
            System.out.println(fisReadByteInt);

            // .read(bytes)，每次只从流中读取2个字节，UTF-8编码，一个汉字占3个字节
            byte[] bytes = new byte[2];
            int len;
            while ((len = bis.read(bytes)) != -1){
                // new String() 强行将一个汉字的 2 个字节转为字符串，会乱码
                System.out.print(new String(bytes));
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
BufferedOutputStream 带缓冲区的字节输出流
  • 构造方法
构造器方法说明
BufferedOutputStream(OutputStream out)有参构造器，传入 OutputStream 对象
  • 常用方法
返回类型方法方法说明
voidwrite(int b)将一个字节 的 整型数字，写入该带缓冲区的字节输出流
voidwrite(byte[] b)将 b.length 个字节从 字节数组b 写入该带缓冲区的字节输出流
voidwrite(byte[] b, int off, int len)将 字节数组b中，从 偏移量off 开始的 len个字节 数据，写入到该带缓冲区的字节输出流
voidclose()关闭此带缓冲区的字节输出流并释放与流相关联的任何系统资源，只有 close() 后，数据才会真正写到磁盘
  • 代码演示
package com.wei.java.basic.io;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;

/**
 * @author: wei
 * @date 2022/5/7 21:30
 * 说明：
 **/
public class BufferedOutputStream_my {
    public static void main(String[] args) {
        String filePath = "D:\\IdeaProjects\\my-study\\java-basic\\java-basic-begin\\src\\main\\resources\\io\\text_01.txt";
        String outFilePath = "D:\\IdeaProjects\\my-study\\java-basic\\java-basic-begin\\src\\main\\resources\\io\\out_01.txt";
        try (
                FileInputStream fis = new FileInputStream(filePath);
                BufferedInputStream bis = new BufferedInputStream(fis);

                FileOutputStream fos = new FileOutputStream(outFilePath);

        ) {
            BufferedOutputStream bos = new BufferedOutputStream(fos);
            byte[] bytes = new byte[2];
            int len;
            while ((len = bis.read(bytes)) != -1) {
                bos.write(bytes, 0, len);
            }
            // 只有 执行了 flush()，才会输出到磁盘，close()内调用了 flush()  方法
            bos.close();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
ObjectInputStream 对对象操作的字节输入流、ObjectInputStream 对对象操作的字节输出流
  • 构造方法
  • 常用方法
    用得少，主要用于序列化与反序列化

字符流

FileReader 对文件操作的字符输入流
  • 构造方法
构造器方法说明
FileReader(File file)有参构造，传入 File 对象
FileReader(String fileName)有参构造，传入文件路径（含文件名）
  • 常用方法
返回类型方法方法说明
intread()从该字符输入流中读取 下一个字符，并返回 该字符 对应的 整型数值
intread(char[] cbuf)从该字符输入流读取最多 cbuf.length 个字符的数据放入 字符数组cbuf，并返回读取到的字符个数
intread(char[] cbuf, int offset, int length)从该字符输入流读取最多 length 个字节的数据放入 字符数组cbuf，并返回读取到的字符个数
voidclose()关闭流并释放与之相关联的任何系统资源
  • 代码演示
package com.wei.java.basic.io;

import java.io.FileReader;
import java.io.IOException;

/**
 * @author: wei
 * @date 2022/5/8 10:11
 * 说明：
 **/
public class FileReader_my {
    public static void main(String[] args) throws Exception {
        String filePath = "D:\\IdeaProjects\\my-study\\java-basic\\java-basic-begin\\src\\main\\resources\\io\\text_01.txt";
        try (
                FileReader fr = new FileReader(filePath);
        ) {

            int charInt = fr.read();
            System.out.println((char) charInt);

            char[] bytes = new char[2];
            int len;
            while ((len = fr.read(bytes)) != -1) {
                System.out.print(new String(bytes));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
FileWriter 对文件操作的字符输出流
  • 构造方法
构造器方法说明
FileWriter(File file)有参构造，传入 File 对象，给一个File对象构造一个FileWriter对象。
FileWriter(File file, boolean append)
FileWriter(String fileName)有参构造，传入文件路径（含文件名）
FileWriter(String fileName, boolean append)有参构造，传入文件路径（含文件名），append 设置是否追加写入数据，true-追加，false-覆盖，默认false
  • 常用方法
返回类型方法方法说明
voidwrite(int c)写一个字符
voidwrite(char[] cbuf, int off, int len)将 字符数组cbuf 中，从 偏移量off 开始的 len个字符 数据，写入到该文件字符输出流
voidwrite(String str, int off, int len)将 字符串str 中，从 偏移量off 开始的 len个字符 数据，写入到该文件字符输出流
voidflush()刷新流，需要刷新流，数据才会真正写入到文件
voidclose()内部调用刷新流方法，再关闭流，释放资源
  • 代码演示
package com.wei.java.basic.io;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/**
 * @author: wei
 * @date 2022/5/8 10:29
 * 说明：
 **/
public class FileWriter_my {
    public static void main(String[] args) throws IOException {
        String filePath = "D:\\IdeaProjects\\my-study\\java-basic\\java-basic-begin\\src\\main\\resources\\io\\text_01.txt";
        String outFilePath = "D:\\IdeaProjects\\my-study\\java-basic\\java-basic-begin\\src\\main\\resources\\io\\out_01.txt";
        try (
                FileReader fr = new FileReader(filePath);

        ){
            FileWriter fw = new FileWriter(outFilePath);

            // 写入单个字符
            fw.write("w");

            // 循环 读取 -> 写入
            char[] chars = new char[2];
            int len;
            while ((len = fr.read(chars)) != -1){
                fw.write(chars, 0, len);
            }

            fw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
BufferedReader 带缓冲区的字符输入流
  • 构造方法
构造器方法说明
BufferedReader(Reader in)有参构造，传入 Reader 对象
  • 常用方法
返回类型方法方法说明
intread()从该带缓冲区的字符输入流中读取 下一个字节，并返回 该字节 对应的 整型数值
intread(char[] cbuf)从该带缓冲区的字符输入流读取最多 cbuf.length 个字符的数据放入 字符数组cbuf，并返回读取到的字符个数
intread(char[] cbuf, int offset, int length)从该带缓冲区的字符输入流读取最多 length 个字节的数据放入 字符数组cbuf，并返回读取到的字符个数
StringreadLine()读取一行字符串，并返回该行字符串
voidclose()关闭流并释放与之相关联的任何系统资源
  • 代码演示
package com.wei.java.basic.io;

import java.io.BufferedReader;
import java.io.FileReader;

/**
 * @author: wei
 * @date 2022/5/8 10:42
 * 说明：
 **/
public class BufferedReader_my {
    public static void main(String[] args) throws Exception {
        String filePath = "D:\\IdeaProjects\\my-study\\java-basic\\java-basic-begin\\src\\main\\resources\\io\\text_01.txt";
        FileReader fr = new FileReader(filePath);
        BufferedReader br = new BufferedReader(fr);

        // 读取单个字符
        int charInt = br.read();
        System.out.println((char) charInt);
        // 读取一行字符串
        String line = br.readLine();
        System.out.println(line);

        // 按行，循环读取
        String src;
        while ((src = br.readLine()) != null) {
            System.out.println(src);
        }

        // 只需要关闭缓冲流，缓冲流内部会把它包装的流都关掉
        br.close();
    }
}
BufferedWriter 带缓冲区的字符输出流
  • 构造方法
构造器方法说明
BufferedWriter(Writer out)有参构造，传入 Writer 对象
  • 常用方法
返回类型方法方法说明
voidwrite(int c)写一个字符
voidwrite(char[] cbuf, int off, int len)将 字符数组cbuf 中，从 偏移量off 开始的 len个字符 数据，写入到该带缓冲区的字符输出流
voidwrite(String str, int off, int len)将 字符串str 中，从 偏移量off 开始的 len个字符 数据，写入到该带缓冲区的字符输出流
voidnewLine()写入一换行符
voidflush()刷新流，需要刷新流，数据才会真正写入到文件
voidclose()内部调用刷新流方法，再关闭流，释放资源
  • 代码演示
package com.wei.java.basic.io;

import java.io.*;

/**
 * @author: wei
 * @date 2022/5/8 10:42
 * 说明：
 **/
public class BufferedWriter_my {
    public static void main(String[] args) throws Exception {
        String filePath = "D:\\IdeaProjects\\my-study\\java-basic\\java-basic-begin\\src\\main\\resources\\io\\text_01.txt";
        String outFilePath = "D:\\IdeaProjects\\my-study\\java-basic\\java-basic-begin\\src\\main\\resources\\io\\out_01.txt";
        try (
                // 在 try() 括号里创建的流，方法运行结束，会自动调用 close() 方法，
                // 因为JDK8 及以上版本 编译后代码会在 finally 块里加上 close() 方法
                FileReader fr = new FileReader(filePath);
                BufferedReader bf = new BufferedReader(fr);
                FileWriter fw = new FileWriter(outFilePath);
        ) {

            BufferedWriter bw = new BufferedWriter(fw);

            // 方式1：
            //String line;
            //while ((line = bf.readLine()) != null) {
            //    bw.write(line, 0, line.length());
            //}
            //bw.close();

            // 方式2：
            char[] chars = new char[2];
            int len;
            while ((len = bf.read(chars)) != -1) {
                bw.write(chars, 0, len);
            }
            // 只有关闭流，数据才会输出到磁盘
            bw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

常用流的分类与选择

在这里插入图片描述

小结：

  • 字符流只适用于操作纯文本文件
  • 字节流可以操作任何文件
fengshangzhuzhu
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java-常用的IO流
梅长苏的博客
03-09 144
常用的IO流
Java中的IO流（最详细解说）
spade_Kwo的博客
08-06 8191
IO流一、File类的使用1.常用构造器2.路径分隔符3.常用方法二、IO流原理及流的分类1.Java IO原理三、流的分类1.输入流(1)InputStream & Reader(2)InputStream(3)Reader2.输出流(1)OutputStream & Writer(2)OutputStream(3)Writer3.节点流(1)读取文件1.字符读取FileReader (read(char[] cbuf))2.字节读取FileInputStream (read(byte
Java中的IO流
最新发布
bala_jiang的博客
04-21 838
简要介绍Java中的字节流和字符流对应的类的使用。目录前言一、Java流的介绍2、流的分类3、Java中的流4、java.io包下的六大流二、文件专属流3、FileReader和FileWriter三、带有缓冲区的流、数据专属流和标准流1、带有缓冲区的流2、数据流3、标准流四、对象专属流五、File类流（Stream）是计算机数据传输中一个相对比较抽象的概念，可以借助现实生活的各种流动的现象来理解。简单来说，流所具有的特点包括，总体以串行的方式一点点的移动，通常具有方向性和连续性，向某个特定的方向汇集。
Java IO流的种类
程序员
02-20 3200
Java IO流的种类
java中IO流有哪些？
liuqinhou的博客
11-16 738
java 流
小白必看！Java中各种IO流的梳理总结
weixin_39158966的博客
03-17 342
同样的，程序中的IO流，则是以程序代码为标准，程序写出数据到文件是输出流，程序读取文件数据是输入流。当然，不同的场景需要应用不同的IO流，平哥给大家整理了不同流的应用场景。字符转换流：可以将字节流转换为字符流，可以用在对于字节流的优化上，例如socket编程中，将字节流的数据传输转字符流来提升性能。字节缓冲流：带缓冲区的字节流，是对字节节点流的性能优化，当需要读写大批量的数据时可选择字节缓冲流，例如拷贝视频文件。字符缓冲流：带缓冲的字符流，与字节缓冲流类似，其性能比字节缓冲流更高，但只能读写文本文件。
JAVA_IO流整理思维导图.emmx
06-04
JAVA_IO流整理思维导图.
Java 的 IO流笔记.md
03-08
Java IO流的笔记，写了常用的类和方法的示例，以及部分Apache的commons-io的IO类，如果没有积分，可以到我的博客里查看下载
Java反射、IO流.pdf
05-07
Java的IO库提供了一套丰富的流类，分为字符流和字节流，以及它们的读取流、写入流、过滤流等子类。 在Java IO中，`InputStream`和`OutputStream`是所有字节流的基类，用于处理二进制数据；`Reader`和`Writer`则处理...
Java基础篇：IO流.pdf
05-19
该文档主要整理了Java IO流的相关信息，主要包括IO流的按照不同维度的分类、节点流、处理流、输入输出流的处理过程、抽象基类的使用等细节内容
Java进阶IO流讲义大全.docx
09-09
Java进阶IO流讲义大全.docx
Java IO流学习总结
weixin_33895516的博客
01-06 1150
Java流操作有关的类或接口： Java流类图结构：   流的概念和作用 流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。  IO流的分类 根据处理数据类型的不同分为：字符流和字节流 根据数据流向不同分为：输入流和输出流   字符流...
Java中常见的IO流及其使用
孙群
07-09 9984
Java中常见的IO流的介绍及使用： ByteArrayInputStream & ByteArrayOutputStream FileInputStream & FileOutputStream PipedInputStream & PipedOutputStream ObjectInputStream & ObjectOutputStream SequenceInputStream ...
Java 常用IO流操作详解
热门推荐
MAGIC
05-22 3万+
IO流大家肯定不陌生，简单整理了一下常用IO流基本用法，其他的IO流以后有时间在整理。 1.基本概念IO：Java对数据的操作是通过流的方式，IO流用来处理设备之间的数据传输，上传文件和下载文件，Java用于操作流的对象都在IO包中。2.IO流的分类图示：（主要IO流） 3.字节流（1）.字节流基类1）.InputStreamInputStream：字节输入流基类，抽象类是表示字节输入流的所有
JAVA常用的IO操作
KEVEN410423的博客
04-23 157
输入输出流区别：从硬盘读到内存中是InputStream操作，从内存写入到硬盘上是OutputStream操作。FileInputStream/FileoutputStream操作步骤：1.创建流；2.通过流进行文件的读取;3.用完后关闭流。FileInputStreamFile file = new File("F:\\1.txt"); InputStream inputStream = ...
java常用IO流集合用法模板
weixin_30919571的博客
08-03 138
package com.fmy; import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.ByteArrayInputStream; impor...
java常用io流_Java常用工具_IO流
weixin_31613423的博客
02-13 98
1. 异常1.1 异常的概述image.png1.2 异常的处理方式Java中异常的顶层父类是Throwablefinally中的语句一定会执行，即使catch中有return，finally里的代码也会执行，这就是加不加finally的区别。image.pngimage.pngpackage cn.case5;public class Test4 {public static void main...
java常用IO流操作
一名小码农的博客
04-24 674
一、概述 1. 流的分类 2. 常用流的继承关系 二、File类 1. 构造方法 2. 实例方法 3. 静态方法 4. 一些例子 三、InputStream及其子类 1. InputStream 2. FileInputStream 3. BufferedInputStream 4. DataInputStream 5. ObjectInputStream 四、OutputStream及其子类
java中常用IO流
weixin_46672808的博客
01-18 284
java中IO输入输出流 java中IO字符输入输出流 java文件缓冲流 Java打印流的使用 java中的对象流 java中的字节数组流 Java数据流 java中的字符串流
java.io.NotSerializableException: java.lang.Object
11-15
java.io.NotSerializableException: java.lang.Object是一个异常，表示试图序列化一个不可序列化的对象。要想一个对象是可序列化的，需要满足以下要求： 1. 该对象必须实现Serializable接口。 2. 需要提供一个全局...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值