IO流 Properties集合

最新推荐文章于 2022-07-15 11:02:53 发布
最新推荐文章于 2022-07-15 11:02:53 发布
阅读量52 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47044513/article/details/120700787
版权

IO流
在这里插入图片描述
字节流：可以读取任意的文件

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

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.释放资源(流使用会占用一定的内存,使用完毕要把内存清空,提供程序的效率)

例：

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

}

原理：
在这里插入图片描述
另外两种方法

/*
    一次写多个字节的方法:
        - 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 {
        //创建FileOutPutStream对象，构造方法中绑定要写入数据的目的地
        FileOutputStream fos = new FileOutputStream(new File("C:\\Users\\45109\\IdeaProjects\\pro02\\src\\com\\itheima\\day09\\OutPutStream\\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};//ABCDE
//        byte[] bytes = {-65,66,-67,68,69};//緽紻E

        fos.write(bytes);

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

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

        //释放资源
        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
 */

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

public class Demo03OutPutStream {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("C:\\Users\\45109\\IdeaProjects\\pro02\\src\\com\\itheima\\day09\\OutPutStream\\c.txt",true);
        for (int i = 0; i < 10; i++) {
            fos.write("你好".getBytes());//每运行一次就会增加一次你好,不会覆盖重写
            fos.write("\r\n".getBytes());
        }

        fos.close();
    }
}

java.io.InputStream:字节输入流
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.释放资源

例：


public class Demo01InPutStream {

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

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

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

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

         /*
            发现以上读取文件是一个重复的过程,所以可以使用循环优化
            不知道文件中有多少字节,使用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.print(len);//97 98 99
            System.out.print((char) len);//abc
        }


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

    }

原理
在这里插入图片描述
一次打印多个字节的方法
字节输入流一次读取多个字节的方法:
int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
明确两件事情:
1.方法的参数byte[]的作用?
起到缓冲作用,存储每次读取到的多个字节
数组的长度一般定义为1024(1kb)或者1024的整数倍
2.方法的返回值int是什么?
每次读取的有效字节个数
String类的构造方法
String(byte[] bytes) :把字节数组转换为字符串
String(byte[] bytes, int offset, int length) 把字节数组的一部分转换为字符串 offset:数组的开始索引 length:转换的字节个数

例：

 public class Demo02InPutStream {
    public static void main(String[] args) throws IOException {
        //创建FileInPutStream对象，构造方法中绑定要读的数据源
        FileInputStream fis = new FileInputStream("C:\\Users\\45109\\IdeaProjects\\pro02\\src\\com\\itheima\\day09\\OutPutStream\\b.txt");
        //使用FileInPutStream对象中的方法read读取文件
//        int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
       /* byte[] bytes = new byte[2];
        int len = fis.read(bytes);
        System.out.println(len);//2 每次读取字节的个数
//        System.out.println(Arrays.toString(bytes));//[65, 66]
        System.out.println(new String(bytes));//AB


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

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

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

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

        }


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

    }
}

字节流练习：图片复制
原理：
在这里插入图片描述
文件复制练习:一读一写

明确:
数据源: D:\PTE\17.jpg
数据的目的地: C:\111

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



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

public class Demo03CopyFile {

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

        //使用数组缓冲读取多个字节，写入多个字节
        byte[] bytes = new byte[1024];
        int len =0;//每次读取的有效字节个数
        while ((len=fis.read(bytes))!=-1){
            fos.write(bytes);
        }

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

    }
}

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

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

public class Demo01InputStream {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("C:\\Users\\45109\\IdeaProjects\\pro02\\src\\com\\itheima\\day09\\OutPutStream\\c.txt");
        int len = 0;
        byte[] bytes = new byte[6];
        while ((len = fis.read())!=-1){
            System.out.println((char) len);//会出现乱码现象
        }
        fis.close();
    }
}

字符流

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

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

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.释放资源

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

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

//        int read(char[] char)一次读取多个字符,将字符读入数组。
        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));//你好123abc
            System.out.println(cs);
        }

        fr.close();
    }
}

字符输出流
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.FileWriter;
import java.io.IOException;

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


    }
}

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

public class Demo02CloseFlush {
    public static void main(String[] args) throws IOException {
        //1.创建FileWriter对象,构造方法中绑定要写入数据的目的地
        FileWriter fw = new FileWriter("C:\\Users\\45109\\IdeaProjects\\pro02\\src\\com\\itheima\\day09\\OutPutStream\\c.txt");
        //2.使用FileWriter中的方法write,把数据写入到内存缓冲区中(字符转换为字节的过程)
        fw.write("int c");
        fw.write(98);
        //3.使用FileWriter中的方法flush,把内存缓冲区中的数据,刷新到文件中
        fw.flush();
        //刷新后可以继续使用
        fw.write(99);
        //4.释放资源(会先把内存缓冲区中的数据刷新到文件中)
        fw.close();
        //close方法之后流已经关闭了,已经从内存中消失了,流就不能再使用了
        //fw.write(99);//IOException: Stream closed
    }
    }

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

字符输出流写数据的其他方法
- void write(char[] char)写入字符数组。
- abstract void write(char[] char, int off, int len)写入字符数组的某一部分,off数组的开始索引,len写的字符个数。
- void write(String str)写入字符串。
- void write(String str, int off, int len) 写入字符串的某一部分,off字符串的开始索引,len写的字符个数。

public class Demo03Write {
    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("C:\\Users\\45109\\IdeaProjects\\pro02\\src\\com\\itheima\\day09\\OutPutStream\\f.txt");
        char[] cs ={'a','b','c'};
//        void write(char[] char)写入字符数组。
        fw.write(cs);//abc

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

//        void write(String str)写入字符串。
        fw.write("吃吃吃c");//吃吃吃c

//        void write(String str, int off, int len) 写入字符串的某一部分,off字符串的开始索引,len写的字符个数。
        fw.write("程序员",0,2);//程序
  fw.close();//abcbc
    }
}

字符流的续写与换行

/*
    续写和换行
    续写,追加写:使用两个参数的构造方法
        FileWriter(String fileName, boolean append)
        FileWriter(File file, boolean append)
        参数:
            String fileName,File file:写入数据的目的地
            boolean append:续写开关 true:不会创建新的文件覆盖源文件,可以续写; false:创建新的文件覆盖源文件
     换行:换行符号
        windows:\r\n
        linux:/n
        mac:/r
 */

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

public class Demo04Write {
    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter
                ("C:\\Users\\45109\\IdeaProjects\\pro02\\src\\com\\itheima\\day09\\OutPutStream\\c.txt",true);
        for (int i = 0; i < 20; i++) {
            fw.write("Hello" + i + "\r\n");
        }
        fw.close();
    }

}

