【Java学习笔记】字节流、字符流

最新推荐文章于 2022-07-26 22:26:13 发布
原创 最新推荐文章于 2022-07-26 22:26:13 发布 · 253 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文深入讲解Java中的IO流概念，包括字节流、字符流的分类、流向及顶级父类，详细介绍了FileOutputStream、FileInputStream、FileWriter和FileReader的使用方法，探讨了流操作中的异常处理，并展示了Properties类的应用。

【字节流、字符流】

文章目录

第一章 IO概述

1.1 什么是IO

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

Java中I/O操作主要是指使用java.io包下的内容，进行输入、输出操作。输入也叫做读取数据，输出也叫做作写出数据。

1.2 IO的分类

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

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

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

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

1.3 IO的流向说明图解

[外链图片转存失败(img-6Wn9xwRh-1567680679155)(img/1_io.jpg)]

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类

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

java.io.FileOutputStream类是文件输出流，用于把内存中的数据写入到硬盘的文件中。

构造方法

  • public FileOutputStream(File file)：创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
  • public FileOutputStream(String name)：创建一个向具有指定名称的文件中写入数据的输出文件流。

参数: 写入数据的目的地
String name: 目的地是一个文件的路径
File file: 目的地是一个文件

构造方法的作用:

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

写入数据的原理(内存–>硬盘)
   java程序–>JVM(java虚拟机)–>OS(操作系统)–>OS调用写数据的方法–>把数据写入到文件中

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

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

写出字节数据

  1. 写出字节：write(int b) 方法，每次可以写出一个字节数据，代码使用演示：
public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 1、创建一个FileOutputStream类对象  构造参数写要写出的目的地
        FileOutputStream fos = new FileOutputStream("D:\JAVA\IdeaProject\basic-code\09-code\09_IOAndProperties\lalala.txt");     
      	// 2、调用FileOutputStream对象中的方法write,把数据写入到文件中
        // public abstract void write(int b) ：将指定的字节输出流。
      	fos.write(97); // 写出第1个字节
      	fos.write(98); // 写出第2个字节
      	fos.write(99); // 写出第3个字节
      	// 关闭资源(流使用会占用一定的内存,使用完毕要把内存清空,提供程序的效率)
        fos.close();
    }
}
输出结果：
abc

小贴士：

  1. 虽然参数为int类型四个字节，但是只会保留一个字节的信息写出。
  2. 流操作完毕后，必须释放系统资源，调用close方法，千万记得。
  1. 写出字节数组：write(byte[] b)，每次可以写出数组中的数据，代码使用演示：
public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");     
      	// 字符串转换为字节数组
      	byte[] b = "黑马程序员".getBytes();
      	// 写出字节数组数据
      	fos.write(b);
      	// 关闭资源
        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

注：一次写多个字节:

如果写的第一个字节是正数(0-127),那么显示的时候会查询ASCII表
如果写的第一个字节是负数,那第一个字节会和第二个字节,两个字节组成一个中文显示,查询系统默认码表(GBK)

数据追加续写

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

  • FileOutputStream(File file, boolean append)：创建一个向具有指定 name 的文件中写入数据的输出文件流。
  • FileOutputStream(String name, boolean append)： 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。

这两个构造方法，参数中都需要传入一个boolean类型的值，true 表示追加数据，false 表示清空原有数据。这样创建的输出流对象，就可以指定是否追加续写了。

  • 系统中的换行：
    • Windows系统里，每行结尾是 回车+换行 ，即\r\n；
    • Unix系统里，每行结尾只有 换行 ，即\n；
    • Mac系统里，每行结尾是 回车 ，即\r。从 Mac OS X开始与Linux统一。

代码使用演示：

public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("D:\\JAVA\\IdeaProject\\basic-code\\09-code\\09_IOAndProperties\\lalala.txt",true);
        for (int i = 1; i <=10 ; i++) {
            fos.write("你好".getBytes());
            fos.write("\r\n".getBytes());
        }

        fos.close();
    }
