java-doc-文件与io

流

Java程序通过流执行I/O。流是一种抽象，要么产生信息，要么使用信息。流通过Java的I/O系统链接到物理设备。所有流的行为方式都是相同的，尽管与它们链接的物理是被是不同的。因此，可以为任意类型的设备应用相同的I/O类和方法。这意味着可以将许多不同类型的输入————磁盘文件、键盘或网络socket，抽象为输入流。与之对应，输出流可以引用控制台、磁盘文件或网络连接。流是处理输入/输出的一种清晰方式，例如，代码中的所有部分都不需要理解键盘和网络之间的区别。流是Java在由java.io包定义的类层次中实现的。

Java定义了两种类型的流：字节流和字符流。字节流为处理字节的输入和输出提供了方法。例如，当读取和写入二进制数据时，使用的就是字节流。字符流为处理字符的输入和输出提供了方便的方法。它们使用Unicode编码，所以可以被国际化。此外，在某些情况下，字符流比字节流高效。

最初版本的Java没有提供字符流，因此，所有I/O都是面向自己的。字符流是Java1.1添加的，并且某些面向自己的类和方法不再推荐使用。尽管不使用字节流的旧代码越来宇少，但是有时仍然会遇到。作为一般原则，在合适的情况下应当更新旧代码以利用字符流的优点。

虽然字节流开始不推荐使用，但是在最底层，所有I/O仍然是面向字节的。基于字符流只是为了处理字符提供了一种方便和高效的方法。

字节流类

字节流是通过两个类层次定义的。在顶级是两个抽象类：InputStream和OutputStream。每个抽象类都有几个处理各种不同设备的具体子类，例如磁盘文件、网络连接甚至内存缓存区。

抽象类InputStream和OutputStream定义了其他流实现的一些关键方法。其中最重要的两个方法是read()和write()，这两个方法分别读取和写入字节数据。每个方法都有抽象形式，派生的流类必须重写这两个方法。

• java.io包中的字节流类

流类	含义
BufferedInputStream	缓冲的输入流
BufferedOutputStream	缓冲的输入流
ByteArrayInputStream	读取字节流数组内容的输入流
ByteArrayOutputStream	向字节数组写入内容的输出流
DataInputStream	包含读取Java标准数据类型的方法的输入流
DataOutputStream	包含写入Java标准数据类型的方法的输出流
FileInputStream	读取文件内容的输入流
FileOutputStream	向文件中写入内容的输出流
FilterInputStream	实现InputStream
FilterOutputStream	实现OutputStream
InputStream	描述流输入的抽象类
ObjectInputStream	用于对象的输入流
ObjectOutputStream	用于对象的输出流
OutputStream	描述流输出的抽象类
PipledInputStream	输入管道
PipedOutputStream	输出管道
PrintStream	包含print()和println()的输出流
PushbackInputStream	支持1字节“取消获取”输入流，这种流向输入流返回1字符
SequenceInputStream	由两个或多个按顺序依次读取的输入流组合而成的输入流

InputStream

InputStream是抽象类，定义了Java字节流的输入模型，并且还实现了AutoCloseable和Closeable接口。

• InputStream类定义的方法

方法	描述
int available()	返回当前可读取的输入字节数
void close()	关闭输入源。如果试图继续进行读取，会产生IOException异常
void mark(int numBytes)	在输入流的当前位置放置标记，该标记在读入numBytes个字节之前一直都有效
boolean markSupported	如果调用流支持mark()或reset()方法，就返回true
int read()	返回代表下一个可用字节的整数。当到达文件末尾时，返回-1
int read(byte buffer[])	尝试读取buffer.length个字节到buffer中，并返回实际成功读取的字节数。如果到达文件末尾，就返回-1
int read(byte buffer[], int offset, int numBytes)	尝试读取numBytes个字节到buffer中，从buffer[offset]开始保存读取的字节。该方法返回成功读取的字节数；如果到达文件末尾，就返回-1
void reset()	将输入指针重置为当前设置的标记
long skip(long numBytes)	忽略(即跳过)numBytes个字节的输入，返回实际忽略的字节数

OutputStream

OutputStream是定义流字节输出的抽象类，实现了AutoCloseable、Closeable以及Flushable接口。

• OutputStream类定义的方法

方法	描述
void close()	关闭输出流。如果试图继续向流中写入内容，将产生IOException异常
void flush()	结束输出状态，从而清空所有缓冲区，即刷新输出缓冲区
void write(int b)	向输出流中写入单个字节。注意参数是int类型，从而允许使用表达式调用write()方法，而不用将表达式强制转换回byte类型
void write(byte buffer[])	向输出流中写入一个完整的字节数组
void write(byte buffer[], int offset, int numBytes)	将buffer数组中从buffer[offet]开始的numBytes个字节写入输出流中

