Java基础5

最新推荐文章于 2022-03-17 21:57:47 发布

weixin_43664947

最新推荐文章于 2022-03-17 21:57:47 发布

阅读量57

点赞数

分类专栏： java基础文章标签： java

本文链接：https://blog.csdn.net/weixin_43664947/article/details/110382795

版权

java基础专栏收录该内容

9 篇文章 0 订阅

订阅专栏

File类：

package FileDemo;

import java.io.File;

/**
 * java.io.File类：
 * 文件和目录路径名的抽象表示形式
 * java把电脑中的文件和文件夹封装为了一个File类，我们可以使用File类对文件和文件夹进行操作
 * File类方法：
 * 创建一个文件/文件夹
 * 删除一个文件/文件夹、
 * 获取一个文件/文件夹
 * 判断一个文件/文件夹
 * 对文件夹进行遍历
 * 获取文件的大小
 *
 * File类是一个与系统无关的类，任何的操作系统都可以使用这个类中的方法
 *
 * 重点记住这三个单词：
 * file   directory    path
 *
 *
 *
 *
 * static String pathSeparetor:与系统有关的路径分隔符，为了方便，它别表示为一个字符串
 * static char pathSeparetorChar:与系统有关的路径分割符
 *
 * static String separator:与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串
 * static char separatorChar:与系统有关的默认名称分隔符
 */

public class FileMainDemo {
    public static void main(String[] args) {
        String pathSeparator = File.pathSeparator;
        System.out.println(pathSeparator);//路径分隔符，wondows：分号;   linux：冒号:

        String separator = File.separator;
        System.out.println(separator);//文件名称分隔符    windows:反斜杠\    linux:正斜杠/
        System.out.println("======================================================");
        /**
         * File类的构造方法：
         *  * public File（String pathname）:通过将给定的路径名字字符串转换为抽象路径名来创建的File实例
         *  * public File(String parent,String child):从父路径字符串和子路径字符串创建的File实例
         *  * 参数：把路径分为两部分
         *  * String parent：父路径
         *  * String child：子路径
         *  * 好处：父路径和子路径分离，可以单独写，使用起来非常灵活，父路径和子路径都可以变化
         *  * public File(File parent,String child):从父抽象路径和子路径名字符串创建新的File实例
         */
        File f1 = new File("C:\\Users\\luokaili\\IdeaProjects\\list\\2020.11.27\\a.txt");
        System.out.println(f1);
        File f2 = new File("C:\\Users\\luokaili\\IdeaProjects\\list\\","2020.11.27\\a.txt");
        System.out.println(f2);
        
        
    }
}

File类常用方法：

package FileDemo;

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

/**
 *
 *
 *
 *
 *
 *
 */

public class FileMainDemo2 {
    public static void main(String[] args) throws IOException {
        show01();
        System.out.println("===============================");
        show02();
        System.out.println("===============================");
        show03();
        System.out.println("===============================");
        show04();
        System.out.println("===============================");
        show05();
    }

    /**
     * File类常用方法：
     *  * public String getAbsolutePath():返回次File的绝对路径名字符串(永远都返回绝对路径)
     *  * public String getPath():将此File转换为路径名字符串（File的路径是什么，返回的就是什么路径）
     *  * public String getName():返回由此File表示的文件或目录名称
     *  * public long length():返回此File表示的文件的长度（文件夹没有大小概念，不能获取文件夹的大小。构造方法中
     *  * 给出的路径不存在，那么length返回0）
     */
    private static void show01(){
        File f1 = new File("C:\\Users\\luokaili\\IdeaProjects\\list\\2020.11.27\\a.txt");
        String absolutePath1 = f1.getAbsolutePath();
        System.out.println(absolutePath1);
    }

    /**
     * 判断功能方法：
     *  * public boolean exists():此File表示的文件或目录是否实际存在
     *  * public boolean isDirextory():此File表示是否为目录
     *  * public boolean isFile():此File表示是否为文件
     */
    private static void show02(){
        File f1 = new File("C:\\Users\\luokaili\\IdeaProjects\\list\\2020.11.27\\a.txt");
        System.out.println(f1.exists());
    }

