Java-字节流、字符流

最新推荐文章于 2021-07-09 19:03:45 发布
最新推荐文章于 2021-07-09 19:03:45 发布
阅读量205 收藏 1
点赞数 1
分类专栏： JAVA 文章标签： Java 字节流 字符流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42545106/article/details/103338719
版权

第一章 IO概述

1.1 什么是IO

生活中，你肯定经历过这样的场景。当你编辑一个文本文件，忘记了ctrl+s ，可能文件就白白编辑了。当你电脑上插入一个U盘，可以把一个视频，拷贝到你的电脑硬盘里。那么数据都是在哪些设备上的呢？键盘、内存、硬盘、外接设备等等。

我们把这种数据的传输，可以看做是一种数据的流动，按照流动的方向，以内存为基准，分为输入input 和输出output ，即流向内存是输入流，流出内存的输出流。

Java中I/O操作主要是指使用java.io包下的内容，进行输入、输出操作。

输入也叫做读取数据（把硬盘中的数据督导内存中使用）

输出也叫做作写出数据（把内存中的数据写到硬盘中保存）

1.2 IO的分类

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

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

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

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

1.3 IO的流向说明图解

1.4 顶级父类们

输入流输出流
字节流字节输入流
InputStream		字节输出流
OutputStream
字符流字符输入流
Reader		字符输出流
Writer

第二章 字节流

2.1 一切皆为字节

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

2.2 字节输出流【OutputStream】

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

  • public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。
  • public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。
  • public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。
  • public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
  • public abstract void write(int b) ：将指定的字节输出流。

小贴士：

close方法，当完成流的操作时，必须调用此方法，释放系统资源。

2.3 FileOutputStream类

FileOutputStream文件字节输出流

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

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

构造方法

  • public FileOutputStream(File file)：创建文件输出流以写入由指定的 File对象表示的文件。

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

    file和name都是写数据的目的地，只不过file目的地是一个文件，name目的地是一个路径

构造方法的作用：

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

写入数据的原理（内存–>硬盘）：

​ java程序–>JVM（java虚拟机）–>OS（操作系统）–>OS调用写数据的方法–>把数据写到文件中

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有这个文件，会创建该文件。如果有这个文件，会清空这个文件的数据。

  • 构造举例，代码如下：
public class FileOutputStreamConstructor throws IOException {
    public static void main(String[] args) {
   	 	// 使用File对象创建流对象
        File file = new File("a.txt");
        FileOutputStream fos = new FileOutputStream(file);
      
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("b.txt");
    }
}

写出字节数据

字节输出流的使用步骤：

  1. 创建一个FileOutputStream对象，构造方法中传入写入数据的目的地

  2. 调用FileOutputStream对象中的write方法，把数据写入

  3. 释放资源

  4. 写出字节：write(int b) 方法，每次可以写出一个字节数据，代码使用演示：

package Demo10;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class DemoOutputStream {
    public static void main(String[] args) throws IOException {
        File file = new File("D:\\JAVA\\a.txt");
        FileOutputStream fos = new FileOutputStream(file);
        fos.write(65);		//写入的时候，会把10进制的65转换为2进制------A
        fos.write(66);
        fos.write(67);
        fos.close();
    }
}
输出结果：
ABC

小贴士：

  1. 虽然参数为int类型四个字节，但是只会保留一个字节的信息写出。
  2. 流操作完毕后，必须释放系统资源，调用close方法，千万记得。
  1. 写出字节数组：write(byte[] b)，每次可以写出数组中的数据，代码使用演示：
/*
一次写多个字节：
如果第一个字节是正数（0-127），那么显示的时候会查询ASCII表
如果第一个字节是负数，那第一个字节回合第二个字节，两个字节组成一个中文显示，铲鲟系统默认码表（GBK）
*/
package Demo10;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class DemoOutputStream {
    public static void main(String[] args) throws IOException {
        File file = new File("D:\\JAVA\\a.txt");
        FileOutputStream fos = new FileOutputStream(file);
        byte[] b = "三千七百万".getBytes();
        fos.write(b);
        byte[] b1 = {-65,-66,-67,68,69};    //烤紻E
        fos.write(b1);
        fos.close();
    }
}
输出结果：
三千七百万
  1. 写出指定长度字节数组：write(byte[] b, int off, int len) ,每次写出从off索引开始，len个字节，代码使用演示：
public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");     
      	// 字符串转换为字节数组
      	byte[] b = "abcde".getBytes();
		// 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
        fos.write(b,2,2);
      	// 关闭资源
        fos.close();
    }
}
输出结果：
cd
==============================================
package Demo10;

import sun.nio.cs.ext.GBK;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class DemoOutputStream {
    public static void main(String[] args) throws IOException {
        File file = new File("D:\\JAVA\\a.txt");
        FileOutputStream fos = new FileOutputStream(file);
        byte[] b2 = "abcdefghijklmn".getBytes();
        fos.write(b2,2,7);  //cdefghi
        fos.close();
    }
}

