java---字节流、字符流

最新推荐文章于 2024-07-14 07:30:00 发布
最新推荐文章于 2024-07-14 07:30:00 发布
阅读量156 收藏
点赞数 1
分类专栏： Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43430343/article/details/118613039
版权

一、IO

概述：

i:input o:output 流：数据（分为字符流和字节流）1个字符=2个字节 1个字节=8个二进制位

IO的分类

分为输入流和输出流，输入和输出是相对于内存来说的

IO的流向说明

image-20210709094209107

顶级父类

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

二 、字节流

字节输出流【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方法，当完成流的操作时，必须调用此方法，释放系统资源。

FileOutputStream类

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

作用:把内存中的数据写入到硬盘的文件中

构造方法

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

参数：写入数据的目的地

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

File file：目的地是一个文件

构造方法的作用：

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

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

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

字节输出流的使用步骤：

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

2、调用FileOutputStream对象中的方法write，把数据写入到文件中

3、释放资源（流使用会占用一定的内存，使用完毕要把内存清空，提高程序的效率）

代码演示：

package com.itheima.demo01.IO;

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

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

2、调用FileOutputStream对象中的方法write，把数据写入到文件中

3、释放资源（流使用会占用一定的内存，使用完毕要把内存清空，提高程序的效率）*/
public class Demo01OutputStream {
    public static void main(String[] args) throws IOException {
        //创建一个FileOutputStream对象，构造方法中传递写入数据的目的地
        //文件可以不存在，因为构造方法会创建
        FileOutputStream fos = new FileOutputStream("C:\\Users\\大 大\\Desktop\\About learn\\java学习\\代码\\IdeaProgrames\\Code\\09_IOAndProperties\\b.txt");//可以是相对路径也可以是绝对路径
        //OutputStream共性方法
        // `public abstract void write(int b)` ：将指定的字节输出流
        fos.write(1234);
        //释放资源（流使用会占用一定的内存，使用完毕要把内存清空，提高程序的效率）
        fos.close();
    }

}

文件存储的原理和记事本打开文件的原理

image-20210709105728019

字节输出流写多个字节的方法

public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。

一次写多个字节：

1、如果写的第一个字节是正数（0-127），那么显示的时候会查询ASCII表

2、如果写的第一个字节是负数，那第一个字节会和第二个字节，两个字节组成一个中文显示，查询系统默认表（GBK）

要写入100，它需要三个字节去写入

fos.write(49);		fos.write(48);	fos.write(48);

总结：
字节输出流写多个字节的方法有三种
前两种就是使用字节输出流中的方法，还有一种是利用String类中的方法，将字符串转换为字符数组，之后再用write方法写入到指定的文件

代码演示：

package com.itheima.demo01.IO;

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

/** `public void write(byte[] b)`：将 b.length字节从指定的字节数组写入此输出流。
 * `public void write(byte[] b, int off, int len)` ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。*/

public class Demo02OutputStream {
    public static void main(String[] args) throws IOException {
        //1、创建一个FileOutputStream对象，构造方法中传递写入数据的目的地
        FileOutputStream fos = new FileOutputStream("C:\\Users\\大 大\\Desktop\\About learn\\java学习\\代码\\IdeaProgrames\\Code\\09_IOAndProperties\\b.txt");
    //2、调用FileOutputStream对象中的方法write，把数据写入到文件中
        //方法一：public void write(byte[] b)`：将 b.length字节从指定的字节数组写入此输出流
        byte[] b={69,66,97,98,67};
        fos.write(b);//EBabC
        byte[] b1={-69,-66,-97,98,67};
        fos.write(b1);//EBabC痪焍C

        //方法二：public void write(byte[] b, int off, int len)` ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
        fos.write(b,1,2);//EBabC痪焍CBa

        //方法三：使用String类中的方法把字符串转换为字符数组
        //byte[]  getBytes()
        byte[] bytes="哈哈".getBytes();
        System.out.println(Arrays.toString(bytes));//[-27, -109, -120, -27, -109, -120]
        //utf-8中一个汉字表示3个字符，gbk中一个汉字表示2个字符
        fos.write(bytes);//EBabC痪焍CBa鍝堝搱



        //3、释放资源（流使用会占用一定的内存，使用完毕要把内存清空，提高程序的效率）*/
        fos.close();
    }
}