    /**
     * 创建删除功能的方法：
     *  * public boolean createNewFile():当且仅当具有该名称的文件尚不存在时，创建一个新的空文件
     *  返回值：布尔值
     *  true:文件不存在，创建文件，返回true
     *  false:文件存在，不会创建，返回false
     *  注意：
     *  1.此方法之只能创建文件，不能创建文件夹
     *  2.创建文件的路径必须存在，否则会抛出异常
     *  * public boolean delete():删除由此File表示的文件或目录
     *  * public boolean mkdir():创建由此File表示的目录(只能创建单级文件夹)
     *  返回值：布尔值
     *      *  true:文件夹不存在，创建文件夹，返回true
     *      *  false:文件夹存在，不会创建，返回false
     *      *  注意：
     *      *  1.此方法之只能创建文件夹，不能创建文件
     *      *  2.创建文件夹的路径必须存在，否则会抛出异常
     *  * public boolean madirs():创建由此File表示的目录，包括任何必须但不存在的父目录（既可以创建单级文件夹，
     *  也可以创建多级文件夹）
     *  *
     */
    private static void show03() throws IOException {
        File f1 = new File("C:\\Users\\luokaili\\IdeaProjects\\list\\2020.11.27\\1.txt");
        boolean newFile = f1.createNewFile();
        System.out.println("newFile:"+newFile);



    }

    private static void show04(){
        File f1 = new File("C:\\Users\\luokaili\\IdeaProjects\\list\\2020.11.27\\aaa");
        boolean mkdir = f1.mkdir();
        System.out.println(mkdir);

        File f2 = new File("C:\\Users\\luokaili\\IdeaProjects\\list\\2020.11.27\\111\\222");
        boolean mkdirs = f2.mkdirs();
        System.out.println(mkdirs);
    }

    /**
     * File类遍历（文件夹）目录功能
     * public String[] list():返回一个String数组，表示该File目录中的所有子文件或目录
     * public File[] listFiles():返回一个File数组，表示该File目录中的所有子文件或目录
     *
     * 注意：list方法和listFiles方法遍历的是构造方法中给出的目录
     * 如果构造方法中给出的目录路径不存在，会抛出空指针异常
     * 如果构造方法中给出的路径不是一个目录，也会抛出空指针异常
     */
    public static void show05(){
        File f1 = new File("C:\\Users\\luokaili\\IdeaProjects\\list\\2020.11.27");
        String[] list = f1.list();
        for (String s : list) {
            System.out.println(s);
        }

        File[] files = f1.listFiles();
        for (File file : files) {
            System.out.println(file);
        }
    }
}

递归打印多级目录：

package FileDemo;

import java.io.File;

/**
 * 递归打印多级目录
 */

public class FileMainDemo3 {
    public static void main(String[] args) {
        File f1 = new File("C:\\Users\\luokaili\\IdeaProjects\\list\\2020.11.27");
        getAllFiel(f1);
    }

    public static void getAllFiel(File dir){
        File[] files = dir.listFiles();
        for (File file : files) {
            System.out.println(file);
            if (file.isDirectory()){
                getAllFiel(file);
            }
        }

    }
}

只搜索以.java结尾的文件：

package FileDemo;

import java.io.File;

/**
 * 递归打印多级目录
 */

public class FileMainDemo3 {
    public static void main(String[] args) {
        File f1 = new File("C:\\Users\\luokaili\\IdeaProjects\\list\\2020.11.27");
        getAllFiel(f1);
    }

    public static void getAllFiel(File dir){
        File[] files = dir.listFiles();
        for (File file : files) {
            if (file.isDirectory()){
                getAllFiel(file);
            }
            if(file.getName().endsWith(".java"))
                System.out.println(file);
        }

    }
}

文件过滤器：

package FileDemo;

import java.io.File;
import java.io.FileFilter;