FileInputStream

使用FileInputStream类创建的InputStream对象可以用于从文件读取字节。

FileInputStream类重写了InputStream抽象类中的6个方法，但没有重写mark()和reset()。在FileInputStream对象试图调用reset()方法，会抛出IOException异常。

• 构造函数

方法	描述
FileInputStream(String filePath)	通过文件路径创建输入流
FileInputStream(File fileObj)	通过文件对象创建输入流

FileOutputStream

FileOutputStream类创建能够用于向文件中写入字节的OutputStream对象。该类实现了AutoCloseable、Closeable以及Flushable接口。

FileOutputStream对象的创建不依赖于已经存在的文件，当创建对象时，会在打开之前创建文件，如果试图打开只读文件会抛出异常。

• 构造函数

方法	描述
FileOutputStream(String filePath)	filePath是文件的完整路径
FileOutputStream(File fileObj)	fileObj是描述文件的对象
FileOutputStream(String filePath, boolean append)	filePath是文件的完整路径，append为是否以追加方式写入文件
FileOutputStream(File fileObj, boolean append)	fileObj是描述文件的对象，append为是否以追加方式写入文件

ByteArrayInputStream

ByteArrayInputStream是使用字节数组作为源的输入流的一个实现。

• 构造函数

方法	描述
ByteArrayInputStream(byte array[])	array是输入源
ByteArrayInputStream(byte array[], int start, int numBytes)	array是输入源，start指定数组字符开始的索引，numBytes指定字节数量

import java.io.ByteArrayInputStream;

public class LearnByteArrayInputStream1 
{
    public static void main(String args[])
    {
        String tmp = "abcdefghigklmn";
        byte b[] = tmp.getBytes();
        
        ByteArrayInputStream input1 = new ByteArrayInputStream(b);
        ByteArrayInputStream input2 = new ByteArrayInputStream(b, 1, 3);
        
        ReadAll(input1);
        ReadAll(input2);
    }
    
    private static void ReadAll(ByteArrayInputStream input)
    {   
            int c;
            while((c = input.read()) != -1) {
                System.out.print((char)c);
            }
            
            System.out.println();
    }
}

ByteArrayOutputStream

ByteArrayOutputStream是使用字节数组作为目标的输出流的一个实现。

• 构造函数

方法	描述
ByteArrayOutputStream()	创建一个32字节的缓冲区
ByteArrayOutputStream(int numBytes)	创建一个由numBytes指定大小的缓冲区

缓冲区被保存在ByteArrayOutputStream中受保护的buf域变量中，缓冲区的大小会自动增加。

import java.io.*;

public class LearnByteArrayOutputStream1 
{
    public static void main(String args[])
    {
        ByteArrayOutputStream f = new ByteArrayOutputStream();
        String s = "hello world!!";
        byte buf[] = s.getBytes();
        
        try {
            f.write(buf);
        } catch(IOException e) {
            System.out.println("Error Waiting to Buffer");
            return;
        }
        
        System.out.println(f.toString());
        
        try(FileOutputStream f2 = new FileOutputStream("LearnByteArrayOutputStream1.txt")){
            f.writeTo(f2);
        } catch(IOException e) {
            System.out.println("Occur IOException");
            return;
        }
        
        String s2 = "hello world2222!!";
        byte buf2[] = s2.getBytes();
        
        try {
            f.reset();
            f.write(buf2);
        } catch(IOException e) {
            System.out.println("Error Waiting to Buffer");
            return;
        }
        
        
        System.out.println(f.toString());
    }
}

FilterOutputStream

过滤的字节流是简单的封装器，用于封装底层的输出流，并且还透明地提供一些扩展级别的功能。

• 构造函数

方法	描述
FilterOutputStream(OutputStream os)	输出流过滤器

FilterInputStream

过滤的字节流是简单的封装器，用于封装底层的输入流，并且还透明地提供一些扩展级别的功能。

• 构造函数

方法	描述
FilterInputStream(InputStream is)	输入流过滤器

BufferedInputStream

BufferedInputStream类运行将任何InputStream对象封装到缓冲流中以提高性能。

• 构造函数

方法	描述
BufferedInputStream(InputStream inputStream)	使用默认缓冲区大小创建缓冲流
BufferedInputStream(InputStream inputStream, int buffSize)	指定缓冲区默认大小

