Java基础语法（二十五）

版权声明：作者已开启版权声明，如转载请注明转载地址。 https://blog.csdn.net/qq_34829447/article/details/82157065

一.Properties集合

1.Properties集合的特点

• Properties类介绍：Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。
• 特点
  
  • Hashtable的子类，map集合中的方法都可以用
  • 该集合没有泛型。键值都是字符串
  • 它是一个可以持久化的属性集。键值可以存储到集合中，也可以存储到持久化的设备(硬盘、U盘、光盘)上。键值的来源也可以是持久化的设备。
  • 有和流技术相结合的方法
• 方法介绍
  
  • load(InputStream inputStream)把指定流所对应的文件中的数据，读取出来，保存到Propertie集合中
  • load(Reader reader)按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）
  • store(OutputStream outputStream,String commonts)把集合中的数据，保存到指定的流所对应的文件中，参数commonts代表对描述信息
  • stroe(Writer writer,String comments)以适合使用 load(Reader) 方法的格式，将此 Properties 表中的属性列表（键和元素对）写入输出字符

2.Properties集合存储键值对

• Properties集合存储键值对方法介绍

  • 集合对象Properties类,继承Hashtable,实现Map接口
  • 可以和IO对象结合使用,实现数据的持久存储
  • 使用Properties集合,存储键值对
  • setProperty等同与Map接口中的put
  • setProperty(String key, String value)
  • 通过键获取值, getProperty(String key)

• 实例代码

  public class PropertiesDemo {
    public static void main(String[] args)throws IOException {
        function_2();
    }
    /*
               * 使用Properties集合,存储键值对
               * setProperty等同与Map接口中的put
               * setProperty(String key, String value)
               * 通过键获取值, getProperty(String key)
               */
    public static void function(){
        Properties pro = new Properties();
        pro.setProperty("a", "1");
        pro.setProperty("b", "2");
        pro.setProperty("c", "3");
        System.out.println(pro);
        String value = pro.getProperty("c");
        System.out.println(value);
        //方法stringPropertyNames,将集合中的键存储到Set集合,类似于Map接口的方法keySet
        Set<String> set = pro.stringPropertyNames();
        for(String key : set){
            System.out.println(key+"..."+pro.getProperty(key));
        }
    }
  }

3.Properties集合的方法load

• Properties集合的方法load方法介绍

  • Properties集合特有方法 load
  • load(InputStream in)
  • load(Reader r)
  • 传递任意的字节或者字符输入流
  • 流对象读取文件中的键值对,保存到集合

• 实例代码

  public class PropertiesDemo {
    public static void main(String[] args)throws IOException {
        function_1();
    }                                 
    /*
               * Properties集合特有方法 load
               * load(InputStream in)
               * load(Reader r)
               * 传递任意的字节或者字符输入流
               * 流对象读取文件中的键值对,保存到集合
               */
    public static void function_1()throws IOException{
        Properties pro = new Properties();
        FileReader fr = new FileReader("c:\\pro.properties");
        //调用集合的方法load,传递字符输入流
        pro.load(fr);
        fr.close();
        System.out.println(pro);
    }                 
  }

4.Properties集合的方法store

• Properties集合的方法store介绍

  • Properties集合的特有方法store
  • store(OutputStream out)
  • store(Writer w)
  • 接收所有的字节或者字符的输出流,将集合中的键值对,写回文件中保存

• 实例代码

  public class PropertiesDemo {
    public static void main(String[] args)throws IOException {
        function_2();
    }
    /*
               * Properties集合的特有方法store
               * store(OutputStream out)
               * store(Writer w)
               * 接收所有的字节或者字符的输出流,将集合中的键值对,写回文件中保存
               */
    public static void function_2()throws IOException{
        Properties pro = new Properties();
        pro.setProperty("name", "zhangsan");
        pro.setProperty("age", "31");
        pro.setProperty("email", "[email protected]");
        FileWriter fw = new FileWriter("c:\pro.properties");
        //键值对,存回文件,使用集合的方法store传递字符输出流
        pro.store(fw, "");
        fw.close();
    }
  }

二.序列化流与反序列化流

1.对象的序列化与反序列化基本概念

• 对象的序列化
  
  • 对象中的数据，以流的形式，写入到文件中保存过程称为写出对象，对象的序列化
  • ObjectOutputStream将对象写到文件中，实现序列化
• 对象的反序列化
  
  • 在文件中，以流的形式，将对象读出来，读取对象，对象的反序列化
  • ObjectInputStream 将文件对象读取出来

2.ObjectOutputStream流写对象