/**
 * 文件过滤器
 * 在File类中有两个和ListFiles重载的方法，方法的参数传递的就是过滤器
 * File[] listFiles(FileFilter filter):用于抽象路径名的过滤器
 * 作用：用来过滤文件（File对象）
 * 抽象方法：用来过滤文件的方法
 * boolean accept(File pathname):测试指定抽象路径名是否包含在某个路径名列表中
 * 参数：File pathname：使用ListFiles方法遍历目录，得到每一个文件对象
 * File[] listFiles(FilenameFilter filter):实现此接口的类实例可用于过滤文件名
 * 作用：用来过滤文件名称
 * 抽象方法：用来过滤文件的方法
 * boolean accept（File dir,String name）:测试指定文件是否包含在某一个文件列表中
 * 参数：File dir:构造方法中传递的被遍历的目录
 * String name:使用ListFiles方法遍历目录，获取每一个文件夹的名称
 *
 * 注意：两个过滤器接口是没有实现类的，需要自己写实现类，重写过滤的方法accept，在方法中定义过滤的规则
 */

public class FileMainDemo4 {

    public static void main(String[] args) {
        File f1 = new File("C:\\Users\\luokaili\\IdeaProjects\\list\\2020.11.27");
        getAllFiel(f1);
    }

    public static void getAllFiel(File dir){
        //File[] files = dir.listFiles(new FileFilterImpl());
        File[] files = dir.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                return pathname.isDirectory() || pathname.getName().toLowerCase().endsWith(".java");
            }
        });
        for (File file : files) {
            if (file.isDirectory()){
                getAllFiel(file);
            }
            else {
                System.out.println(file);
            }
        }

    }

}

package FileDemo;

import java.io.File;
import java.io.FileFilter;

/**
 * 需要自己写实现类，重写过滤的方法accept，在方法中定义过滤的规则
 */

public class FileFilterImpl implements FileFilter {
    @Override
    public boolean accept(File pathname) {
        if(pathname.isDirectory()){
            return true;
        }
        return pathname.getName().toLowerCase().endsWith(".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):将指定的字节输出流

package IODemo;

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

/**
 * 字节输出流（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开始输出到此输出流
 *
 * FileOutputStream:文件字节输出流
 * 作用：把内存中的数据写入到硬盘文件中
 * 构造方法：
 * FileOutputStream(String name)：创建一个向具有指定名称的文件中写入数据的输出流
 * FileOutputStream(File file)：创建一个向指定File对象表示的文件中写入数据的输出流
 * 参数：写入数据的目的地
 * String name:目的地是一个路径
 * File file:目的地是一个文件
 * 构造方法的作用：
 * 1.创建一个FileOutputStream对象
 * 2.会根据构造方法中传递的文件/文件路径，创建一个空的文件
 * 3.会把FileOutputStream对象指向创建好的文件
 *
 * 写入数据的原理：java程序->JVM->OS（操作系统）->OS调用写数据的方法->把数据写到文件中
 *
 * 字节输出流的使用步骤：
 * 1.创建一个FileOutpurStream对象，构造方法中传递写入数据的目的地
 * 2.调用FileOutputStream对象中的方法write,把数据写入到文件中
 * 3.释放资源(流使用会占用一定的内存，使用完毕把内存清空，提高程序的效率)
 */

public class FileOutputStreamDemo1 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("C:\\Users\\" +
                "luokaili\\IdeaProjects\\list\\2020.11.27\\11.txt");
        fos.write(97);
        fos.close();
    }
}

在这里插入图片描述

package IODemo;

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

/**
 * 字节输出流（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开始输出到此输出流
 *
 * FileOutputStream:文件字节输出流
 * 作用：把内存中的数据写入到硬盘文件中
 * 构造方法：
 * FileOutputStream(String name)：创建一个向具有指定名称的文件中写入数据的输出流
 * FileOutputStream(File file)：创建一个向指定File对象表示的文件中写入数据的输出流
 * 构造方法2(追加写)：
 *  * FileOutputStream(String name,boolean append)：创建一个向具有指定名称的文件中写入数据的输出流
 *  * FileOutputStream(File file,boolean append)：创建一个向指定File对象表示的文件中写入数据的输出流
 *  换行符号：
 *  windows:\r\n
 *  linux:/n
 *  mac:/r
 * 参数：写入数据的目的地
 * String name:目的地是一个路径
 * File file:目的地是一个文件
 * 构造方法的作用：
 * 1.创建一个FileOutputStream对象
 * 2.会根据构造方法中传递的文件/文件路径，创建一个空的文件
 * 3.会把FileOutputStream对象指向创建好的文件
 *
 * 写入数据的原理：java程序->JVM->OS（操作系统）->OS调用写数据的方法->把数据写到文件中
 *
 * 字节输出流的使用步骤：
 * 1.创建一个FileOutpurStream对象，构造方法中传递写入数据的目的地
 * 2.调用FileOutputStream对象中的方法write,把数据写入到文件中
 * 3.释放资源(流使用会占用一定的内存，使用完毕把内存清空，提高程序的效率)
 */

public class FileOutputStreamDemo1 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("C:\\Users\\" +
                "luokaili\\IdeaProjects\\list\\2020.11.27\\11.txt",true);
        byte[] b = {97,98,99};
        //fos.write(97);
        fos.write(b,0,2);
        fos.write("\r\n".getBytes());
        fos.write("你好".getBytes());
        fos.close();
    }
}