IO异常处理
使用try…catch…finally处理
在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) {
        //提高变量fw的作用域，让finally可以使用
        //变量在定义时可以不设值，但是使用的时候必须有值
        //fw = new FileWriter(""C:\\Users\\4510...",true); 执行失败,fw没有值,fw.close会报错
        FileWriter fw = null;
        try {
            fw = new FileWriter
                    ("C:\\Users\\45109\\IdeaProjects\\pro02\\src\\com\\itheima\\day09\\OutPutStream\\g.txt",true);
            for (int i = 0; i < 20; i++) {
                fw.write("Hello" + i + "\r\n");
            }
        } catch (IOException e){
        //异常处理逻辑
        System.out.println(e);

        }finally {
        //一定会执行的代码
        //创建对象失败了,fw的默认值就是null,null是不能调用方法的,会抛出NullPointerException,需要增加一个判断,不是null再把资源释放
            if(fw!=null){
                try {
                    fw.close();
                    //fw.close方法声明抛出了IOException异常对象,所以我们就的处理这个异常对象,要么throws,要么try catch
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
            
        }
    }
}

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

public class Demo02JDK7 {

    public static void main(String[] args) {
       try(//1.创建一个字节输入流对象,构造方法中绑定要读取的数据源
           FileInputStream fis = new FileInputStream("D:\\PTE\\17.jpg");
           //2.创建一个字节输出流对象,构造方法中绑定要写入的目的地
           FileOutputStream fos = new FileOutputStream("C:\\111\\17.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 FileNotFoundException {

        //1.创建一个字节输入流对象,构造方法中绑定要读取的数据源
            FileInputStream fis = new FileInputStream("D:\\PTE\\17.jpg");
            //2.创建一个字节输出流对象,构造方法中绑定要写入的目的地
            FileOutputStream fos = new FileOutputStream("C:\\111\\17.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

//
    }
    }

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

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

Properties集合有一些操作字符串的特有方法

例：

/*
        使用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方法
     */

    private static void show01() {
        //创建Properties集合对象
        Properties prop = new Properties();
        //使用setProperty往集合中添加数据
        prop.setProperty("W","188");
        prop.setProperty("z","198");
        prop.setProperty("x","178");

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

        //遍历Set集合,取出Properties集合的每一个键
        for (String key : set) {
            String value = prop.getProperty(key);
            System.out.println(key+value);
        }

    }
}

可以使用Properties集合中的方法store

可以使用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.释放资源

例：

private static void show02() throws IOException {
        //1.创建Properties集合对象,添加数据
        Properties prop = new Properties();
        prop.setProperty("泽","188");
        prop.setProperty("z","198");
        prop.setProperty("x","178");
//        2.创建字节输出流/字符输出流对象,构造方法中绑定要输出的目的地
//        FileWriter fw = new FileWriter("C:\\Users\\45109\\IdeaProjects\\pro02\\src\\com\\itheima\\day09\\OutPutStream\\c.txt");
//        3.使用Properties集合中的方法store,把集合中的临时数据,持久化写入到硬盘中存储
//        prop.store(fw,"save data");

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

        //中文会出现乱码，说明字节流不能写中午
        prop.store(new FileOutputStream("C:\\Users\\45109\\IdeaProjects\\pro02\\src\\com\\itheima\\day09\\OutPutStream\\f.txt"),"");
    }

   /*
        可以使用Properties集合中的方法load,把硬盘中保存的文件(键值对),读取到集合中使用
        void load(InputStream inStream)
        void load(Reader reader)
        参数:
            InputStream inStream:字节输入流,不能读取含有中文的键值对
            Reader reader:字符输入流,能读取含有中文的键值对
        使用步骤:
            1.创建Properties集合对象
            2.使用Properties集合对象中的方法load读取保存键值对的文件
            3.遍历Properties集合
        注意:
            1.存储键值对的文件中,键与值默认的连接符号可以使用=,空格(其他符号)
            2.存储键值对的文件中,可以使用#进行注释,被注释的键值对不会再被读取
            3.存储键值对的文件中,键与值默认都是字符串,不用再加引号
     */
    private static void show03() throws IOException {
//        1.创建Properties集合对象
        Properties prop = new Properties();
        //2.使用Properties集合对象中的方法load读取保存键值对的文件
        //使用字节流同样读取不了中文，所以一般使用字符流       
        prop.load(new FileInputStream("C:\\Users\\45109\\IdeaProjects\\pro02\\src\\com\\itheima\\day09\\OutPutStream\\c.txt"));
        //3.遍历Properties集合
        Set<String> set = prop.stringPropertyNames();
        for (String key : set) {
            String value = prop.getProperty(key);
            System.out.println(key + value);
        }

    }
WRZLLZ
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
day10-IO流&Properties集合1
08-04
1.IO流案例 1. 定义学生类 2. 创建TreeSet集合，通过比较器排序进行排序 3. 键盘录入学生数据 4. 创建学生对象，把键盘录入的数据对应赋值给学
IO流及Properties集合
qq_53264704的博客
10-13 181
File类 1.File类概述以及构造方法 概述 它是文件和目录路径名的抽象表示 文件和目录是可以通过File封装成对象的 对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在的，也可以是不存在的。将来是要通过具体的操作把这个路径的内容转换为具体存在的 构造方法 方法名 说明 File(String pathname) 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例 File(String p..
IO流(Properties 很重要 实例)
weixin_34208185的博客
01-24 85
package com.yyq; import java.io.*; /* * 用于记录应用程序的运行次数 * 如果使用次数已到，那么给出注册提示 * * 很容易想到： 计数器 * 可是该计数器定义在程序中，随着程序的运行而在内存中存在，并进行自增 * 可是随着该应用程序的退出，该计数器也在内存中消失了 * * 下次程序启动会先加载计数器的值并加1后再重...
IO流专题（05）——Properties类
yuhuofei的草屋
11-07 260
一. 概念 二. 用途
IO流 & Properties集合
JhonnyLee的博客
08-17 149
1.IO流案例 1.1 集合到文件数据排序改进版【应用】 1.2 复制单级文件夹【应用】 1.3 复制多级文件夹【应用】 1.4 复制文件的异常处理【应用】 1.4.1 基本做法 1.4.2 JDK7版本改进 1.4.3 JDK9 版本改进 2. IO流特殊操作流 2.1 标准输入流 2.2 标准输出流 2.3 字节打印流 2.4 字符打印流 2.5 复制Java文件打印改进版 2.6 对象序列化流 2.7 对象反序列化流 2.8 serialVersionUID & transient 3. Pr
IO流和集合的交集Properties类的介绍。
liuhenghui5201的专栏
12-17 1781
Properties类继承了Hashtable，Hashtable实现了Map接口。该类的键值对 都是字符串。 Properties的构造方法：Properties pro = new Properties();//创建一个Properties集合。   常用方法： String setProperties(String key,String value);//添加元素，修改元素。
Java-IO流/Stream流总结
最新发布
07-12
内容：IO流及其分类、分类比较、转换流、缓存流、IO流异常处理、Stream流、Properties教程等。 适合人群：有编程基础及Java基础伙伴 适用场景：Java中的流是随处可见的，涉及文件的操作必须使用IO流，Stream流可以对...
用户管理系统
10-19
基于Java技术开发的用户管理系统，可以对数据库中的用户进行查询、添加、修改、删除，比较简单。该系统使用到了Java JDBC、集合、io流等知识点。
flink入门到精通视频教程
07-15
10.Flink进阶 异步IO，背压，内存管理 11.Flink Table API与SQL 课程目录介绍 第一章 Flink简介 01.Flink的引入 02.什么是Flink 03.Flink流处理特性 04.Flink基石 05.批处理与流处理 第二章 Flink架构体系 01.Flink...
Java SE编程入门教程 properties（共3页）.pptx
12-04
java IO（共28页） java Math（共11页） java object（共9页） java static final（共24页） java this和super（共10页） java 常用API（共22页） javaGUI编程快速入门(1)（共82页） java包装器（共9页） java反射...
IO流（七） Properties类
qq_41781316的博客
07-22 339
Properties类介绍 Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。 Properties：Map集合的一种，它是Hashtable集合的子集合,它键与值都是String类型,它是唯一能与IO流结合使用的集合 特点： 1、Hashtable的子类，map集合中的方法都可以用。 2、该集合没有...
【IO流】Properties操作配置文件
无心博客
06-04 917
Properties操作配置文件 /** * properties操作配置文件 * * @author xiazhang * @date 2017-6-4 */ public class PropertiesTest { /** * 生成配置文件 */ public static void createIniFile(){ //新建一个propertie
IO流——Properties类
lidong777777的博客
07-15 213
本次博客带领大家了解IO流中的Properties类，介绍它的常用方法和注意事项等等。
day19-IO流&Properties集合
at10090的博客
07-09 181
1.IO流案例 1.1集合到文件数据排序改进版【应用】 1.1.1案例需求 键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩)。要求按照成绩总分从高到低写入文本文件 格式：姓名,语文成绩,数学成绩,英语成绩 举例：林青霞,98,99,100 1.1.2分析步骤 定义学生类 创建TreeSet集合，通过比较器排序进行排序 键盘录入学生数据 创建学生对象，把键盘录入的数据对应赋值给学生...
Java基础知识IO流（Properties）
u013951760的博客
05-04 1635
Properties概述Properties类是hashtable的子类，它具备map集合的特点，而且它里面存储的键值对都是字符。Properties 可保存在流中或从流中加载。 Properties是集合和IO技术相结合的集合容器。 Properties 类表示了一个持久的属性集，可以用于键值对形式的配置文件,在加载数据时，需要数据有固定格式：键=值。 比如软件的配置文件：软件的配置信息和数
IO流properties
weixin_30391339的博客
07-26 65
package properties; import java.util.Properties; public class Demo1 { public static void main(String[] args) { /** * java.lang.Object 继承者 java....
Java-基础语法17:IO流&Properties集合
DrewWong的博客
10-31 253
1.IO流案例 1.1集合到文件数据排序改进版【应用】 1.1.1案例需求 键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩)。要求按照成绩总分从高到低写入文本文件 格式：姓名,语文成绩,数学成绩,英语成绩 举例：林青霞,98,99,100 1.1.2分析步骤 定义学生类 创建TreeSet集合，通过比较器排序进行排序 键盘录入学生数据 创建学生对象，把键盘录入的数据对应赋值给学生对象的成员变量 把学生对象添加到TreeSet集合 创建字符缓冲输出流对象 遍历集合，得到每一个学生对象 把学生
Java基础 -IO流&Properties
上山打卤面的博客
01-19 256
IO流
Properties和IO流的结合使用
Shaun_Guo的博客
03-22 730
package gxx22;import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;import java.io.Reader;import java.io.Writer;import java.util.Properties;//Properties集合的读取与存储：效果是进度的保存和加载/*p...
Properties集合学会Properties集合的使用，添加两个元素分别为： fruit=apple，animal=cat，并将Properties保存到fileName中
05-30
好的，以下是Java示例代码，演示如何使用Properties集合实现上述操作： ```java import java.io.FileOutputStream; import java.io.IOException; import java.util.Properties; public class PropertiesDemo { ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值