• ObjectOutputStream流写对象介绍

  • IO流对象,实现对象Person序列化,和反序列化
  • 构造方法：ObjectOutputStream(OutputStream os)写对象,实现序列化方法writeObject(Object o)（对象o必须是实现了Serializable接口的对象）
  • 构造方法:ObjectInputStream(InputStream is)读取对象,实现反序列化方法Object readObject()（传递的输入流封装的文件必须是序列化的文件）

• 序列化对象，实例代码

  public class Person implements Serializable{
    public String name;
    public int age;
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Person(){}
  
    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 + "]";
    }             
  }
  
  public class ObjectStreamDemo {
    public static void main(String[] args)throws IOException, ClassNotFoundException {
        //        writeObject();
        readObject();
    }
    /*
           * ObjectOutputStream
           * 构造方法: ObjectOutputStream(OutputSteam out)
           * 传递任意的字节输出流
           * void writeObject(Object obj)写出对象的方法
           */
    public static void writeObject() throws IOException{
        //创建字节输出流,封装文件
        FileOutputStream fos = new FileOutputStream("c:\\person.txt");
        //创建写出对象的序列化流的对象,构造方法传递字节输出流
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        Person p = new Person("lisi",25);
        //调用序列化流的方法writeObject,写出对象
        oos.writeObject(p);
        oos.close();
    }
  }

• 反序列化对象，实例代码

  /*
                 *  IO流对象,实现对象Person序列化,和反序列化
                 *  ObjectOutputStream 写对象,实现序列化
                 *  ObjectInputStream 读取对象,实现反序列化
                 */
  public class ObjectStreamDemo {
    public static void main(String[] args)throws IOException, ClassNotFoundException {
        readObject();
    }
  
    /*
                     * ObjectInputStream
                     * 构造方法:ObjectInputStream(InputStream in)
                     * 传递任意的字节输入流,输入流封装文件,必须是序列化的文件
                     * Object readObject()  读取对象
                     */
  
    public static void readObject() throws IOException, ClassNotFoundException{
        FileInputStream fis = new FileInputStream("c:\person.txt");
        //创建反序列化流,构造方法中,传递字节输入流
        ObjectInputStream ois = new ObjectInputStream(fis);
        //调用反序列化流的方法 readObject()读取对象
        Object obj =ois.readObject();
        System.out.println(obj);
        ois.close();
    }             
  }

3.静态不能序列化原因

• 序列化是把对象数据进行持久化存储
• 静态的东西不属于对象，而属于类

4.transient关键字作用

• 被transient修饰的属性不会被序列化
• transient关键字只能修饰成员变量

5.Serializable接口的作用

• 给需要序列化的类上加标记。该标记中没有任何抽象方法
• 只有实现了 Serializable接口的类的对象才能被序列化

6.序列化中的序列号冲突问题

• 问题产生原因

  • 当一个类实现Serializable接口后，创建对象并将对象写入文件，之后更改了源代码(比如：将成员变量的修饰符有private改成public)，再次从文件中读取对象时会报异常

• 序列号的冲突

  

7.序列化中自定义的序列号

• 定义方式

  • private static final long serialVersionUID = 1478652478456L;
  • 这样每次编译类时生成的serialVersionUID值都是固定的

• 实例代码

  public class Person implements Serializable{
    public String name;
    public /*transient阻止成员变量序列化*/ int age;
    //类,自定义了序列号,编译器不会计算序列号
    private static final long serialVersionUID = 1478652478456L;
  
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Person(){}
  
    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 + "]";
    }             
  }

三.打印流

1.打印流概述

• 概述
  
  • 打印流添加输出数据的功能，使它们能够方便地打印各种数据值表示形式.
  • 打印流根据流的分类
    
    • 字节打印流 PrintStream
    • 字符打印流 PrintWriter
  • 方法
    
    • void print(String str): 输出任意类型的数据
    • void println(String str): 输出任意类型的数据，自动写入换行操作
• 特点
  
  • 此流不负责数据源,只负责数据目的
  • 为其他输出流,添加功能
  • 永远不会抛出IOException，但是可能抛出别的异常
  • 两个打印流的方法,完全一致
  • 构造方法,就是打印流的输出目的端
    
    • PrintStream构造方法：接收File类型,接收字符串文件名,接收字节输出流OutputStream
    • PrintWriter构造方法：接收File类型,接收字符串文件名,接收字节输出流OutputStream, 接收字符输出流Writer

2.打印流输出目的是File对象

• 打印流的输出目的是File时，可以利用println()方法输出boolean类型、string类型、数组等内容

