Java进阶_IO流

IO流

一、流的概念

什么是流

• 概念：内存与存储设备之间传输数据的通道。

• 水借助管道传输;数据借助流传输。

二、流的分类

1、按方向【重点】

• 输入流：将<存储设备>中的内容读入到<内存>中。
• 输出流：将<内存>中的内容写入到<存储设备>中。

2、按单位

• 字节流：以字节为单位，可以读写所有数据。
• 字符流：以字符为单位，只能读写文本数据。

3、按功能

• 节点流：具有实际传输数据的读写功能。
• 过滤流：在节点流的基础之上增强功能。

三、字节流

1、字节流的父类(抽象类)

• InputStream：字节输入流

public int read() {}

public int read (byte[] b) {}

public int read (byte[] b, int off, int len) {}

• OutputStream：字节输出流

public void write(int n) {}

public void write(byte[] b) {}

public void write(byte[] b, int off, int len) {}

2、字节流的实现类

2.1、文件字节流

• FileInputStream:

  • public int read(byte[] b) //从流中读取多个字节，将读到内容存入b数组，返回实际读到的字节数;如果达到文件的尾部，则返回-1。

• File0utputStream:

  • public void write(byte[] b) //-次写多个字节，将b数组中所有字节，写入输出流。

FileInputStream案例

D盘的记事本：aaa.txt

读取记事本内容

package com.mike.test;

/*
        演示FileInputStream的使用
        文件字节输入流
*/
import java.io.FileInputStream;