字节输出流的续写和换行

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

String name,File file: 写入数据的目的地

boolean append：追加写开关

​ true：创建对象不会覆盖源文件，继续在文件的末尾追加写数据

​ false：创建一个新文件，覆盖原文件

写换行：写换行符号

windows: \r\n

Linux: /n

mac: /r

代码演示：

package com.itheima.demo01.IO;

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

public class Demo03OutputStream {
    public static void main(String[] args) throws IOException {
        //创建一个FileOutputStream对象，构造方法中传递写入数据的目的地
        FileOutputStream fos = new FileOutputStream("C:\\Users\\大 大\\Desktop\\About learn\\java学习\\代码\\IdeaProgrames\\Code\\09_IOAndProperties\\c.txt",true);
        //写数据,实现多次写（不覆盖源文件），并换行
        for (int i = 0; i <5 ; i++) {
            fos.write("haha".getBytes());
            fos.write("\r\n".getBytes());
        }

        //关资源
        fos.close();
    }
}

三、字节输入流【InputStream】

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

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

小贴士：

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

FileInputStream类

java.io.FileInputStream类是文件输入流

作用：把硬盘中的数据，读取到内存中使用

构造方法

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

参数：读取文件的数据源

​ String name：文件的路径 File file：文件

构造方法的作用：

​ 1、会创建一个FileInputStream对象

​ 2、会把FileInputStream对象指定构造方法中要读取得文件

读取数据的原理（硬盘—> 内存）

java---->JVM---->OS------> OS调用读取数据的方法-----> 读取文件

字节输入流的使用步骤：

1、创建FileInputStream对象，构造方法中绑定要读取的数据源

2、使用FileInputStream对象中的方法read，读取文件

3、释放资源

代码演示：

package com.iheima.demo02.IO;


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

public class Demo01InputStream {
    public static void main(String[] args) throws IOException {
        //1.创建对象，并传入要读取的文件
        FileInputStream fis = new FileInputStream("C:\\Users\\大 大\\Desktop\\About learn\\java学习\\代码\\IdeaProgrames\\Code\\09_IOAndProperties\\c.txt");
        //2.进行读操作
        //`public abstract int read()`： 从输入流读取数据的下一个字节。
        //它读到文件末尾会返回-1
        int L=0;
        while ((L=fis.read())!=-1){
            //将它强转为char类型
            System.out.println((char)L);
        }
        
        //3.关闭资源
        fis.close();
    }

}

字节输入流一次读取一个字节的原理

image-20210709142516401

字节输入流一次读取多个字节的方法

public int read(byte[] b)： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 。

明确两件事情：

1、方法的参数byte[ ] 的作用？

​	起到缓冲作用，存储每次读取的多个字节

​	数组的长度一般定义为1024（1kb）或者1024的整数倍

2、方法的返回值int是什么？

​	每次读取的有效字节个数

​

image-20210709145004149

代码演示：

package com.iheima.demo02.IO;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Arrays;