• 实例代码

  public class PrintWriterDemo {
    public static void main(String[] args) throws  IOException {
        function();
    }
    /*
           * 打印流,向File对象的数据目的写入数据
           * 方法print println  原样输出
           * write方法走码表
           */
    public static void function() throws FileNotFoundException{
        File file = new File("c:\\1.txt");
        PrintWriter pw = new PrintWriter(file);
        pw.println(true);
        pw.write(100);
        pw.close();//文件输出true 100
    }
  }

3.打印流输出目的是String和流对象

• 实例代码

  public class PrintWriterDemo {
    public static void main(String[] args) throws  IOException {
        function_2();
    }
    /*
           * 打印流,输出目的,是流对象
           * 可以是字节输出流,可以是字符的输出流
           * OutputStream  Writer
           */
    public static void function_2() throws IOException{
        //    FileOutputStream fos = new FileOutputStream("c:\\3.txt");
        FileWriter fw = new FileWriter("c:\\4.txt");
        PrintWriter pw = new PrintWriter(fw);
        pw.println("打印流");
        pw.close();
    }
    /*
           * 打印流,输出目的,String文件名
           */
    public static void function_1() throws FileNotFoundException{
        PrintWriter pw = new PrintWriter("c:\\2.txt");
        pw.println(3.5);
        pw.close();
    } 
  
  }

4.打印流开启自动刷新

• 打印流,可以开启自动刷新功能

  • 输出的数据目的必须是流对象（Writer或OutputStream）

  • 必须调用println、printf、format三个方法中的一个，启用自动刷新

  • 开启自动刷新写入功能，使用对应的构造方法

  public PrintWriter(OutputStream out, boolean autoFlush)

  public PrintWriter(Writer out, boolean autoFlush)

• 实例代码

  public static void function_3()throws  IOException{
    FileOutputStream fos = new FileOutputStream("c:\\5.txt");
    PrintWriter pw = new PrintWriter(fos,true);
    pw.println("i");
    pw.println("love");
    pw.println("java");
    pw.close();
  }

5.打印流复制文本文件

/*
             * 打印流实现文本复制
             *   读取数据源  BufferedReader+File 读取文本行
             *   写入数据目的 PrintWriter+println 自动刷新
             */
public class PrintWriterDemo1 {
    public static void main(String[] args) throws IOException{
        BufferedReader bfr = new BufferedReader(new FileReader("c:\a.txt"));
        PrintWriter pw = new PrintWriter(new FileWriter("d:\a.txt"),true);
        String line = null;
        while((line = bfr.readLine())!=null){
            pw.println(line);
        }
        pw.close();
        bfr.close();
    }
}

四.commons-IO

1.IO工具类FilenameUtils

• 方法介绍

  • getExtension(String path)：获取文件的扩展名；
  • getName()：获取文件名；
  • isExtension(String fileName,String ext)：判断fileName是否是ext后缀名；

• 实例代码

  public class Commons_IODemo {
    public static void main(String[] args) {
        function_2();
    }
    /*
               * FilenameUtils类的方法
               * static boolean isExtension(String filename,String extension)
               * 判断文件名的后缀是不是extension
               */
    public static void function_2(){
        boolean b = FilenameUtils.isExtension("Demo.java", "java");
        System.out.println(b);
    }
    /*
           * FilenameUtils类的方法
           * static String getName(String filename)
           * 获取文件名
           */
    public static void function_1(){
        String name = FilenameUtils.getName("c:\\windows\\");
        System.out.println(name);
    }
  
    /*
           * FilenameUtils类的方法
           * static String getExtension(String filename)
           * 获取文件名的扩展名
           */
    public static void function(){
        String name = FilenameUtils.getExtension("c:\\windows");
        System.out.println(name);
    }
  }

2.IO工具类FileUtils

• IO工具类FileUtils方法介绍

  • readFileToString(File file)：读取文件内容，并返回一个String；
  • writeStringToFile(File file，String content)：将内容content写入到file中；
  • copyDirectoryToDirectory(File srcDir,File destDir);文件夹复制
  • copyFile(File srcFile,File destFile);文件复制

• 实例代码

  public class Commons_IODemo1 {
    public static void main(String[] args)throws IOException {
        function_3();
    }
    /*
           * FileUtils工具类方法
           * static void copyDirectoryToDirectory(File src,File desc)
           * 复制文件夹
           */
    public static void function_3() throws IOException{
        FileUtils.copyDirectoryToDirectory(new File("d:\\demo"), new File("c:\\"));
    }
  
    /*
           * FileUtils工具类的方法
           * static void copyFile(File src,File desc)
           * 复制文件
           */
    public static void function_2() throws IOException{
        FileUtils.copyFile(new File("c:\\k.jpg"),new File("d:\\k.jpg"));
    }
  
    /*
           * FileUtils工具类的方法
           * static void writeStringToFile(File src,String date)
           * 将字符串直接写到文件中
           */
    public static void function_1() throws IOException{
        FileUtils.writeStringToFile(new File("c:\\b.txt"),"我爱Java编程");
    }
  
    /*
           * FileUtils工具类的方法
           * static String readFileToString(File src)读取文本,返回字符串
           */
    public static void function() throws IOException{
        String s = FileUtils.readFileToString(new File("c:\\a.txt"));
        System.out.println(s);
    }
  }

