Java语言的字节流、字符流

最新推荐文章于 2024-04-30 09:30:00 发布
最新推荐文章于 2024-04-30 09:30:00 发布
阅读量231 收藏
点赞数
分类专栏： Java语言进阶 笔记 文章标签： java stream
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Williams10/article/details/108920967
版权

IO

在这里插入图片描述

字节流

2.1字节输出流【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) ：将指定的字节输出流。

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

2.3FileOutputStream类

java.io.FileOutputStream extends OutputStream
FileOutputStream:文件字节输出流
作用:把内存中的数据写入到硬盘的文件中

构造方法:

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

  • 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 Demo01OutputStream {
    public static void main(String[] args) throws IOException {
        //1.创建一个FileOutputStream对象，构造方法中传递写入数据的目的地
        FileOutputStream fos = new FileOutputStream("day09\\a.txt");
        //2.调用FileOutputStream对象中的方法write，把数据写入到文件中
        //public abstract void write(int b):将指定的字节输出流
        fos.write(98);
        //3.释放资源（六使用会占用一定的 内存，使用完毕要把内存清空，提高程序的效率）
        //fos.close();
    }
}

写出字节数据

一次写多个字节的方法:

  • public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。
  • public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
    在这里插入图片描述
 
import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.reflect.Array;
import java.util.Arrays;

 public class Demo02OutputStream {
    public static void main(String[] args) throws IOException {
        //创建FileOutputStream对象，构造方法中绑定要写入数据的目的地
        FileOutputStream fos = new FileOutputStream("day09\\b.txt");
        //调用FileOutputStream对象中的方法write，把数据写入到文件中
        //在文件中显示100，写个字节
        fos.write(49);
        fos.write(48);
        fos.write(48);

         /*
            public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。
            一次写多个字节:
                如果写的第一个字节是正数(0-127),那么显示的时候会查询ASCII表
                如果写的第一个字节是负数,那第一个字节会和第二个字节,两个字节组成一个中文显示,查询系统默认码表(GBK)
         */
         byte[] bytes = {65,66,67,68,69};
         //byte[] bytes = {-65,-66,-67,68,69};
        fos.write(bytes);

        /*
            public void write(byte[] b, int off, int len) ：把字节数组的一部分写入到文件中
                int off:数组的开始索引
                int len:写几个字节
         */
        byte[] bytes2 = "您好".getBytes();
        System.out.println(Arrays.toString(bytes2));
        fos.write(bytes2);

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

数据追加续写

追加写/续写:使用两个参数的构造方法
FileOutputStream(String name, boolean append)创建一个向具有指定 name 的文件中写入数据的输出文件流。
FileOutputStream(File file, boolean append) 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
参数:

  • String name,File file:写入数据的目的地
  • boolean append:追加写开关
  • true:创建对象不会覆盖源文件,继续在文件的末尾追加写数据
  • false:创建一个新文件,覆盖源文件
  • 写换行:写换行符号
    windows:\r\n
    linux:/n
    mac:/r
public class Demo03OutputStream {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("day09\\c.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抽象类是表示字节输入流的所有类的超类，可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。

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

2.5 FileInputStream类

java.io.InputStream:字节输入流
（ 此抽象类是表示字节输入流的所有类的超类。）

定义了所有子类共性的方法:

  • int read()从输入流中读取数据的下一个字节。

  • int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。

  • void close() 关闭此输入流并释放与该流关联的所有系统资源。

    java.io.FileInputStream extends InputStream
    FileInputStream:文件字节输入流
    作用:把硬盘文件中的数据,读取到内存中使用

构造方法:

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

读取字节数据

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

字节输入流的使用步骤(重点):
1.创建FileInputStream对象,构造方法中绑定要读取的数据源
2.使用FileInputStream对象中的方法read,读取文件
3.释放资源

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

public class Demo01InputStream {
    public static void main(String[] args) throws IOException {
        //1.创建FileInputStream对象，构造方法中绑定要读取的数据源
        FileInputStream fis = new FileInputStream("day09\\c.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(len);//abc
        }

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

Tips:

  1. 虽然读取了一个字节，但是会自动提升为int类型。
  2. 流操作完毕后，必须释放系统资源，调用close方法，千万记得。
  3. 使用字节数组读取：read(byte[] b)，每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回-1>

字节输入流一次读取多个字节的方法:
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:转换的字节个数。
    在这里插入图片描述
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Arrays;

public class Demo02InputStream {
    public static void main(String[] args) throws IOException {
        //创建FileInputStream对象，构造方法中绑定要读取的数据源
        FileInputStream fis = new FileInputStream("day09\\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));//0A

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

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

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

         /*
            发现以上读取时一个重复的过程,可以使用循环优化
            不知道文件中有多少字节,所以使用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();
    }
}

2.6字节流练习：图片复制

明确:
数据源: c:\1.jpg
数据的目的地: d:\1.jpg
在这里插入图片描述

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

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

public class Demo01CopyFile {
    public static void main(String[] args) throws IOException {
        long s = System.currentTimeMillis();
        //1.创建一个字节输入流对象，构造方法中绑定要读取的数据源
        FileInputStream fis = new FileInputStream("E:\\empty\\AdvancedJavaLanguage\\day08\\1.jpg");
        //2.创建一个字节输出流对象，构造方法中绑定要写入的目的地
        FileOutputStream fos = new FileOutputStream("E:\\empty\\AdvancedJavaLanguage\\day09\\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)+"毫秒");
    }
}

字符流

3.1字符输入流

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

共性的成员方法:

  • int read() 读取单个字符并返回。
  • int read(char[] cbuf)一次读取多个字符,将字符读入数组。
  • void close() 关闭该流并释放与之关联的所有资源。

3.2FileReader类

java.io.FileReader extends InputStreamReader extends Reader
FileReader:文件字符输入流。
作用:把硬盘文件中的数据以字符的方式读取到内存中。

构造方法:

  • FileReader(String fileName)

  • FileReader(File file)
    参数:读取文件的数据源

  • String fileName:文件的路径

  • File file:一个文件
    FileReader构造方法的作用:
    1.创建一个FileReader对象
    2.会把FileReader对象指向要读取的文件
    字符输入流的使用步骤:
    1.创建FileReader对象,构造方法中绑定要读取的数据源
    2.使用FileReader对象中的方法read读取文件
    3.释放资源
    使用字节流读取中文文件与使用字符流读取中文文件的区别：

  • 使用字节流读取中文文件
    1个中文
    GBK:占用两个字节。
    UTF-8:占用3个字节。

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

public class Demo01InputStream {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("day09\\c.txt");
        int len = 0;
        while ((len = fis.read())!=-1){
            System.out.println((char)len);
        }
        fis.close();
    }
}
  • 字节流复制中文文件
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class Demo02Reader {
    public static void main(String[] args) throws IOException {
        //1.创建FileReader对象,构造方法中绑定要读取的数据源
        FileReader fr = new FileReader("day09\\c.txt");
        //2.使用FileReader对象中的方法read读取文件
        //int read() 读取单个字符并返回。
       /* int len = 0;
        while ((len = fr.read())!=-1){
            System.out.println((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.4FileWriter类

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

    java.io.FileWriter extends OutputStreamWriter extends Writer
    FileWriter:文件字符输出流
    作用:把内存中字符数据写入到文件中.

构造方法:

  • FileWriter(File file)根据给定的 File 对象构造一个 FileWriter 对象。

  • FileWriter(String fileName) 根据给定的文件名构造一个 FileWriter 对象。
    参数:写入数据的目的地
    String fileName:文件的路径。
    File file:是一个文件。
    构造方法的作用:
    1.会创建一个FileWriter对象。
    2.会根据构造方法中传递的文件/文件的路径,创建文件。
    3.会把FileWriter对象指向创建好的文件。

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

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

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

flush方法和close方法的区别

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

public class Demo02CloseAndFlush {
    public static void main(String[] args) throws IOException {
        //1.创建FileWriter对象,构造方法中绑定要写入数据的目的地
        FileWriter fw = new FileWriter("day09\\e.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
    }
}

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

  • 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写的字符个数。
import java.io.FileWriter;
import java.io.IOException;

public class Demo03Writer {
    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("day09\\f.txt");
        char[] cs = {'a','b','c','d','e'};
        //void write(char[] cbuf)写入字符数组
        fw.write(cs,1,3);

        //void write(String str)写入字符串
        fw.write("海绵");

        //void write(String str, int off,int len)写入字符串的某一部分，off字符串的开始索引，len写的字符个数
        fw.write("宝宝",0,2);

        fw.close();
    }
}

续写和换行

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

  • FileWriter(String fileName, boolean append)
  • FileWriter(File file, boolean append)
    参数:
    1.String fileName,File file:写入数据的目的地。
  1. boolean append:续写开关 true:不会创建新的文件覆盖源文件,可以续写; false:创建新的文件覆盖源文件。
  2. 换行:换行符号
    windows:\r\n
    linux:/n
    mac:/r

IO异常的处理

JDK7前处理

在jdk1.7之前使用try catch finally 处理流中的异常
格式:
try{
可能会产出异常的代码
}catch(异常类变量 变量名){
异常的处理逻辑
}finally{
一定会指定的代码
资源释放
}

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

public class Demo01TryCatch {
    public static void main(String[] args) throws IOException {
        //提高变量fw的作用域,让finally可以使用
        //变量在定义的时候,可以没有值,但是使用的时候必须有值
        //fw = new FileWriter("09_IOAndProperties\\g.txt",true); 执行失败,fw没有值,fw.close会报错
        FileWriter fw = null;
        try {
            //可能会产生异常的代码
            fw = new FileWriter("day09\\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是不能调用方法的，会抛出NulllPointerException，需要增加一个判断，不是null再把资源释放
            if (fw!=null){
                try {
                    //fw.close方法声明抛出了IOException异常对象,所以我们就的处理这个异常对象,要么throws,要么try catch
                    fw.close();
                }catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

JDK7的处理

JDK7的新特性
在try的后边可以增加一个(),在括号中可以定义流对象
那么这个流对象的作用域就在try中有效
try中的代码执行完毕,会自动把流对象释放,不用写finally
格式:
try(定义流对象;定义流对象…){
可能会产出异常的代码
}catch(异常类变量 变量名){
异常的处理逻辑
}

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

public class Demo02JDK7 {
    public static void main(String[] args) {
        try {//1.创建一个字节输入流对象,构造方法中绑定要读取的数据源
            FileInputStream fis = new FileInputStream("E:\\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);
        }
    }
}

JDK9的改进

JDK9新特性
try的前边可以定义流对象
在try后边的()中可以直接引入流对象的名称(变量名)
在try代码执行完毕之后,流对象也可以释放掉,不用写finally
格式:
A a = new A();
B b = new B();
try(a,b){
可能会产出异常的代码
}catch(异常类变量 变量名){
异常的处理逻辑
}

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

public class Demo03JDK9 {
    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

    }
}

属性集

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

5.1Properties类

java.util.Properties集合 extends Hashtable<k,v> implements Map<k,v>

  • Properties 类表示了一个持久的属性集。- Properties 可保存在流中或从流中加载。
  • Properties集合是一个唯一和IO流相结合的集合
    1 可以使用Properties集合中的方法store,把集合中的临时数据,持久化写入到硬盘中存储
  1. 可以使用Properties集合中的方法load,把硬盘中保存的文件(键值对),读取到集合中使用

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

构造方法

使用Properties集合存储数据,遍历取出Properties集合中的数据。
Properties集合是一个双列集合,key和value默认都是字符串
Properties集合有一些操作字符串的特有方法

  • Object setProperty(String key, String value) 调用 Hashtable 的方法 put。
  • String getProperty(String key)通过key找到value值,此方法相当于Map集合中的get(key)方法。
  • Set<String> stringPropertyNames()返回此属性列表中的键集，其中该键及其对应值是字符串,此方法相当于Map集合中的keySet方法>。

基本的存储方法

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

  • void store(OutputStream out, String comments)
  • void store(Writer writer, String comments)
    参数:
  • OutputStream out:字节输出流,不能写入中文
  • Writer writer:字符输出流,可以写中文
    -String comments:注释,用来解释说明保存的文件是做什么用的；
    不能使用中文,会产生乱码,默认是Unicode编码；
    一般使用""空字符串。

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

与流相关的方法

可以使用Properties集合中的方法load,把硬盘中保存的文件(键值对),读取到集合中使用。
-void load(InputStream inStream)

  • void load(Reader reader)
    参数:
  • InputStream inStream:字节输入流,不能读取含有中文的键值对。
  • Reader reader:字符输入流,能读取含有中文的键值对。
    使用步骤：
    1.创建Properties集合对象
    2.使用Properties集合对象中的方法load读取保存键值对的文件
    3.遍历Properties集合
    注意:
    1.存储键值对的文件中,键与值默认的连接符号可以使用=,空格(其他符号)。
    2.存储键值对的文件中,可以使用#进行注释,被注释的键值对不会再被读取。
    3.存储键值对的文件中,键与值默认都是字符串,不用再加引号。
import java.io.*;
import java.util.Properties;
import java.util.Set;

public class Demo01Properties {
    public static void main(String[] args) throws IOException {
        show03();
    }

    private static void show03() throws IOException {
        //1.创建Properties集合对象
        Properties prop = new Properties();
        //2.使用Properties集合对象中的方法load读取保存键值对的文件
        prop.load(new FileReader("day09\\prop.txt"));
        //prop.load(new FileInputStream("day09\\prop.txt"));
        //3.遍历Properties集合
        Set<String> set = prop.stringPropertyNames();
        for (String key : set) {
            String value = prop.getProperty(key);
            System.out.println(key+"="+value);
        }
    }
   private static void show02() throws IOException {
        //1.创建Properties集合对象,添加数据
        Properties prop = new Properties();
        prop.setProperty("哈维","170");
        prop.setProperty("伊涅斯塔","175");
        prop.setProperty("布斯克茨","176");

        //2.创建字节输出流/字符输出流对象,构造方法中绑定要输出的目的地
        //FileWriter fw = new FileWriter("day09\\prop.txt");

        //3.使用Properties集合中的方法store,把集合中的临时数据,持久化写入到硬盘中存储
        //prop.store(fw,"save data");

        //4.释放资源
        //fw.close();
    }

private static void show01() {
        //创建Properties集合对象
        Properties prop = new Properties();
        //使用setProperty往集合中添加数据
        prop.setProperty("哈维","170");
        prop.setProperty("伊涅斯塔","175");
        prop.setProperty("布斯克茨","176");
        //prop.put(1,true);

        //使用stringPropertyNames把Properties集合中的键取出，存储到一个Set集合中
        Set<String> set = prop.stringPropertyNames();

        //遍历Set集合，去除Properties集合的每一个键
        for (String key : set) {
            //使用getProperty方法通过key获取value
            String value = prop.getProperty(key);
            System.out.println(key+"="+value);
        }
    }
}
Williams10
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ByteIO_java_字节流_
10-04
在Java编程语言中，字节流（Byte Stream）是I/O操作的基础，它处理的是单个字节的数据。本文将详细解析"ByteIO_java_字节流_"这个主题，主要基于提供的`ByteIO.java`源代码文件，探讨字节流的基本概念、分类、常用类...
python：traceback —— 打印或读取堆栈的跟踪信息
点点关注不迷路
03-13 1625
python：traceback —— 打印或读取堆栈的跟踪信息
Python中的traceback的基本用法（异常处理）
YFater的博客
08-26 7万+
文章目录一.Traceback介绍二.Traceback中的相关函数1.traceback.print_exc 一.Traceback介绍 在日常开发中，我们会做一些基本的异常处理，但是有时候只能打印我们处理的结果或者将异常打印出来，不能直观的知道在哪个文件中的哪一行出错。 def func(num1, num2): try: x = num1 * num2 y = num1 / num2 return x, y except Exceptio
Python使用traceback.print_exc()输出异常信息
hyy
06-23 1915
Python使用traceback.print_exc()输出异常信息
【python异常捕获】traceback.print_exc()打印异常的堆栈跟踪信息
weixin_43941438的博客
04-27 775
时，可以将打印异常的堆栈跟踪信息，包括异常类型、异常消息和代码中引发异常的位置。这样，您就可以看到异常的完整堆栈跟踪，从而更好地理解异常发生的位置和原因。当运行这段代码时，由于尝试除以零会引发异常，函数也可能捕获异常并打印堆栈信息。函数尝试除以零时，会引发。函数捕获了该异常并使用。多个函数调用引发异常时。
python笔记71 - traceback.print_exc()保存异常内容
qq_27371025的博客
11-28 1671
前言 python运行代码出现异常后，会在控制台输出报错内容，那么如何把报错的完整内容保存到日志文件中呢？ try…expect捕获异常 当运行下面的代码 a = ["hello", "yoyo"] print(a[4]) 在控制台会输出异常 Traceback (most recent call last): File "D:/demo/aa.py", line 4, in <module> print(a[4]) IndexError: list index out of ra
Java字符流与字节流区别与用法分析
09-02
Java中的流分为两种类型：字符流（Character Stream）和字节流（Byte Stream），它们都是Java I/O系统的基础。字符流处理的是Unicode字符，而字节流则处理单个字节的数据。 字节流是最基础的流，主要包括...
Java字节与字符流永久存储json数据
10-18
Fastjson是Java语言编写的高性能功能完备的JSON库，它可以方便地将Java对象转换为JSON字符串，反之亦然。 我们定义了一个简单的User类，包含两个属性：userName（名字）和balance（金额），并提供了对应的构造方法...
Java IO 字节流 字符流
04-11
Java IO系统分为两大类：字节流和字符流。字节流主要用于处理任何类型的原始数据，如图片、音频文件或者二进制文件，而字符流则专注于处理基于文本的数据。本文将深入探讨这两类流的原理、用途以及它们之间的关联。 ...
JAVA字符流加密实验代码报告
10-12
1. **Java流的层次结构**：Java流被组织成一个层次结构，包括字节流（InputStream/OutputStream）和字符流（Reader/Writer）。字符流是基于字节流之上，专门用于处理文本数据的流，如文件的读写。 2. **字节流与...
飘逸的python - 使用traceback获取详细的异常信息
mattkang
07-18 10万+
try: 1/0 except Exception,e: print e 输出结果是integer division or modulo by zero，只知道是报了这个错，但是却不知道在哪个文件哪个函数哪一行报的错。 下面使用traceback模块 try: 1/0 except Exception,e: traceback.prin
python 获取异常信息traceback输出到日志txt
野猫炫的博客
04-12 1131
【代码】python 获取异常信息traceback输出日志txt。
Controller 层返回值的公共包装类-避免每次都包装一次返回-InitializingBean增强
热门推荐
hu10131013的博客
09-07 10万+
场景：在微服务中，一般返回数据都会有个返回码、返回信息和返回消息体，但是每次返回时候调用或者是封装，太过麻烦，有没有什么办法不用每次都封装呢？ 答案是有的。 返回值对象 package com.study.auth.comm; import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.annotation.JSONField; import com.alibaba.fastjson.serializer.Serialize..
python traceback print_traceback如何在python中提取程序信息？
weixin_29672983的博客
01-28 283
在我们的程序进行报错后，就要找寻一些处理报错的方法。有一种思路是，我们可以使用traceback来对错误的地方进行跟踪，然后对错误的信息进行整合和传回。这样我们可以利用传回的信息进行错误分析，从而分析问题的所在点。下面小编就为大家详细的带来traceback在python中提取程序信息的方法。traceback模块作用：traceback模块被用来跟踪异常返回信息import traceback ...
Python进阶之-traceback详解
最新发布
Summer的博客
04-30 2646
在日常开发中，我们会做一些基本的异常处理，但是有时候只能打印我们处理的结果或者将异常打印出来，不能直观的知道在哪个文件中的哪一行出错。在Python中，traceback是一个用来跟踪异常错误信息的标准库，常用于异常处理和调试。它可以帮助开发者了解异常发生的上下文，并提供关于异常发生处的调用堆栈的信息。在实际开发中，通过使用traceback模块，可以更清晰地看到错误发生的位置及其前后调用关系，从而帮助快速定位并修复问题。
Python异常处理及错误日志
Mengcccc的博客
07-13 557
1.基本异常处理方式 多层嵌套try catch只能捕获到异常，无法处理，无法溯源 def foo(s): return 10 / int(s) def bar(s): return foo(s)*2 def main(): try: bar('0') except Exception as e: print('Error:',e) finally: print('end') main() Error: divisi
traceback.print_exc()打印到文件
Debug yourself!
11-25 1289
try: pass except Exception as e: trace_file=open(trace_file_path, 'a') print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()),file=trace_file)#记录报错的时间 traceback.print_exc(file=trace_file)#输出报...
Python 输出详细的异常信息（traceback）
GodLordGee的博客
06-03 2万+
问题描述 为了程序的正常运行，进行异常处理是有必要的，甚至于有时候，我们会主动的抛出异常，然后让程序进行异常捕获，再进行进一步的处理。但是，在开发的程序相对较大的过程中，我们不能一昧的进行try....except。而是要弄清楚到底抛出的是什么异常，同时，对于某些未知的异常，我们应该清楚的定位到到底是哪一行程序抛出的异常，针对这种情况，traceback库能极大的帮助我们。 解...
python中使用try exception时，打印完整出错代码追踪
zerfew的博客
03-28 3809
使用python程序时，不使用try exception时，虽然能打印完整的出错代码追踪，但是会发生异常崩溃导致程序卡死；启用try exception后，一般也只能打印异常类型和异常信息，无法直接获取到出错代码行和代码追踪信息，找到的解决办法有这么两个。
Java I/O流详解：字节流、字符流与缓冲流
数据可以是字节或字符，因此又有字节流和字符流之分。 2. **输入流和输出流** - 输入流（InputStream/Reader）负责从数据源读取数据，而输出流（OutputStream/Writer）则负责向数据目标写入数据。Java.io包提供了...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值