Java基础——IO流（1）——字节流、字符流、IO异常处理

最新推荐文章于 2023-12-18 10:31:56 发布
最新推荐文章于 2023-12-18 10:31:56 发布
阅读量362 收藏 1
点赞数
分类专栏： # Java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34805255/article/details/91134265
版权

目录

1.IO概述

2.字节流

2.1 一切皆为字节

2.2 字节输出流【OutputStream】

2.3 FileOutputStream类

（1）构造方法

（2）一次写多个字节

（3）续写和换行

2.4 字节输入流【InputStream】

2.5 FileInputStream类

（1）构造方法

（2）一次读取一个字节

（3）一次读取多个字节

（4）练习：文件的复制

（5）使用字节流读取中文的问题

3.字符流

3.1 字符输入流Reader

3.2 FileReader

3.3 字符输出流Writer

3.4 FileWriter

（1）构造方法

（2）flush方法和close方法的区别

（3）字符输出流写数据的其他方法

（4）续写和换行

4.IO异常的处理

（1）在JDK1.7之前

（2）JDK1.7

（3）JDK1.9

1.IO概述

根据数据的流向分为：输入流和输出流。

  • 输入流 ：把数据从其他设备上读取到内存中的流。

  • 输出流 ：把数据从内存中写出到其他设备上的流。

根据数据的类型分为：字节流和字符流。

  • 字节流 ：以字节为单位，读写数据的流。

  • 字符流 ：以字符为单位，读写数据的流。

图解：

2.字节流

2.1 一切皆为字节

一切文件数据(文本、图片、视频等)在存储时，都是以二进制数字的形式保存，都一个一个的字节，那么传输时一样如此。所以，字节流可以传输任意文件数据。在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底层传输的始终为二进制数据。

2.2 字节输出流【OutputStream】

java.io.OutputStream抽象类是表示字节输出流的所有类的超类，将指定的字节信息写出到目的地。它定义了字节输出流的基本共性功能方法。

2.3 FileOutputStream类

OutputStream有很多子类，我们从最简单的一个子类开始。OutputStream有很多子类，我们从最简单的一个子类开始。

java.io.FileOutputStream类是文件输出流，用于将数据写出到文件。

（1）构造方法

参数:写入数据的目的：

  • String name:目的地是一个文件的路径
  • File file:目的地是一个文件

构造方法的作用：

  • 1.创建一个FileOutputStream对象
  • 2.会根据构造方法中传递的文件/文件路径,创建一个空的文件
  • 3.会把FileOutputStream对象指向创建好的文件

写入数据的原理(内存-->硬盘)

  • java程序-->JVM(java虚拟机)-->OS(操作系统)-->OS调用写数据的方法-->把数据写入到文件中

字节输出流的使用步骤：

  • 1.创建一个FileOutputStream对象,构造方法中传递写入数据的目的地
  • 2.调用FileOutputStream对象中的方法write,把数据写入到文件中
  • 3.释放资源(流使用会占用一定的内存,使用完毕要把内存清空,提供程序的效率)
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo01 {
    public static void main(String[] args) throws IOException {
        //1.创建一个FileOutputStream对象,构造方法中传递写入数据的目的地
        FileOutputStream fos = new FileOutputStream("a.txt");
        //2.调用FileOutputStream对象中的方法write,把数据写入到文件中
        //public abstract void write(int b) ：将指定的字节输出流。
        fos.write(97);
        //3.释放资源(流使用会占用一定的内存,使用完毕要把内存清空,提供程序的效率)
        //fos.close();
    }
}

（2）一次写多个字节

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