字节输入流（InputStream）：
一次读取一个字节：

package FileDemo;

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

/**
 * 字节输入流（IutputStream）：
 *  * public void close():关闭此输入流并释放与流相关联的任何系统资源
 *  * public void read():从输入流中读取数据的下一个字节(一次读取一个字节)
 *  * public void read(byte[] b):从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中
 *  *
 *  FileInputStream:文件字节输入流
 *  作用：把硬盘文件中的数据，读取到内存中使用
 *
 *  构造方法：
 *  FileInputStrream(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 FileInputStreamDemo {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("2020.11.27\\11.txt");
        //int read()读取文件中的一个字节并返回，读取到文件的末尾返回-1
        /*int len = fis.read();
        System.out.println(len);
        */
        int len = 0;
        while((len = fis.read())!=-1){
            System.out.println(len);
        }

        fis.close();
    }

}

一次读取多个字节：

package FileDemo;

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

/**
 * 字节输入流（IutputStream）：
 *  * public void close():关闭此输入流并释放与流相关联的任何系统资源
 *  * public void read(byte[] b):从输入流中读取数据的下一个字节（一次读取一个字节）
 *  * public void read(byte[] b):从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中（一次读取多个字节）
 *  *
 *  FileInputStream:文件字节输入流
 *  作用：把硬盘文件中的数据，读取到内存中使用
 *
 *  构造方法：
 *  FileInputStrream(String name)
 *  FileInputStream(File file)
 *  参数：读取文件的数据源
 *  String name:文件的路径
 *  File file:文件名
 *  构造方法的作用：
 *  1.会创建一个FileInputStream对象
 *  2.会把FileInputStream对象指定构造方法中要读取的文件
 *
 *  写入数据的原理：java程序->JVM->OS（操作系统）->OS调用写数据的方法->把数据写到文件中
 *
 *  字节输入流的步骤：
 *  1.创建FileInputStream对象，构造方法中绑定要读取的数据源
 *  2.使用FileInputStream对象中的方法read，读取文件
 *  3.释放资源
 *
 *  String类构造方法：
 *  String(byte[] bytes):把字节数组转换Wie字符串
 *  String (byte[] bytes,int off,int len):把字节数组的一部分转换为字符串
 */