public class Demo02InputStream {
    public static void main(String[] args) throws IOException {
        //创建对象
        FileInputStream fis = new FileInputStream("C:\\Users\\大 大\\Desktop\\About learn\\java学习\\代码\\IdeaProgrames\\Code\\09_IOAndProperties\\c.txt");
        //进行读操作
     /*   byte[] bytes=new byte[3];
        int len = fis.read(bytes);
       *//* String类的构造方法
            String(byte[] bytes):把字节数组转为字符串
            String(byte[] bytes，int offest,int length)把字节数组的一部分转换为字符串
       * *//*
        System.out.println(new String(bytes));//abc
        System.out.println(len);//3
        System.out.println("-------");

        //System.out.println(Arrays.toString(bytes));//[97, 98, 99]

         len = fis.read(bytes);
       *//* String类的构造方法
            String(byte[] bytes):把字节数组转为字符串
            String(byte[] bytes，int offest,int length)把字节数组的一部分转换为字符串
       * *//*
        System.out.println(new String(bytes));//ABC
        System.out.println(len);//3
        System.out.println("-------");

        len = fis.read(bytes);
       *//* String类的构造方法
            String(byte[] bytes):把字节数组转为字符串
            String(byte[] bytes，int offest,int length)把字节数组的一部分转换为字符串
       * *//*
        System.out.println(new String(bytes));//e
        System.out.println(len);//3
        System.out.println("-------");*/

        /*上述代码重复，简化代码*/
        byte[] bytes1=new byte[1024];
        int len1=0;
        while ((len1=fis.read(bytes1))!=-1){
            //为避免浪费空间
            //String(byte[] bytes，int offest,int length)把字节数组的一部分转换为字符串
            System.out.println(new String(bytes1,0,len1));
        }


        //关闭资源
        fis.close();
    }
}

字节流练习：图片复制

image-20210709150533009

代码演示：

package com.itheima.demo03.IO;

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

public class Demo01Copy {
    public static void main(String[] args) throws IOException {
        //创建字节输入流，并给出数据源
        FileInputStream fis = new FileInputStream("C:\\Users\\大 大\\Desktop\\aaa\\1.jpg");
        //创建字节输出流对象，并给出要写入的文件地址
        FileOutputStream fos = new FileOutputStream("C:\\Users\\大 大\\Desktop\\bbb\\1.jpg");
        //进行读写操作
        byte[] b2=new byte[1024];//使用数组缓冲读取多个字节，写入多个字节
        int len=0;//每次读取的有效字节个数
        while((fis.read(b2))!=-1){
            //使用字节输出中的write，把读取到的字节写入到目的地的文件中
            fos.write(b2);


        }

        //关闭资源,先关闭写的，后关闭读的，如果写完了，肯定读取完毕了
        fos.close();
        fis.close();

    }
}

四、字符流

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

字符输入流【Reader】

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

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

FileReader类

java.io.FileReader extends InputStreamReader extends Reader

FileReader:文件字符输入流

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

构造方法

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

参数：读取文件的数据源

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

构造方法的作用：

1、创建一个FileReader对象

2、会把FileReader对象指向要读取的文件

读取字符数据

代码演示：（和读取字节数据方法一样）

package com.itheima.demo04.Reader;

import java.io.FileReader;
import java.io.IOException;
import java.util.Arrays;

public class Demo01Reader {
    public static void main(String[] args) throws IOException {
        //创建字符流对象，并绑定要读取的数据源
        FileReader fr = new FileReader("C:\\Users\\大 大\\Desktop\\About learn\\java学习\\代码\\IdeaProgrames\\Code\\09_IOAndProperties\\b.txt");
        //进行读操作
      /*  int len = 0;
        while ((len=fr.read())!=-1){
            System.out.print((char)len);
        }*/
      //定义一个字符数组，用来存储读取到的多个字符
      char[] b=new char[1024];
      int len=0;//记录的是每次读取的有效字符个数
        while ((len=fr.read(b))!=-1){
            System.out.print(new String(b,0,len));
        }

        //关闭资源
        fr.close();
    }

}

字符输出流【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() 关闭此流，但要先刷新它。

FileWriter类

java.io.FileWriter extends OutputStreamWriter extends Writer

FileWriter：文件字符输出流

作用：把内存中的字符数据写到文件中

构造方法

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

构造方法的作用：