文件操作前：aab
文件操作后：
aab你好
你好
你好
你好
你好
你好
你好
你好
你好
你好

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(String name)：

参数: 读取文件的数据源
  String name:文件的路径
  File file:文件
构造方法的作用:
1.会创建一个FileInputStream对象
2.会把FileInputStream对象指定构造方法中要读取的文件

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

读取数据的原理(硬盘–>内存)
  java程序–>JVM–>OS–>OS读取数据的方法–>读取文件

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

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

读取字节数据

  1. 读取字节：read方法，每次可以读取一个字节的数据，提升为int类型，读取到文件末尾，返回-1，代码使用演示：
public static void main(String[] args) throws IOException {
        // 1、创建一个FileInputStream类的对象，构造参数写硬盘中文件的地址
        FileInputStream fis = new FileInputStream("D:\\JAVA\\IdeaProject\\basic-code\\09-code\\09_IOAndProperties\\lalala.txt");  // abc
        //2.使用FileInputStream对象中的方法read,读取文件
        //int read()读取文件中的一个字节并返回,读取到文件的末尾返回-1
        int len = 0;
        while((read = fis.read())!=-1){

            System.out.println(len);
        }
        fis.close();
    }
输出结果：
97
97
98
  1. 使用字节数组读取：read(byte[] b)，每次读取字节数组b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回-1 ，代码使用演示：
public static void main(String[] args) throws IOException {
        // 1、创建一个FileInputStream类的对象，构造参数写硬盘中文件的地址
        FileInputStream fis = new FileInputStream("D:\\JAVA\\IdeaProject\\basic-code\\09-code\\09_IOAndProperties\\lalala.txt");    // 文件内部：abcde
        // 2、调用FileInputStream对象中的方法read读取文件
        //int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
        byte[] b = new byte[2];
        int read = fis.read(b);

        System.out.println(read);    //打印得到 2 ：读取的有效字节个数是2个
		//System.out.println(b); // 打印b得到的是地址：[B@4554617c
        System.out.println(Arrays.toString(b));    //[97, 98]

		while ((read = fis.read(b))!=-1){
            System.out.println(Arrays.toString(b));  
        }        

        fis.close();
    }


		byte[] b1 = new byte[2];
        int read1 = fis.read(b1,0,2);
        System.out.println(read1);  //2
        System.out.println(Arrays.toString(b1)); //[97, 98]

字节流读取文件的原理
在这里插入图片描述