使缓冲区大小等于内存页面、磁盘块等大小的整数倍，可以明显提高性能。然而，这依赖于具体实现。最优的缓冲区大小通常依赖于宿主操作系统、可用的内存量以及机器的配置。为了充分利用缓冲区，比较好的缓冲大小大约是8192字节，并且对I/O系统来说既是附加较小的缓冲区，也总是一个好主意。这样的话，低级的系统也可以从磁盘或网络获取多块数据，并将结果存储在缓冲区中。因此，既是正在一次从InputStream对象读取一个字节，大部分时间也都是在操作访问速度较快的内存。

import java.io.*;

public class LearnBufferInputStream1 
{
    public static void main(String args[]) throws IOException
    {
        String s = "Tihis is a &py; copy right symbol but this is & copy not \n";
        byte buf[] = s.getBytes();
        
        ByteArrayInputStream in = new ByteArrayInputStream(buf);
        int c;
        boolean marked = false;
        
        try(BufferedInputStream f = new BufferedInputStream(in)){
            while((c = f.read()) != -1) {
                switch(c) {
                case '&':
                    if(!marked) {
                        f.mark(32);
                        marked = true;
                    } else {
                        marked = false;
                    }
                    break;
                case ';':
                    if(marked) {
                        marked = false;
                        System.out.print("(c)");
                    } else {
                        System.out.print((char)c);
                    }
                    break;
                case ' ':
                    if(marked) {
                        marked = false;
                        f.reset();
                        System.out.print("&");
                    } else {
                        System.out.print((char)c);
                    }
                    break;
                default:
                    if(!marked) {
                        System.out.print((char)c);
                        break;
                    } 
                }
            } 
        }catch(IOException e) {
            System.out.println("IO ERROR" + e);
        }
    }
}

BufferedOutputStream

除了增加flush()方法之外，BufferedOutputStream与所有的OutputStream类似，flush()方法用于确保数据缓冲区写入被缓存的流中。BufferedOutputStream是通过减少系统实际写数据的次数来提高性能的，因此可能需要调用flush()方法，从而要求立即写入缓冲区的所有数据。

• 构造函数

方法	描述
BufferedOutputStream(OutputStream outputStream)	构建默认缓冲区大小的缓冲流
BufferedOutputStream(OutputStream outputStream, int bufSize)	使用bufSize指定默认缓冲区大小

PushbackInputStream

缓冲的新应用之一，回推。回推用于输入流，以允许读取字节，然后再将它们返回(回推)到流中。PushbackInputStream类实现了这一思想，提供了一种机制，可以“偷窥”来自输入流的内容而不对它们进行破坏。但是，当回推缓冲区已满时，如果试图回推字节，就会抛出IOException异常。

• 构造函数

方法	描述
PushbackInputStream(InputStream inputStream)	创建的流对象允许将一个字节回到输入流
PushbackInputStream(InputStream inputStream, int numBytes)	创建的流对象允许一个长度为numBytes的回推缓存区。

• PushbackInputStream类声明的方法

方法	描述
void unread(int b)	回推b的低字节
void unread(byte buffer[])	回推buff中的字节
void unread(byte buffer, int offset, int numBytes)	回推buffer中从offset开始的numBytes个自己

SequenceInputStream

SequenceInputStream类运行连接多个InputStream对象。SequenceInputStream对象的构造与其他所有InputStream对象都不同。SequenceInputSteam构造函数使用一对InputStream对象或InputStream对象的一个Enumeration对象作为参数。

• 构造函数

方法	描述
SequenceInputStream(InputStream first, InputStream second)	从第一个InputStream对象进行读取，直到读取完全部内容，然后切换到第二个InputStream对象。
SequenceInputStream(Enumeration<? extends InputStream> streamEnum)	持续读取所有InputStream对象中的内容，直到到达最后一个InputStream对象的末尾位置。当到达每个文件末尾时，与之关联的流就会被关闭。关闭通过SequenceInputStream创建的流，会导致关闭所有未关闭的流。

PrintStream

PrintStream类提供了我们一直使用的来自System文件句柄System.out的所有输出功能。PrintStream实现了Appendable、AutoCloseable、Closeable以及Flushable接口。

• 构造函数

方法	描述
PrintStream(OutputStream outputStream)
PrintStream(OutputStream outputStream, boolean autoFlushingOn)
PrintStream(OutputStream outputStream, boolean autoFlushingOn, String charset)
PrintStream(File outputFile)
PrintStream(File outputFile, String charSet)
PrintStream(String outputFileName)
PrintStream(String outputFileName, String charSet)