public class Demo01 {
    public static void main(String[] args) throws IOException {
        //创建FileOutputStream对象,构造方法中绑定要写入数据的目的地
        FileOutputStream fos1 = new FileOutputStream(new File("b.txt"));
        FileOutputStream fos2 = new FileOutputStream(new File("c.txt"));
        FileOutputStream fos3 = new FileOutputStream(new File("d.txt"));
        /*
            public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。
            一次写多个字节:
                如果写的第一个字节是正数(0-127),那么显示的时候会查询ASCII表
                如果写的第一个字节是负数,那第一个字节会和第二个字节,两个字节组成一个中文显示,查询系统默认码表(GBK)
         */
        byte[] bytes1 = {65,66,67,68,69};//ABCDE
        byte[] bytes2 = {-65,-66,-67,68,69};//烤紻E
        fos1.write(bytes2);

        /*
            public void write(byte[] b, int off, int len) ：把字节数组的一部分写入到文件中
                int off:数组的开始索引
                int len:写几个字节
         */
        fos2.write(bytes1,1,2);//BC

        /*
            写入字符的方法:可以使用String类中的方法把字符串,转换为字节数组
                byte[] getBytes()  把字符串转换为字节数组
         */
        byte[] bytes3 = "你好".getBytes();
        System.out.println(Arrays.toString(bytes3));//[-28, -67, -96, -27, -91, -67]
        fos3.write(bytes3);

        //释放资源
        fos1.close();
        fos2.close();
        fos3.close();
    }
}

       

（3）续写和换行

追加写/续写:使用两个参数的构造方法


参数:

  • String name,File file:写入数据的目的地
  • boolean append:追加写开关
    • true:创建对象不会覆盖源文件,继续在文件的末尾追加写数据
    • false:创建一个新文件,覆盖源文件

回车符\r和换行符\n ：

  • 回车符：回到一行的开头（return）

  • 换行符：下一行（newline）

系统中的换行：

  • Windows系统里，每行结尾是 回车+换行 ，即\r\n；

  • Unix系统里，每行结尾只有 换行 ，即\n；

  • Mac系统里，每行结尾是 回车 ，即\r。从 Mac OS X开始与Linux统一。

示例：

import java.io.FileOutputStream;
import java.io.IOException;


public class Demo01 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("e.txt",true);
        for (int i = 1; i <=10 ; i++) {
            fos.write("你好".getBytes());
            fos.write("\r\n".getBytes());
        }
        fos.close();
    }
}

2.4 字节输入流【InputStream】

java.io.InputStream抽象类是表示字节输入流的所有类的超类，可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。

2.5 FileInputStream类

java.io.FileInputStream类是文件输入流，从文件中读取字节。

（1）构造方法

参数:读取文件的数据源

  • String name:文件的路径
  • File file:文件

构造方法的作用:

  • 1.会创建一个FileInputStream对象
  • 2.会把FileInputStream对象指定构造方法中要读取的文件

读取数据的原理(硬盘-->内存)

  • java程序-->JVM-->OS-->OS读取数据的方法-->读取文件

字节输入流的使用步骤(重点)：

  • 1.创建FileInputStream对象,构造方法中绑定要读取的数据源
  • 2.使用FileInputStream对象中的方法read,读取文件
  • 3.释放资源

（2）一次读取一个字节

package com.boboyu;

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