五.IO总结

1.字节流

• 字节输入流 InputStream
  
  • FileInputStream 操作文件的字节输入流
  • BufferedInputStream高效的字节输入流
  • ObjectInputStream 反序列化流
• 字节输出流 OutputStram
  
  • FileOutputStream 操作文件的字节输出流
  • BufferedOutputStream 高效的字节输出流
  • ObjectOuputStream 序列化流
  • PrintStream 字节打印流

2.字符流

• 字符输入流 Reader
  
  • FileReader 操作文件的字符输入流
  • BufferedReader 高效的字符输入流
  • InputStreamReader 输入操作的转换流(把字节流封装成字符流)
• 字符输出流 Writer
  
  • FileWriter 操作文件的字符输出流
  • BufferedWriter 高效的字符输出流
  • OutputStreamWriter 输出操作的转换流(把字节流封装成字符流)
  • PrintWriter 字符打印流

2.方法：

• 读数据方法：
  
  • read() 一次读一个字节或字符的方法
  • read(byte[] char[]) 一次读一个数组数据的方法
  • readLine() 一次读一行字符串的方法(BufferedReader类特有方法)
  • readObject() 从流中读取对象(ObjectInputStream特有方法)
• 写数据方法：
  
  • write(int) 一次写一个字节或字符到文件中
  • write(byte[] char[]) 一次写一个数组数据到文件中
  • write(String) 一次写一个字符串内容到文件中
  • writeObject(Object ) 写对象到流中(ObjectOutputStream类特有方法)
  • newLine() 写一个换行符号(BufferedWriter类特有方法)

3.向文件中写入数据的过程

• 创建输出流对象
• 写数据到文件
• 关闭输出流

4.从文件中读数据的过程

• 创建输入流对象
• 从文件中读数据
• 关闭输入流

5.文件复制的过程

• 创建输入流（数据源）
• 创建输出流（目的地）
• 从输入流中读数据
• 通过输出流，把数据写入目的地
• 关闭流

6.File类

• 方法
  
  • 获取文件名称 getName()
  • 获取文件绝对路径 getAbsolutePath()
  • 获取文件大小 length()
  • 获取当前文件夹中所有File对象 File[] listFiles()
  • 判断是否为文件 isFile()
  • 判断是否为文件夹 isDirectory()
  • 创建文件夹 mkdir() mkdirs()
  • 创建文件 createNewFile()

7.异常

• try..catch…finally捕获处理异常
• throws 声明异常
• throw 抛出异常对象

8.异常的分类

• 编译期异常 Exception
• 运行期异常 RuntimeException
• 注意：
  
  • 编译期异常，必须处理，不然无法编译通过
  • 运行期异常，程序运行过程中，产生的异常信息

9.Properties：Map集合的一种，它是Hashtable集合的子集合,它键与值都是String类型,它是唯一能与IO流结合使用的集合

• 方法
  
  • load( InputStream in ) 从流所对应的文件中，读数据到集合中
  • load( Reader in ) 从流所对应的文件中，读数据到集合中
  • store( OutputStream out , String message ) 把集合中的数据，写入到流所对应的文件中
  • store( Writer out , String message) 把集合中的数据，写入到流所对应的文件中

10.实现文件内容的自动追加

• 构造方法
  
  • FileOutputStream(File file, boolean append)
  • FileOutputStream(String fileName, boolean append)
  • FileWriter(File, boolean append)
  • FileWriter(String fileName, boolean append)
• 实现文件内容的自动刷新构造方法
  
  • PrintStream(OutputStream out, boolean autoFlush)
  • PrintStream(Writer out, boolean autoFlush)
  • PrintWriter(OutputStream out, boolean autoFlush)
  • PrintWriter(Writer out, boolean autoFlush)

11.Commons-IO方法

• readFileToString(File file)：读取文件内容，并返回一个String；
• writeStringToFile(File file，String content)：将内容content写入到file中；
• copyDirectoryToDirectory(File srcDir,File destDir);文件夹复制
• copyFileToDirectory (File srcFile,File destFile);文件复制