数据追加续写

经过以上的演示，每次程序运行，创建输出流对象，都会清空目标文件中的数据。如何保留目标文件中数据，还能继续添加新数据呢？

  • public FileOutputStream(File file, boolean append)： 创建文件输出流以写入由指定的 File对象表示的文件。
  • public FileOutputStream(String name, boolean append)： 创建文件输出流以指定的名称写入文件。

这两个构造方法，参数中都需要传入一个boolean类型的值，append表示追加写开关，true 表示追加数据，继续在原文件的末尾写数据，false 表示清空原有数据，创建一个新的文件，来覆盖原文件。这样创建的输出流对象，就可以指定是否追加续写了，代码使用演示：

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt"，true);     
      	// 字符串转换为字节数组
      	byte[] b = "abcde".getBytes();
		// 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
        fos.write(b);
      	// 关闭资源
        fos.close();
    }
}
文件操作前：cd
文件操作后：cdabcde

写出换行

Windows系统里，换行符号是\r\n 。把

以指定是否追加续写了，代码使用演示：

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");  
      	// 定义字节数组
      	byte[] words = {97,98,99,100,101};
      	// 遍历数组
        for (int i = 0; i < words.length; i++) {
          	// 写出一个字节
            fos.write(words[i]);
          	// 写出一个换行, 换行符号转成数组写出
            fos.write("\r\n".getBytes());
        }
      	// 关闭资源
        fos.close();
    }
}

输出结果：
a
b
c
d
e
  • 回车符\r和换行符\n ：
    • 回车符：回到一行的开头（return）。
    • 换行符：下一行（newline）。
  • 系统中的换行：
    • Windows系统里，每行结尾是 回车+换行 ，即\r\n；
    • Unix系统里，每行结尾只有 换行 ，即\n；
    • Mac系统里，每行结尾是 回车 ，即\r。从 Mac OS X开始与Linux统一。

2.4 字节输入流【InputStream】

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

  • public void close() ：关闭此输入流并释放与此流相关联的任何系统资源。
  • public abstract int read()： 从输入流读取数据的下一个字节。
  • public int read(byte[] b)： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 。

小贴士：

close方法，当完成流的操作时，必须调用此方法，释放系统资源。

2.5 FileInputStream类

java.io.FileInputStream类是文件输入流，从文件中读取字节，把硬盘中的数据读取到内存中。

构造方法

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

构造方法的作用：

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

写入数据的原理（内存–>硬盘）：

​ java程序–>JVM（java虚拟机）–>OS（操作系统）–>OS读取数据的方法–>把数据读取到内存中

字节输入流的使用步骤：

  1. 创建一个FileInputStream对象，构造方法中传入写入数据的目的地
  2. 调用FileInputStream对象中的read方法，读取文件
  3. 释放资源

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有该文件,会抛出FileNotFoundException

  • 构造举例，代码如下：
public class FileInputStreamConstructor throws IOException{
    public static void main(String[] args) {
   	 	// 使用File对象创建流对象
        File file = new File("a.txt");
        FileInputStream fos = new FileInputStream(file);
      
        // 使用文件名称创建流对象
        FileInputStream fos = new FileInputStream("b.txt");
    }
}

读取字节数据

  1. 读取字节：read方法，每次可以读取一个字节的数据，提升为int类型，读取到文件末尾，返回-1，代码使用演示：

    package Demo10;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class DemoInputStream {
    public static void main(String[] args) throws IOException {
        File file = new File("D:\\JAVA\\b.txt");	//ABCDEFG
        FileInputStream fis = new FileInputStream(file);
        //(read = fis.read()) != -1，首先fis.read()读取一个字节，然后赋值给read，然后判断是否不等于-1
        int read = 0;
        while((read = fis.read()) != -1){
            System.out.print((char) read);
        }
    }
}
结果：ABCDEFG

  2. 使用字节数组读取：read(byte[] b)，每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回-1 ，代码使用演示：

package Demo10;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.lang.reflect.Array;
import java.util.Arrays;

public class DemoInputStream2 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("D:\\JAVA\\b.txt");	//ABCDEFG
        byte[] bytes = new byte[2];
        int len = fis.read(bytes);
        System.out.println(len);    //读取的元素的个数---2
        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);    //读取的元素的个数---2
        System.out.println(new String(bytes));  //EF

        len = fis.read(bytes);
        System.out.println(len);    //读取的元素的个数---1
        System.out.println(new String(bytes));  //GF
        fis.close();
    }
}

错误数据d，是由于最后一次读取时，只读取一个字节e，数组中，上次读取的数据没有被完全替换，所以要通过len ，获取有效的字节，代码使用演示：