public class FileInputStreamDemo1 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("2020.11.27\\22.txt");
        //int read()读取文件中的一个字节并返回，读取到文件的末尾返回-1
        /*int len = fis.read();
        System.out.println(len);
        */
       /* int len = 0;
        while((len = fis.read())!=-1){
            System.out.println(len);
        }*/

        byte[] bytes = new byte[1024];
        //int len = fis.read(bytes);
        int len = 0;
        /*System.out.println(len);
        System.out.println(Arrays.toString(bytes));
        System.out.println(new String(bytes));*/

        while((len = fis.read(bytes))!=-1){
            System.out.println(len);
            System.out.println(new String(bytes));
        }

        fis.close();
    }

}

文件复制：

package FileDemo;

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

/**
 * 字节输入流（IutputStream）：
 *  * public void close():关闭此输入流并释放与流相关联的任何系统资源
 *  * public void read(byte[] b):从输入流中读取数据的下一个字节（一次读取一个字节）
 *  * public void read(byte[] b):从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中（一次读取多个字节）
 *  *
 *  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.释放资源
 *
 *  String类构造方法：
 *  String(byte[] bytes):把字节数组转换Wie字符串
 *  String (byte[] bytes,int off,int len):把字节数组的一部分转换为字符串
 */

public class FileInputStreamDemo2 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("2020.11.27\\1.jpg");
        FileOutputStream fos = new FileOutputStream("2020.11.27\\2.jpg");
        //int read()读取文件中的一个字节并返回，读取到文件的末尾返回-1
        /*int len = fis.read();
        System.out.println(len);
        */
       /* int len = 0;
        while((len = fis.read())!=-1){
            System.out.println(len);
        }*/

        byte[] bytes = new byte[1024];
        //int len = fis.read(bytes);
        int len = 0;
        /*System.out.println(len);
        System.out.println(Arrays.toString(bytes));
        System.out.println(new String(bytes));*/

        while((len = fis.read(bytes))!=-1){
            System.out.println(len);
            System.out.println(new String(bytes,0,len));
            fos.write(bytes,0,len);
        }
		fos.close();
        fis.close();
    }

}

字符流：
使用字节流读取中文文件：
1个中文：
GBK：占用连个字节
UTH-8：占用三个字节
文件字符输入流（FileReader）：

package FileDemo;

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

/**
 * Reader字符输入流：是字符输入流的最顶层的父类，定义了一些共性的成员方法，是一个抽象类
 * 共性的成员方法：
 * int read():读取单个字符并返回
 * int read(char[] cbuf):一次读取多个字符将字符读入数组
 * void close():关闭该流并释放与之关联的所有资源
 *
 * FileReader:文件字符输入流
 * 作用：把硬盘文件中的数据以字符的方式读取到内存中
 *
 * 构造方法：
 * FileReader(String fileName)
 * FileReader(File file)
 * 参数：读取文件的数据源
 *  *  String fileName:文件的路径
 *  *  File file:文件名
 *  构造方法的作用：
 *  *  1.会创建一个FileReader对象
 *  *  2.会把FileReader对象指向构造方法中要读取的文件
 * 字节输入流的步骤：
 *  *  1.创建FileReader对象，构造方法中绑定要读取的数据源
 *  *  2.使用FileReader对象中的方法read，读取文件
 *  *  3.释放资源
 *  
 *  String类构造方法：
 *  *  String(char[] value):把字符数组转换为字符串
 *  *  String (char[] value,int off,int len):把字符数组的一部分转换为字符串
 */

public class FileReaderDemo {
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("2020.11.27\\11.txt");
        int len = 0;
        /*while((len = fr.read())!=-1){
            System.out.print((char)len);
        }*/


        char[] cs = new char[1024];
        while ((len = fr.read(cs))!=-1){
            System.out.println(new String(cs));
        }
        fr.close();
    }
}

文件字符输出流(FileWriter)：

package FileDemo;

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

