IO源码笔记

InputStream

Class Name	@since	Field	Method	Comment
InputStream	1.0	MAX_SKIP_BUFFER_SIZE = 2048	int read() int read(byte b[]) int read(byte b[], int off, int len) long skip(long n) int available() void close() synchronized void mark(int readlimit) synchronized void reset() boolean markSupported()
FilterInputStream	1.0	volatile InputStream in		所有方法都转发给了被装饰字段。 这个类有点鸡肋
ByteArrayInputStream	1.0	byte buf[] int pos int mark = 0 int count		字节数组作为数据来源，支持标记、重置等方法
FileInputStream	1.0	final FileDescriptor fd; final String path; FileChannel channel = null; final Object closeLock = new Object(); volatile boolean closed = false;	final FileDescriptor getFD() FileChannel getChannel()	基本都是native方法
PipedInputStream	1.0	boolean closedByWriter = false; volatile boolean closedByReader = false; boolean connected = false; Thread readSide; Thread writeSide; static final int DEFAULT_PIPE_SIZE = 1024; static final int PIPE_SIZE = DEFAULT_PIPE_SIZE; byte buffer[]; int in = -1; int out = 0;	void connect(PipedOutputStream src) synchronized void receive(int b) synchronized void receive(byte b[], int off, int len) void checkStateForReceive() void awaitSpace() void receivedLast()	PipedInputStream和PipedOutputStream详解 PipedInputStream与PipedOutputStream组合使用，PipedOutputStream接收外部输入的数据，存储到PipedInputStream的字节数组中，消费程序从PipedInputStream数组中获取数据
BufferedInputStream	1.0	static int DEFAULT_BUFFER_SIZE = 8192; static int MAX_BUFFER_SIZE = Integer.MAX_VALUE - 8; volatile byte buf[]; static final AtomicReferenceFieldUpdater bufUpdater = AtomicReferenceFieldUpdater.newUpdater (BufferedInputStream.class, byte[].class, “buf”); int count; int pos; int markpos = -1; int marklimit;	void fill()	内部通过字节数组作为缓冲区。缓冲区大小取决于磁盘和网络
PushbackInputStream	1.0	byte[] buf; int pos;	void unread(int b) void unread(byte[] b, int off, int len) void unread(byte[] b)	将读取的字节回退到buf数组中，供下次继续读取。 pos初始位置是buf.length，从后向前存储数据（一般是存储字节数组，字节数组顺序不变）。 读取数据是从前向后读取
DataInputStream	1.0	byte bytearr[] = new byte[80]; char chararr[] = new char[80]; byte readBuffer[] = new byte[8]; char lineBuffer[];	void readFully(byte b[]) void readFully(byte b[], int off, int len) final int skipBytes(int n) final boolean readBoolean final byte readByte() final int readUnsignedByte() final short readShort() final int readUnsignedShort() final char readChar() final int readInt() final long readLong() final float readFloat() final double readDouble() final String readLine() final String readUTF() final static String readUTF(DataInput in)	读取java类型值（一次读取多个字节） 结束标志建议通过捕获EOFException异常（有可能传入了一个-1整数）
ObjectInputStream	1.1		final Object readObject()	字段方法较多，后续再说。 比较有用的是readObject()方法，与ObjectOutputStream实现序列化与反序列化
SequenceInputStream	1.0	Enumeration e; InputStream in;	final void nextStream()	将多个InputStream合并为一个，按顺序读取

FileDescriptor

认知IO流之 — FileDescriptor

OutputStream

Class Name	@since	Field	Method	Comment
OutputStream	1.0		void write(int b) void write(byte b[]) void write(byte b[], int off, int len) void flush() void close()
FilterOutputStream	1.0	protected OutputStream out;
ByteArrayOutputStream	1.0	protected byte buf[]; protected int count;	synchronized byte toByteArray()[] synchronized void reset() synchronized int size()	默认数组大小32，最大Integer.MAX_VALUE 可通过toByteArray()方法获取输出数组
FileOutputStream	1.0	final FileDescriptor fd; final boolean append; FileChannel channel; final String path; final Object closeLock = new Object(); volatile boolean closed = false;	native void write(int b, boolean append) native void writeBytes(byte b[], int off, int len, boolean append) final FileDescriptor getFD() FileChannel getChannel()	默认覆盖原文件
PipedOutputStream	1.0	private PipedInputStream sink;	synchronized void connect(PipedInputStream snk)	PipedOutputStream中持有对应的PipedInputStream对象 write()方法实际调用PipedInputStream的receive()方法存储到PipedInputStream中
BufferingOutputStream		final OutputStream other; final byte[] buf; int bufOff;		缓冲区默认大小4096，
DataOutputStream	1.0	int written; byte[] bytearr = null; byte writeBuffer[] = new byte[8];	private void incCount(int value) final void writeBoolean(boolean v) final void writeByte(int v) final void writeShort(int v) final void writeChar(int v) final void writeInt(int v) final void writeFloat(float v) final void writeDouble(double v) final void writeBytes(String s) final void writeChars(String s) final void writeUTF(String str) static int writeUTF(String str, DataOutput out) final int size()	将java类型转换为字节输出
PrintStream	1.0	final boolean autoFlush; boolean trouble = false; Formatter formatter; BufferedWriter textOut; OutputStreamWriter charOut; boolean closing = false;	PrintStream append PrintStream format PrintStream printf void println void print void write(byte buf[], int off, int len) void write(int b)	System.out和System.err的类型。 能够将原始值转换为文本、格式化
ObjectOutputStream	1.1		final void writeObject(Object obj)