public class FISRead {
    public static void main(String[] args) throws IOException{
      	// 使用文件名称创建流对象.
       	FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde
      	// 定义变量，作为有效个数
        int len ；
        // 定义字节数组，作为装字节数据的容器   
        byte[] b = new byte[2];
        // 循环读取
        while (( len= fis.read(b))!=-1) {
           	// 每次读取后,把数组的有效字节部分，变成字符串打印
            //String(byte[] bytes, int offset, int length) 通过使用平台的默认字符集解码指定的 byte子数组，构造一个新的 String。
            System.out.println(new String(b，0，len));//  len 每次读取的有效字节个数
        }
		// 关闭资源
        fis.close();
    }
}

输出结果：
ab
cd
e
===============================================
package Demo10;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.lang.reflect.Array;
import java.util.Arrays;

public class DemoInputStream2 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("D:\\JAVA\\b.txt");
        byte[] bytes = new byte[2];
        int len = 0;
        while((len = fis.read(bytes)) != -1){
            System.out.println(new String(bytes,0,len));    //从0到len个有效字符个数
        }
        fis.close();
    }
}
结果：
AB
CD
EF
G

小贴士：

使用数组读取，每次读取多个字节，减少了系统间的IO操作次数，从而提高了读写的效率，建议开发中使用。

2.6 字节流练习：图片复制

案例实现

复制图片文件，代码使用演示：

public class Copy {
    public static void main(String[] args) throws IOException {
        // 1.创建流对象
        // 1.1 指定数据源
        FileInputStream fis = new FileInputStream("D:\\test.jpg");
        // 1.2 指定目的地
        FileOutputStream fos = new FileOutputStream("test_copy.jpg");

        // 2.读写数据
        // 2.1 定义数组
        byte[] b = new byte[1024];
        // 2.2 定义长度
        int len;
        // 2.3 循环读取
        while ((len = fis.read(b))!=-1) {
            // 2.4 写出数据
            fos.write(b, 0 , len);
        }

        // 3.关闭资源
        fos.close();
        fis.close();
    }
}
==============================================================
package Demo10;

import com.sun.xml.internal.ws.policy.privateutil.PolicyUtils;

import java.io.*;