/**
 * Writer字符输出流：是字符输出流的最顶层的父类，定义了一些共性的成员方法，是一个抽象类
 * 共性的成员方法：
 * void write(int c):写入单个字符
 * void write (char[] cbuf):写入字符数组
 * void write(char[] cbuf,int off,int len):写入字符数组的一部分
 * void write(String str):写入字符串
 * void write(String str，int off,int len):写入字符串的一部分
 * void flush():刷新该流的缓冲
 * void close():关闭此流，但要先刷新它
 *
 *
 * FileWriter:文件字符输出流
 * 作用：把内存中的数据以字符的方式写到文件中
 *
 * 构造方法：
 * FileWriter(String fileName)
 * FileWriter(File file)
 * 参数：读取文件的数据源
 *  *  String fileName:文件的路径
 *  *  File file:文件名
 *  构造方法的作用：
 *  *  1.会创建一个FileWriter对象
 *      2.会根据构造方法中传递的文件/文件的路径，创建文件
 *  *  3.会把FileWriter对象指向构造方法中要读取的文件
 * 字节输入流的步骤：
 *  *  1.创建FileWriter对象，构造方法中绑定要读取的数据源
 *  *  2.使用FileWriter对象中的方法write，把数据写入到内存的缓冲区中（字符转换为字节的过程）
 *  *  3.使用FileWriter对象中的方法flush，把内存缓冲区中的数据，刷新到文件中
 *  *  3.释放资源
 *
 *  String类构造方法：
 *  *  String(char[] value):把字符数组转换为字符串
 *  *  String (char[] value,int off,int len):把字符数组的一部分转换为字符串
 */

public class FileWriterDemo {
    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("2020.11.27\\aa.txt",true);
        char[] chs = {'a','b','c'};
        fw.write(chs);
        fw.write("\r\n");
        fw.write("你好");
        fw.close();
    }
}

属性集（Properties）：

package FileDemo;

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

/**
 * Properties继承于HashTable
 * Properties类表示了一个持久的属性集，可保存在流中或从流中加载
 * Properties集合是一个唯一和IO流相结合的集合
 * 可以使用Properties集合中的方法Store，把集合中的临时数据，持久化写入到硬盘中存储
 * 可以使用Properties集合中的方法Load，把集合硬盘中存储的文件，读取到集合中使用
 *
 * 属性中的每个键及其值都是一个字符串
 * Properties集合是一个双列集合，key和value默认都是字符串
 *
 * 常用方法：
 * Object setPropertiy(String key,String value):调用HashTable的方法put
 * String getProperty(String key):通过key值找value
 * Set<String> stringPropertyNames():返回此属性列表中的键集，
 * 其中该键及其对应值是字符串，此方法相当于Map集合中的keySet()
 */

public class PropertiesDemo {
    public static void main(String[] args) throws IOException {
        show01();
        System.out.println("==========================");
        show02();
        show04();
    }

    private static void show01(){
        Properties prop = new Properties();
        prop.setProperty("赵丽颖","168");
        prop.setProperty("迪丽热巴","165");
        prop.setProperty("古力娜扎","160");

        Set<String> strings = prop.stringPropertyNames();
        for (String string : strings) {
            String property = prop.getProperty(string);
            System.out.println(string+"="+property);
        }
    }

    /**
     * 可以使用Properties集合中的方法Store，把集合中的临时数据，持久化写入到硬盘中存储
     * void store(OutputStream out,String comments)
     * void store(Writer writer,String comments)
     * 参数：
     * OutputStream out：字节输出流，不能写入中文
     * Writer writerm：字符输出流，可以写入中文
     * String comments：注释  用来说明保存的文件时做什么用的  不能使用中文  一般使用空字符串""
     *
     * 使用步骤：
     * 1.创建Properties集合对象，添加数据
     * 2.创建字节/字符输出流对象，构造方法绑定要输出的目的地
     * 3.使用Properties集合中的方法store，把集合中的临时数据，持久化写入到硬盘中存储
     * 4.释放资源
     */
    private static void show02() throws IOException {
        Properties prop = new Properties();
        prop.setProperty("赵丽颖","168");
        prop.setProperty("迪丽热巴","165");
        prop.setProperty("古力娜扎","160");

        FileWriter fw = new FileWriter("2020.11.27\\pro.txt");

        prop.store(fw,"save data");

        fw.close();
    }

