JAVA文件IO

IO

常用文件操作File

package com.lyq.kaikeba.codeLearn.io;

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

public class Demo1 {
    public static void main(String[] args) throws IOException {
        File file = new File("D://test.txt");
        // 创建一个新的文件,如果存在返回false，不存在返回true
        boolean flag = file.createNewFile();
        // 创建新的文件夹，如果存在返回false，不存在返回true
        boolean dirFlag = file.mkdir();

        File file1 = new File("D://hah");

        // 构造方法1使用
        File a = new File(file1, "a.text");
        a.createNewFile();

        // 构造方法2使用
        File b = new File("D:hah", "b.text");
        b.createNewFile();

        // 删除
        a.delete();
        b.delete();

        // 获取文件路径
        a.getAbsolutePath();
        // 获取名称
        a.getName();

        a.isFile();

        a.isDirectory();

        a.exists();
        // 获取文件夹下所有文件对象
        a.listFiles();


        // 创建多层文件夹
        File f1 = new File("D://ha/ha/ha");
        f1.mkdirs();    // 创建多层文件夹只能用mkdirs而不能使用mkdir

        // 剪切至另一个文件下
        f1.renameTo(file1);

        /**
         * 分隔符
         */
        // 路径分隔符
        System.out.println(File.pathSeparator);
        // 名称分隔符
        System.out.println(File.separator);

    }
}

遍历文件

package com.lyq.kaikeba.codeLearn.io;

import java.io.File;

/**
 * 遍历文件
 */
public class Demo2 {
    public static void main(String[] args) {
        File file = new File("D:\\");
        File[] files = file.listFiles();
        listFile(files);
    }

    private static void listFile(File[] files) {
        if(files != null && files.length > 0){
            for(File f : files){
                if(f.isFile()){
                    if(f.getName().endsWith(".avi")){
                        System.out.println(f.getAbsolutePath());
                    }
                }else {
                    listFile(f.listFiles());
                }
            }
        }
    }
}

文件过滤器

package com.lyq.kaikeba.codeLearn.io;

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

/**
 * 文件过滤器的使用
 */
public class Demo3 {
    public static void main(String[] args) {
        File file = new File("D:\\");
        listFile(file);
    }

    private static void listFile(File file) {
        File[] files = file.listFiles(new FileFilter(){

            @Override
            public boolean accept(File pathname) {
                if(pathname.isDirectory() || pathname.getName().endsWith(".avi")){
                    return true;
                }
                return false;
            }
        });
        if(files != null && files.length > 0){
            for(File f : files){
                if(f.isFile()){
                    System.out.println(f.getName());
                }else {
                    listFile(f);
                }
            }
        }
    }
}

输入输出流

字节流（可能会出现乱码）

• 输入流：InputStream

package com.lyq.kaikeba.codeLearn.io;

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

/**
 * 文件写出流
 */
public class Demo4 {
    public static void main(String[] args) throws IOException {
        // 是否追加
        FileOutputStream fos = new FileOutputStream("d:\\a.txt", true);

        fos.write(65);
        fos.write("afhd".getBytes(StandardCharsets.UTF_8));
        fos.write("dfdifd".getBytes(StandardCharsets.UTF_8), 1, 5);
        fos.close(); // 注意关闭
    }
}

• 输出流：OutputStream

package com.lyq.kaikeba.codeLearn.io;

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

/**
 * FileInputStream
 */
public class Demo5 {
    public static void main(String[] args) throws IOException {

        FileInputStream fis = new FileInputStream("d:\\a.txt");

        // 每次读取一个字节
        while(true){
            byte b = (byte) fis.read();
            if(b==-1)
                break;
            System.out.println((char)b);
        }

        // 每次读取多个字节
        while(true){
            byte[] bytes = new byte[10];
            int len = fis.read(bytes);
            if(len == -1)
                break;
            String content = new String(bytes);
            System.out.println(content);
        }
        
        fis.close(); // 注意关闭
    }
}

字符编码

• UTF-8 可变长度字符编码

字符流

• 输入流：Reader

package com.lyq.kaikeba.codeLearn.io;

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

/**
 * Writer
 */
public class Demo6 {
    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("d:\\a.txt", true);
        
        fw.write("fdjfid");
        
        fw.append("fdfd");
        
        fw.close();
        
    }
}

• 输出流：Writer

package com.lyq.kaikeba.codeLearn.io;

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

/**
 * Writer
 */
public class Demo6 {
    public static void main(String[] args) throws IOException {
        
        // 读字符
        FileReader fr = new FileReader("d:\\a.txt");
        
        // 每次读一个字符
        while(true){
            char c = (char) fr.read();
            if(c == -1)
                break;
            System.out.println(c);
        }
        
        // 每次读多个字符
        char[] chars = new char[100];
        int len = fr.read(chars);
        String s = new String(chars, 0, len);
        System.out.println(s);
        
        fr.close();

    }
}

对于字符输出流可用*flush()*方法刷新管道，将内存中的数据写入文件。