public class DemoCopy {
    public static void main(String[] args) throws IOException {
        //把b.txt的内容复制到a.txt里面
        File f1 = new File("D:\\JAVA\\学习笔记图片\\2_copy.jpg");  //需要读取的图片
        File f2 = new File("D:\\JAVA\\a.jpg");  //需要写入的图片

        FileInputStream fis = new FileInputStream(f1);
        FileOutputStream fos = new FileOutputStream(f2);

        byte[] bytes = new byte[1024];
        int len =0;
        while((len = fis.read(bytes)) != -1){
            fos.write(bytes,0,len);
        }

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

小贴士：

流的关闭原则：先开后关，后开先关。

第三章 字符流

对于中文，使用字节流读取中文文件：一个中文GBK是占用两个字节、UTF-8占用3个字节

当使用字节流读取文本文件时，可能会有一个小问题。就是遇到中文字符时，可能不会显示完整的字符，那是因为一个中文字符可能占用多个字节存储。所以Java提供一些字符流类，以字符为单位读写数据，专门用于处理文本文件。

3.1 字符输入流【Reader】

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

  • public void close() ：关闭此流并释放与此流相关联的任何系统资源。
  • public int read()： 从输入流读取一个字符。
  • public int read(char[] cbuf)： 从输入流中读取一些字符，并将它们存储到字符数组 cbuf中 。

3.2 FileReader类

java.io.FileReader类是读取字符文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。

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

小贴士：

  1. 字符编码：字节与字符的对应规则。Windows系统的中文编码默认是GBK编码表。

idea中UTF-8

  1. 字节缓冲区：一个字节数组，用来临时存储字节数据。

构造方法

  • FileReader(File file)： 创建一个新的 FileReader ，给定要读取的File对象。
  • FileReader(String fileName)： 创建一个新的 FileReader ，给定要读取的文件的名称。

当你创建一个流对象时，必须传入一个文件路径。类似于FileInputStream 。

构造方法的作用：

  1. 创建一个FileReader对象
  2. 会把FileReader对象指向要读取的文件
  • 构造举例，代码如下：
public class FileReaderConstructor throws IOException{
    public static void main(String[] args) {
   	 	// 使用File对象创建流对象
        File file = new File("a.txt");
        FileReader fr = new FileReader(file);
      
        // 使用文件名称创建流对象
        FileReader fr = new FileReader("b.txt");
    }
}

读取字符数据

  1. 读取字符：read方法，每次可以读取一个字符的数据，提升为int类型，读取到文件末尾，返回-1，循环读取，代码使用演示：
public class FRRead {
    public static void main(String[] args) throws IOException {
      	// 使用文件名称创建流对象
       	FileReader fr = new FileReader("read.txt");
      	// 定义变量，保存数据
        int b ；
        // 循环读取
        while ((b = fr.read())!=-1) {
            System.out.println((char)b);
        }
		// 关闭资源
        fr.close();
    }
}
输出结果：
黑
马
程
序
员

小贴士：虽然读取了一个字符，但是会自动提升为int类型。

  1. 使用字符数组读取：read(char[] cbuf)，每次读取b的长度个字符到数组中，返回读取到的有效字符个数，读取到末尾时，返回-1 ，代码使用演示：
public class FRRead {
    public static void main(String[] args) throws IOException {
      	// 使用文件名称创建流对象
       	FileReader fr = new FileReader("read.txt");
      	// 定义变量，保存有效字符个数
        int len ；
        // 定义字符数组，作为装字符数据的容器
         char[] cbuf = new char[2];
        // 循环读取
        while ((len = fr.read(cbuf))!=-1) {
            System.out.println(new String(cbuf));
        }
		// 关闭资源
        fr.close();
    }
}
输出结果：
黑马
程序
员序

获取有效的字符改进，代码使用演示：

public class FISRead {
    public static void main(String[] args) throws IOException {
      	// 使用文件名称创建流对象
       	FileReader fr = new FileReader("read.txt");
      	// 定义变量，保存有效字符个数
        int len ；
        // 定义字符数组，作为装字符数据的容器
        char[] cbuf = new char[2];
        // 循环读取
        while ((len = fr.read(cbuf))!=-1) {
            System.out.println(new String(cbuf,0,len));
        }
    	// 关闭资源
        fr.close();
    }
}

输出结果：
黑马
程序
员

3.3 字符输出流【Writer】

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

  • void write(int c) 写入单个字符。
  • 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写的字符个数。
  • void flush()刷新该流的缓冲。
  • void close() 关闭此流，但要先刷新它。

3.4 FileWriter类

java.io.FileWriter类是写出字符到文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。

构造方法

  • FileWriter(File file)： 创建一个新的 FileWriter，给定要读取的File对象。
  • FileWriter(String fileName)： 创建一个新的 FileWriter，给定要读取的文件的名称。

当你创建一个流对象时，必须传入一个文件路径，类似于FileOutputStream。

字符出输出流的使用步骤：

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

如果不调用flush方法，就只会在缓冲区中有数据，不会真正写入到文件中

  • 构造举例，代码如下：
public class FileWriterConstructor {
    public static void main(String[] args) throws IOException {
   	 	// 使用File对象创建流对象
        File file = new File("a.txt");
        FileWriter fw = new FileWriter(file);
      
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("b.txt");
    }
}

基本写出数据

写出字符：write(int b) 方法，每次可以写出一个字符数据，代码使用演示：

public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("fw.txt");     
      	// 写出数据
      	fw.write(97); // 写出第1个字符
      	fw.write('b'); // 写出第2个字符
      	fw.write('C'); // 写出第3个字符
      	fw.write(30000); // 写出第4个字符，中文编码表中30000对应一个汉字。
      
      	/*
        【注意】关闭资源时,与FileOutputStream不同。
      	 如果不关闭,数据只是保存到缓冲区，并未保存到文件。
        */
        // fw.close();
    }
}
输出结果：
abC田

小贴士：

  1. 虽然参数为int类型四个字节，但是只会保留一个字符的信息写出。
  2. 未调用close方法，数据只是保存到了缓冲区，并未写出到文件中。

关闭和刷新

因为内置缓冲区的原因，如果不关闭输出流，无法写出字符到文件中。但是关闭的流对象，是无法继续写出数据的。如果我们既想写出数据，又想继续使用流，就需要flush 方法了。

flush和close的区别：

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

代码使用演示：

public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("fw.txt");
        // 写出数据，通过flush
        fw.write('刷'); // 写出第1个字符
        fw.flush();
        fw.write('新'); // 继续写出第2个字符，写出成功
        fw.flush();
      
      	// 写出数据，通过close
        fw.write('关'); // 写出第1个字符
        fw.close();
        fw.write('闭'); // 继续写出第2个字符,【报错】java.io.IOException: Stream closed
        fw.close();
    }
}

小贴士：即便是flush方法写出了数据，操作的最后还是要调用close方法，释放系统资源。

写出其他数据

  1. 写出字符数组 ：write(char[] cbuf) 和 write(char[] cbuf, int off, int len) ，每次可以写出字符数组中的数据，用法类似FileOutputStream，代码使用演示：
public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("fw.txt");     
      	// 字符串转换为字节数组
      	char[] chars = "黑马程序员".toCharArray();
      
      	// 写出字符数组
      	fw.write(chars); // 黑马程序员
        
		// 写出从索引2开始，2个字节。索引2是'程'，两个字节，也就是'程序'。
        fw.write(b,2,2); // 程序
      
      	// 关闭资源
        fos.close();
    }
}
  1. 写出字符串：write(String str) 和 write(String str, int off, int len) ，每次可以写出字符串中的数据，更为方便，代码使用演示：