RandomAccessFile

Class Name	@since	Field	Method	Comment
RandomAccessFile	1.0	FileDescriptor fd; FileChannel channel = null; boolean rw; final String path; Object closeLock = new Object(); volatile boolean closed = false; static final int O_RDONLY = 1; static final int O_RDWR = 2; static final int O_SYNC = 4; static final int O_DSYNC = 8;	native long getFilePointer() void seek(long pos) native long length()	随机读写 r、rw、rws、rwd

Reader

Class Name	@since	Field	Method	Comment
Reader	1.1	Object lock; static final int maxSkipBufferSize = 8192; char skipBuffer[] = null;	int read(java.nio.CharBuffer target) int read() int read(char cbuf[]) int read(char cbuf[], int off, int len) boolean ready() boolean markSupported() void mark(int readAheadLimit) void reset() void close()
InputStreamReader	1.1	final StreamDecoder sd;	String getEncoding()	方法转发给了StreamDecoder，StreamDecoder属于nio包中内容，后续分析
FilterReader	1.1	Reader in;
CharArrayReader	1.1	char buf[]; int pos; int markedPos = 0; int count;		从buf中读取数据，支持标记、重置
FileReader	1.1			继承者InputStreamReader 如果需要使用不同的字符编码解决方案，请使用InputStreamReader
PipedReader	1.1	boolean closedByWriter = false; boolean closedByReader = false; boolean connected = false; Thread readSide; Thread writeSide; static final int DEFAULT_PIPE_SIZE = 1024; char buffer[]; int in = -1; int out = 0;	void connect(PipedWriter src) synchronized void receive(int c) synchronized void receive(char c[], int off, int len) synchronized void receivedLast() synchronized int read() synchronized int read(char cbuf[], int off, int len) synchronized boolean ready()	read()方法会阻塞等待，read(buf[])不会（读取第一个字符可能会阻塞）
BufferedReader	1.1	Reader in; char cb[]; int nChars, nextChar; static final int INVALIDATED = -2; static final int UNMARKED = -1; int markedChar = UNMARKED; int readAheadLimit = 0; /* Valid only when markedChar > 0 */ boolean skipLF = false; boolean markedSkipLF = false; static int defaultCharBufferSize = 8192; static int defaultExpectedLineLength = 80;	String readLine() Stream lines()
PushbackReader	1.1	char[] buf; int pos;	void unread(int c) void unread(char cbuf[], int off, int len) void unread(char cbuf[])	如果需要提前阅读几个字符以了解即将发生的情况，然后才能确定如何解释当前字符。将读取的字符推回Reader，下次调用read()时读取
LineNumberReader	1.1	int lineNumber = 0; int markedLineNumber; // Defaults to 0 boolean skipLF; boolean markedSkipLF; static final int maxSkipBufferSize = 8192; char skipBuffer[] = null;	void setLineNumber(int lineNumber) int getLineNumber() String readLine()
StringReader	1.1	String str; int length; int next = 0; int mark = 0;		mark()方法没有实际限制

Writer

Class Name	@since	Field	Method	Comment
Writer	1.1	char[] writeBuffer; static final int WRITE_BUFFER_SIZE = 1024; Object lock;	void write(int c) void write(char cbuf[]) void write(char cbuf[], int off, int len) write(String str) write(String str, int off, int len) Writer append(CharSequence csq) Writer append(CharSequence csq, int start, int end) Writer append(char c) void flush() void close()
OutputStreamWriter	1.1	final StreamEncoder se;		方法转发给了StreamEncoder，StreamEncoder属于nio包中内容，后续分析
CharArrayWriter	1.1	char buf[]; int count;	void writeTo(Writer out) char toCharArray()[] int size() String toString()	数组默认大小32，
FileWriter	1.1			继承者OutputStreamWriter 如果需要使用不同的字符编码解决方案，请使用OutputStreamWriter
PipedWriter	1.1	PipedReader sink; boolean closed = false;		PipedWriter中持有对应的PipedReader对象 write()方法实际调用PipedReader的receive()方法存储到PipedReader中，flush()方法会唤醒PipedReader所在线程
BufferedWriter	1.1	Writer out; char cb[]; int nChars, nextChar; static int defaultCharBufferSize = 8192; String lineSeparator;	void flushBuffer() void newLine()	数据缓冲，缓冲区满了会刷新到底层Writer中。 flush()方法可手动刷新
FilterWriter	1.1	Writer out;
StringWriter	1.1	StringBuffer buf;	String toString() StringBuffer getBuffer()	底层使用StringBuffer存储数据
PrintWriter	1.1	Writer out; final boolean autoFlush = false; boolean trouble = false; Formatter formatter; PrintStream psOut = null; final String lineSeparator;	void write void newLine void print void println PrintWriter printf PrintWriter format PrintWriter append	将格式化的数据写入底层Writer