public class Demo01 {
    public static void main(String[] args) throws Exception {
        //1、创建FileInputStream对象
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        //2、读取文件
        //fis.read()
        //2.1、单个字节读取
//        int data = 0;
//        while ((data=fis.read())!=-1){
//            System.out.print((char) data);
//        }
        //2.2、一次读取多个字节

        byte[] buf = new byte[1024];
        int count = 0;
        while ((count=fis.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
//        int count = fis.read(buf);
//        System.out.println(new String(buf));
//        System.out.println(count);


        //3、关闭
        fis.close();
        System.out.println("执行完毕！");

    }
}
 /*输出结果
                HelloWord！
                执行完毕！
*/

File0utputStream案例

package com.mike.test;

/*
        演示文件字节输出流的使用
        FileOutputStream
*/

import java.io.FileOutputStream;
import java.nio.charset.StandardCharsets;

public class Demo02 {
    public static void main(String[] args) throws Exception{
        //1、创建FileOutputStream对象
//        FileOutputStream fos = new FileOutputStream("d:\\bbb.txt");//没有true表示覆盖原内容
        //FileOutputStream("d:\\bbb.txt",true);true表示如果有内容，运行一次追加一次
        //这里我运行了两次
        FileOutputStream fos = new FileOutputStream("d:\\bbb.txt",true);
        //2、写入文件
//        fos.write(97);
//        fos.write('b');
//        fos.write('c');

//		一次性写入多个字符
        String string = "HelloEarth";
        fos.write(string.getBytes());



        //3、关闭流
        fos.close();
        System.out.println("执行完毕！");
    }
}

/*
                执行完毕！
*/

小案例：实现文件的复制

package com.mike.test;

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

/*
        实现文件的复制
        FileInputStream，FileOutputStream
*/
public class Demo03 {
    public static void main(String[] args) throws Exception{
        //1、创建流
        //1.1、创建文件输入流
        FileInputStream fis = new FileInputStream("d:\\001.jpg");
        //1.2、创建文件输出流
        FileOutputStream fos = new FileOutputStream("d:\\002.jpg");

        //2、一边读，一边写
        byte[] buf = new byte[1024];
        int count = 0;
        while ((count=fis.read(buf))!=-1){
            fos.write(buf,0,count);
        }

        //3、关闭流
        fis.close();
        fos.close();
        System.out.println("复制完毕！");

    }
}

/*
                复制完毕！
*/

2.2、字节缓冲流

• 缓冲流: BufferedInputStream/ BufferedOutputStream
  • 提高IO效率，减少访问磁盘的次数;
  • 数据存储在缓冲区中，flush是将缓存区的内容写入文件中，也可以直接close。

BufferedInputStream案例

package com.mike.test;

import java.io.BufferedInputStream;
import java.io.FileInputStream;

/*
            使用字节缓冲流读取
            BufferedInputStream
*/
public class Demo04 {
    public static void main(String[] args) throws Exception{
        //1、创建BufferedInputStream
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);

        //2、读取
//        int data = 0;
//        while ((data=bis.read())!=-1){
//            System.out.println((char) data);
//        }

        //BufferedInputStream有自己的缓冲区是8k
        //这里我们自己创建一个缓冲区，一次性读取多字节
        byte[] buf = new byte[1024];
        int count = 0 ;
        while ((count=bis.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }

        //3、关闭流
        //这里只要关闭缓冲流就行，文件字节流会因为缓冲流的关闭自动关闭
        bis.close();
        System.out.println("利用缓冲流读取完毕！");

    }
}
/*
                HelloWord！
                利用缓冲流读取完毕！
*/

BufferedOutputStream案例

package com.mike.test;

/*
            使用字节缓冲流读取
            BufferedOutputStream
*/

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;

public class Demo05 {
    public static void main(String[] args) throws Exception{
        FileOutputStream fos = new FileOutputStream("d:\\buffer.txt");
        //1、创建字节输出缓冲流
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //2、写入文件
        String s = "HelloWord\n";
        for (int i = 0; i < 10; i++) {
            bos.write(s.getBytes());
            bos.flush();//刷新到硬盘
        }

        //3、关闭字节输出缓冲流
        bos.close();//内部会调用一次flush();
        System.out.println("利用缓冲流写入完毕！");
    }
}

​

四、对象流

• 对象流: ObjectInputStream/ObjectOutputStream
  • 增强了缓冲区功能
  • 增强了读写8种基本数据类型和字符串功能
  • 增强了读写对象的功能
    • readObject( ) 从流中读取一个对象（反序列化）
    • writeObject (Object obj) 向流中写入一个对象（序列化）

使用流传输对象的过程称为序列化、反序列化。

序列化案例

写入操作

Student类

package com.mike.test;

import java.io.Serializable;

public class Student implements Serializable {
    //    serialVersionUID:序列化版本号ID
    private static final 1ong serialVersionUID = 100L ;
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Demo6 类

package com.mike.test;


import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

/*
*使用objectOutputStream实现对象的序列化
* 要求:序列化类必须要实现Serializable接口
 * */
public class Demo6 {
    public static void main(String[] args) throws Exception{
        FileOutputStream fos = new FileOutputStream("d:\\stu.bin");
        //1、创建对象流
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        //2、序列化(写入操作)
        Student zhangsan = new Student("张三",20);
        /*序列化多个对象，用集合来存放
        Student zhangsan=new Student("张三"，20);
		Student lisi=new Student("李四", 22);
		ArrayList<student> list = new ArrayList<student>();
		list.add(zhangsan);
		list.add(lisi);
		oos.write0bject(list);
        */
        oos.writeObject(zhangsan);
        //3、关闭流
        oos.close();
        System.out.println("序列化完毕！");

    }
}
/*
用记事本打开stu.bin文件，看到一堆乱码，但是还是可以看到一些信息。这就是序列化操作
*/

反序列化案例

读取操作

package com.mike.test;


import java.io.FileInputStream;
import java.io.ObjectInputStream;

/*
*使用objectInputStream实现反序列化(读取重构成对象)
 * */
public class Demo7 {
    public static void main(String[] args) throws Exception{
        FileInputStream fis = new FileInputStream("d:\\stu.bin");
        //1、创建对象流
        ObjectInputStream ois = new ObjectInputStream(fis);
        //2、反序列化（读取文件）
        Student s = (Student) ois.readObject();//只能读取一次，就像刮卡一样
        //ArrayList<Student> list = (ArrayList<student>)ois.readobject();
        //3、关闭流
        ois.close();
        System.out.println("反序列化完毕！");
        System.out.println(s.toString());
        //System.out.println(list.toString());
    }
}
/*读取stu.bin文件后，输出结果：
                反序列化完毕！
                Student{name='张三', age=20}
*/

注意点

序列化ObjectOutputStream和反序列化ObjectInputStream注意事项：

• (1)序列化类必须要实现Serializable接口
• (2)序列化类中对象属性要求实现Serializable接口
• (3)序列化版本号ID,保证序列化的类和反序列化的类是同一个类
• (4)使用transient（瞬间的）修饰属性，这个属性不能序列化
• (5)静态属性不能序列化
• (6)序列化多个对象,可以借助集合实现

五、编码方式

字符编码

• ISO-8859-1   收录除ASCII外，还包括西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号。
• UTF-8     针对Unicode码表的可变长度字符编码
• GB2312    简体中文
• GBK      简体中文、扩充
• BIG5      台湾，繁体中文

当编码方式和解码方式不一致时，会出现乱码。

六、字符流

• 字符流的父类(抽象类) ：

  • Reader： 字符输入流

  public int read() {}
  
  public int read (char[] c) {}
  
  public int read (char[] b, int off, int len) {}
  

  • Writer：字符输出流

  public void write(int n) {}
  
  public void write(String str) {}
  
  public void write(char[] c) {}
  

文件字符流

• FileReader:

  • public int read(char[] c) //从流中读取多个字符，将读到内容存入c数组，返回实际读到的字符数;如果达到文件的尾部，则返回-1。

• FileWriter:

  • public void write(String str) //一次写多个字符，将b数组中所有字符，写入输出流。

FileReader的使用

package com.mike.test;

/*
        使用FileReader读取文件
*/

import java.io.FileOutputStream;
import java.io.FileReader;


public class Demo02 {
    public static void main(String[] args) throws Exception{
        //1、创建FileReader  文件字符输入流
        FileReader fr = new FileReader("d:\\hello.txt");
        //2、文件读取
        //2.1、单个字符读取
/*        int data = 0;
        while ((data= fr.read())!=-1){
            System.out.print((char) data);
        }*/
        char[] buf = new char[1024];
        int count = 0;
        while ((count= fr.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }

        //3、关闭流
        fr.close();
        System.out.println("\n文件字符输入流读取完毕！");
    }
}
/*
            人生最大的悲痛莫过于辜负青春。——薄伽丘

            文件字符输入流读取完毕！
*/

FileWriter的使用

package com.mike.test;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileWriter;

/*
        使用FileWriter写入文件
*/
public class Demo03 {
    public static void main(String[] args) throws Exception{
        //1、创建FileWriter对象
        FileWriter fw = new FileWriter("d:\\write.txt");
        //写入方法
        for (int i = 0; i < 10; i++) {
            fw.write("Java是世界上最好的语言\t");
            fw.flush();
        }

        //3、关闭FileWriter对象
        fw.close();
        System.out.println("利用FileWriter写入完毕！");

        
    }
}
                /*输出结果
                利用FileWriter写入完毕！
                */

字符流复制文件

package com.mike.test;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.FileWriter;

/*
            使用FileReader和FileWriter复制文本文件，不能复制图片或二进制文件(不能复制图片，声音，视频)

*/
public class Demo04 {
    public static void main(String[] args) throws Exception{
        //1、创建FileRead和FileWriter
        FileReader fr = new FileReader("d:\\write.txt");
        FileWriter fw = new FileWriter("d:\\write2.txt");
        //2、一边读一边写
        int data = 0;
        while ((data=fr.read())!=-1){
            fw.write(data);
        }

/*
        char[] buf = new char[1024];
        int count = 0;
        while ((count= fr.read(buf))!=-1){
            fw.write(buf);
        }
*/

        //3、关闭流
        fr.close();
        fw.close();
        System.out.println("文本复制完毕！");
    }
}
/*输出结果：
                    文本复制完毕！
*/

字符缓冲流

• 缓冲流: BufferedReader/BufferedWriter
  • 高效读写
  • 支持输入换行符。
  • 可一次写一行、读一行。

BufferedReader的使用

package com.mike.test;

/*
        使用字符缓冲流读取文件
        BufferedReader
*/

import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.FileOutputStream;
import java.io.FileReader;

public class Demo05 {
    public static void main(String[] args) throws Exception{
        //1、创建缓冲流
        FileReader fr = new FileReader("d:\\write.txt");
        BufferedReader br = new BufferedReader(fr);
        //2、读取文件
        //2.1、第一种方式
/*        char[] buf = new char[1024];
        int count = 0;
        while ((count= br.read(buf))!=-1){
            System.out.print(new String(buf,0,count));
        }*/
        //2.2、第二种方式,一行一行的读取
        String line = null;
        while ((line= br.readLine())!=null){
            System.out.println(line);
        }
        //3、关闭
        br.close();
        System.out.println("读取完毕！");
    }
}
/*输出结果：
                    Java是世界上最好的语言
                    Java是世界上最好的语言
                    Java是世界上最好的语言
                    Java是世界上最好的语言
                    Java是世界上最好的语言
                    Java是世界上最好的语言
                    Java是世界上最好的语言
                    Java是世界上最好的语言
                    Java是世界上最好的语言
                    Java是世界上最好的语言
                    读取完毕！
*/

BufferedWriter的使用

package com.mike.test;


import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.ObjectOutputStream;

/*
    演示BufferedWriter的使用
  */
public class Demo6 {
    public static void main(String[] args) throws Exception{
        //1、创建BufferedWriter对象
        FileWriter fw = new FileWriter("d:\\buffer.txt");
        BufferedWriter bw = new BufferedWriter(fw);
        //2、写入
        for (int i = 0; i < 10; i++) {
            bw.write("好好学习，天天向上！");
            bw.newLine();//写入一个换行符Windows-->\r\n      Linux-->\n
            bw.flush();
        }
        //3、关闭

        bw.close();
        System.out.println("写入完毕！");
    }
}
                /*输出结果
                		写入完毕！
                */

打印流

• PrintWriter:
  • 封装了print() / println()方法，支持写入后换行。
  • 支持数据原样打印

PrintWriter的使用

package com.mike.test;


import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.io.PrintWriter;

/*
    演示PrintWriter的使用
  */
public class Demo7 {
    public static void main(String[] args) throws Exception{
        //1、创建打印流
        PrintWriter pw = new PrintWriter("d:\\print.txt");
        //2、打印
        pw.println(97);
        pw.println(true);
        pw.println(3.14);
        pw.println('c');
        //3、关闭
        pw.close();
        System.out.println("打印完毕！");
    }
}

转换流

• 桥转换流: InputStreamReader/OutputStreamWriter
  • 可将字节流转换为字符流。
  • 可设置字符的编码方式。

InputStreamReader的使用

package com.mike.test;


import java.io.FileInputStream;
import java.io.InputStreamReader;

/*
        使用InputStreamReader读取文件，指定使用的编码
*/
public class Demo08 {
    public static void main(String[] args) throws Exception{
        //1、创建InputStreamReader对象
        FileInputStream fis = new FileInputStream("d:\\write.txt");
        InputStreamReader isr = new InputStreamReader(fis,"utf-8");

        //2、读取文件
        int data = 0;
        while ((data= isr.read())!=-1){
            System.out.print((char) data);
        }

        //3、关闭
        isr.close();
        System.out.println("读取完毕！");
    }
}

/*
            Java是世界上最好的语言
            Java是世界上最好的语言
            Java是世界上最好的语言
            Java是世界上最好的语言
            Java是世界上最好的语言
            Java是世界上最好的语言
            Java是世界上最好的语言
            Java是世界上最好的语言
            Java是世界上最好的语言
            Java是世界上最好的语言
            读取完毕！
*/

OutputStreamWriter的使用

package com.mike.test;

import java.io.FileOutputStream;
import java.io.OutputStreamWriter;

/*
        使用OutputStreamWriter写入文件，指定使用的编码
*/
public class Demo09 {
    public static void main(String[] args) throws Exception{
        //1、创建OutputStreamWriter对象
        FileOutputStream fos = new FileOutputStream("d:\\info.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos,"utf-8");
        //2、写入文件
        for (int i = 0; i < 10; i++) {
            osw.write("我爱北京天安门！！！\r\n");
            osw.flush();
        }

        //3、关闭
        osw.close();
        System.out.println("写入完毕！");

    }
}
                /*输出结果:
                		写入完毕！
                */

七、File类

• 概念:代表物理盘符中的一个文件或者文件夹。
• 方法:
  • createNewFile()//创建一一个新 文件
  • mkdir()//创建-一个新目录
  • delete()//删除文件或空目录
  • exists ()//判断File对象所对象所代表的对象是否存在
  • getAbsolutePath()//获取文件的绝对路径
  • getName()//取得名字
  • getParent()//获取文件/目录所在的目录.
  • isDirectory()//是否是目录
  • isFile()//是否是文件
  • length()//获得文件的长度
  • listFiles ()//列出目录中的所有内容
  • renameTo()//修改文件名为

创建文件/文件夹

package com.mike.test;

/*
File类的使用
(1)分隔符
(2)文件操作
(3)文件夹操作
*/

import java.io.File;
import java.util.Date;

public class Demo01 {
    public static void main(String[] args) throws Exception {
        //separator();
        //fileOpe();
        directoryOpe();

    }

    //(1)、分隔符
    public static  void  separator(){
        System.out.println("路径分隔符"+ File.pathSeparator);
        System.out.println("名称分隔符"+ File.separatorChar);
    }

    //(2)、文件操作
    public static void fileOpe() throws Exception{
        //1、创建文件
        File file = new File("d:\\file.txt");
        //System.out.println(file.toString());

        if (!file.exists()){
            boolean b = file.createNewFile();
            System.out.println("创建的结果："+b);
        }
        //============================================
        //2、删除文件
        //2.1、直接删除
/*        boolean delete = file.delete();
        System.out.println("删除结果："+delete);*/
        //2.2、使用JVM退出时删除文件
/*        file.deleteOnExit();
        Thread.sleep(5000);//休眠5秒钟后，JVM进程结束*/
        //============================================
        //3、获取文件信息
        System.out.println("获取文件的绝对路径:"+file.getAbsolutePath());
        System.out.println("获取路径:"+file.getPath());
        System.out.println("获取文件名称:"+file.getName());
        System.out.println("获取父目录:"+file.getParent());
        System.out.println("获取文件长度:"+file.length()+"字节");
        System.out.println("获取文件创建时间:"+new Date(file.lastModified()).toLocaleString());

        //4、判断
        //============================================
        System.out.println("文件是否可写:"+file.canWrite());
        System.out.println("是否属于文件:"+file.isFile());
        System.out.println("是否属于隐藏文件:"+file.isHidden());

    }

    //(3)、文件夹操作
    public static  void directoryOpe() throws Exception {
        //1、创建文件夹
        File dir = new File("d:\\aaa\\bbb\\ccc");
        System.out.println(dir.toString());
        if (!dir.exists()){
            //dir.mkdir();//只能创建单级目录
            boolean mkdirs = dir.mkdirs();//可以创建多级目录
            System.out.println("创建文件夹结果:"+mkdirs);
        }
        //2、删除文件夹
        //2.1、直接删除（注意：只能删除空目录）
        /*System.out.println("删除结果:"+dir.delete());*/
        //2.2、使用JVM删除
/*        dir.deleteOnExit();
        Thread.sleep(5000);//睡眠5秒后删除*/
        //3、获取文件夹信息
        System.out.println("获取绝对路径:"+dir.getAbsolutePath());
        System.out.println("获取路径:"+dir.getPath());
        System.out.println("获取文件夹名称:"+dir.getName());
        System.out.println("获取父目录:"+dir.getParent());
        System.out.println("获取文件夹创建时间:"+new Date(dir.lastModified()).toLocaleString());
        //4、判断
        System.out.println("是否属于文件夹:"+dir.isDirectory());
        System.out.println("是否属于隐藏文件夹:"+dir.isHidden());

        //5、遍历文件夹
//        File dir2 = new File("");
//        String[] files = dir2.list();
//        System.out.println("------------------------------");
//        for (String string : files) {
//            System.out.println(string);
//        }
    }
}
 /*输出结果
                d:\aaa\bbb\ccc
                获取绝对路径:d:\aaa\bbb\ccc
                获取路径:d:\aaa\bbb\ccc
                获取文件夹名称:ccc
                获取父目录:d:\aaa\bbb
                获取文件夹创建时间:2022-3-12 20:16:14
                是否属于文件夹:true
                是否属于隐藏文件夹:false
*/

FileFilter接口

• FileFilter（文件过滤器）

• public interface FileFilter

  • boolean accept (File pathname)

• 当调用File类中的listFiles()方法时，支持传入FileFilter接口接口实现类，对获取文件进行过滤，只有满足条件的文件的才可出现在listFiles()的返回值中。

过滤出.jpg文件

package com.mike.test;

/*
File类的使用
(1)分隔符
(2)文件操作
(3)文件夹操作
*/

import java.io.File;
import java.io.FileFilter;
import java.util.Date;

public class Demo01 {
    public static void main(String[] args) throws Exception {
        directoryOpe();

    }

    //文件夹操作
    public static  void directoryOpe() throws Exception {
       
        //遍历文件夹
        File dir2 = new File("d:\\aaa");
        String[] files = dir2.list();
        System.out.println("------------------------------");
        for (String string : files) {
            System.out.println(string);
        }

        System.out.println("-------------FileFilter的使用---------------");
        File[] files2 = dir2.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                //过滤后缀为.jpg的文件
                if (pathname.getName().endsWith("jpg")) {
                    return true;
                }
                return false;
            }
        });
        for (File file : files2) {
            System.out.println(file.getName());
        }
    }
}
 /*输出结果

*/

递归遍历，递归删除

递归遍历文件夹

package com.mike.test;

/*
            案例1:递归遍历文件夹
*/

import java.io.File;
import java.io.FileFilter;
import java.util.Date;

public class Demo01 {
    public static void main(String[] args) throws Exception {
        listDir(new File("d:\\myfiles"));
    }

    public static void listDir(File dir){
        File[] files = dir.listFiles();
        System.out.println(dir.getAbsolutePath());
        if (files!=null&&files.length>0){
            for (File file : files) {
                if (file.isDirectory()){
                    listDir(file);//递归
                }else {
                    System.out.println(file.getAbsolutePath());
                }
            }
        }
    }
}

递归删除文件夹

package com.mike.test;

/*
            案例2:递归删除文件夹
*/

import java.io.File;
import java.io.FileFilter;
import java.util.Date;

public class Demo01 {
    public static void main(String[] args) throws Exception {
        deleteDir(new File("d:\\myfiles"));
    }
    
    public static void deleteDir(File dir){
        File[] files = dir.listFiles();
        if (files!=null&&files.length>0){
            for (File file : files) {
                if (file.isDirectory()){
                    deleteDir(file);//递归
                }
                else {
                    System.out.println(file.getAbsolutePath()+"删除"+file.delete());
                }
            }
        }
        System.out.println(dir.getAbsolutePath()+"删除"+dir.delete());
    }
}

八、补充: Properties

• Properties:属性集合
• 特点
  • 1、存储属性名和属性值
  • 2、属性名和属性值都是字符串类型
  • 3、没有泛型
  • 4、和流有关
  • 5、线性安全的集合

Properties的使用

package com.mike.test;

/*
        演示Properties集合的使用
*/

import java.io.*;
import java.util.Date;
import java.util.Properties;
import java.util.Set;

public class Demo01 {
    public static void main(String[] args) throws Exception {
        //1、创建集合
        Properties properties = new Properties();//此集合是一个规范型集合，不用设置泛型
        //2、添加元素
        properties.setProperty("username","zhangsan");
        properties.setProperty("age","20");
        System.out.println(properties.toString());

        //3、遍历
        //3.1、-----keySet----
        //3.2、------entrySet----
        //3.3、-------stringPropertyNames()------
        Set<String> pronames = properties.stringPropertyNames();
        for (String pro : pronames) {
            System.out.println(pro+"====="+properties.getProperty(pro));
        }

        //4、和流有关的方法
        //----------list方法--------(将控制台信息打印到文本)
/*        PrintWriter pw = new PrintWriter("d:\\print.txt");
        properties.list(pw);
        pw.close();*/
        //--------------store方法---------------(保存到文本)
/*        FileOutputStream fos = new FileOutputStream("d:\\store.properties");
        properties.store(fos,"注释");
        fos.close();*/
        //--------------load方法---------------(加载)
        Properties properties2 = new Properties();
        FileInputStream fis = new FileInputStream("d:\\store.properties");
        properties2.load(fis);
        fis.close();
        System.out.println(properties2.toString());
    }
}
 /*load方法输出结果
            {age=20, username=zhangsan}
            age=====20
            username=====zhangsan
            {age=20, username=zhangsan}
*/

list方法运行截图

store方法运行截图

总结

• 流的概念:

  • 内存与存储设备之间传输数据的通道。

• 流的分类:

  • 输入流、输出流；字节流、字符流；节点流、过滤流；

• 序列化、反序列化:

  • 将对象通过流写入到文件，或将对象通过流读取到内存，必须实现Serializable接口。

• File对象:

  • 代表物理盘符中的一个文件或者文件夹。