DataOutputStream

DataOutputStream实现了DataOutput接口，可以向流中直接写入基本数据类型

DataInputStream

DataInputStream实现了DataInput接口，可以从流中直接读取基本数据类型。

RandomAccessFile

RandomAccessFile封装了随机访问文件的功能，该类并非派生自InputStream或OutputStream类，而是实现了DataInput和DataOutPut接口。

字符流类

字符流是通过两个类层次定义的。在顶层是两个抽象类：Reader和Writer。这两个抽象类处理Unicode字符流。

抽象类Reader和Writer定义了其他几个流类实现的重要方法。最重要的两个方法是read()和write()，这两个方法分别读取和写入字符数据。每个方法都有抽象形式，派生的流类必须实现这两个方法。

• java.io包中的字符流列

流类	含义
BufferedReader	缓冲的输入字符流
BufferedWriter	缓冲的输入字符流
CharArrayReader	从字符数组读取内容的输入流
CharArrayWriter	向字符数组写入内容的输入流
FileReader	从文件读取内容的输入流
FileWriter	向文件中写入内容的输出流
FilterReader	过滤的读取器
FilterWriter	过滤的写入器
InputStreamReader	将字节转换成字符的输入流
LineNumberReader	计算行数的输入流
OutputStreamWriter	将字符转换成字节的输出流
PipedReader	输入管道
PipedWriter	输出管道
PrintWriter	包含print()和println()的输出流
PushbackReader	允许字符返回到输入流的输入流
Reader	描述字符流输入的抽象类
StringReader	从字符串读取内容的输入流
StringWriter	向字符串写入内容的输出流
Writer	描述字符流输出的抽象类

Reader

Reader是抽象类，定义了Java的流字符输入模型。该类实现了AutoCloseable、closeable以及Readable接口。

• Reader类定义的方法

方法	描述
abstract void close()	关闭输入源。如果试图继续读取，就产生IOException异常
void mark(int numChars)	在输入流的当前位置放置标记，该标记在读入numChars个字符之前一直都有效
boolean markSupported()	如果这个流支持mark()或reset()方法，就返回true
int read()	返回一个表示调用输入流中下一个可用字符的整数。如果到达文件末尾，就返回-1
int read(char buffer[])	尝试读取buffer.length个字符到buffer中，并且返回成功读取的实际字符数。如果到达文件末尾，就返回-1
int read(CharBuffer buffer)	尝试读取字符到buffer中，并且返回成功读取的实际字符数。如果到达文件末尾，就返回-1
abstract int read(char buffer[], int offset, int numChars)	尝试读取numChars个字符到buffer中，从buffer[offset]开始保存读取的字符，返回成功读取的字符数。如果到达文件末尾，就返回-1
boolean ready()	如果下一个输入请求不当代，就返回true；否则返回false
void reset()	将输入指针重新设置为前面设置的标记位置
long skin(long numChars)	略过numChars个输入字符，返回实际略过的字符数

Write

Write是定义字符输出模型的抽象类，实现了AutoCloseable、Closeable、Flushable以及 Appendable接口。

• Write类定义的方法

方法	描述
Writer append(char ch)	将ch追加到调用输出流的末尾，返回对调用流的引用
Writer append(charSequence chars)	将chars追加到调用输出流的末尾，返回对调用流的引用
Writer append(CharSequence chars, int begin, int end)	将chars中从begin到end-1之间的字符追加到调用输出流的末尾，返回对调用流的引用
abstract void close()	关闭输出流。如果试图继续向其中写入内容，将产生IOException异常
abstract void flush()	完成输出状态，从而情况所有缓冲区，即刷新输出换种去
void write(int ch)	向调用输出流写入单个字符。注意参数是int类型，从而可以直接使用表达式调用write()方法，而不必将之强制转换回char类型。但是只会写入低阶16位
void write(char buffer[])	将整个字符数组写入调用输出流中
abstract void writer(char buffer[], int offset, int numChars)	将buffer数组中从buffer[offset]开始的numChars个字符写入调用输出流中
void write(String str)	将str写入调用输出流中
void write(String str, int offset, int numChars)	将字符串str中从offset开始的numChars个字符写入调用输出流中

FileReader

FileReader类可以创建用于读取文件内容的Reader对象。

• 构造函数

方法	描述
FileReader(String filePath)	filePath是文件的完整路径名
FileReader(File fileObj)	fileObj是描述文件的File对象

FileWriter

FileWriter类可以创建能够用于写入文件的Writer对象。