    /**
     * 可以使用Properties集合中的方法Load，把硬盘中的文件，读取到集合中使用
     *      * void load(InputStream out)
     *      * void store(Reader reader)
     *      * 参数：
     *      * InputStream out：字节输入流，不能写入中文
     *      * Reader reader：字符输入流，可以写入中文
     *      *
     *      *
     *      * 使用步骤：
     *      * 1.创建Properties集合对象
     *      *
     *      * 2.使用Properties集合中的方法load读取保存键值对的文件
     *      * 3.遍历Properties集合
     *
     *      注意：
     *      1.存储键值对的文件中，键与值默认的连接符号可以使用=，空格（其它符号）
     *      2.存储键值对的文件中，可以使用#进行注释，被注释的键值对不会被读取
     *      3.存储键值对的文件中，键与值默认是字符串，可以不用双引号了
     */
    private static void show04() throws IOException {
        Properties prop = new Properties();
        prop.load(new FileReader("2020.11.27\\pro.txt"));

        Set<String> strings = prop.stringPropertyNames();
        for (String string : strings) {
            String property = prop.getProperty(string);
            System.out.println(string+"="+property);
        }

    }

}

缓冲流(原理类似于输出字节/字符数组，提高流的效率)：
字节缓冲输出流（BufferedOutputStream）:
在这里插入图片描述

字节缓冲输入流（BufferedInputStream）:

字符缓冲输出流：

字符缓冲输入流：

转换流：字节流->字符流/字符流->字节流

OutputStreamWriter:是字符流转向字节流的桥梁：可使用指定的charset将要写入的流中的字符编码成字节（编码：把能看懂的变成看不懂的）
在这里插入图片描述

InputStreamReader:是字节流转向字符流的桥梁：可使用指定的charset读取字节并将其解码成字符（编码：把能不看懂的变成能看懂的）

序列化与反序列化：

序列化：
注意：被transient修饰的成员变量不能被序列化

package FileDemo;

import java.io.Serializable;

/**
 * 要进行序列化和反序列化的类必须实现Serializable接口
 */

public class Person implements Serializable {

    private String name;
    private int age;

    public Person() {
    }

    public Person(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 "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

package FileDemo;

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

/**
 * public ObjectOutputStream(OutputStream out):创建一个指定OutputStream的ObjectOutputStream
 * ObjectOutputStream：对象的序列化流
 * 作用：把对象以流的形式写入到文件中保存
 * 构造方法：
 * public ObjectOutputStream(OutputStream out):创建一个指定OutputStream的ObjectOutputStream
 *
 * 特有的成员方法：
 * void writeObject(Object obj):将指定的对象写入到流中
 * 使用步骤：
 * 1.创建ObjectOutputStream对象，构造方法中传递字节输出流
 * 2.使用ObjectOutputStream对象的writeObject方法，把对象写入到文件中
 * 3.释放资源
 */

public class ObjectOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream
                (new FileOutputStream("2020.11.27\\Person.txt"));
        oos.writeObject(new Person("赵丽颖",18));
        oos.close();
    }
}

反序列化：

package FileDemo;

import java.io.*;

/**
 *
 * ObjectOutputStream：对象的反序列化流
 * 作用：把文件中保存的对象，以流的方式读取出来使用
 *
 *
 * 构造方法：
 * public ObjectInputStream(InputStream in):创建一个指定InputStream的ObjectInputStream
 *
 * 特有的成员方法：
 * void readObject():从ObjectInoutStream读取对象
 * 使用步骤：
 * 1.创建ObjectInputStream对象，构造方法中传递字节输入流
 * 2.使用ObjectInputStream对象的readObject方法读取保存对象的文件
 * 3.释放资源
 * 4.使用读取出来的额对象
 */

public class ObjectInputStreamDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream
                (new FileInputStream("2020.11.27\\Person.txt"));
        Object o = ois.readObject();
        ois.close();
        System.out.println(o);
    }
}