Bits

使用大端字节排序将原语值放入/取出字节数组的实用程序方法。

// 获取对应值
static XXX getXXX(byte[] b, int off)
// 放入对应值。多字节类型值放入时，使用>>>无符号右移运算
static void putXXX(byte[] b, int off, XXX val)

Closeable

一个 Closeable是可以关闭的数据的源或目的地。 调用close方法来释放对象持有的资源（如打开的文件）。

// 关闭此流并释放与之相关联的任何系统资源。 如果流已经关闭，则调用此方法将不起作用。 
public void close() throws IOException;

Console

Java控制台

@Since: 1.6

Comment:

• 访问与当前Java虚拟机关联的基于字符的控制台设备（如果有的话）的方法。虚拟机是否具有控制台取决于底层平台以及虚拟机的调用方式。 如果虚拟机从交互式命令行启动，而不重定向标准输入和输出流，则其控制台将存在，并且通常将连接到启动虚拟机的键盘和显示器。 如果虚拟机是自动启动的，例如由后台作业调度程序启动，则通常不具有控制台。
• 如果这个虚拟机有一个控制台，那么它有一个这个类的唯一实例表示，可以通过调用System.console()方法获得。 如果没有控制台设备可用，则该方法的调用将返回null 。
• 读取和写入操作是同步的，以保证关键操作的原子完成; 因此调用方法readLine() ， readPassword() ， format() ， printf()以及读，格式和写在由返回的对象的操作reader()和writer()在多线程方案可能阻塞。
• 对reader()和writer()返回的对象调用close()将不会关闭这些对象的基础流（重写了close方法）。

Method	Comment
PrintWriter writer()	检索与此控制台关联的唯一PrintWriter对象。
Reader reader()	检索与此控制台关联的唯一Reader对象。
Console format(String fmt, Object …args)	使用指定的格式字符串和参数将格式化的字符串写入此控制台的输出流。
Console printf(String format, Object … args)	使用指定的格式字符串和参数将格式化的字符串写入此控制台的输出流的便利方法。
String readLine()	从控制台读取一行文本。
String readLine(String fmt, Object … args)	提供一个格式化的提示，然后从控制台读取一行文本。
char[] readPassword()	从禁用回音的控制台读取密码或密码
char[] readPassword(String fmt, Object … args)	提供一个格式化的提示，然后从禁用回显的控制台读取密码或密码。
void flush()	刷新控制台并强制任何缓冲输出立即写入。

DataInput

@Since：1.0

Comment：提供从二进制流读取字节并从其中重建任何Java原语类型的数据。 还有，为了重建设施String从数据修改UTF-8格式。

Method	Comment
void readFully(byte b[])	从输入流读取一些字节，并将它们存储到缓冲区数组 b 。 该方法会阻塞
void readFully(byte b[], int off, int len)	从输入流读取 len个字节。该方法会阻塞
int skipBytes(int n)	尝试从输入流中跳过 n字节的数据，丢弃跳过的字节。
boolean readBoolean()	读取一个输入字节，并返回 true如果该字节不为零， false如果该字节是零。
byte readByte()	读取并返回一个输入字节。
int readUnsignedByte()	读取一个输入字节，将其扩展到类型 int ，并返回结果，因此在 0到 255 。
short readShort()	读取两个输入字节并返回一个 short值。
int readUnsignedShort()	读取两个输入字节，并返回 0到 65535的 int值。
char readChar()	读取两个输入字节并返回一个 char值
int readInt()	读取四个输入字节并返回一个 int值。
long readLong()	读取八个输入字节并返回一个 long值。
float readFloat()	读取四个输入字节并返回一个 float值
double readDouble()	读取八个输入字节并返回一个 double值
String readLine()	从输入流读取下一行文本。
String readUTF()	读取已使用UTF-8格式编码的字符串

DataOutput

@Since：1.0