public class Demo01 {
    public static void main(String[] args) throws IOException {
        //1.创建FileInputStream对象,构造方法中绑定要读取的数据源
        FileInputStream fis = new FileInputStream("c:\\a.txt");
        //2.使用FileInputStream对象中的方法read,读取文件
        //int read()读取文件中的一个字节并返回,读取到文件的末尾返回-1
        /*int len = fis.read();
        System.out.println(len);//97 a

        len = fis.read();
        System.out.println(len);// 98 b

        len = fis.read();
        System.out.println(len);//99 c

        len = fis.read();
        System.out.println(len);//-1

        len = fis.read();
        System.out.println(len);//-1*/

        /*
            发现以上读取文件是一个重复的过程,所以可以使用循环优化
            不知道文件中有多少字节,使用while循环
            while循环结束条件,读取到-1的时候结束

            布尔表达式(len = fis.read())!=-1
                1.fis.read():读取一个字节，读完之后会把指针向后移动一个字节
                2.len = fis.read():把读取到的字节赋值给变量len
                3.(len = fis.read())!=-1:判断变量len是否不等于-1
         */
        int len = 0; //记录读取到的字节
        while((len = fis.read())!=-1){
            System.out.println((char)len);//abc
        }

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

原理：

（3）一次读取多个字节

package com.boboyu;

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

/*
    字节输入流一次读取多个字节的方法:
        int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
    明确两件事情:
        1.方法的参数byte[]的作用?
            起到缓冲作用,存储每次读取到的多个字节
            数组的长度一把定义为1024(1kb)或者1024的整数倍
        2.方法的返回值int是什么?
            每次读取的有效字节个数

    String类的构造方法
        String(byte[] bytes) :把字节数组转换为字符串
        String(byte[] bytes, int offset, int length) 把字节数组的一部分转换为字符串 offset:数组的开始索引 length:转换的字节个数
 */
public class Demo01 {
    public static void main(String[] args) throws IOException {
        //创建FileInputStream对象,构造方法中绑定要读取的数据源
        FileInputStream fis = new FileInputStream("c:\\b.txt");
        //使用FileInputStream对象中的方法read读取文件
        //int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
        /*byte[] bytes = new byte[2];
        int len = fis.read(bytes);
        System.out.println(len);//2
        //System.out.println(Arrays.toString(bytes));//[65, 66]
        System.out.println(new String(bytes));//AB

        len = fis.read(bytes);
        System.out.println(len);//2
        System.out.println(new String(bytes));//CD

        len = fis.read(bytes);
        System.out.println(len);//1
        System.out.println(new String(bytes));//ED

        len = fis.read(bytes);
        System.out.println(len);//-1
        System.out.println(new String(bytes));//ED*/

        /*
            发现以上读取时一个重复的过程,可以使用循环优化
            不知道文件中有多少字节,所以使用while循环
            while循环结束的条件,读取到-1结束
         */
        byte[] bytes = new byte[1024];//存储读取到的多个字节
        int len = 0; //记录每次读取的有效字节个数
        while((len = fis.read(bytes))!=-1){
            //String(byte[] bytes, int offset, int length) 把字节数组的一部分转换为字符串 offset:数组的开始索引 length:转换的字节个数
            System.out.println(new String(bytes,0,len));
        }

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

原理：

（4）练习：文件的复制

package com.boboyu;

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

/*
    文件复制练习:一读一写

    明确:
        数据源: c:\\1.jpg
        数据的目的地: d:\\1.jpg

    文件复制的步骤:
        1.创建一个字节输入流对象,构造方法中绑定要读取的数据源
        2.创建一个字节输出流对象,构造方法中绑定要写入的目的地
        3.使用字节输入流对象中的方法read读取文件
        4.使用字节输出流中的方法write,把读取到的字节写入到目的地的文件中
        5.释放资源
 */
public class Demo01 {
    public static void main(String[] args) throws IOException {
        long s = System.currentTimeMillis();
        //1.创建一个字节输入流对象,构造方法中绑定要读取的数据源
        FileInputStream fis = new FileInputStream("c:\\1.jpg");
        //2.创建一个字节输出流对象,构造方法中绑定要写入的目的地
        FileOutputStream fos = new FileOutputStream("d:\\1.jpg");
        //一次读取一个字节写入一个字节的方式
        //3.使用字节输入流对象中的方法read读取文件
        /*int len = 0;
        while((len = fis.read())!=-1){
            //4.使用字节输出流中的方法write,把读取到的字节写入到目的地的文件中
            fos.write(len);
        }*/

        //使用数组缓冲读取多个字节,写入多个字节
        byte[] bytes = new byte[1024];
        //3.使用字节输入流对象中的方法read读取文件
        int len = 0;//每次读取的有效字节个数
        while((len = fis.read(bytes))!=-1){
            //4.使用字节输出流中的方法write,把读取到的字节写入到目的地的文件中
            fos.write(bytes,0,len);
        }

        //5.释放资源(先关写的,后关闭读的;如果写完了,肯定读取完毕了)
        fos.close();
        fis.close();
        long e = System.currentTimeMillis();
        System.out.println("复制文件共耗时:"+(e-s)+"毫秒");
    }
}

（5）使用字节流读取中文的问题

使用字节流读取中文会产生乱码

package com.boboyu;

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

/*
    使用字节流读取中文文件
    1个中文
        GBK:占用两个字节
        UTF-8:占用3个字节
 */
public class Demo01 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("c:\\c.txt");
        int len = 0;
        while((len = fis.read())!=-1){
            System.out.println((char)len);
        }
        fis.close();
    }
}

3.字符流

3.1 字符输入流Reader

java.io.Reader：字符输入流,是字符输入流的最顶层的父类,定义了一些共性的成员方法,是一个抽象类

共性的成员方法：

3.2 FileReader

作用：作用:把硬盘文件中的数据以字符的方式读取到内存中

（1）构造方法

参数：读取文件的数据源

  • String fileName:文件的路径
  • File file:一个文件

FileReader构造方法的作用:

  • 1.创建一个FileReader对象
  • 2.会把FileReader对象指向要读取的文件

字符输入流的使用步骤:

  • 1.创建FileReader对象,构造方法中绑定要读取的数据源
  • 2.使用FileReader对象中的方法read读取文件
  • 3.释放资源

示例代码：

package com.boboyu;

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


public class Demo01 {
    public static void main(String[] args) throws IOException {
        //1.创建FileReader对象,构造方法中绑定要读取的数据源
        FileReader fr = new FileReader("c:\\c.txt");
        //2.使用FileReader对象中的方法read读取文件
        //int read() 读取单个字符并返回。
        /*int len = 0;
        while((len = fr.read())!=-1){
            System.out.print((char)len);
        }*/

        //int read(char[] cbuf)一次读取多个字符,将字符读入数组。
        char[] cs = new char[1024];//存储读取到的多个字符
        int len = 0;//记录的是每次读取的有效字符个数
        while((len = fr.read(cs))!=-1){
            /*
                String类的构造方法
                String(char[] value) 把字符数组转换为字符串
                String(char[] value, int offset, int count) 把字符数组的一部分转换为字符串 offset数组的开始索引 count转换的个数
             */
            System.out.println(new String(cs,0,len));
        }

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

注意：字符流每次读取一个字符，不管这个字符是中文还是英文

3.3 字符输出流Writer

java.io.Writer:字符输出流,是所有字符输出流的最顶层的父类,是一个抽象类

3.4 FileWriter

作用:把内存中字符数据写入到文件中

（1）构造方法

参数:写入数据的目的地

  • String fileName:文件的路径
  • File file:是一个文件

构造方法的作用:

  • 1.会创建一个FileWriter对象
  • 2.会根据构造方法中传递的文件/文件的路径,创建文件
  • 3.会把FileWriter对象指向创建好的文件

字符输出流的使用步骤(重点):

  • 1.创建FileWriter对象,构造方法中绑定要写入数据的目的地
  • 2.使用FileWriter中的方法write,把数据写入到内存缓冲区中(字符转换为字节的过程)
  • 3.使用FileWriter中的方法flush,把内存缓冲区中的数据,刷新到文件中
  • 4.释放资源(会先把内存缓冲区中的数据刷新到文件中)

示例代码：

package com.boboyu;


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

public class Demo01 {
    public static void main(String[] args) throws IOException {
        //1.创建FileWriter对象,构造方法中绑定要写入数据的目的地
        FileWriter fw = new FileWriter("c:\\d.txt");
        //2.使用FileWriter中的方法write,把数据写入到内存缓冲区中(字符转换为字节的过程)
        //void write(int c) 写入单个字符。
        fw.write(97);   //这步执行完并没有把数据写入文件中，必须使用flush方法把内存中的数据写入到文件中
        //3.使用FileWriter中的方法flush,把内存缓冲区中的数据,刷新到文件中
        //fw.flush();
        //4.释放资源(会先把内存缓冲区中的数据刷新到文件中)
        fw.close();
    }
}

（2）flush方法和close方法的区别

flush ：刷新缓冲区，流对象可以继续使用。

close:  先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。

package com.boboyu;

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

/*
    flush方法和close方法的区别
        - flush ：刷新缓冲区，流对象可以继续使用。
        - close:  先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。
 */
public class Demo01 {
    public static void main(String[] args) throws IOException {
        //1.创建FileWriter对象,构造方法中绑定要写入数据的目的地
        FileWriter fw = new FileWriter("c:\\d.txt");
        //2.使用FileWriter中的方法write,把数据写入到内存缓冲区中(字符转换为字节的过程)
        //void write(int c) 写入单个字符。
        fw.write(97);
        //3.使用FileWriter中的方法flush,把内存缓冲区中的数据,刷新到文件中
        fw.flush();
        //刷新之后流可以继续使用
        fw.write(98);

        //4.释放资源(会先把内存缓冲区中的数据刷新到文件中)
        fw.close();

        //close方法之后流已经关闭了,已经从内存中消失了,流就不能再使用了
        fw.write(99);//IOException: Stream closed
    }
}

（3）字符输出流写数据的其他方法

package com.boboyu;

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

/*
    字符输出流写数据的其他方法
        - void write(char[] cbuf)写入字符数组。
        - abstract  void write(char[] cbuf, int off, int len)写入字符数组的某一部分,off数组的开始索引,len写的字符个数。
        - void write(String str)写入字符串。
        - void write(String str, int off, int len) 写入字符串的某一部分,off字符串的开始索引,len写的字符个数。
 */
public class Demo01 {
    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("c:\\e.txt");
        char[] cs = {'a','b','c','d','e'};
        //void write(char[] cbuf)写入字符数组。
        fw.write(cs);//abcde

        //void write(char[] cbuf, int off, int len)写入字符数组的某一部分,off数组的开始索引,len写的字符个数。
        fw.write(cs,1,3);//bcd

        //void write(String str)写入字符串。
        fw.write("重庆大学");//重庆大学

        //void write(String str, int off, int len) 写入字符串的某一部分,off字符串的开始索引,len写的字符个数。
        fw.write("计算机学院",3,2);//程序员

        fw.close();
    }
}

（4）续写和换行

续写,追加写:使用两个参数的构造方法：

参数：

  • String fileName,File file:写入数据的目的地
  • boolean append:续写开关 true:不会创建新的文件覆盖源文件,可以续写; false:创建新的文件覆盖源文件

换行:换行符号

  • windows:\r\n
  • linux:/n
  • mac:/r

示例代码：

package com.boboyu;

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

public class Demo01 {
    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("c:\\g.txt",true);
        for (int i = 0; i <10 ; i++) {
            fw.write("HelloWorld"+i+"\r\n");
        }

        fw.close();
    }
}

4.IO异常的处理

（1）在JDK1.7之前

package com.boboyu;

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

/*
    在jdk1.7之前使用try catch finally 处理流中的异常
    格式:
        try{
            可能会产出异常的代码
        }catch(异常类变量 变量名){
            异常的处理逻辑
        }finally{
            一定会执行的代码
            资源释放
        }
 */
public class Demo01 {
    public static void main(String[] args) {
        //提高变量fw的作用域,让finally可以使用
        //变量在定义的时候,可以没有值,但是使用的时候必须有值
        //fw = new FileWriter("09_IOAndProperties\\g.txt",true); 执行失败,fw没有值,fw.close会报错
        FileWriter fw = null;
        try{
            //可能会产出异常的代码
            fw = new FileWriter("w:\\g.txt",true);
            for (int i = 0; i <10 ; i++) {
                fw.write("HelloWorld"+i+"\r\n");
            }
        }catch(IOException e){
            //异常的处理逻辑
            System.out.println(e);
        }finally {
            //一定会执行的代码
            //创建对象失败了,fw的默认值就是null,null是不能调用方法的,会抛出NullPointerException,需要增加一个判断,不是null在把资源释放
            if(fw!=null){
                try {
                    //fw.close方法声明抛出了IOException异常对象,所以我们就的处理这个异常对象,要么throws,要么try catch
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
    }
}

（2）JDK1.7

package com.boboyu;

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

/*
    JDK7的新特性
    在try的后边可以增加一个(),在括号中可以定义流对象
    那么这个流对象的作用域就在try中有效
    try中的代码执行完毕,会自动把流对象释放,不用写finally
    格式:
        try(定义流对象;定义流对象....){
            可能会产出异常的代码
        }catch(异常类变量 变量名){
            异常的处理逻辑
        }
 */
public class Demo01 {
    public static void main(String[] args) {
        try(//1.创建一个字节输入流对象,构造方法中绑定要读取的数据源
            FileInputStream fis = new FileInputStream("c:\\1.jpg");
            //2.创建一个字节输出流对象,构造方法中绑定要写入的目的地
            FileOutputStream fos = new FileOutputStream("d:\\1.jpg");){

            //可能会产出异常的代码
            //一次读取一个字节写入一个字节的方式
            //3.使用字节输入流对象中的方法read读取文件
            int len = 0;
            while((len = fis.read())!=-1){
                //4.使用字节输出流中的方法write,把读取到的字节写入到目的地的文件中
                fos.write(len);
            }

        }catch (IOException e){
            //异常的处理逻辑
            System.out.println(e);
        }
    }
}

（3）JDK1.9

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

/*
    JDK1.9新特性
    try的前边可以定义流对象
    在try后边的()中可以直接引入流对象的名称(变量名)
    在try代码执行完毕之后,流对象也可以释放掉,不用写finally
    格式:
        A a = new A();
        B b = new B();
        try(a,b){
            可能会产出异常的代码
        }catch(异常类变量 变量名){
            异常的处理逻辑
        }
 */
public class Demo01 {
    public static void main(String[] args) throws IOException {
        //1.创建一个字节输入流对象,构造方法中绑定要读取的数据源
        FileInputStream fis = new FileInputStream("c:\\1.jpg");
        //2.创建一个字节输出流对象,构造方法中绑定要写入的目的地
        FileOutputStream fos = new FileOutputStream("d:\\1.jpg");

        try(fis;fos){
            //一次读取一个字节写入一个字节的方式
            //3.使用字节输入流对象中的方法read读取文件
            int len = 0;
            while((len = fis.read())!=-1){
                //4.使用字节输出流中的方法write,把读取到的字节写入到目的地的文件中
                fos.write(len);
            }
        }catch (IOException e){
            System.out.println(e);
        }

        //fos.write(1);//Stream Closed

    }
}

 

喵的波波鱼
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java IO流基础知识详解
NiShoushun的博客
03-18 507
Java IO流 前话- 自己在学习Java IO时网上查了很多资料，感觉写的都并不完善，所以特地整理了一晚上，希望整理后的资料能帮到有需要的人 文章目录Java IO流1. javaIO流概述1.1 IO流介绍1.1.1 什么是IO流？1.1.2 java中的IO流列表1.2 IO流分类1.2.1 按方向分类1.2.2 按传输单位分类1.2.3 按功能分类2.常用 java IO流使用2.1 ...
Java IO流常用字节字符流原理解析
08-19
Java IO流中的字节流和字符流是两个基本的流类型，字节流用于对文件、网络等进行读写操作，而字符流用于对文本文件、网络等进行读写操作。了解Java IO流的原理和实现，可以帮助我们更好地使用Java IO流来进行文件、...
一、IO异常处理二、字节缓冲流
weixin_60166864的博客
08-20 91
8.19
Java之IO流异常处理
qq_43531919的博客
07-18 517
**jdk1.7之前** 使用try catch finally处理 /* 在jdk1.7之前使用try catch finally 处理流中的异常 格式: try{ 可能会产出异常的代码 }catch(异常类变量 变量名){ 异常的处理逻辑 }finally{ 一定会指定的代码 资源释放 } */ import java.io.
IO流有趣的问题 字节流读取，字符流输出会不会有问题？
yellow__star的博客
08-15 333
如果使用字节流读取，字符流输出会不会有问题？ 首先字符流用来读取文本文件的，不能够去读取视频和图片的。因为字符流会使用对应的编码转换为字符，视频和图片都不是字符的。所以就测试文本文件 测试结果： 如果使用一次读取一个字节的方法来写入文件，就没有问题。 使用字节数组就会有问题。不难理解，字节流的read()方法如果读取一个字节数组的话，对应的字符流的write()方法缺没有写入字节数组的方法...
Java基础IO总结
最新发布
Hi，我是sharkchili，CSDN Java领域博客专家，开源项目JavaGuide维护人员，我想写一些有意思的东西，希望对你有帮助。
12-18 289
以字符的形式读取或者写入数据，从而避免一些编码问题。utf8:英文一个字节，一个中文占3个字节。unicode:无论中文英文都占2个字节。gbk:一个英文1个字节，中文2个字节。
JAVA IO流缓冲字节流缓冲字符流等流经典代码示例加注释总结.rar
11-30
1、博客地址：...3、JAVA IO流经典代码示例，示例从易到难。代码功能涉及字节、字符、字符串、文本文件、图片、音频、视频。演示错误用法和经典用法。 4、代码的结构可查看README文件。
浅谈java IO流——四大抽象类
08-26
java IO流是java语言中用于输入输出操作的基本类库，IO流是Java程序中最基本也最重要的一部分，java IO流主要可以分为两大类：字节流和字符流。在java中，四大抽象类是IO流的基础，它们分别是InputStream、...
IO流——文件操作字节流常用方法一览
12-22
总的来说，`FileInputStream` 和 `FileOutputStream` 是Java中处理文件字节流的基本工具，它们提供了一种高效且灵活的方式来读取和写入二进制文件。理解并熟练掌握这两个类的方法对于进行文件操作至关重要。
javaIO字符流文件写入总结共1页.pdf.zip
10-29
Java IO字符流是Java平台中用于处理文本数据的重要部分，特别是在进行文件读写操作时。字符流处理单个字符，适合处理基于字符编码（如UTF-8、GBK等）的文本文件。本篇将深入探讨Java IO中的字符流以及如何进行文件...
java基础IO流
lihao_521的博客
01-30 784
IO 可以将数据从本地文件读取出来 可以将数据从内存保存到本地文件 概述 I表示input，是数据从硬盘进内存的过程，称之为读。 O表示output，是数据从内存到硬盘的过程，称之为写。 IO的数据传输，可以看作是一种数据的流动，按照流动的方向，以内存为参照物，进行读写操作 IO流的分类 按流向分 输入流 输出流 按数据类型分 字节流：操作所有类型的文件，包括音频视频图片等 字符流：只能操作纯文本文件，...
Java学习(IO流,字节流,字符流,流中的异常处理,Properties集合)
XXX_17的博客
02-08 333
2022/1/28 1.IO概述和分类 i:input输入（读取） o:output输出（写入） 流：数据（字符，字节）1个字符 = 2个字节 1个字节 = 8个二进制位 输入：把硬盘中的数据，读取到内存中使用 输出：把内存中的数据，写入到硬盘中保存 所以流分为输入流和输出流，又因为有字符和字节，所以又分为字节输入流（InputStream），字节输出流（OutputStream）和字符输入流（Reader），字符输出流（Writer），这四个是IO流的顶级父类 2.字节流 1）一切皆为字节（一切文.
File、IO流—知识整合（一）
温良
06-29 99
File类的构造方法 File(Fileparent, Stringchild) File类中常用方法 public String getAbsolutePath():返回此Flie的绝对路径字符串 public String getPath():将此转换为路径名字符串//toString方法调用的就是getPath方法 public String getName():返回由此File表示的文件或目录的名称 public String length():获取的是构造方法指定的文件的大小，以字..
教你完全理解IO流里的 read(),read(byte[]),read(byte[],int off,int len)以及write
热门推荐
农展飞的博客
07-01 2万+
len的作用 write(bytes);不严谨,后续有空的 write(bytes,0,len);严谨,和原来一模一样
浅谈write(byte[] b)和write(byte[] b,int off,int len)的区别
wxg6203的专栏
05-12 1597
浅谈write(byte[] b)和write(byte[] b,int off,int len)的区别 相信大家都会用着2个方法吧，但是真正理解他们的机制相信不多，现在我以代码来解释他们的机制及区别 举例新建一个类 package io; import java.io.ByteArrayInputStream; import java.io.File; i...
字节流和字符流
今晚打老虎的博客
10-28 269
目录 IO概述 1.1 什么是IO 1.2 IO的分类 1.3 IO的流向说明图解 1.4 顶级父类们 字节流 2.1 一切皆为字节 2.2 字节输出流【OutputStream】 2.3 FileOutputStream类 构造方法 写出字节数据 ​ 数据追加续写 写出换行 2.4 字节输入流【InputStream】 2.5 FileInputStream类...
Java基础：字节输入流 InputStream与文件复制练习：一读一写
JinxLin的博客
08-27 337
InputStream java.io.InputStream:字节输入流 此抽象类是表示字节输入流的所有类的超类 定义了所有子类共性的方法： int read()从输入流中读取数据的下一个字节 int read(byte[] b)从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中 java.io.FileInputStream extends InputStream FileInputStream:文件字节输入流 作用：把硬盘文件中的数据，读取到内存中使用 构造方法： FileInputStre
inputStream.read(byteArray) != -1 死循环问题
qq_34756209的博客
03-12 2392
while ((len = inputStream.read(byteArray)) != -1){ message = new String(byteArray,0,len); System.out.println(len); } 类似于这种inputStream读取完数据之后，但是不跳出循环的问题，首先先看下你的inputStream是不是scoket通信的，如果是就将你的输入方的socket关闭就好 // 这是输入方 创建socket对象 Socket socket =..
IO字节流
Java初学者
06-10 214
未完待续~……

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值