FileWriter在打开不存在的文件时，会先创建文件。

• 构造函数

方法	描述
FileWriter(String filePath)	filePath是文件的完整路径名
FileWriter(String filePath, boolean append)	filePath是文件的完整路径名，append表示是否追加方式写入文件
FileWriter(File fileObj)	fileObj是描述文件的File对象
FileWriter(File fileObj, boolean append)	fileObj是描述文件的对象，append表示是否追加方式希写入文件

CharArrayReader

CharArrayReader类是使用字符数组作为源的一个流实现

• 构造函数

方法	描述
CharArrayReader(char array[])	array是输入源
CharArrayReader(char array[], int start, int numChars)	array是输入源，start指定开始的索引位置，numChars指定一共读取的字符数

CharArrayWriter

CharArrayWriter类是使用数组作为目标的一个输出流的实现。

• 构造函数

方法	描述
CharArrayWriter()	创建使用默认大小的缓冲区
CharArrayWriter(int numChars)	创建由numChars指定带下的缓冲区

BufferedReader

BufferedReader类通过缓冲输入提高性能

方法	描述
BufferedReader(Reader inputStream)	使用默认缓冲区大小创建缓冲的字符流
BufferedReader(Reader inputStream, int bufSize)	bufSize指定默认缓冲区大小

BufferedWriter

BufferedWriter是缓冲输出的Writer，可以通过减少实际向输出设备写入数据的次数来提高性能。

• 构造函数

方法	描述
BufferedWriter(Writer outputStream)	使用具有默认大小的缓冲区
BufferedWriter(Writer outputStream, int bufSize)	指定默认缓冲区大小为bufSize

PushbackReader

PushbackReader类允许将一个或多个字符返回到输入流，从而可以向前查看输入流。

• 构造函数

方法	描述
PushbackReader(Reader inputStream)	创建的缓冲流允许回推一个字符
PushbackReader(Reader inputStream, int bufSize)	指定允许回推多个字符

• PushbackReader类常用方法

方法	描述
void unread(int ch)	回推ch字符
void unread(char buffer[])	回推buffer中的字符
void unread(char buffer[], int offset, int numChars)	回推buffer中指定偏移和数量的字符

PrintWriter

PrintWriter本质上市PrintStream的面向字符的版本，实现了Appendable、AutoCloseable、Closeable以及Flushable接口。

• 构造函数

方法	描述
PrintWriter(OutputStream outputStream)	outputStream指定将接收输出的对象
PrintWriter(OutputStream ouputStream, boolean autoFlushingOn)	autoFlushingOn指定是否自动刷新输出缓冲区
PrintWriter(Writer outputStream)
PrintWriter(Writer outputStream, boolean autoFlushingOn)
PrintWriter(File outputFile)
PrintWriter(File outputFile, String charSet)
PrintWriter(String outputFileName)
PrintWriter(String outputFileName, String charSet)
PrintWriter(String fmtString, Object … args)
PrintWriter(Locale loc, String fmtString, Object … args)

预定义流

Java的System类，封装了运行时环境的某些方法，还包含了3个预定义的流变量：in、out以及err。这些变量在System类中被声明为public、static以及final。这意味着程序中的任何部分都可以使用它们，而不需要引用特定的System对象。

System.out引用标准的输出流，默认情况下是控制台。System.in引用标准的输入流，默认情况下是键盘。 System.err引用标准的错误流，默认情况下也是控制台。但是，这些流可以被重定向到任何兼容的I/O设备。

System.in是InputStream类型的对象；System.out和System.err是PrintStream类型的对象。这些都是字节流，尽管它们通常用于从控制台读取字符及向控制台写入字符。

控制台输入输出

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;

public class LearnConsoleInput 
{
    public static void main(String args[]) throws IOException
    {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(System.out, true);
        
        String str;
        pw.println("Enter lines of text.");
        pw.println("Enter 'stop' to quit");
        
        do {
            str = br.readLine();
            pw.println(str);
        } while(!str.equals("stop"));
    }
}

文件读写

对于读写文件，两个最常用的流类是FileInputStream和FileOutputStream，这两个类创建与文件链接的字节流。为了打开文件，只需要简单地创建这些类中某个类的对象，指定文件名作为构造函数的参数即可。

当创建输入流时，如果文件不存在，就会抛出FileNotFoundException异常。对于输出流，如果不能打开文件或不能创建文件，也会抛出FileNotFoundException异常。FileNotFoundException是IOException的紫烈。当打开输出文件时，先前存在的同命文件将被销毁。