Comment：提供将数据从任何Java基本类型转换为一系列字节，并将这些字节写入二进制流。 还有一种将String转换为modified UTF-8格式并编写结果字节系列的功能。 多字节使用**>>>**无符号右移按序输出

Method	Comment
void write(int b)	向输出流写入参数 b的八个低位。
void write(byte b[])	将输出流写入数组 b中的所有字节。
void write(byte b[], int off, int len)	从阵列 b写入 len字节，以输出流。
void writeBoolean(boolean v)	将 boolean值写入此输出流。
void writeByte(int v)	向输出流写入参数 v的八个低位位。
void writeShort(int v)	将两个字节写入输出流以表示参数的值。
void writeChar(int v)	将两个字节组成的 char值写入输出流。
void writeInt(int v)	将 int值（由四个字节组成）写入输出流。
void writeLong(long v)	将 long值（由八个字节组成）写入输出流。
void writeFloat(float v)	将 float值写入输出流，该值由四个字节组成。
void writeDouble(double v)	将 double值（由8个字节组成）写入输出流。
void writeBytes(String s)	将一个字符串写入输出流。
void writeChars(String s)	写入每一个字符在字符串中 s ，到输出流中，为了，每个字符使用两个字节。
void writeUTF(String s)	将两个字节的长度信息写入输出流，其后是 字符串 s中每个字符的 s 。

DefaultFileSystem

@Since：1.8

Comment：无注释说明，根据唯一的方法推测，作用应该时用于跨平台获取当前系统对应的文件系统

public static FileSystem getFileSystem() {
    return new WinNTFileSystem();
}

DeleteOnExitHook

Comment：这个类保存了一组要在VM退出时通过关闭钩子删除的文件名。set用于防止重复插入同一个文件，并提供快速删除。

Bug？https://stackoverflow.com/questions/40119188/memory-leak-on-deleteonexithook

// DeleteOnExitHook必须是最后一个被调用的关闭钩子。应用程序关闭钩子可以将第一个文件添加到退出列表的delete中，并导致在关闭过程中注册DeleteOnExitHook。因此，将registerShutdownInProgress参数设置为true。
static {
	sun.misc.SharedSecrets.getJavaLangAccess()
        .registerShutdownHook(2 /* Shutdown hook invocation order，关闭钩子调用顺序 */,
            true /* register even if shutdown in progress，即使正在关闭也要注册 */,
            new Runnable() {
                public void run() {
                   runHooks();
                }
            }
    );
}

static void runHooks() {
    LinkedHashSet<String> theFiles;

    synchronized (DeleteOnExitHook.class) {
        theFiles = files;
        files = null;
    }

    ArrayList<String> toBeDeleted = new ArrayList<>(theFiles);
	// 最新的文件先被删除
    // reverse the list to maintain previous jdk deletion order.
    // Last in first deleted.
    Collections.reverse(toBeDeleted);
    for (String filename : toBeDeleted) {
        (new File(filename)).delete();
    }
}

ExpiringCache

Comment：带过期的缓存

// 缓存时长，默认30000毫秒。超过该时间，会被清理
private long millisUntilExpiration;
// 实际存储数据。Entry中存储实际数据和存储数据时时间。实际类型是LinkedHashMap，重写了removeEldestEntry()方法
private Map<String,Entry> map;
// get()和put()方法调用时会加1，每隔queryOverflow次会重置该值
// Clear out old entries every few queries
private int queryCount;
// 清理map的频率
private int queryOverflow = 300;
// map中保存数据的最大数量
private int MAX_ENTRIES = 200;

Externalizable

@Since：1.1

Comment：实现对象的序列化与反序列化

• 通过writeExternal(ObjectOutput out)和readExternal(ObjectInput in)实现序列化与反序列化。
• 属性字段使用 transient 和不使用没有任何区别。Serializable 序列化、反序列化时会跳过transient修饰的字段。
• 优先级比Serializable的优先级高。
• 必须要有默认的构造方法，而Serializable可以没有默认的构造方法。
• 通过writeExternal(ObjectOutput out)可以自由的选择需要序列化的字段，readExternal(ObjectInput in)读取顺序需要一致。（Serializable 可以通过transient修饰选择）
• Serializable 通过private static final long serialVersionUID;字段识别相同版本

Method	Comment
void writeExternal(ObjectOutput out)	该对象实现了writeExternal方法来通过调用DataOutput的原始值或调用ObjectOutput的对象，字符串和数组的writeObject方法来保存其内容。
void readExternal(ObjectInput in)	该对象实现了readExternal方法来恢复其内容，方法是为对象，字符串和数组调用基本类型的DataInput方法和readObject。 readExternal方法必须以与writeExternal写的相同的顺序读取相同的值。

Serializable

java序列化，看这篇就够了