public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("fw.txt");     
      	// 字符串
      	String msg = "黑马程序员";
      
      	// 写出字符数组
      	fw.write(msg); //黑马程序员
      
		// 写出从索引2开始，2个字节。索引2是'程'，两个字节，也就是'程序'。
        fw.write(msg,2,2);	// 程序
      	
        // 关闭资源
        fos.close();
    }
}
  1. 续写和换行：操作类似于FileOutputStream。
public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象，可以续写数据
        FileWriter fw = new FileWriter("fw.txt"，true);     
      	// 写出字符串
        fw.write("黑马");
      	// 写出换行
      	fw.write("\r\n");
      	// 写出字符串
  		fw.write("程序员");
      	// 关闭资源
        fw.close();
    }
}
输出结果:
黑马
程序员

小贴士：字符流，只能操作文本文件，不能操作图片，视频等非文本文件。

当我们单纯读或者写文本文件时 使用字符流 其他情况使用字节流

第四章 IO异常的处理

JDK7前处理

之前的入门练习，我们一直把异常抛出，而实际开发中并不能这样处理，建议使用try...catch...finally 代码块，处理异常部分，代码使用演示：

public class HandleException1 {
    public static void main(String[] args) {
      	// 声明变量
        FileWriter fw = null;
        try {
            //创建流对象
            fw = new FileWriter("fw.txt");
            // 写出数据
            fw.write("黑马程序员"); //黑马程序员
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fw != null) {
                    fw.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

JDK7的处理(扩展知识点了解内容)

还可以使用JDK7优化后的try-with-resource 语句，该语句确保了每个资源在语句结束时关闭。所谓的资源（resource）是指在程序完成后，必须关闭的对象。

格式：

try (创建流对象语句，如果多个,使用';'隔开) {
	// 读写数据
} catch (IOException e) {
	e.printStackTrace();
}

代码使用演示：

public class HandleException2 {
    public static void main(String[] args) {
      	// 创建流对象
        try ( FileWriter fw = new FileWriter("fw.txt"); ) {
            // 写出数据
            fw.write("黑马程序员"); //黑马程序员
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

JDK9的改进(扩展知识点了解内容)

JDK9中try-with-resource 的改进，对于引入对象的方式，支持的更加简洁。被引入的对象，同样可以自动关闭，无需手动close，我们来了解一下格式。

改进前格式：

// 被final修饰的对象
final Resource resource1 = new Resource("resource1");
// 普通对象
Resource resource2 = new Resource("resource2");
// 引入方式：创建新的变量保存
try (Resource r1 = resource1;
     Resource r2 = resource2) {
     // 使用对象
}

改进后格式：

// 被final修饰的对象
final Resource resource1 = new Resource("resource1");
// 普通对象
Resource resource2 = new Resource("resource2");

// 引入方式：直接引入
try (resource1; resource2) {
     // 使用对象
}

改进后，代码使用演示：

public class TryDemo {
    public static void main(String[] args) throws IOException {
       	// 创建流对象
        final  FileReader fr  = new FileReader("in.txt");
        FileWriter fw = new FileWriter("out.txt");
       	// 引入到try中
        try (fr; fw) {
          	// 定义变量
            int b;
          	// 读取数据
          	while ((b = fr.read())!=-1) {
            	// 写出数据
            	fw.write(b);
          	}
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

第五章 属性集

5.1 概述

java.util.Properties 继承于Hashtable ，来表示一个持久的属性集。它使用键值结构存储数据，每个键及其对应值都是一个字符串。该类也被许多Java类使用，比如获取系统属性时，System.getProperties 方法就是返回一个Properties对象。

Properties 是唯一一个和IO六相结合的集合

​ 可以使用Properties 集合中的方法store，把集合中的临时数据，持久化写入到硬盘中储存

​ 可以使用Properties集合中的方法Load，把硬盘中保存的文件（键值对），读取到集合中使用

每个键及其对应值都是一个字符串，KV默认都是字符串

5.2 Properties类

构造方法

  • public Properties() :创建一个空的属性列表。

基本的存储方法

  • public Object setProperty(String key, String value) ： 保存一对属性。
  • public String getProperty(String key) ：使用此属性列表中指定的键搜索属性值。
  • public Set<String> stringPropertyNames() ：所有键的名称的集合。
public class ProDemo {
    public static void main(String[] args) throws FileNotFoundException {
        // 创建属性集对象
        Properties properties = new Properties();
        // 添加键值对元素
        properties.setProperty("filename", "a.txt");
        properties.setProperty("length", "209385038");
        properties.setProperty("location", "D:\\a.txt");
        // 打印属性集对象
        System.out.println(properties);
        // 通过键,获取属性值
        System.out.println(properties.getProperty("filename"));
        System.out.println(properties.getProperty("length"));
        System.out.println(properties.getProperty("location"));

        // 遍历属性集,获取所有键的集合
        Set<String> strings = properties.stringPropertyNames();
        // 打印键值对
        for (String key : strings ) {
          	System.out.println(key+" -- "+properties.getProperty(key));
        }
    }
}
输出结果：
{filename=a.txt, length=209385038, location=D:\a.txt}
a.txt
209385038
D:\a.txt
filename -- a.txt
length -- 209385038
location -- D:\a.txt
============================================================
package Demo10;

import java.util.Properties;
import java.util.Set;

public class DemoProperties {
    public static void main(String[] args) {
        Properties properties = new Properties();
        properties.setProperty("张三","175");
        properties.setProperty("李四","180");
        properties.setProperty("王五","160");

        Set<String> set = properties.stringPropertyNames();

        for(String i: set){
            System.out.println(i+":"+properties.getProperty(i));
        }
    }
}

与流相关的方法

store

将键值对，写入到指定的文件中

  • void store(OutputStream out, String comments) 以适合使用 load(InputStream) 方法加载到 Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流。
  • void store(Writer writer, String comments) 以适合使用 load(Reader) 方法的格式，将此 Properties 表中的属性列表（键和元素对）写入输出字符。

OutputStream和Writer的区别：

​ 如果用OutputStream，就是字节输出流，不能写入中文

​ Writer，字符输出流，可以写中文

​ String comments：注释，用来解释说明保存的文件是做什么的，不能使用中文，会产生乱码，默认是Unicode编码，一般使用空字符串

使用步骤：

  1. 创建Properties集合对象，添加数据
  2. 创建字节输出六/字符输出流对象，构造方法中绑定要输出的目的地
  3. 使用Properties集合中的方法store，啊把集合中的临时数据，持久化写入到硬盘中储存
  4. 释放资源
package Demo10;

import java.io.File;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;

public class DemoStore {
    public static void main(String[] args) throws IOException {
        Properties properties = new Properties();
        properties.setProperty("张三","175");
        properties.setProperty("李四","180");
        properties.setProperty("王五","160");

        //a.txt使用字符流在存取
        FileWriter fw = new FileWriter("D:\\JAVA\\a.txt");
        properties.store(fw,"save data");
                    结果：
                    #save data
                    #Mon Nov 25 16:41:57 CST 2019
                    王五=160
                    张三=175
                    李四=180
        fw.close();

        //b.txt使用字节流在存取
        FileOutputStream fos = new FileOutputStream("D:\\JAVA\\b.txt");
        properties.store(fos,"save data");
        			结果：
                    #save data
                    #Mon Nov 25 16:43:07 CST 2019
                    \u738B\u4E94=160
                    \u5F20\u4E09=175
                    \u674E\u56DB=180
        fos.close();
    }
}
//一个能写中文，一个不能写中文
Load

将指定文件的键值对读取出来

注意：

  1. 存储键值对的文件中，键与值默认的连接符号可以使用=，空格
  2. 存储键值对的文件中，可以使用#进行注释，被注释过后的键值对，不会再被读取
  3. 存储键值对的文件中，键与值默认都是字符串，不用再加引号

  • void load(InputStream inStream) 从输入流中读取属性列表（键和元素对）。

  • void load(Reader reader) 按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。

    InputStream字节输入流，不能使用中文，Reader可以使用中文

参数中使用了字节输入流，通过流对象，可以关联到某文件上，这样就能够加载文本中的数据了。文本数据格式:

filename=a.txt
length=209385038
location=D:\a.txt

加载代码演示：

public class ProDemo2 {
    public static void main(String[] args) throws FileNotFoundException {
        // 创建属性集对象
        Properties pro = new Properties();
        // 加载文本中信息到属性集
        pro.load(new FileInputStream("read.txt"));
        // 遍历集合并打印
        Set<String> strings = pro.stringPropertyNames();
        for (String key : strings ) {
          	System.out.println(key+" -- "+pro.getProperty(key));
        }
     }
}
输出结果：
filename -- a.txt
length -- 209385038
location -- D:\a.txt
=============================================================
package Demo10;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;

public class DemoLoad {
    public static void main(String[] args) throws IOException {
        Properties prop = new Properties();
        //b.txt是字节流存储的，所以只能用字节流读取
        FileInputStream fis = new FileInputStream("D:\\JAVA\\b.txt");

        prop.load(fis);
        Set<String> set = prop.stringPropertyNames();

        for (String i : set){
            System.out.println(i+":"+prop.getProperty(i));
        }

    }
}

小贴士：文本中的数据，必须是键值对形式，可以使用空格、等号、冒号等符号分隔。

java中字节流的分类都有哪些_Java------字节流和字符流（I）
weixin_29649815的博客
02-16 2263
字节流：读写字节文件，通常使用字节流，如：二进制文件，.jpg,.mp3,.avi,.exe,.com,.dllwindows平台的执行文件：.exe,.com,.dll字符流：读写字符文件，通常使用字符流，如：.txt,.java,.css,.doc,.html,*.xml字节流可以读写任意文件。字符流不能读写字节文件。字节流的概念传输的数据单位是字节，也意味着字节流能够处理任何一种文件字节流的...
Java-字节流
m0_46761016的博客
05-25 2985
1、IO流概述和分类 IO流概述： IO：输入/输出(Input/Output) 流：是一种抽象概念，对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输 IO流就是用来处理设备间数据传输问题的 常见的应用：文件复制；文件上传；文件下载 IO流分类： 按照数据的流向 输入流：读数据 输出流：写数据 按照数据类型来分 字节流：字节输入流；字节输出流 字符流：字符输入流；字符输出流 一般来说，IO流的分类是按照数据类型来分的 字节流和字符流使用： 如果
byte api java_java-API之字节流的读取与写入
weixin_32412839的博客
02-12 321
字节流的读取与写入字节流的读取InputStreamInputStream类是抽象类，是表示字节输入流的所有类的超类。public abstract class InputStream{} // InputStream类是抽象类public class FileInputStream extends InputStream{} // InputStream类是FileInputStreamext...
详解java字符流和字节流_IO 字节流与字符流相关的几个常规笔试题解析
weixin_39994270的博客
02-25 131
问：字节流与字符流有什么区别？答：计算机中的一切最终都是以二进制字节形式存在的，对于我们经常操作的字符串，在写入时其实都是先得到了其对应的字节，然后将字节写入到输出流，在读取时其实都是先读到的是字节，然后将字节直接使用或者转换为字符给我们使用。由于对于字节和字符两种操作的需求比较广泛，所以 Java 专门提供了字符流与字节流相关IO类。对于程序运行的底层设备来说永远都只接受字节数据，所以当我们往设...
字节流，字符流（java）
heromps的博客
07-19 367
IO概述 生活中，肯定经历过这样的场景：当编辑一个文本文件，忘记了ctrl+S，可能文件就白白编辑了。当电脑上插入一个U盘，把一个视频，拷贝到电脑硬盘中，数据是在哪存储呢？键盘，内存，硬盘，外接设备等等。 对于这种数据的传输，可以看作是一种数据的流动，按照流动的方向，以内存为基准，分为input和输出output，即流向内存的是数入流，流出内存的是输出流。 java中I/O操作捉妖是指用java.io包下的内容，进行输入输出操作。输入也叫读取数据，输出也叫做写出数据。 IO的分类 根据数据的流向分为：数入流
字节流、字符流
huangyh技术栈
08-09 453
1.1 IO概述： 学习IO流的目的： 实现数据的持久化。 什么是IO： Input：输入 Output：输出 输入输出称为IO操作 IO流的作用： 将文件中的数据读取到内存中 将内存中的数据保存到文件中 IO流的分类： 按照数据流向分类：输入流（将文件中的数据读取到内存中）/输出流（将内存中的数据保存到文件中） 按照操作的数据类型进行分类：字节流（以字节为单位读写数据）/字符流（以字...
字符流、字节流、IO读写相关
m0_49397863的博客
07-29 291
今天来复习一下IO的基础知识，2020-7-29，一边学习一边敲代码，说实话效率挺高的。虽然说就是慢了一点点。 IO概述 IO分类 根据数据的流向分为：输入流和输出流。 输入流 ：把数据从其他设备上读取到内存中的流。 输出流 ：把数据从内存 中写出到其他设备上的流。 格局数据的类型分为：字节流和字符流。 字节流 ：以字节为单位，读写数据的流。 字符流 ：以字符为单位，读写数据的流。 根据处理数据的单位： 1字符=2字节、1字节（Bytes）=8位（bit） 字节流：每次读取一个字节，每当传输的资源
详解Java中字符流与字节流的区别
09-02
根据处理的数据单位，Java提供了两种主要类型的流：字符流和字节流。这两种流在处理数据时有显著的区别，尤其是在处理文本数据和二进制数据时。 1. 什么是流 流在Java中是一个抽象概念，它描述了数据如何从一个地方...
java---字节流、字符流
qq_43430343的博客
07-09 182
一、IO 概述： i:input o:output 流：数据（分为字符流和字节流）1个字符=2个字节 1个字节=8个二进制位 IO的分类 分为输入流和输出流，输入和输出是相对于内存来说的 IO的流向说明 顶级父类 输入流 输出流 字节流 字节输入流InputStream 字节输出流OutputStream 字符流 字符输入流Reader 字符输出流Writer 二 、字节流 字节输出流【OutputStream】 java.io.OutputStream抽象类是表示字节
理解Java中字符流与字节流的区别
12-22
1. 什么是流 ...Java中基本的两个字节流类是InputStream和OutputStream，它们分别代表了组基本的输入字节流和输出字节流。InputStream类与OutputStream类均为抽象类，我们在实际使用中通常使用Java类库中提
关于字符流和字节流
anqini的专栏
04-27 800
字符流，顾名思义，是面向字符的。Java类库根据不同平台、不同编码做了相应处理，使得对于流的使用者来说，比特层是透明的，可以不关心具体传输的是什么比特（即字节）。 字节流，就是直接使用流中的比特（即字节），类只保证正确传输字节，不保证字节的具体含义，字节的具体含义是用户之间约定的。 因为字节是组成数据的最小单位，所以，字节流可以承载任何形式的数据，包括字符。 Java类库提供了一系列经过滤的字节流
java中的io流——字节流
余温0218的博客
12-23 249
io流概述 Java中对数据的操作都是通过流的方式。 Java的IO流是实现输入/输出的基础，它可以方便地实现数据的输入/输出操作。 Java用于操作流的类都在io包中。 流的分类 流按照处理数据类型的单位的不同可以分为字节流和字符流。 流按照流向数据流向的不同可以分为输入流和输出流。 字节流：FileInputStream和FileOutputStream是java中可以按照最小字节单位读...
java IO流之字节流
qq_41587409的博客
04-07 1307
1 IO流相关概念 1.1 什么是IO流？ IO流用来处理设备之间的数据传输 Java对数据的操作是通过流的方式 Java用于操作流的类都在IO包中 1.2 IO流分类 按流向来分 输入流InpuStream Reader（读取数据） 输出流OutStream Writer（写数据） 按操作类型分 字节流 : 字节流可以操作任何数据,因为在计算机中任何数据都是以字节的形式存储的 字符流 : 字...
字符流与字节流
suyi的博客
06-10 423
字符流与字节流 什么是流 流是一个抽象概念，是对输入输出设备的抽象，输入流可以看作一个输入管道，输出流可以看作一个输出管道。 输入流是相对于程序而言的，从硬盘上传递数据给程序需要借助输入流 输出流也是相对于程序而言的，程序需要把数据传递给硬盘需要借助输出流 程序硬盘 什么是字节流 字节流是指传输过程中，传输数据的基本单位是字节的流。 众所周知，一个字节是8bit，故输出的字节流必须指定编码方式才能正确显现信息。 字节流的结构体系 字节流输入字节流输出字节流InputStreamFile
Java文本数据IO操作-字符流）
学海无涯
07-31 407
文本数据IO操作 流的拓展：字符流 java将流按照读写单位划分为字节流和字符流 我们前面学的文件流、缓冲流、对象流 字符流是为了方便我们读写文本 字符流介绍： java.io.Reader java.io.Writer 上述两个类是所以字符流的超类，规定了所有字符流都必须具备的读写字符的相关方法 字符流是以字符（char）为单位读写数据的 一次处理一个unicode 字符流的底层仍然是基本的字节...
java-字节流/字符流
lyxnb_的博客
01-25 121
今天主要总结一下字节流和字符流的用法以及特点，建议大家记忆常见的父类中的方法 记忆具体的实现子类对应的操作。 流模型字节流InputStreamOutputStream字符流Reader字符输入流Writer字符输出流文件节点流内存数组节点总结 主要目的：屏蔽具体实现的区别,使用统一的方法进行编程 输入和输出 字节和字符 节点和过滤 装饰模式 BIO NIO AIO 字节流 父类InputStream和OutputStream 一次一字节的操作方式，一般用于声音、图像、视频之类的二进制文件 In.
java 字节流和字符流的区别详解
08-25
Java 字节流和字符流的区别详解 Java 中的字节流和字符流是两种不同的输入 / 输出流，它们之间的区别是非常重要的。在本文中，我们将详细介绍 Java 中的字节流和字符流的区别，并通过示例代码来演示它们的使用。 ...
字节流与字符流的使用
martinmateng的博客
03-11 480
字节流的两个基类是 inputstram outputstream 字符流的两个基类是 reader writer 当操作文件时使用字符流。当操作其他时使用字节流 因为字符流只能传输字符或者字符串，而字节流可以处理任何的对象，包括二进制对象。
java文件之输入输出流
rim32的博客
05-21 403
字节流：     输入流： extends InputStream         FileInputStream 字节输入流         BufferedInputStream 缓冲输入流         ObjectInputStream 对象输入流     输出流： extends OutputStream         FileOutputStre
java_字节流、字符流、Properties的使用
Itmei的博客
09-08 397
生活中，你肯定经历过这样的场景。当你编辑一个文本文件，忘记了ctrl+s，可能文件就白白编辑了。当你电脑上插入一个U盘，可以把一个视频，拷贝到你的电脑硬盘里。那么数据都是在哪些设备上的呢？键盘、内存、硬盘、外接设备等等。我们把这种数据的传输，可以看做是一种数据的流动，按照流动的方向，以内存为基准，分为输入input和输出output，即流向内存是输入流，流出内存的输出流。Java中I/O操作主要是指使用java.io包下的内容，进行输入、输出操作。输入也叫做读取数据，输出也叫做作写出数据。继承于。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值