文件使用完之后必须关闭，关闭文件会释放文件分配的系统资源，从而允许其他文件使用这些资源。关闭文件是不会导致“内存泄漏”，因为未使用的资源没有被释放。

JDK7之后的版本，添加了自动关闭文件的处理，使用带资源的try语句，当不再需要文件时能够自动关闭文件，当离开try代码块时，会隐式地调用close()方法以关闭与fin关联的流。比较推荐的是使用带资源的try语句。

• 常用方法

方法	描述
close()	关闭文件
read()	从文件读取一个字节，并作为整形值返回。当到达文件末尾时，返回-1。该方法可能抛出IOException异常
write()	向文件中写入由byteval指定的字节。尽管byteval被声明为整形，但只有低8位会被写入到文件中。如果在写文件期间发生了错误，会抛出IOException异常。

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

public class LearnFileIO 
{
    public static void main(String args[]) throws IOException
    {
        int i ;
        FileInputStream fin = null;
        FileOutputStream fout = null;
        
        try {
            fin = new FileInputStream("input.txt");
            fout = new FileOutputStream("output.txt");
            
            do {
                i = fin.read();
                if(i != -1) {
                    fout.write(i);
                } 
            } while(i != -1);
        } catch (IOException e) {
            System.out.println("I/O Error:" + e);
        } finally {
            try {
                if(fin != null) {
                    fin.close();
                } 
            } catch(IOException e2) {
                System.out.println("Error Closing Input File");
            }
            
            try {
                if(fout != null) {
                    fout.close();
                }
            } catch (IOException e2) {
                System.out.println("Error Closing Output File");
            }
            
            System.out.println("file copy finish!");
        }
        
        // 自动关闭
        try(FileInputStream fin2 = new FileInputStream("output.txt")){
            do {
                i = fin2.read();
                if(i != -1) {
                    System.out.print((char)i);
                }
            } while(i != -1);
        } catch(FileNotFoundException e) {
            System.out.println("File Not Found");
        } catch(IOException e) {
            System.out.println("AN I/O Error Occured");
        }
        
        System.out.println("\nfile print finish!");
    }
}

文件

File

File类直接处理文件和文件系统，File类没有指定如果从文件检索信息以及如何向文件中存储信息，而是描述了文件本身的属性。File对象用于获取和操作与磁盘文件关联的信息。

• 构造函数

方法	描述
File(String directoryPath)	directoryPath是文件路径名
File(String directoryPath, String filename)	directoryPath是文件路径名，filename是文件或子目录名称
File(File dirObj, String filename)	dirObj是指定目录的File对象，filename是文件或子目录名称
File(URI uriObj)	uriObj是描述文件的URI对象

• File类常用方法

方法	描述
String getName()	返回文件的名称
String getParent()	返回父目录名称
boolean exists()	如果文件存在，返回true；否则返回false
boolean isFile()	如果调用对象是文件返回true；否则返回false
boolean isAbsolute()	如果文件的路径是绝对路径，返回ture；否则返回false
boolean renameTo(File newName)	由newName指定的文件名为调用File对象的新名称。如果操作成功，就返回true；如果文件不能被重命名(文件已存在等)就返回false
boolean delete()	如果目录为空或是文件，删除成功时返回true；否则返回false
void deleteOnExit()	当Java虚拟机终止时，删除与调用对象关联的文件
long getFreeSpace()	返回在与调用对象关联的分区中，剩余存储空间的字节数
long getTotalSpace()	返回在与调用对象关联的分区的存储容量
long getUsableSpace()	返回在与调用对象关联的分区中，剩余可用存储空间的字节数
boolean isHidden()	如果调用文件是隐藏的，就返回true；否则返回false
boolean setLastModified(long millisec)	将调用文件的时间戳设置为由millisec指定的时间，表示从标准时间1970年1月1日(UTC)起到现在经历的毫秒数
boolean setReadOnly()	将调用文件设置为只读的
Path toPath()	将File对象转换成Path对象
boolean isDirectory()	如果调用对象是目录，返回true；否则返回false
String[] list()	提取调用对象(目录)内部的其他文件和目录列表
String[] list(FilenameFilter FFObj)	以FFObj作为过滤的匹配方式筛选返回的文件列表
File[] listFiles()	返回所有的文件对象
File[] listFiles(FilenameFilter FFObj)	过滤的方式返回所有符合的文件
File[] listFiles(FileFilter FObj)	过滤的方式返回所有符合的文件
boolean mkdir()	创建目录，成功返回true；否则返回false
boolean mkdirs()	迭代方式创建完整的目录