Method	Comment
ANY-ACCESS-MODIFIER Object writeReplace() throws ObjectStreamException;	在序列化时，会先调用此方法，再调用writeObject方法。此方法可将任意对象代替目标序列化对象
ANY-ACCESS-MODIFIER Object readResolve() throws ObjectStreamException;	反序列化时替换反序列化出的对象，反序列化出来的对象被立即丢弃。此方法在readeObject后调用。 强制单例
private void writeObject(java.io.ObjectOutputStream out) throws IOException	负责为其特定的类编写对象的状态，以便相应的readObject方法可以恢复它。 可以通过调用out.defaultWriteObject来调用保存对象字段的默认机制。
private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException;	负责从流中读取并恢复类字段。 它可以调用in.defaultReadObject来调用恢复对象的非静态和非瞬态字段的默认机制。 defaultReadObject方法使用流中的信息将保存在流中的对象的字段分配给当前对象中相应命名的字段。 当处理类进化到添加新字段时，这将处理这种情况。 该方法不需要关注属于其超类或子类的状态。
private void readObjectNoData() throws ObjectStreamException;	如果序列化流未将给定类列为反序列化对象的超类，则readObjectNoData方法负责初始化其特定类的对象的状态。 这可能发生在接收方使用与发送方不同的反序列化实例的类的版本的情况下，并且接收者的版本扩展了不被发送者版本扩展的类。 如果序列化流已被篡改，也可能发生这种情况; 因此，尽管存在“敌对”或不完整的源流，readObjectNoData可用于正确初始化反序列化对象。

File

文件和目录路径名的抽象表示

private static final FileSystem fs = DefaultFileSystem.getFileSystem();
private final String path;
private final transient int prefixLength;
// 文件状态，INVALID无效、垃圾，CHECKED不能保证路径有效
private static enum PathStatus { INVALID, CHECKED };
private transient PathStatus status = null;
// 与系统相关的默认名称分隔符
public static final char separatorChar = fs.getSeparator();
public static final String separator = "" + separatorChar;
// 与系统相关的路径分隔符
public static final char pathSeparatorChar = fs.getPathSeparator();
public static final String pathSeparator = "" + pathSeparatorChar;
private static final long PATH_OFFSET;
private static final long PREFIX_LENGTH_OFFSET;
private static final sun.misc.Unsafe UNSAFE;
// 与java.nio.File集成
private volatile transient Path filePath;

Method	Comment
String getName()	返回由此抽象路径名表示的文件或目录的名称。
String getParent()	返回此抽象路径名的父路径名字符串，如果此路径名未命名为父目录，则返回null。
File getParentFile()	返回此抽象路径名的父目录。如果此路径名没有指定父目录，则返回null
String getPath()	将此抽象路径名转换为路径名字符串。
boolean isAbsolute()	测试这个抽象路径名是否是绝对的。
String getAbsolutePath()	返回此抽象路径名的绝对路径名字符串。
File getAbsoluteFile()	返回此抽象路径名的绝对形式。
String getCanonicalPath()	返回此抽象路径名的规范路径名字符串。
File getCanonicalFile()	返回此抽象路径名的规范形式。
URI toURI()	构造一个表示此抽象路径名的 file: URI
boolean canRead()	测试应用程序是否可以读取由此抽象路径名表示的文件。
boolean canWrite()	测试应用程序是否可以修改由此抽象路径名表示的文件。
boolean exists()	测试此抽象路径名表示的文件或目录是否存在。
boolean isDirectory()	测试此抽象路径名表示的文件是否为目录。
boolean isFile()	测试此抽象路径名表示的文件是否为普通文件。
boolean isHidden()	测试此抽象路径名命名的文件是否为隐藏文件。
long lastModified()	返回此抽象路径名表示的文件上次修改的时间。
long length()	返回由此抽象路径名表示的文件的长度。
boolean createNewFile()	当且仅当具有该名称的文件尚不存在时，原子地创建一个由该抽象路径名命名的新的空文件。
boolean delete()	删除由此抽象路径名表示的文件或目录。
void deleteOnExit()	请求在虚拟机终止时删除由此抽象路径名表示的文件或目录。
String[] list()	返回一个字符串数组，命名由此抽象路径名表示的目录中的文件和目录。
String[] list(FilenameFilter filter)	返回一个字符串数组，命名由此抽象路径名表示的目录中满足指定过滤器的文件和目录。
File[] listFiles()	返回一个抽象路径名数组，表示由该抽象路径名表示的目录中的文件。
File[] listFiles(FilenameFilter filter)	返回一个抽象路径名数组，表示由此抽象路径名表示的满足指定过滤器的目录中的文件和目录。
File[] listFiles(FileFilter filter)	返回一个抽象路径名数组，表示由此抽象路径名表示的满足指定过滤器的目录中的文件和目录。
boolean mkdir()	创建由此抽象路径名命名的目录。
boolean mkdirs()	创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录。
boolean renameTo(File dest)	重命名由此抽象路径名表示的文件。
boolean setLastModified(long time)	设置由此抽象路径名命名的文件或目录的最后修改时间。
boolean setReadOnly()	标记由此抽象路径名命名的文件或目录，以便只允许读取操作。
boolean setWritable(boolean writable, boolean ownerOnly)	设置此抽象路径名的所有者或每个人的写入权限。
boolean setWritable(boolean writable)	一种方便的方法来设置所有者对此抽象路径名的写入权限。
boolean setReadable(boolean readable, boolean ownerOnly)	设置此抽象路径名的所有者或每个人的读取权限。
boolean setReadable(boolean readable)	一种方便的方法来设置所有者对此抽象路径名的读取权限。
boolean setExecutable(boolean executable, boolean ownerOnly)	设置该抽象路径名的所有者或每个人的执行权限。
boolean setExecutable(boolean executable)	为此抽象路径名设置所有者的执行权限的便利方法。
boolean canExecute()	测试应用程序是否可以执行此抽象路径名表示的文件。
static File[] listRoots()	列出可用的文件系统根。
long getTotalSpace()	通过此抽象路径名返回分区的大小
long getFreeSpace()	返回分区未分配的字节数
long getUsableSpace()	返回上的分区提供给该虚拟机的字节数
static File createTempFile(String prefix, String suffix, File directory)	在指定的目录中创建一个新的空文件，使用给定的前缀和后缀字符串生成其名称。
static File createTempFile(String prefix, String suffix)	在默认临时文件目录中创建一个空文件，使用给定的前缀和后缀生成其名称。
int compareTo(File pathname)	比较两个抽象的路径名字典。
boolean equals(Object obj)	测试此抽象路径名与给定对象的相等性。
String toString()	返回此抽象路径名的路径名字符串。
Path toPath()	返回从此抽象路径构造的java.nio.file.Path对象。

