Java基础复习——DAY13（多级文件夹复制案例；特殊操作流）

续 IO小结

案例：复制多级文件夹

运用到递归

package file;

import java.io.*;

public class Demo {
    public static void main(String[] args) throws IOException {
        //创建数据源对象
        File srcFile = new File("G:\\Program\\itcast");
        //创建目的地对象
        File destFile = new File("G:\\");

        //方法实现文件复制
        copyFolder(srcFile, destFile);
    }

    //复制文件夹
    private static void copyFolder(File srcFile, File destFile) throws IOException {
        //判断是否是目录
        if (srcFile.isDirectory()) {
            String srcFileName = srcFile.getName();
            File newFolder = new File(destFile, srcFileName);
            if (!newFolder.exists()) {
                newFolder.mkdir();
            }
            //获取数据源所有文件
            File[] listFiles = srcFile.listFiles();
            for (File f : listFiles) {
                //获取名称
                String destname = f.getName();
                //创建目的地文件对象，注意路径
                File destfile = new File(destFile, destname);
                copyFolder(f, newFolder);
            }
        } else {
            File newfile = new File(destFile, srcFile.getName());
            copyFile(srcFile, newfile);
        }
    }

    //复制文件
    private static void copyFile(File srcfile, File destfile) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcfile));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destfile));
        byte[] bys = new byte[1024];
        int len;
        while ((len = bis.read(bys)) != -1) {
            bos.write(bys, 0, len);
        }
        bis.close();
        bos.close();
    }
}

特殊操作流

1. 标准输入输出流

标准输入流

• public static final lnputStreamin:标准输入流。通常该流对应于键盘输入或由主机环境或用户指定的另一个输入源
• public static final PrintStream out:标准输出流。通常该流对应于显示输出或由主机环境或用户指定的另一个输出目标

自己实现键盘录入数据:

• BufferedReader br =
  newBufferedReader(newInputStreamReader(System.in));

写起来太麻烦，Java就提供了一个类实现键盘录入

• Scanner sc = new Scanner(System.in);

标准输出流
System类中有两个静态的成员变量:

• public static final lnputStreamin:标准输入流。通常该流对应于键盘输入或由主机环境或用户指定的另一个输入源
• public static final Printstream out:标准输出流。通常该流对应于显示输出或由主机环境或用户指定的另一个输出目标

输出语句的本质:是一个标的输出流

• PrintStream ps = System.out;
• PrintStream类有的方法，System.out都可以使用

2. 打印流

• 字节打印流:PrintStream
• 字符打印流: PrintWriter

打印流特点：

• 只负责输出数据，不负责读取数据
• 有自己的特有方法

字节打印流

• PrintStream(String fileName):使用指定的文件名创建新的打印流
• 用自己特有方法写数据，可以数据原样输出；使用继承父类的方法写数据，查看时候会转码

package file;

import java.io.*;

public class Demo {
    public static void main(String[] args) throws IOException {
        //字节打印流对象
        PrintStream ps = new PrintStream("java.txt");

        ps.write(97);//a
        ps.println(97);//97换行
        ps.print(98);//98不换行

        ps.close();
    }
}

案例：字符打印流复制java文件

package file;

import java.io.*;

public class Demo {
    public static void main(String[] args) throws IOException {
        //数据源对象
        BufferedReader br = new BufferedReader(new FileReader("java.txt"));
        //更具目的地创建字符输出流对象
        PrintWriter pw = new PrintWriter(new FileWriter("G:\\Program\\java_basic_learning\\src\\file\\copy.txt"));
        String line;
        while ((line = br.readLine()) != null) {
            pw.println(line);
        }
        br.close();
        pw.close();
    }
}

3. 对象序列化流

对象序列化：将对象保存在磁盘中，或者网络中传输对象.

要实现序列化和反序列化就要使用对象序列化流和对象反序列化流:

• 对象序列化流:ObjectOutputStream（将java对象写入）
  构造方法：ObjectOutputStream(OutputStream out): 创建一个写入指定的OutputStream的ObjectOutputStream
  写入方法：void writeObject(Object obj):将指定的对象写入ObjectOutputStream

注意： 一个对象要想被序列化，该对象所属的类必须必须实现Serializable接口Serializable是一个标记接口，实现该接口，不需要重写任何方法。

public class Student implements Serializable {//不用重写任何方法

package file;

import java.io.*;

public class Demo {
    public static void main(String[] args) throws IOException {
        //对象序列化流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("G:\\Program\\java_basic_learning\\src\\file\\copy.txt"));
        //创建学生对象
        Student s1 = new Student("wts",100,90,80);
        //将对象写入
        oos.writeObject(s1);

        oos.close();
    }
}

最终结果：把对象存入文件

• 对象反序列化流:ObjectlnputStream
  构造方法：
  ObjectInputStream(InputStream in):创建从指定的InputStream读取的ObjectInputStream

  反序列化对象的方法:
  Object readObject():从ObjectlnputStream读取一个对象

package file;

import java.io.*;

public class Demo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //对象反序列化流
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("G:\\Program\\java_basic_learning\\src\\file\\copy.txt"));

        Object o = ois.readObject();

        Student s = (Student) o;//向下转型
        System.out.println(s.getName() + ',' + s.getChinese());//wts,100
    }
}

序列化细节：

1. 用对象序列化一个对象之后，假如我们修改了对象所属的类的文件，会报错，抛出，InvalidClassExpection异常
2. 若出现问题，如何解决？
   给对象所属的类，加一个serialVersionUID
   public static final long serialVersionUID = 42L
3. 一个对象的成员变量不想被序列化，怎么操作？
   transient修饰后的成员变量，不参与序列化

4. Properties

4.1 Properties概述

概述：

• 是一个Map体系的集合类
• Properties可以保存到流中或从流中加载

package file;

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

public class Demo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //创建集合对象
        Properties p = new Properties();

        p.put("cczu001", "wts");
        p.put("cczu002", "tian");
        p.put("cczu003", "sheng");

        Set<Object> keySet = p.keySet();
        for (Object key : keySet) {
            Object values = p.get(key);
            System.out.println(key + "," + values);
            //cczu002,tian
            //cczu001,wts
            //cczu003,sheng
        }
    }
}

4.2 Properties特有方法

package file;

import java.util.Properties;
import java.util.Set;

public class Demo {
    public static void main(String[] args)  {
        Properties p = new Properties();

        p.setProperty("cczu001", "wts");//底层最终还是put
        p.setProperty("cczu002", "lx");
        p.setProperty("cczu003", "wyx");

        System.out.println(p.getProperty("cczu001"));//根据键值得value
        //wts

        Set<String> names = p.stringPropertyNames();//返回一个不可修改的键集，键和值都是字符串
        for (String key : names) {
            String value = p.getProperty(key);
            System.out.println(key + "," + value);
            //cczu002,lx
            //cczu001,wts
            //cczu003,wyx
        }
    }
}

4.3 Properties和io相结合的方法

以字符流为例

package file;

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

public class Demo {
    public static void main(String[] args) throws IOException {
        //把集合保存到文件
        //Store();
        //把文件加载到集合
        Load();
    }

    private static void Load() throws IOException {
        FileReader fr = new FileReader("G:\\Program\\java_basic_learning\\src\\file\\copy.txt");
        Properties p = new Properties();
        p.load(fr);
        System.out.println(p);//{cczu002=lx, cczu001=wts, cczu003=wyx}
    }

    private static void Store() throws IOException {
        Properties p = new Properties();
        p.setProperty("cczu001", "wts");
        p.setProperty("cczu002", "lx");
        p.setProperty("cczu003", "wyx");

        FileWriter fw = new FileWriter("G:\\Program\\java_basic_learning\\src\\file\\copy.txt");
        p.store(fw, null);//null表示文件说明
        fw.close();
    }
}