FilenameFilter

• FilenameFilter类常用方法

方法	描述
boolean accept(File directory, String filename)	在由directory指定的目录中，对于那些应当被包含到列表的文件中(也就是那些能匹配filename参数的文件)，accept()方法返回true；对于那些应当排除的文件，accept()方法返回false

import java.io.*;

class OnlyExt implements FilenameFilter
{
    String ext;
    
    public OnlyExt(String ext)
    {
        this.ext = "." + ext;
    }
    
    public boolean accept(File dir, String name)
    {
        return name.endsWith(this.ext);
    }
}

public class LearnFilenameFilter1 
{
    public static void main(String args[])
    {
        String dirname = "./java";
        File f1 = new File(dirname);
        FilenameFilter only = new OnlyExt("html");
        String s[] = f1.list(only);
        
        for(int i = 0; i < s.length; ++i) {
            System.out.println(s[i]);
        }
    }
}

FileFilter

• FileFilter类常用方法

方法	描述
boolean accept(File path)	对于应当包含到列表中的文件(也就是那些能匹配path参数的文件)，该方法返回true；对于那些应当排除的文件，该方法返回false

Console

Console用于从控制台读取内容以及向控制台写入内容，并且实现了Flushable接口。

• Console类定义的方法

方法	描述
void flush()	将缓冲的输出物理地写到控制台
Console format(String fmtString, Object … args)	使用fmtString指定的格式将args写到控制台
Console printf(String fmtString, Object … args)	使用fmtString指定的格式将args写到控制台
Reader reader()	返回对连接到控制台的Reader对象的引用
String readLine()	读取并返回从键盘输入的字符串。当用户按下回车键时，输入结束。如果已经到达控制台输入流的末尾，就返回null；如果失败，就抛出IOError异常
String readLine(String fmtString, Object … args)	按照fmtString和args指定的格式显示的提示字符串，然后读取并返回从键盘输入的字符串。当用户按下回车键时，输入结束。如果已经到达控制台输入流的末尾，就返回null；如果失败，就抛出IOError异常
char[] readPassword()	读取从键盘输入的字符串。当用户按下回车键时，输入结束。输入的字符串并不显示。如果已经到达控制台输入流的末尾，就返回null；如果失败，抛出IOError异常
char[] readPassword(String fmtString, Object … args)	按照fmtString和args指定的格式显示提示字符串，然后读取从键盘输入的字符串。当用户按下回车键时，输入结束。输入的字符串不显示，如果已经到达控制台输入流的末尾，就返回null；如果失败，就抛出IOError异常
PrintWriter writer()	返回对连接到控制台的Writer对象的引用

串行化

串行化是将对象的状态写入字节流的过程。

import java.io.*;

class MyClass implements Serializable
{
    String s;
    int i;
    double d;
    
    public MyClass(String s, int i, double d)
    {
        this.s = s;
        this.i = i;
        this.d = d;
    }
    
    public String toString()
    {
        return "s=" + s + ";i=" + i + ";d=" + d;
    }
}

public class LearnSerialization1 
{
    public static void main(String args[])
    {
        try (ObjectOutputStream objOStrm = new ObjectOutputStream(new FileOutputStream("serial"))){
            MyClass object1 = new MyClass("Hello", -7, 2.7e10);
            System.out.println("object1:" + object1);
            objOStrm.writeObject(object1);
        } catch(IOException e) {
            System.out.println("Exception during serialization: " + e);
        }
        
        try(ObjectInputStream objIStrm = new ObjectInputStream(new FileInputStream("serial"))) {
            MyClass object2 = (MyClass)objIStrm.readObject();
            System.out.println("object2:" + object2);
        } catch(Exception e) {
            System.out.println("Exception during deserialization:" + e);
        }
    }
}

Serializable

只有实现了Serializable接口的类才能够通过串行化功能进行保存和恢复。Serializable接口没有定义成员，只是简单地用于指示类可以被串行化。如果一个类是可串行化的，那么这个类的所有子类也都是可串行化的。

声明为transient的变量不能通过串行化的功能进行保存。此外，也不能保存static变量。

Externalizable

Externalizable用于控制串行化的过程。

ObjectOutput

ObjectOutput接口扩展了DataOutput和AutoCloseable接口，并且支持对象串行化。

方法	描述
void close()	关闭调用流。如果试图继续向流中写入内容，将产生IOException异常
void flush()	完成输出状态，以便清空所有缓冲区，即刷新输出缓冲区
void write(byte buffer[])	将字节数组写入调用流中
void write(byte buffer[], int offset, int numBytes)	将buffer数组中从buffer[offset]位置开始的numBytes个字节写入调用流中
void write(int b)	将单个字节写入调用流中，写入的字节是b的低阶字节
void writeObject(Object obj)	将obj对象写入调用流中