FileFilter

@Since：1.2

// 测试指定的抽象路径名是否应包含在路径名列表中。
boolean accept(File pathname);

FilenameFilter

@Since：1.0

// 测试指定文件是否应包含在文件列表中。
boolean accept(File dir, String name);

FilePermission

@Since：1.2

此类表示访问文件或目录。 FilePermission由路径名和对该路径名有效的一组操作组成。

Method	Comment
String getActions()	返回动作的“规范字符串表示”。
boolean implies(Permission p)	检查此FilePermission对象是否“暗示”指定的权限。
PermissionCollection newPermissionCollection()	返回一个新的PermissionCollection对象，用于存储FilePermission对象。

测试代码：

String fileName = "text.txt";
final FilePermission filePermission = new FilePermission(fileName, "read,write");
System.err.println(filePermission.getActions());
FilePermission filePermission2 = new FilePermission(fileName, "read");
System.err.println(filePermission.implies(filePermission2));
filePermission2 = new FilePermission(fileName, "read,delete");
System.err.println(filePermission.implies(filePermission2));
final PermissionCollection permissionCollection = filePermission.newPermissionCollection();
permissionCollection.add(filePermission);
permissionCollection.add(filePermission2);
final Enumeration<Permission> elements = permissionCollection.elements();
while (elements.hasMoreElements()) {
    System.err.println(elements.nextElement());
}

执行结果：

read,write
true
false
(“java.io.FilePermission” “text.txt” “read,write”)
(“java.io.FilePermission” “text.txt” “read,delete”)

FileSystem

提供文件系统的接口，并且是工厂用于访问文件系统中的文件和其他对象的对象。