字节流转换

package com.lyq.kaikeba.codeLearn.io;

import java.io.*;

/**
 * 字节流转为字符流
 */
public class Demo7 {
    public static void main(String[] args) throws IOException {

        // 转换流
        // 字节流 '装饰' 为字符流    ： 使用了装饰者模式

        // 1. 将读取的字节流转换为字符流
        FileInputStream fis = new FileInputStream("D:\\a.txt");
        /**
         * 输入字节流，转换为字符流
         * 参数1. 要转换的字符
         * 参数2. 编码方式
         */
        InputStreamReader isr = new InputStreamReader(fis, "GBK");

        while(true){
            int c =  isr.read();
            if(c == -1)
                break;
            System.out.println((char) c);
        }



        // 2.将要写入的字节以字符的方式写入
        FileOutputStream fos = new FileOutputStream("d:\\a.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos);
        osw.write("niaho ");
        osw.flush();
        osw.close();

    }
}

打印流和缓存流

package com.lyq.kaikeba.codeLearn.io;

import java.io.*;

/**
 * 打印流和缓冲流
 */
public class Demo8 {
    public static void main(String[] args) throws IOException {
        // 打印流
        // PrintStream
        PrintStream ps = new PrintStream("d:\\a.txt");
        ps.println("fdf");
        ps.close();


        PrintWriter pw = new PrintWriter("d:\\a.txt");
        pw.println("fdf");
        pw.close();


        FileOutputStream fos = new FileOutputStream("d:\\a.txt");
        PrintWriter pw1 = new PrintWriter(fos);
        pw1.write("fdfd");
        pw1.flush();
        pw1.close();


        // 缓冲流 将读到的字符流转换成一行一行输出
        FileReader fw = new FileReader("d:\\a.txt");
        BufferedReader br = new BufferedReader(fw);
        String text = br.readLine();
        System.out.println(text);

    }
}

收集错误日志到文件中

package com.lyq.kaikeba.codeLearn.io;

import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.PrintWriter;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 收集异常日志
 */
public class Demo9 {
    public static void main(String[] args) throws FileNotFoundException {
        try{
            String s = null;
            s.toString();
        }catch(Exception e){
            PrintWriter pw = new PrintWriter("  ");
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            pw.println(sdf.format(new Date()));
            e.printStackTrace(pw);
            pw.close();
        }
    }
}

Properties文件与Properties类

package com.lyq.kaikeba.codeLearn.io;

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

/**
 * Properties文件与Properties类
 */
public class Demo {
    public static void main(String[] args) throws IOException {

        // 存
        Properties ppt = new Properties();
        ppt.put("书名", "苹果乐园");
        ppt.put("hello", "world");
        FileWriter fw = new FileWriter("d://a.txt");
        ppt.store(fw, "test");
        fw.close();

        // 取
        Properties ppt1 = new Properties();
        FileReader fr = new FileReader("d://a.txt");
        ppt1.load(fr);
        System.out.println(ppt1.get("书名"));
        System.out.println(ppt1.getProperty("hello"));

    }
}

序列化和反序列化

• 表示将对象存入文件和取出文件的操作

package com.lyq.kaikeba.codeLearn.io;

import java.io.*;

/**
 * 序列化和反序列化
 * 表示将对象存入文件和取出文件的操作
 */
public class Demo10 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 序列化
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("d://a.txt"));
        Book b1 = new Book("apple","appleInfo");
        oos.writeObject(b1);
        oos.close();

        // 反序列化
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d://a.txt"));
        Object o = ois.readObject();
        System.out.println(o);

    }
    static class Person implements Serializable{
        private String name;
    }
    // 序列化需要实现Serializable接口
    static class Book implements Serializable{
        private String name;
        private String info;
        private Person p;
        
        

        public Book() {
        }

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

        public Book(String name, String info) {
            this.name = name;
            this.info = info;
        }

        public String getName() {
            return name;
        }

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

        public String getInfo() {
            return info;
        }

        public void setInfo(String info) {
            this.info = info;
        }
    }

}

部分属性的序列化

• 对属性加transient修饰后则对应属性不被反序列化

• 对属性加static修饰后则则对应属性不被反序列化，但是可以对获取的对象进行set操作

• 默认方法writeObject和readObject

• Extenalizable实现java序列化

try-with-resource

package com.lyq.kaikeba.codeLearn.io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;

/**
 * try-with-resources
 */
public class Demo11 {
    public static void main(String[] args) throws FileNotFoundException {
        // 1.7
        try(FileReader f = new FileReader("d://a.txt")){
            int c = f.read();
            System.out.println(c);
        }catch(Exception e){
            e.printStackTrace();
        }

        // 1.9优化
        FileReader f = new FileReader("d://a.txt");
        try(f){
            int c = f.read();
            System.out.println(c);
        }catch(Exception e){
            e.printStackTrace();
        }
        
        
        // 注意：FileReader需要实现Closeable或AutoCloseable接口才会自动close()
    }
}