ObjectOutputStream

ObjectOutputStream类扩展了OutputStream类并实现了ObjectOutput接口，负责将对象写入流中。

• 构造函数

方法	描述
ObjectOutputStream(OutputStream outStream)	outStream是将向其中写入串行化对象的输入流。关闭ObjectOutputStream对象回自动关闭outStream指定的底层流

• ObjectOutpuStream类定义的常用方法

方法	描述
void close()	关闭调用流。如果试图继续向流中写入内容，将产生IOException异常
void flush()	完成输出状态，以便清空所有缓冲区，即刷新输出缓冲区
void write(byte buffer[])	将字节数组写入调用流中
void write(byte buffer[], int offset, int numBytes)	将buffer数组中从buffer[offset]位置开始的numBytes个字节写入调用流中
void write(int b)	将单个字节写入调用流中，写入的字节是b的低阶字节
void writeBoolean(boolean b)	将一个布尔值写入调用流中
void writeByte(int b)	将一个byte值写入调用流中，写入的字节是b的低阶字节
void writeBytes(String str)	将表示str的字节写入调用流中
void writeChar(int c)	将一个char值写入调用流中
void writeChars(String str)	将str中的字符写入调用流中
void writeDouble(double d)	将一个double值写入调用流中
void writeFloat(float f)	将一个float值写入调用流中
void writeInt(int i)	将一个int值写入调用流中
void writeLong(long l)	将一个long值写入调用流中
final void writeObject(Object obj)	将obj对象写入调用流中
void writeShort(int i)	将一个short值写入调用流中

ObjectInput

ObjectInput接口扩展了DataInput和AutoCloseable接口，ObjectInput接口支持对象串行化。

• ObjectInput接口定义的方法

方法	描述
int avaliable()	返回输入缓冲区中现在可用的字节数
void close()	关闭调用流。如果试图继续从中读取内容，将产生IOException异常
int read()	返回一个表示输入流中下一个可用字节的整数。如果到达文件末尾，就返回-1
int read(byte buffer[])	尝试读取buffer.length个字节到buffer中，返回成功读取的实际字节数。如果到达文件末尾，就返回-1
int read(byte buffer[], int offset, int numBytes)	尝试读取numBytes个字节到buffer中，从buffer[offset]位置开始存储，返回成功读取的字节数。如果达到文件末尾，就返回-1
Object readObject()	从调用流中读取对象
long skip(long numBytes)	忽略调用字节中numBytes个字节，返回实际忽略的字节数

ObjectInputStream

ObjectInputStream类扩展了InputStream类并实现了ObjectInput接口。ObjectInputStream负责从流中读取对象

• 构造函数

方法	描述
ObjectInputStream(InputStream inStream)	inStream是从读取串行化对象的输入流。关闭ObjectInputStream对象会自动关闭inStream指定的底层流

• ObjectInputStream类定义的常用方法

方法	描述
int available()	返回输入缓冲区中现在可用的字节数
void close()	关闭调用流。如果试图继续从中读取内容，将产生IOException异常。底层流会被关闭
int read()	返回一个表示输入流中下一个可用字节的整数。如果到达文件末尾，就返回-1
int read(byte buffer[], int offset, int numBytes)	尝试读取numBytes个字节到buffer中，从buffer[offset]位置开始存储，返回成功读取的字节数。如果达到文件末尾，就返回-1
boolean readBoolean()	从调用流中读取并返回一个布尔值
byte readByte()	从调用流中读取并返回一个byte值
char readChar()	从调用流中读取并返回一个char值
double readDouble()	从调用流中读取并返回一个double值
float readFloat()	从调用流中读取并返回一个float值
void readFully(byte buffer[])	读取buffer.length个字节到buffer中。只有当所有字节都读取完之后才返回
void readFully(byte buffer[], int offset, int numBytes)	读取numBytes个字节到buffer中，从buffer[offset]位置开始存储。只有当读取了numBytes个字节之后才返回
int readInt()	从调用流中读取返回一个int值
long readLong()	从调用流中读取并返回一个long值
final Object readObject()	从调用流中读取并返回一个对象
short readShort()	从调用流中读取并返回一个short值
int readUnsignedByte()	从调用流中读取并返回一个无符号byte值
int readUnsignedShort()	从调用流中读取并返回一个无符号short值