Method	Comment
char getSeparator()	返回本地文件系统的名称分隔符。
char getPathSeparator()	返回本地文件系统的路径分隔符。
String normalize(String path)	将给定的路径名字符串转换为普通形式。如果字符串已经是标准形式，则简单地返回它。
int prefixLength(String path)	计算路径名字符串前缀的长度。路径名字符串必须是正常形式。
String resolve(String parent, String child)	将子路径名字符串解析为父路径名字符串。两个字符串都必须是标准形式，结果也将是标准形式。
String getDefaultParent()	当有两个参数的File构造函数中的parent-directory参数为空路径名时，返回父路径名字符串。
String fromURIPath(String path)	如果需要，对给定的URI路径字符串进行后处理。
boolean isAbsolute(File f)	判断给定的抽象路径名是否为绝对路径。
String resolve(File f)	将给定的抽象路径名解析为绝对形式。由File类中的getAbsolutePath和getCanonicalPath方法调用。
String canonicalize(String path)	规范化路径
int getBooleanAttributes(File f)	返回由给定的抽象路径名表示的文件或目录的简单布尔属性，如果它不存在或发生其他I/O错误，则返回0。
boolean checkAccess(File f, int access)	检查由给定的抽象路径名表示的文件或目录是否可以被该进程访问。第二个参数指定要检查哪些访问ACCESS_READ、ACCESS_WRITE或ACCESS_EXECUTE。如果访问被拒绝或I/O错误发生，返回false
boolean setPermission(File f, int access, boolean enable, boolean owneronly)	基于enable、access和oweronly参数，设置或关闭对给定抽象路径名所表示的文件或目录的访问权限(仅对所有者或对所有人)。
long getLastModifiedTime(File f)	返回由给定的抽象路径名表示的文件或目录最后修改的时间，如果它不存在或发生其他I/O错误，则返回0。
long getLength(File f)	返回由给定的抽象路径名表示的文件的字节长度，如果它不存在，则为零，是一个目录，或发生其他一些I/O错误。
boolean createFileExclusively(String pathname)	使用给定的路径名创建一个新的空文件。如果文件已经创建，则返回true;如果给定路径名的文件或目录已经存在，则返回false。如果发生I/O错误，抛出IOException。
boolean delete(File f)	删除由给定的抽象路径名表示的文件或目录，当且仅当操作成功时返回true。
String[] list(File f)	列出由给定的抽象路径名表示的目录的元素。如果成功，返回一个命名目录元素的字符串数组;否则,返回<代码>零> < /代码。
boolean createDirectory(File f)	创建一个由给定的抽象路径名表示的新目录，当且仅当操作成功时返回true。
boolean rename(File f1, File f2)	将第一个抽象路径名表示的文件或目录重命名为第二个抽象路径名，当且仅当操作成功时返回true。
boolean setLastModifiedTime(File f, long time)	设置给定抽象路径名所表示的文件或目录的最后修改时间，当且仅当操作成功时返回true。
boolean setReadOnly(File f)	将给定抽象路径名所表示的文件或目录标记为只读，当且仅当操作成功时返回true。
File[] listRoots()	列出可用的文件系统根。
long getSpace(File f, int t)
int compare(File f1, File f2)	按字典序比较两个抽象路径名。
int hashCode(File f)	计算抽象路径名的散列代码。

Flushable

@Since：1.5

Comment：刷新数据到目的地

// 通过将任何缓冲的输出写入底层流来刷新流。
void flush() throws IOException;

ObjectInput

@Since：1.1

Comment：扩展了DataInput接口以包含对象的读取。 DataInput包括用于输入原始类型的方法，ObjectInput将该接口扩展为包含对象，数组和字符串。

Method	Comment
Object readObject()	读取并返回一个对象。
int read()	读取一个字节的数据。
int read(byte b[])	读入一个字节数组。
int read(byte b[], int off, int len)	读入一个字节数组。
long skip(long n)	跳过n个字节的输入。
int available()	返回可以读取而不阻塞的字节数。
void close()	关闭输入流。

ObjectOutput

@Since：1.1

Comment：扩展了DataOutput接口，包括写入对象。 DataOutput包括用于输出原始类型的方法，ObjectOutput将该接口扩展为包含对象，数组和字符串。

Method	Comment
void writeObject(Object obj)	将对象写入底层存储或流。
void write(int b)	写一个字节。
void write(byte b[])	写入一个字节数组。
void write(byte b[], int off, int len)	写入一个子字节数组
void flush()	刷新流。
void close()	关闭流。

ObjectInputValidation

@Since：1.1

Comment：回调界面允许验证图中的对象。 允许在对象的完整图反序列化时调用对象。

// 验证对象。 
public void validateObject() throws InvalidObjectException;

ObjectStreamClass

@Since：1.1

Comment：序列化的类的描述符。 它包含该类的名称和serialVersionUID。 可以使用lookup方法查找/创建Java Java中加载的特定类的ObjectStreamClass。

Method	Comment
static ObjectStreamClass lookup(Class cl)	找到可以序列化的类的描述符。
static ObjectStreamClass lookupAny(Class cl)	返回任何类的描述符，无论它是否实现Serializable。
String getName()	返回此描述符描述的类的名称。
long getSerialVersionUID()	返回此类的serialVersionUID。
Class forClass()	返回此版本映射到的本地VM中的类。
ObjectStreamField[] getFields()	返回此可序列化类的字段数组。
ObjectStreamField getField(String name)	通过名称获取此类的字段。

Java 序列化和反序列化（三）Serializable 源码分析 - 2

ObjectStreamField

@Since：1.2

Comment：Serializable类的Serializable字段的描述。 ObjectStreamFields的数组用于声明一个类的Serializable字段

Method	Comment
String getName()	获取此字段的名称。
Class getType()	获取字段的类型。
char getTypeCode()	返回字段类型的字符编码。
String getTypeString()	返回JVM类型签名。
int getOffset()	实例数据内的字段偏移量。
boolean isPrimitive()	如果此字段具有原始类型，则返回true。
boolean isUnshared()	返回指示此ObjectStreamField实例表示的可序列化字段是否未共享的布尔值。
int compareTo(Object obj)	将此字段与另一个 ObjectStreamField进行比较。

