一、File

java.io提供了File对象来操作文件和目录。构造File对象时，可以传入绝对路径，也可以传入相对路径。

windows用\作为路径分隔符，java需要用\\表示一个\。linux使用/作为路径分隔符。用.表示当前目录，..表示上级目录。

File对象有一个静态变量用来表示当前平台的系统分隔符：separator

File对象有3种形式表示路径：

getPath()：返回构造方法传入的路径
getAbsolutePath()：返回绝对路径
getCanonicalPath()：返回规范路径

package org.example;
import java.io.*;

public class Main {
    public static void main(String[] args) {
        try {
            File file=new File(".\\one.txt");
            System.out.println(file.getAbsolutePath());
            System.out.println(file.getPath());
            System.out.println(file.getCanonicalPath());
        }
         catch (IOException e) {
            throw new RuntimeException("getCanonicalPath()有问题",e);
        }
    }
}

File对象可以表示文件，也可以表示目录。

isFile()：是否是一个存在的文件
isDirectory()：是否是一个存在的目录
canRead()：是否可读
canWrite()：是否可写
canExecute()：是否可执行，对于目录而言，表示能否列出包含的文件和子目录
length()：文件字节大小

package org.example;
import java.io.*;

public class Main {
    public static void main(String[] args) {
        File file=new File(".\\one.txt");
        if(file.isFile()){
            System.out.println(File.separator);
        }else{
            throw new RuntimeException("文件不存在");
        }
    }
}

craeteNewFile()：创建文件
delete()：删除文件，删除目录时只有目录为空才能删除成功
createTempFile()：创建临时文件
deleteOnExit()：在JVM退出时自动删除该文件
mkdir()：创建目录
mkdirs()：创建目录并且创建不存在的父目录
list()：列出文件名
listFiles()：列出文件对象，好分辨哪个是目录，哪个是文件

package org.example;
import javax.annotation.processing.FilerException;
import java.io.*;


public class Main {
    public static void main(String[] args) throws IOException {
        File file=new File(".\\one.txt");
        File dir=new File(".\\src\\main\\java\\demo");
        File newFile=new File(dir,file.getName());
        if(!dir.exists()){
            dir.mkdirs();
        }
        if (!newFile.exists()) {
            newFile.createNewFile();
        }
        File[] files=dir.listFiles();
        printFile(files);
    }
    static void printFile(File[] file){
        if(file == null || file.length == 0){
            System.out.println("目录为空或不存在");
            return;
        }
        for(File f:file){
            try {
                System.out.println(f.getCanonicalFile());
            } catch (IOException e) {
                throw new RuntimeException("路径有问题");
            }
        }
    }
}

Path类

二、OutputStream

write方法会写入一个字节到输出流，虽然传入的是int参数，但只会写入一个字节。

flush()方法将缓冲区的内容输出到目的地。因为向磁盘、网络写入数据的时候，出于效率的考虑，操作系统并不是输出一个字节就立刻写入到文件或者发送到网络，而是把输出的字节先放到内存的一个缓冲区里(本质上就是一个byte[]数组)，等到缓冲区写满了，再一次性写入文件或者网络。

package org.example;
import javax.annotation.processing.FilerException;
import java.io.*;


public class Main {
    public static void main(String[] args) throws IOException {
        File file=new File(".\\one.txt");
        File dir=new File(".\\src\\main\\java\\demo\\");
        File newFile=new File(dir,file.getName());
        OutputStream out=new FileOutputStream(newFile);
        out.write('a');
        out.close();
    }
}

可以通过重载void wirte(byte[])来一次性写入多个字节。

package org.example;
import javax.annotation.processing.FilerException;
import java.io.*;


public class Main {
    public static void main(String[] args) throws IOException {
        File file=new File(".\\one.txt");
        File dir=new File(".\\src\\main\\java\\demo\\");
        File newFile=new File(dir,file.getName());
        OutputStream out=new FileOutputStream(newFile);
        out.write("abc".getBytes("UTF-8"));
        out.close();
    }
}

上述代码如果发生异常就无法正确关闭资源，所以需要用try(resource)来保证无论是否发生IO错误都能正确关闭。

package org.example;
import javax.annotation.processing.FilerException;
import java.io.*;


public class Main {
    public static void main(String[] args){
        File file=new File(".\\one.txt");
        File dir=new File(".\\src\\main\\java\\demo\\");
        File newFile=new File(dir,file.getName());
        try(OutputStream out=new FileOutputStream(newFile)) {
            out.write("abc".getBytes("UTF-8"));
        }catch (IOException e){ 
            e.printStackTrace();
        }
    }
}

