IO_SXL

---

引言

做个俗人，贪财好色，一身正气。

---

一、File

1.1 File的基本使用

		// 系统默认;符号
        System.out.println(File.pathSeparator);
        // 系统默认\符号
        System.out.println(File.separator);

		// 替换系统默认符号
        String filePath = "E://dir";
        filePath = filePath.replace("//", File.separator);
        // 正常文件夹路径
        File dir = new File(filePath);
        // 创建文件夹 mkdirs能把中间缺失文件夹补全 mkdir缺少会报错
        dir.mkdirs();
        // 创建实例 dir上级文件夹
        File a = new File(dir,"a.txt");
        // 在test文件夹中创建test.txt文件
        a.createNewFile();

        // 创建实例 dir上级文件夹路径
        File b = new File(filePath,"b.txt");
        b.createNewFile();

        // 删除文件
        a.delete();
        b.delete();
        dir.delete();

1.2 File遍历

文件垃圾回收在相应地方添加delete删除，后缀慎重选择。

	public static void main(String[] args) throws IOException {

        File file = new File("D://SOFT");
        File[] files = file.listFiles();
        // 递归遍历
        listFiles(files);
    }

    private static void listFiles(File[] files) {
        if (files != null && files.length > 0) {
            // 循环
            for (File file : files) {
                // isFile 非文件夹文本
                if (file.isFile()) {
                    // 文件
                    if (file.getName().endsWith(".exe")) {
                        // 内存
                        if (file.length() > 1 * 1024 * 1024) {
                            System.out.println("test");
                        } else {
                            // 找到一个.exe文件
                            System.out.println("找到了一个.exe文件：" + file.getAbsolutePath());
                        }

                    }

                } else {
                    // 文件夹
                    File[] fileArr = file.listFiles();
                    // 递归
                    listFiles(fileArr);
                }
            }
        }

    }

1.3 File文件过滤器

	public static void main(String[] args) throws IOException {
        File file = new File("D://SOFT");
        listFiles(file);
    }

    private static void listFiles(File file) {
    	// 实现文件过滤接口的匿名内部类
        File[] files = file.listFiles(pathname -> {
            if (pathname.getName().endsWith(".exe") || pathname.isDirectory()) {
                return true;
            }
            return false;
        });

        for (File f : files) {
            if (f.isDirectory()) {
                listFiles(f);
            } else {
                System.out.println("找到了一个.exe文件：" + file.getAbsolutePath());
            }
        }
    }

---

二、流

IO流的分类：

• 按照流的方向来分，分为输入流和输出流
• 按照流的数据类型来分，分为字节流和字符流

字节流

• 输入流：InputStream
• 输出流：OutputStream

字符流

• 输入流：Reader
• 输出流：Writer

一切皆字节
计算机中任何数据（文本、图片、视频、音乐等等）都是以二进制形式存储的。
数据传输时（任何流），底层都是以二进制形式进行存储。

2.1 FileOutputStream

		// FileOutputStream
        // 第二个参数追加
        FileOutputStream fos = new FileOutputStream("E://a.txt", true);
        // byte[] bytes = {65, 66, 67, 68};
        byte[] bytes = "你好吗".getBytes();
        // 第二个参数是从第几个下标开始 第三个参数是长度
        fos.write(bytes, 1,2);
        // fos.write(65);
        fos.close();

2.2 FileInputStream

		// FileInputStream
        // 字节数组长度不够时可能存在读取一半字节产生乱码问题 可以用字符流或者转换流解决
        FileInputStream fis = new FileInputStream("E://a.txt");
        while(true) {
            byte[] bytes = new byte[1024];
            int len = fis.read(bytes);
            if (len == -1) {
                break;
            }
            System.out.println(new String(bytes, 0 , len));
        }
        fis.close();

2.3 FileWriter

		// FileWriter字符输出流 第二个参数追加模式可以不写，默认false
        FileWriter fw = new FileWriter("E://a.txt");
        // fw.write("121");
        fw.append("锄禾日当午\n\r").append("汗滴禾下土\n\r").append("谁知盘中餐\n\r")
                .append("粒粒皆辛苦");
        // 最好每输出一段文字刷新一下，close方法里有刷新操作
        // flush操作强制把缓存空间的字符输出到文本中去
        fw.flush();
        fw.close();

2.4 FileReader

		// FileReader 字符输入流
        FileReader fr = new FileReader("E://a.txt");