1、会创建一个`FileWriter对象

2、会根据构造方法中传递的文件/文件夹的路径，创建文件

3、会把FileWriter对象指向好的文件

写出单个字符到文件

代码演示：

package com.itheima.demo04.Reader;

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

public class Demo02Reader {
    public static void main(String[] args) throws IOException {
        //创建字符输出流，并绑定要写入的文件地址
        FileWriter fw = new FileWriter("C:\\Users\\大 大\\Desktop\\About learn\\java学习\\代码\\IdeaProgrames\\Code\\09_IOAndProperties\\b.txt");
        //进行写操作
        fw.write(97);
        //关闭资源
        fw.close();
    }
}

【注意】关闭资源时,与FileOutputStream不同。
如果不关闭,数据只是保存到缓冲区，并未保存到文件。

即：未调用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方法，释放系统资源。

写出其他数据

package com.itheima.demo04.Reader;

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

public class Demo02Reader {
    public static void main(String[] args) throws IOException {
        //创建字符输出流，并绑定要写入的文件地址
        FileWriter fw = new FileWriter("C:\\Users\\大 大\\Desktop\\About learn\\java学习\\代码\\IdeaProgrames\\Code\\09_IOAndProperties\\b.txt");
        //进行写操作
        fw.write(97);
        fw.write("好好学习");
        fw.write("好好学习，天天向上",4,5);
        char[] s={'h','a','h','a'};
        fw.write(s);
        //关闭资源
        fw.close();
    }
}

！！！注意：续写就是在创建字符输出流的对象时候加上true

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

写出字符串：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();
    }
}

续写和换行：操作类似于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异常的处理

之前的入门练习，我们一直把异常抛出，而实际开发中并不能这样处理，建议使用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();
            }
        }
    }
}

六、属性集

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

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

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

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

属性列表中每个键及其对应值都是一个字符串，Properties集合是一个双列集合，key和value默认都是字符串

使用Properties集合存储数据,遍历取出Properties集合中的数据
Properties集合是一个双列集合, key和value默认都是字符串

Properties集合有一些操作字符串的特有方法
1、Object setProperty(String key, String value) 调用Hashtable 的方法put。
2、String getProperty(String key)通过key找到value值,此方法相当于Map集合中的get(key)方法
3、Set stringPropertyNames() 返回此属性列表中的键集,其中该键及其对应值是字符串，此方法相当于Map集合中的keySet方法

注意：Properties里面的方法参数都是字符串类型

代码演示Proper的添加数据和遍历

package com.itheima.demo05.Properties;

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

public class Demo01Properties {
    public static void main(String[] args) {
        //创建集合对象
        Properties prop = new Properties();
        //添加一些数据
        prop.setProperty("哈哈","20");
        prop.setProperty("哈哈1","21");
        prop.setProperty("哈哈2","22");
        prop.setProperty("哈哈3","23");
        prop.setProperty("哈哈4","24");
        //将键存到set集合中
        Set<String> set = prop.stringPropertyNames();
        //通过键获得值
        for (String key : set) {
            String value = prop.getProperty(key);
            System.out.println(key+"+"+value);
        }


    }
}

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

void store(OutputStream out,String comments)

void store(Writer writer,String comments)

参数：

OutputStream out：字节输出流，不能写入中文

Writer writer：字符输出流，可以写入中文

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

使用步骤：

1、创建Properties集合对象，添加数据

2、创建字节/字符输出流对象，构造方法中绑定要输出的目的地

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

4、释放资源

package com.itheima.demo05.Properties;

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.Properties;

public class Demo02Properties {
    public static void main(String[] args) {
        //创建Properties集合对象，添加数据
        Properties prop = new Properties();
        prop.setProperty("哈哈","20");
        prop.setProperty("哈哈1","21");
        prop.setProperty("哈哈2","22");
        prop.setProperty("哈哈3","23");
        prop.setProperty("哈哈4","24");
        //创建字节/字符输出流对象，构造方法中绑定要输出的目的地
        FileWriter fw = null;
        try {
            fw = new FileWriter("C:\\Users\\大 大\\Desktop\\About learn\\java学习\\代码\\IdeaProgrames\\Code\\09_IOAndProperties\\c.txt");
            //使用Properties集合中的方法store，把集合中的临时数据，持久化写入到硬盘中存储
            prop.store(fw,"");
            //关闭资源
            fw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }




    }
}

运行结果：image-20210709182724815

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

void Load(InputStream inStream)

void Load(Reader reader)

参数：

InputStream inStream:字节输入流，不能读取含有中文的键值对

Reader reader：字符输入流，能读取含有中文的键值对

使用步骤：

1、创建Properties集合对象

2、使用Properties集合对象中的方法Load读取保存键值对的文件

3、遍历Properties集合

注意：

1、存储键值对的文件中，键与值默认的连接符可以使用=，空格（其他符号）

2、存储键值对的文件中，可以使用#进行注释，被注释的键值对不会再被读取

3、存储键值对的文件中，键与值默认都是字符串，不再加引号

package com.itheima.demo05.Properties;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;

public class Demo03Properties {
    public static void main(String[] args) {
        //1、创建Properties集合对象
        Properties prop = new Properties();
        //2、使用Properties集合对象中的方法Load读取保存键值对的文件
        try {
            prop.load(new FileReader("C:\\Users\\大 大\\Desktop\\About learn\\java学习\\代码\\IdeaProgrames\\Code\\09_IOAndProperties\\c.txt"));
        } catch (IOException e) {
            e.printStackTrace();
        }
        //3遍历Properties集合
        Set<String> set = prop.stringPropertyNames();
        for (String key : set) {
            String value = prop.getProperty(key);
            System.out.println(key+"="+value);
        }
    }
}


package com.itheima.demo05.Properties;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;

public class Demo03Properties {
    public static void main(String[] args) {
        //1、创建Properties集合对象
        Properties prop = new Properties();
        //2、使用Properties集合对象中的方法Load读取保存键值对的文件
        try {
            prop.load(new FileReader("C:\\Users\\大 大\\Desktop\\About learn\\java学习\\代码\\IdeaProgrames\\Code\\09_IOAndProperties\\c.txt"));
        } catch (IOException e) {
            e.printStackTrace();
        }
        //3遍历Properties集合
        Set<String> set = prop.stringPropertyNames();
        for (String key : set) {
            String value = prop.getProperty(key);
            System.out.println(key+"="+value);
        }
    }
}
你好y
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
字节流、字符流
09-09 703
day09【字节流、字符流】 主要内容 IO流 字节流 字符流 异常处理 Properties 教学目标 能够说出IO流的分类和功能 能够使用字节输出流写出数据到文件 能够使用字节输入流读取数据到程序 能够理解读取数据read(byte[])方法的原理 能够...
java-io流学习总结.doc
11-24
Java IO 流学习总结的主要内容是对 Java 语言中 IO 流的机制和应用进行了详细的介绍，包括流的基本概念、字节流和字符流的区别、IO 体系的基本结构、FileReader 和 FileWriter 的使用、IO 流的应用等等。
Java IO 字节流 字符流
04-11
NULL 博文链接：https://xiongjiajia.iteye.com/blog/1683399
Java IO 流：字节流、字符流、接口、实现类与阻塞方法
最新发布
✨ 欢迎来到【Seal ^_^ 的CSDN博客】！这里是我记录技术心得、分享经验的地方。✨
07-14 6441
在 Java 中，IO（Input/Output）流是处理数据输入输出的重要部分。无论是从文件、网络还是其他数据源读取数据，或是将数据写入到这些位置，Java 都提供了丰富的流类库来支持这些操作。下面我们将详细介绍 Java IO 流中的字节流、字符流、常见的接口、实现类以及阻塞方法。
Java的流操作
weixin_34210740的博客
02-13 110
Java的流操作 分为字节流和字符流两种。 1、 字节流 所有的读操作都继承自一个公共超类java.io.InputStream类。 所有的写操作都继承自一个公共超类java.io.OutputStream类。 InputStream和OutputStream都是抽象类。 InputStream有6个低级输入流： 低级流 流的用途 ByteArrayInpu...
java基础：java字节流、字符流。
qq_42777490的博客
05-13 1938
java字节流、InputStream、OutputStream、FileInputStream、FileReader、BufferedReader 、FileOutputStream、FileWriter 、BufferedWriter 、字节流复制文件、字节缓冲流复制文件、BufferedInputStream、BufferedOutputStream、字符流复制文件、InputStreamReader 、OutputStreamWriter
java 字节流和字符流
m0_55680183的博客
05-26 288
java定义了两种类型的输入/输出流：字节流和字符流。 字节流（byte stream）用以处理字节数据的输入、输出； 字符流（character stream）为字符数据的输入和输出提供方便。 字节流有两个重要的抽象类：InputStream和OutputStream，即字节输入流 和字节输出流。 FileInputStream俗称文件输入流，是字节输入流InputStream类的一个子类 //引入相关的类 import java.io.IOException; import java.io.InputS
Java字符流与字节流区别
01-07
Java 流在处理上分为字符流和字节流。字符流处理的单元为 2 个字节的 Unicode 字符，分别操作字符、字符数组或字符串，而字节流处理单元为 1 个字节，操作字节和字节数组。 Java 内用 Unicode 编码存储字符，字符流...
详解Java中字符流与字节流的区别
09-02
根据处理的数据单位，Java提供了两种主要类型的流：字符流和字节流。这两种流在处理数据时有显著的区别，尤其是在处理文本数据和二进制数据时。 1. 什么是流 流在Java中是一个抽象概念，它描述了数据如何从一个地方...
理解Java中字符流与字节流的区别
12-22
1. 什么是流 ...Java中基本的两个字节流类是InputStream和OutputStream，它们分别代表了组基本的输入字节流和输出字节流。InputStream类与OutputStream类均为抽象类，我们在实际使用中通常使用Java类库中提
java 字节流和字符流的区别详解
08-25
Java 字节流和字符流的区别详解 Java 中的字节流和字符流是两种不同的输入 / 输出流，它们之间的区别是非常重要的。在本文中，我们将详细介绍 Java 中的字节流和字符流的区别，并通过示例代码来演示它们的使用。 ...
JAVA--字符流和字节流
m0_65587787的博客
02-24 308
字节流就是万能流，为什么还提出字符流？
Java的字符流和字节流
iteye_517的博客
12-09 76
IO分两种流字节流 InputStream OutputStream字符流 Reader Writer他们都是抽象类具体实现字节流 FileInputStream FileOutputStream字符流 FileReader FileWriter 字符流处理的单元为2个字节的Unicode字符，分别操作字符、字符数组或字符串，而字节流处理单元为1个字节， 操作字节和字节数组。所以字符流是由Java...
JAVA中的字节流和字符流
星空的星星的博客
07-18 874
把数据从其他设备读取到内存中的流把数据从内存写出到其他设备上的流以字节为单位，进行输入和输出的流以字符为单位，进行输入和输出的流。
Java字节流与字符流
十七博客
06-15 341
字节流与字符流字节流与字符流流的概念OutputStream字节输出流InputStream字节输入流Writer字符输出流Reader字符输入流字节流与字符流的区别转换流IO流操作深入字符编码内存操作流管道流RandomAccessFile输入与输出支持打印流System类对IO的支持BufferedReader缓冲输入流Scanner扫描流 字节流与字符流 流的概念 在Java.io包中，File类是唯一一个与文件本身有关的程序处理类，但是File只能操作文件的本身，而不能操作文件的内容。在实际开发中，
Java操作字符流与字节流
仰望星空
03-05 479
前言：这几天在做一些文件的解压加密上传工作，经常用到Java操作字符流与字节流，所以总结一下，本科来自
Java 字节流，字符流
03-31 877
部分转自：http://leonmau.iteye.com/blog/1182712 另外还有一篇文章解释的也比较清楚：http://blog.csdn.net/cynhafa/article/details/6882061  Java 中提供了专用于输入输出功能的包Java.io, 其中包括： InputStream,OutputStream,Reader,Writer l    
Java中的字符流字节流
SunGuoBiao_a的博客
07-22 147
Java中的字符流字节流 (1) java.io.InputStream: 抽象类，输入字节流，可以将本输入流中的字节读取出来。 　　主要方法: void read(byte[] b):从输入流中读取一定数量的字节，将其存储在缓冲区数组b中。 (2) java.io.OutputStream: 抽象类，输出字节流，可以接收待输出的字节并将这些字节发送到某个接收器。 主要方法: void write(byte[] b):接收byte数组中的字节，将byte数组中的字节写入此输出流。 (3) FileInp
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值