ObjectStreamConstants

@Since：1.1

Comment：写入对象序列化流的常量。

SerialCallbackContext

Comment：从对象流向上调用类定义的readObject/writeObject方法时的上下文。保存当前正在反序列化的对象和当前类的描述符。

这个上下文跟踪它被构造的线程，并且只允许调用defaultReadObject, readFields, defaultWriteObject或writeFields，它们必须在类的readObject/writeObject方法返回之前在同一个线程上调用。如果没有设置为当前线程，getObj方法将抛出NotActiveException。

StreamTokenizer

@Since：1.1

Comment：接收输入流并将其解析为“令牌”，允许一次读取一个令牌。 解析过程由表和多个可以设置为各种状态的标志来控制。 流标记器可以识别标识符，数字，引用的字符串和各种注释样式。

Method	Comment
void resetSyntax()	重置这个tokenizer的语法表，使所有的字符都是“普通的”
void wordChars(int low, int hi)	指定范围 low <= c <= high中的所有字符 c都是字组成。
void whitespaceChars(int low, int hi)	指定范围 low <= c <= high中的所有字符 c都是空白字符。
void ordinaryChars(int low, int hi)	指定范围内的所有角色 C low <= c <= high此tokenizer“普通”。
void ordinaryChar(int ch)	指定此标记器中的字符参数为“普通”。
void commentChar(int ch)	指定字符参数启动单行注释。
void quoteChar(int ch)	指定此字符串的匹配对在此分段器中分隔字符串常量。
void parseNumbers()	指定数字应由此分段器解析。
void eolIsSignificant(boolean flag)	确定行尾是否被视为令牌。
void slashStarComments(boolean flag)	确定标记器是否识别C风格的注释。 /*注释
void slashSlashComments(boolean flag)	确定tokenizer是否识别C ++风格的注释。 //注释
void lowerCaseMode(boolean fl)	确定字标记是否自动降低。
int nextToken()	从此分类器的输入流中解析下一个令牌。
void pushBack()	导致下一次调用此标记器的 nextToken方法返回 ttype字段中的当前值，而不修改 nval或 sval字段中的值。
int lineno()	返回当前行号。

测试代码：

/*
	{
      "name": "json在线编辑器",
      "!!warning!!": "由于该工具使用的前端js实现json的encode和decode，所以会存在大数精度丢失的问题，你可以手动将大数用字符串双引号括起来，避免精度丢失。",
      "v1.0": "2014-07-02 22:05 工具上线",
      "v2.0": "2016-11-16 14:13 增加php, go类生成",
      "v2.1": "2016-11-19 01:17 增加java类生成",
      "v2.2": "2021-03-07 10:21 增加转换yaml功能",
      "version": 2.2
    }
*/
try(BufferedReader reader = new BufferedReader(new FileReader("text.txt"))) {
    StreamTokenizer streamTokenizer = new StreamTokenizer(reader);
    while (streamTokenizer.nextToken() != StreamTokenizer.TT_EOF) {
        Object s;
        if (streamTokenizer.ttype == StreamTokenizer.TT_NUMBER) {
            // 数字，double类型
            s = streamTokenizer.nval;
        } else {
            s = streamTokenizer.sval;
        }
        System.out.println(streamTokenizer.toString());
    }
} catch (IOException e) {
    e.printStackTrace();
}

测试结果：

Token[‘{’], line 1
Token[name], line 2
Token[‘:’], line 2
Token[json在线编辑器], line 2
Token[‘,’], line 2
Token[!!warning!!], line 3
Token[‘:’], line 3
Token[由于该工具使用的前端js实现json的encode和decode，所以会存在大数精度丢失的问题，你可以手动将大数用字符串双引号括起来，避免精度丢失。], line 3
Token[‘,’], line 3
Token[v1.0], line 4
Token[‘:’], line 4
Token[2014-07-02 22:05 工具上线], line 4
Token[‘,’], line 4
Token[v2.0], line 5
Token[‘:’], line 5
Token[2016-11-16 14:13 增加php, go类生成], line 5
Token[‘,’], line 5
Token[v2.1], line 6
Token[‘:’], line 6
Token[2016-11-19 01:17 增加java类生成], line 6
Token[‘,’], line 6
Token[v2.2], line 7
Token[‘:’], line 7
Token[2021-03-07 10:21 增加转换yaml功能], line 7
Token[‘,’], line 7
Token[version], line 8
Token[‘:’], line 8
Token[n=2.2], line 8
Token[‘}’], line 9

思考：实现简单的分词器？感觉有点拉，不如用来提取文本中的数字