ByteArrayOutputStream

ByteArrayOutputStream实际上是把一个byte[]数组在内存中变成一个 OutputStream。

package org.example;
import javax.annotation.processing.FilerException;
import java.io.*;


public class Main {
    public static void main(String[] args){
        try(ByteArrayOutputStream out=new ByteArrayOutputStream()) {
            out.write("Hello ".getBytes("UTF-8"));
            out.write("World".getBytes("UTF-8"));
            byte[] data=out.toByteArray();
            System.out.println(new String(data,"UTF-8"));
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

package org.example;
import javax.annotation.processing.FilerException;
import java.io.*;


public class Main {
    public static void main(String[] args){
        File file=new File(".\\one.txt");
        File dir=new File(".\\src\\main\\java\\demo\\");
        File newFile=new File(dir,file.getName());
        try(ByteArrayOutputStream out=new ByteArrayOutputStream()) {
            out.write("Hello ".getBytes("UTF-8"));
            out.write("World".getBytes("UTF-8"));
            byte[] data=out.toByteArray();
            if(newFile.exists()){
                FileOutputStream fis=new FileOutputStream(newFile);
                fis.write(data);
            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

三、InputStream

InpuStream是一个抽象类，是所有输入流的超类。read是该类中最重要的方法。这个方法会读取输入流的下一个字节，并返回字节表示的int值，如果读到末尾会返回-1表示不能继续读取。

FileInputStream是InpuStream的一个子类。

InpuStream提供了两个重载方法来支持读取多个字节：

int read(byte[] b)：读取若干个字节并填充到byte[]数组，返回读取的字节数
int read(byte[] b,int off,int len)：指定byte[]数组的偏移量和最大填充数

InputStream也有缓冲区。读取一个字节时，操作系统往往会一次性读取若干字节到缓冲区，并维护一个指针指向未读的缓冲区。每次我们调用read()读取下一个字节时，可以直接返回缓冲区的下一个字节，避免每次读一个字节都导致IO操作。当缓冲区全部读完后继续调用read()，则会触发操作系统的下一次读取并再次填满缓冲区。

package org.example;
import javax.annotation.processing.FilerException;
import java.io.*;


public class Main {
    public static void main(String[] args) throws IOException {
        File file=new File(".\\one.txt");
        File dir=new File(".\\src\\main\\java\\demo\\");
        File newFile=new File(dir,file.getName());
        try(InputStream in=new FileInputStream(newFile)){
            byte[] buffer=new byte[1024];
            int len=in.read(buffer);
            for(int i=0;i<len;i++){
                System.out.print((char)buffer[i]);
            }
            
        }
    }
}

ByteArrayInputStream

package org.example;
import javax.annotation.processing.FilerException;
import java.io.*;


public class Main {
    public static void main(String[] args) throws IOException {
        File file=new File(".\\one.txt");
        File dir=new File(".\\src\\main\\java\\demo\\");
        File newFile=new File(dir,file.getName());
        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);
            }
        }
    }
}

练习

package org.example;
import javax.annotation.processing.FilerException;
import java.io.*;


public class Main {
    public static void main(String[] args) throws IOException {
        File file=new File(".\\one.txt");
        File dir=new File(".\\src\\main\\java\\demo\\");
        File newFile=new File(dir,file.getName());
        if(!dir.exists()){
            dir.mkdirs();
        }
        if(!newFile.exists()){
            newFile.createNewFile();
        }
        try(OutputStream out=new FileOutputStream(newFile)){
            out.write("Hello World".getBytes());
            out.flush();
            try(InputStream in=new FileInputStream(newFile)){
                byte[] buffer=new byte[1024];
                int i=in.read();
                while(i!=-1){
                    System.out.print((char)i);
                    i=in.read();
                }
            }
        }
    }
}

四、Filter模式

JDK将InputStream和OutputStream分为两大类，避免过多的子类继承导致子类爆炸：

直接提供数据的基础类，如：FileInputStream、ByteArrayInputStream、ServletInputStream等
提供额外附加功能的类，如：BufferedInputStream、CipherInputStream等

1 2	InputStream file = new FileInputStream("test.gz"); InputStream buffered = new BufferedInputStream(file);

不管包装多少次，得到的对象始终是InputStream就可以正常读取。这种通过一个“基础”组件再叠加各种“附加”功能组件的模式，称之为Filter模式或者装饰器模式。

package org.example;
import javax.annotation.processing.FilerException;
import java.io.*;


public class Main {
    public static void main(String[] args) throws IOException {
        byte[] data="hello world".getBytes("UTF-8");
        try(CountInputStream input=new CountInputStream(new ByteArrayInputStream(data))){
            int n;
            while((n=input.read())!=-1){
                System.out.print((char)n);
            }
            System.out.println("\n"+"总共"+input.getBytesRead()+"个byte");
        }
    }
}
class CountInputStream extends FilterInputStream {
    private int count=0;
    CountInputStream(InputStream in) {
        super(in);
    }
    public int getBytesRead(){
        return this.count;
    }
    public int read() throws IOException {
        int n=in.read();
        if(n!=-1){
            this.count++;
        }
        return n;
    }
    public int read(byte[] b) throws IOException {
        int n=in.read(b);
        if(n!=-1){
            this.count+=n;
        }
        return n;
    }
}

序列化

序列化必须实现java.io.Serializable接口。序列化本质就是将一个java对象转化为byte[]数组。

package org.example;
import javax.annotation.processing.FilerException;
import java.io.*;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try(ObjectOutputStream oos = new ObjectOutputStream(baos)){
            oos.writeInt(12345);
            oos.writeObject(Double.valueOf(123.345));
            byte[] bytes = baos.toByteArray();
            System.out.println(Arrays.toString(bytes));
        }
    }
}

五、Reader

是java的IO库中提供的另一个输入流接口。与InputStream的区别在于：

IntputStream是一个字节流，以byte为单位读取；
Reader是一个字符流，以char为单位读取。

FileReader是Reader的一个子类，可以打开文件并获取Reader

package org.example;
import javax.annotation.processing.FilerException;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) throws IOException {
        try(Reader reader=new FileReader(".\\src\\main\\java\\demo\\one.txt", StandardCharsets.UTF_8)) {
            char[] buffer=new char[1024];
            int len=reader.read(buffer);
            for(int i=0;i<len;i++) {
                System.out.print(buffer[i]);
            }
        }
    }
}

