十九、IO操作 - 《Java 入门即巅峰》

File对象
InputStream(输入流)
OnputStream(输出流)
Reader
Writer
使用Files

File对象

// 路径
/*
getPath()                   返回构造方法传入的路径
getAbsolutePath()           返回绝对路径
*/
// 构造一个file对象，即使传入的文件或者目录不存在，代码也不会报错，因为构造对象并不会导致任何磁盘操作
// java中文件用\\代替\连接文件路径
// 文件
/*
isFile()           判断该File对象是否是一个已存在的文件
isDirectory()      判断该File对象是否是一个已存在的目录
canRead()          是否可读
canWrite()         是否可写
canExection()      是否可执行
length()           文件字节大小
*/
// createNewFile()    创建一个新文件
// delete()           删除该文件
// 有的时候我们需要创建临时文件
// createTempFile()   创建临时文件
// deleteOnExit()     在JVM退出时自动删除该文件
// 遍历文件和目录；如果File对象是一个目录时
File f = new File("C:\\Windows");
// File[] fs1 = f.list(); // 列出所有文件
File[] fs1 = f.listFiles(); // 列出所有文件和子目录
// 遍历文件夹下的所有文件
import java.io.File;
import java.util.ArrayList;
import java.util.List;
public class IoStudy {
    public static void showDirectory(File file){
        File[] files = file.listFiles();
        for(File a:files){
            System.out.println(a.getAbsolutePath());
            if(a.isDirectory()){
                showDirectory(a);
            }
        }
    }
    public static void main(String[] args) {
        File file = new File("F:\\Documents");
        showDirectory(file);
    }
}
/*
mkdir()：创建当前File对象表示的目录；
mkdirs()：创建当前File对象表示的目录，并在必要时将不存在的父目录也创建出来；
delete()：删除当前File对象表示的目录，当前目录必须为空才能删除成功
exists():判断目录是否存在
*/

InputStream(输入流)

// InputStream并不是一个接口，而是一个抽象类，它是所有输入流的超类，这个抽象类定义的一个最重要的方法就是int read()
public abstract int read() throws IOException;
// 这个方法会读取输入流的下一个字节，并返回int值（0~255）,如果已读到末尾，则返回-1就是不能继续读取了
// InputStream和OutputStream都是通过close()方法来关闭流。关闭流就会释放对应的底层资源。
//可能因为Io操作错误导致资源没法即使释放，我们需要用try...finally来确保是否发生Io错误都能够正常关闭
// try(resource)主需要编写try语句，让编译器自动为我们关闭资源。
// InputStream实现类
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
public class IoStudy {
    public static void main(String[] args) throws IOException {
        byte[] data = { 72, 101, 108, 108, 111, 33 };
        try (InputStream input = new ByteArrayInputStream(data)) {
            int n;
            while ((n = input.read()) != -1) {
                System.out.println((char)n);
            }
        }
    }
}

OnputStream(输出流)

// 和InputStream类似，OutputStream也是抽象类，它是所有输出流的超类。这个抽象类定义的一个最重要的方法就是void write(int b)
public abstract void write(int b) throws IOException;
// OutputStream还提供了一个flush()方法，它的目的是将缓冲区的内容真正输出到目的地
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class IoStudy{
    public static void main(String[] args) throws IOException{
        try (OutputStream output = new FileOutputStream("F://readme.txt")) {
            output.write("Hello".getBytes("UTF-8")); // Hello
        } // 编译器在此自动为我们写入finally并调用close()
    }
}
// OnputStream实现类
import java.io.ByteArrayOutputStream;
import java.io.IOException;
public class IoStudy {
    public static void main(String[] args) throws IOException {
        byte[] data;
        try (ByteArrayOutputStream output = new ByteArrayOutputStream()) {
            output.write("Hello ".getBytes("UTF-8"));
            output.write("world!".getBytes("UTF-8"));
            data = output.toByteArray();
        }
        System.out.println(new String(data, "UTF-8"));
    }
}
// 读取input.txt，写入output.txt:
try (InputStream input = new FileInputStream("input.txt");
     OutputStream output = new FileOutputStream("output.txt"))
{
    input.transferTo(output); // transferTo的作用是?
    /*
    此方法允许从对象调用方法表示的输入流中轻松传输(复制)字节到提供给该方法的输出流
    此方法不关闭任何流
    强烈建议，如果发生I/O错误，那么输入输出两个流都应该立即关闭。
    */
}