//        while (true) {
//            int len = fr.read();
//            if (len == -1) {
//                break;
//            }
//            System.out.print((char) len);
//        }

        // 与字节输入流类似
        char[] chars = new char[100];
        int len = fr.read(chars);
        System.out.println(new String(chars, 0, len));
        fr.close();

2.5 字节流转字符流

重点 转换流 将字节流转化为字符流。
字节流 ‘装饰’ 为字符流：使用了装饰者设计模式。

        FileInputStream fis = new FileInputStream("E://a.txt");
        // 将字节流输入转换为字符输入流
        // 参数1：要转化的字节流 参数2：指定编码名称
        InputStreamReader isr = new InputStreamReader(fis, "utf-8");
        while (true) {
            int len = isr.read();
            if (len == -1) {
                break;
            }
            System.out.print((char) len);
        }
        fis.close();
        isr.close();

		FileOutputStream fos = new FileOutputStream("E://a.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos, "utf-8");
        osw.append("锄禾日当午\n\r").append("汗滴禾下土\n\r").append("谁知盘中餐\n\r")
                .append("粒粒皆辛苦1");
        osw.flush();
        fos.close();
        osw.close();

2.6 Print和BufferedReader

		// 字符打印流
        /*PrintStream ps = new PrintStream("E://c.txt");
        ps.println("good job;好工作");
        ps.println("good job;好工作");
        ps.println("good job;好工作");
        ps.close();*/

        // 与字节流区别，此方法是需要关流的
        /*PrintWriter pw = new PrintWriter("E://c.txt");
        pw.println("good job;好工作1");
        pw.println("good job;好工作2");
        pw.println("good job;好工作3");
        pw.flush();
        pw.close();*/

        // 转换打印流
        /*FileOutputStream fos = new FileOutputStream("E://d.txt");
        PrintWriter pw = new PrintWriter(fos);
        pw.println("good job;好工作1");
        pw.flush();
        fos.close();
        pw.close();*/

        // 缓存读取流，将字符流转换为带有缓存 可以一次读取一行的缓存字符读取流
        FileReader fw = new FileReader("E://a.txt");
        BufferedReader br = new BufferedReader(fw);
        while (true) {
            String text = br.readLine();
            if (text == null) {
                break;
            }
            System.out.print(text);
        }

        fw.close();
        br.close();

---

三、IO拓展

3.1 Properties

		// .properties文件 与 Properties();
        Properties ppt = new Properties();
        ppt.put("name", "admin");
        ppt.put("pwd", "admin");
        // 文件规范以properties结尾
        FileWriter fw = new FileWriter("e://dev.properties");
        // 参数2是文件中的注释 #开头
        ppt.store(fw, "用户密码");
        fw.close();

        // 读取配置
        Properties properties = new Properties();
        FileReader fr = new FileReader("e://dev.properties");
        properties.load(fr);
        System.out.println("name=" + ppt.getProperty("name"));
        System.out.println("pwd=" + ppt.getProperty("pwd"));

3.2 序列化技术

部分属性的序列化：

• 使用transient修饰符。
• 使用static修饰符。
• 若类有默认writeObject和readObject方法,优先调用。
• 类实现Externalizable接口，重写writeExternal和readExternal方法（与第三个相似）。

public class demo{

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 序列化
        User user = new User("admin", "admin");
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("E://userDev.properties"));
        // 实现序列化的类不进行实行序列化接口会报错
        // 包括对象中的属性均要实现序列化接口
        oos.writeObject(user);
        oos.close();

        // 反序列化
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("E://userDev.properties"));
        User u = (User) ois.readObject();
        System.out.println(u);
    }



}

class User implements Serializable {

    private String name;

    private String pwd;

    public User(String name, String pwd) {
        this.name = name;
        this.pwd = pwd;
    }

    public String getName() {
        return name;
    }

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

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

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

3.3 序列化工具类

package com.sxl.util;

import java.io.*;

/**
 * 序列化工具类
 */
public class MySerializeUtil {

    /**
     * 序列化对象到指定文件
     * @param obj
     * @param fileName
     * @throws IOException
     */
    public static void toSerialize(Object obj, String fileName) throws IOException {

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(fileName));
        oos.writeObject(obj);
        oos.close();

    }

    /**
     * 从指定文件中反序列化对象
     * @param fileName
     * @throws IOException
     */
    public static Object deSerialize(String fileName) throws IOException, ClassNotFoundException {
        
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(fileName));
        Object o = ois.readObject();
        ois.close();
        return o;
        
    }

}

---

总结

人生无限，缓缓起航，修正改错，在满足完成任务的条件下，追求完善，全身而退。