2.6 字节流练习：图片复制```java

文件复制练习:一读一写

明确:
    数据源: D:\JAVA\IdeaProject\basic-code\09-code\09_IOAndProperties\\timg (2).jpg
    数据的目的地: C:\CloudMusic\\timg (2).jpg

文件复制的步骤:
    1.创建一个字节输入流对象,构造方法中绑定要读取的数据源
    2.创建一个字节输出流对象,构造方法中绑定要写入的目的地
    3.使用字节输入流对象中的方法read读取文件
    4.使用字节输出流中的方法write,把读取到的字节写入到目的地的文件中
    5.释放资源

public static void main(String[] args) throws IOException {
        // 1、创建一个文件输入流对象,构造方法中绑定要读取的数据源
        FileInputStream fis = new FileInputStream("D:\\JAVA\\IdeaProject\\basic-code\\09-code\\09_IOAndProperties\\\\timg (2).jpg");
        // 2、创建一个文件输出流,构造方法中绑定要写入的目的地
        FileOutputStream fos = new FileOutputStream("C:\\CloudMusic\\\\timg (2).jpg");
        // 3、使用字节输入流对象中的方法read读取文件

        /*// 一个一个字节来
        int len = 0;
        while ((len=fis.read())!=-1){
            fos.write(len);
        }*/

        // 使用数组缓冲读取多个字节,写入多个字节
        byte [] b = 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)+"毫秒");
    }

第三章 字符流

当使用字节流读取文本文件时，可能会有一个小问题。就是遇到中文字符时，可能不会显示完整的字符，那是因为一个中文字符可能占用多个字节存储。所以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文件字符输入流
作用:把硬盘文件中的数据以字符的方式读取到内存中

构造方法

  • FileReader(File file)： 创建一个新的 FileReader ，给定要读取的File对象。
  • FileReader(String fileName)： 创建一个新的 FileReader ，给定要读取的文件的名称。
    参数: 读取文件的数据源
    String fileName:文件的路径
    File file:一个文件
    FileReader构造方法的作用:
    1.创建一个FileReader对象
    2.会把FileReader对象指向要读取的文件
    当你创建一个流对象时，必须传入一个文件路径。类似于FileInputStream 。

字符输入流的使用步骤:

  1. 创建FileReader对象,构造方法中绑定要读取的数据源
  2. 使用FileReader对象中的方法read读取文件
  3. 释放资源
  • 构造举例，代码如下：
public static void main(String[] args) throws IOException {
        // 1.创建FileReader对象,构造方法中绑定要读取的数据源
        FileReader fr = new FileReader("D:\\JAVA\\IdeaProject\\basic-code\\09-code\\09_IOAndProperties\\c.txt");  //abc你好123###

        //2.使用FileReader对象中的方法read读取文件
        //int read() 读取单个字符并返回。
        /*int read = fr.read();
        System.out.println(read);   // 97*/
        //一直读
        int len = 0;
        while ((len=fr.read())!=-1){
            System.out.println((char)len);
        }
         fr.close();
  }
 结果：
a
b
c
你
好
1
2
3
#
#
#

		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));
        }

读取字符数据

  1. 读取字符：read方法，每次可以读取一个字符的数据，提升为int类型，读取到文件末尾，返回-1，循环读取，代码使用演示：
    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。

  • 构造举例，代码如下：
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:先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。

代码使用演示：

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对象。

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

与流相关的方法

  • public void load(InputStream inStream)： 从字节输入流中读取键值对。

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

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

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

Java io字节流总结
weixin_57614141的博客
01-10 394
创建文件夹：如果文件夹存在显示名称、路径、相对路径否则直接创建 // String pathName ="D:\\text.txt"; // 找到D:\text.txt的文本文件，如果存在，则输出相关文件属性 // 如果不存在，则创建该位置的文件 // String pathName = "D:" + File.separator + "text.txt"; String pathName = "abc" + File.sep...
1、字节流详解
shiyu_951的博客
07-26 6910
Java IO 字节流详解
【Java】I/O流之字节流
weixin_53972936的博客
03-16 1319
电脑中存储的文件都是以二进制以字节为单位的形式保存，在传输时也是按字节传输。所以说，字节流可以读取以及传输任意格式的文件数据。
字节流和处理流
weixin_46065214的博客
04-18 599
基本介绍 1.节点流可以从一个特定的数据源读写数据，；如FileReader 、FileWriter 2.处理流(也叫包装流)是“连接”已存在的流(节点流或处理流)之上，为程序提供更为强大的读写功能，如BufferedReader,BufferWriter 3.数据源：存放数据的地方 4.BufferReader类中，有属性Reader,既可以封装一个节点流，该节点流可以是任意的，只要是Reader子类即可 处理流设计模式 节点流和处理流的区别和联系 1.节点流是底层流/低级流，直接跟数据源相
字节流介绍
m0_54356563的博客
05-17 836
一、字节流顶层的抽象 InputStream和OutputStream专门用来操作字节流，但这两个是抽象基类，不能用来实例化对象，FileInputStream extends InputStream并且FileOutPutStream extends OutputStream,所以我们用FileInputStream和FileOutputStream来实例化对象。 二、核心方法介绍 <一>InputStream下的方法 1.int read();//每次读取一个字节...
Java学习笔记-字节流、字符流
cyh0503的博客
07-09 2406
字节流、字符流 主要内容 IO流 字节流 字符流 异常处理 Properties 第一章 IO概述 1.1 什么是IO 生活中，你肯定经历过这样的场景。当你编辑一个文本文件，忘记了ctrl+s ，可能文件就白白编辑了。当你电脑上插入一个U盘，可以把一个视频，拷贝到你的电脑硬盘里。那么数据都是在哪些设备上的呢？键盘、内存、硬盘、外接设备等等。 我们把这种数据的传输，可以看做是一种数据的流动，按照...
Java学习笔记——字节流与字符流
weixin_44336181的博客
08-24 263
流的基本概念 Java中，File类只能够操作文件本身，而不能够操作文件的内容，在实际开发中IO操作的核心意义在于：输入和输出操作。 输入与输出： 对于服务器或者客户端而言，输入与输出操作实质上传递的就是一种数据流的处理形式。所谓的数据流指的就是字节数据。 对于这种流的处理形式在java.io包里面提供有两类支持： 字节处理流：OutputStream(输出字节流)、InputStream(输入字节流); 字符处理流：Writer（输出字符流）、Reader（输入字符流）。 所有的流操作都应该采用如下
java个人学习笔记字节流、字符流
WW8797456的博客
01-10 183
字节流、字符流 java.io.OutputStream:字节输出流 此抽象类是表示输出字节流的所有类的超类 定义了一些子类共性的成员方法： close() :关闭此输出流并释放与此流有关的所有系统资源。 flush() :刷新此输出流并强制写出所有缓冲的输出字节。 write(byte[] b) :将 b.length 个字节从指定的 byte 数组写入此输出流。 write(byte[] b, int off, int len) :将指定 byte 数组中从偏移量 off 开始的 len 个字节
java学习笔记 day14 字节流、字符流
KKT
11-15 155
java学习笔记 day14 字节流、字符流1. 缓冲字节流2.转换流-中文处理2.1 编码表概述和常见编码表2.2 转换流3 便捷类4. 字符缓冲区流 1. 缓冲字节流 字符缓冲区流： BufferedWriter： 将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。 可以指定缓冲区的大小，或者接受默认的大小。在大多数情况下，默认值就足够大了。 构造方法： BufferedWriter(Writer out) BufferedReader： 从字符输入流中读取文本，
Java文件上传下载删除文件输入输出流IO
赵广陆
08-02 1169
目录 1 IO流概述和分类【理解】 2字节流写数据【应用】 3字节流写数据的三种方式【应用】 4字节流写数据的两个小问题【应用】 5字节流写数据加异常处理【应用】 6字节流读数据(一次读一个字节数据)【应用】 7字节流复制文本文件【应用】 8字节流读数据(一次读一个字节数组数据)【应用】 9字节流复制图片【应用】 1 IO流概述和分类【理解】 IO流介绍 IO：输入/输出(Input/Output) 流：是一种抽象概念，是对数据传输的总称。也就是说数据在设备间...
文件字节流
wszyb的博客
07-29 748
FileInputStream通过字节的方式读取文件，适合读取所有类型的文件(图像、视频、文本文件等)。Java也提供了FileReader专门读取文本文件。 FileOutputStream 通过字节的方式写数据到文件中，适合所有类型的文件。Java也提供了FileWriter专门写入文本文件。 【示例】将文件内容读取到程序中 public class IoTes...
字节流
懒虫翻身的博客
05-08 1633
字节流 字节流的抽象基类： InputStream--读取，OutPutSteam--写入 注：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀 字节流与字符流区别： 【1】字符流的编码表是默认的，而字节流可以自定义 【2】读取字符流需要刷新数据，因为中文字符是由两个字节组成，在读取时需要临时存储，等读完两个字节再对比编码表。 【3】字节流如果没有使用具体的缓冲区，是直接进...
java基础学习心得——字节流读取文章的3种方法
u013867428的专栏
05-28 729
public static void readFile()throws IOException { FileInputStream fis = new FileInputStream ("fos.txt"); int ch; while((ch = fis.read())!=-1) { System.out.println((char)ch); } fis.close(); }
【学习笔记】字符流，字节流
Viking的专栏
09-03 612
字符流 FileReader fr = new FileReader(new File(path)); BufferedReader br = new BufferedReader(fr); String temp = ""; String article = ""; while ((temp = br.readLine()) != null) { article =
关于java文件读写、字节流、字符流的一点心得
hhitom的博客
03-07 9363
转载]转:关于java文件读写、字节流、字符流的一点心得 一.转载网址:http://my.oschina.net/u/232879/blog/155440 关于编码方式我们不讲，有兴趣自己去看，这里大概提一下。 UTF-16采用等幅编码，即每个字符占2个字节。优点：简单；缺点：西文会膨胀到200%，冗余！而且字与字之间的疆界不好找，容易划分错误，没有考虑好前缀问题。这一点huffm
关于Java中的IO流：字符流与字节流的转换
Cool__Wu的博客
11-07 743
字符流与字节流的转换 Java只提供了将字节流转为字符流的方法，并没有字符流转为字节流的方法。 因为字节流是一个通用的流，可以传输各种类型的资源，比如：文本、图片、音频等… 而字符流是一个特殊的流，只能传输文本类型的资源，但是它比字节流传输文本的方式更加方便、快捷。 所以，有些场景需要将字节流转为更加方便快捷的字符流来处理；但没有场景需要将字符流转为字节流，这个很好理解，如果是文本类型，字符流更高效，不需要转为字节流，如果是其它类型，字符流根本就用不了，也不存在转换一说。 将字节流转换成字符流，可以使用
java IO流 字节流 字符流
hello
04-23 210
尽管字节流也能有办法决绝乱码问题，但是还是比较麻烦，于是java就有了字符流，字符为单位读写数据，字符流专门用于处理文本文件。如果处理纯文本的数据优先考虑字符流，其他情况就只能用字节流了（图片、视频、等等只文本例外）。 从另一角度来说：字符流 = 字节流 + 编码表 来自：https://blog.csdn.net/qq_44543508/article/details/102...
Java中的字节流
qq_41571224的博客
03-10 4454
字节流2.1 IO流概述和分类按数据流向:输入流，输出流按数据类型：字节输入流/输出流，字符输入流/输出流 2.1 IO流概述和分类 ##IO流概述： IO：输入/输出（input/ouput） 流：是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输 IO流就是用来处理设备间数据传输问题的 常见的应用：文件复制，文件上传，文件下载 按数据流向:输入流，输出流 输入流为读数据，输出流为写数据 按数据类型：字节输入流/输出流，字符输入流/输出流 一般来说是按数据类型来分的。
java常用字节流总结
五彩世界的博客
12-21 8625
前言： 流的浅显总结（总结了常用的流的操作和一些关键点）： 之前我对流的概念理解很片面，认为所谓输入输出流，都是面对程序和文件的概念 但是，我发现其实比较片面，而且疏漏点很多，其实也有程序和非本程序范围内的内存之间，最终不是都结束于文件和外存，在对已经加载到了内存中的数据的读和写也占了很大的一部分。 如若不全，更多详细方法：请查找JDK文档。 首先请参考于： 什么是native m
java流总结（1） 字节流
好好学习，天天向上！
04-20 602
1、关于流的理论知识     在学习java的过程中，不可避免的会遇到各种流，各种Stream，开始的时候用的很烦，但是细细的总结之后其实也挺简单的。     1.1 什么是流？         按我自己的理解，这个流是一种工具，是程序和数据源之间进行数据交换的工具，但是这个流是单向的，也就是说只能存在程序向         数据源的流或者数据源向程序的流，而且这个流是不面向连接的。  
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值