CharArrayReader

与ByteArrayInputStream类似。

package org.example;
import javax.annotation.processing.FilerException;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) throws IOException {
        char[] body="hello world".toCharArray();
        try(Reader reader=new CharArrayReader(body)){
            char[] chars=new char[body.length];
            int len=reader.read(chars);
            for(int i=0;i<len;i++){
                System.out.print(chars[i]);
            }
        }
    }
}

StringReader可以直接把String作为数据源。

InputStreamReader

除了CharArrayReader与StringReader，普通的Reader都是基于InputStream构造的，都需要从InputStream中读入byte，再根据编码设置转换为char。

InputStreamReader可以把任何InputStream转换为Reader。

package org.example;
import javax.annotation.processing.FilerException;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) throws IOException {
        byte[] bytes = "Hello World".getBytes(StandardCharsets.UTF_8);
        InputStream input=new ByteArrayInputStream(bytes);
        Reader reader=new InputStreamReader(input, StandardCharsets.UTF_8);
        char[] buf=new char[bytes.length];
        int len=reader.read(buf);
        for(int i=0;i<len;i++){
            System.out.print(buf[i]);
        }
        reader.close();
        input.close();
    }
}

六、PrintStream和PrintWriter

PrintStream是一种FilterOutputStream，在OutputStream的接口上额外提供了一些写入各种数据类型的方法。

System.out是系统默认提供的PrintStream，System.err是系统默认提供的标准错误输出。

PrintStream和OutputStream相比，除了添加了一组print() / println()方法，可以打印各种数据类型，比较方便外，它还有一个额外的优点，就是不会抛出IOException，这样我们在编写代码的时候，就不必捕获IOException。

package org.example;
import javax.annotation.processing.FilerException;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) throws IOException {
        PrintStream out = new PrintStream(System.out, true, "UTF-8");
        out.println(123);
    }
}

PrintStream最终输出的总是byte数据，而PrintWriter则是扩展了Writer接口，它的print() / println()方法最终输出的是char数据。两者的使用方法几乎是一模一样的。

package org.example;
import javax.annotation.processing.FilerException;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) throws IOException {
        StringWriter sw = new StringWriter();
        try(PrintWriter pw = new PrintWriter(sw)){
            pw.println("Hello World");
        }
        System.out.println(sw);
    }
}

七、Files

package org.example;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;

public class Main {
    public static void main(String[] args) throws IOException {
        File file=new File(".\\src\\main\\java\\demo\\one.txt");
        byte[] data= Files.readAllBytes(file.toPath());
        System.out.println(data);
        String dataString=Files.readString(file.toPath(), StandardCharsets.UTF_8);
        System.out.println(dataString);
    }
}