Reader

// Reader是Java的IO库提供的另一个输入流接口。下列是Reader与InputStream的区别
    InputStream                             Reader
 字节流，以byte为单位                   字符流，以char为单位
 读取字节（-1，0~255）：               读取字符（-1，0~65535）：
 int read()                            int read()
读到字节数组：int read(byte[] b)    读到字符数组：int read(char[] c)
public class IoStudy{
    public static void main(String[] args) throws IOException {
        try (Reader reader = new FileReader("f://readme.txt", StandardCharsets.UTF_8)) {
            // 缓冲区
            char[] buffer = new char[1000];
            int n;
            while ((n = reader.read(buffer)) != -1) {
                System.out.println("read " + n + " chars.");
            }
        }
    }
}
// CharArrayReader  它的作用实际上是一个char[]数组变成一个Reader
try (Reader reader = new CharArrayReader("Hello".toCharArray())) {}
// StringReader可以直接把String作为数据源
try (Reader reader = new StringReader("Hello")) {}

Writer

Writer和OutputStream的区别如下：
    OutputStream                                        Writer
    字节流，以byte为单位                            字符流，以char为单位
    写入字节（0~255）：                            写入字符（0~65535）：
    void write(int b)                              void write(int c)
写入字节数组：void write(byte[] b)                写入字符数组：void write(char[] c)
    无对应方法                            写入String：void write(String s)
// FileWriter
try (Writer writer = new FileWriter("readme.txt", StandardCharsets.UTF_8)) {
    writer.write('H'); // 写入单个字符
    writer.write("Hello".toCharArray()); // 写入char[]
    writer.write("Hello"); // 写入String
}
// CharArrayWriter
try (CharArrayWriter writer = new CharArrayWriter()) {
    writer.write(65);
    writer.write(66);
    writer.write(67);
    char[] data = writer.toCharArray(); // { 'A', 'B', 'C' }
}
// StringWriter
try (Writer writer = new OutputStreamWriter(new FileOutputStream("readme.txt"), "UTF-8")) {
    // TODO:
}
// PrintWriter
// PrintStream和OutputStream相比，除了添加了一组print()/println()方法，可以打印各种数据类型,而且不会抛出IOException
public class IoStudy {
    public static void main(String[] args)     {
        StringWriter buffer = new StringWriter();
        try (PrintWriter pw = new PrintWriter(buffer)) {
            pw.println("Hello");
            pw.println(12345);
            pw.println(true);
        }
        System.out.println(buffer.toString());
    }
}

使用Files

public class IoStudy{
    public static void main(String[] args) throws IOException {
        // 读文件
        // 把全部内容读取为一个byte[]
        //byte[] data = Files.readAllBytes(Paths.get("f://readme.txt"));
        // 默认使用UTF-8编码读取：
        //String content1 = Files.readString(Paths.get("f:/readme.txt"));
        // 可指定编码：
        //String content2 = Files.readString(Paths.get("f:/readme.txt"), StandardCharsets.ISO_8859_1);
        // 按行读取并返回每行内容
        //List<String> lines = Files.readAllLines(Paths.get("f://readme.txt"));
        // 写文件
        // java7开始提供的写法
        // 写入文本并指定编码  覆盖原本内容
        //Files.write(Paths.get("f://readme.txt"), "无敌最俊朗".getBytes(StandardCharsets.UTF_8));
        // 可以追加写
        //Files.write(Paths.get("f://readme.txt"),"无敌最俊朗666".getBytes(StandardCharsets.UTF_8), StandardOpenOption.APPEND);
        // java8开始提供的写法
        String fileName = "F:\\readme.txt";
        Path path = Paths.get(fileName);
        // 使用newBufferedWriter创建文件并写文件
        // 这里使用了try-with-resources方法来关闭流，不用手动关闭
        try (BufferedWriter writer =
            Files.newBufferedWriter(path, StandardCharsets.UTF_8)) {
                writer.write("无敌最俊朗！");
        }
        //追加写模式
        try (BufferedWriter writer =
                     Files.newBufferedWriter(path,
                             StandardCharsets.UTF_8,
                             StandardOpenOption.APPEND)){
            writer.write("每天进步亿点点！");
        }
    }
}