Java基础系列8——IO流超详细总结
该系列博文会告诉你如何从入门到进阶，一步步地学习Java基础知识，并上手进行实战，接着了解每一个Java知识点背后的实现原理，更完整地了解整个Java技术体系，造成本身的知识框架。html
在初学Java时，IO流是我遇到的一个很头疼的东西，Java IO 体系看起来类不少，感受很复杂，但实际上是 IO 涉及的因素太多了。在设计 IO 相关的类时，编写者也不是从同一个方面考虑的，因此会给人一种很乱的感受，而且还有设计模式的使用，更加难以使用这些 IO 类，因此特意对 Java 的 IO 作一个总结。java
IO流总览
话很少说，直接上图：编程
IO流分类：
按照“流”的数据流向，能够将其化分为：输入流和输出流。设计模式
按照“流”中处理数据的单位，能够将其区分为：字节流和字符流。在java中，字节是占1个Byte，即8位；而字符是占2个Byte，即16位。并且，须要注意的是，java的字节是有符号类型，而字符是无符号类型！数组
字节流的抽象基类：app
InputStream，OutputStream框架
字符流的抽象基类：函数
Reader，Writer学习
由这四个类派生出来的子类名称都是以其父类名做为子类名的后缀，如InputStream的子类FileInputStream，Reader的子类FileReader。测试
字符流
Writer：字符输出流
Writer是字符输出流的基类，Writer的主要方法以下：
Writer append(char c) 将指定的字符附加到此做者 Writer append(CharSequence csq) 将指定的字符序列附加到此做者 Writer append(CharSequence csq, int start, int end) 将指定字符序列的子序列附加到此做者 abstract void close() 关闭流，先刷新 abstract void flush() 刷新流 void write(char[] cbuf) 写入一个字符数组。 abstract void write(char[] cbuf, int off, int len) 写入字符数组的一部分 void write(int c) 写一个字符 void write(String str) 写一个字符串 void write(String str, int off, int len) 写一个字符串的一部分
咱们知道IO流主要是用于操做文件的，可是从上图中咱们发现Writer的直接子类中好像并无直接操做文件，可是细心的你注意到，在Writer的子类OutputStreamWriter的子类中有一个类叫作FileWriter，File这个单词咱们很熟悉——文件，你们能够推测一下这个类是能够用于操做文件的，下面咱们来学习一下FileWriter的用法
FileWriter
一、FileWriter的构造方法：
OutputStreamWriter(OutputStream out) 建立一个使用默认字符编码的OutputStreamWriter OutputStreamWriter(OutputStream out, String charsetName) 建立一个使用命名字符集的OutputStreamWriter OutputStreamWriter(OutputStream out, Charset cs) 建立一个使用给定字符集的OutputStreamWriter OutputStreamWriter(OutputStream out, CharsetEncoder enc) 建立一个使用给定字符集编码器的OutputStreamWriter
二、FileWriter的方法列表：
Writer append(CharSequence csq) 将指定的字符序列附加到此做者。 Writer append(CharSequence csq, int start, int end) 将指定字符序列的子序列附加到此做者。 void close() 关闭流，先刷新。 void flush() 刷新流。 String getEncoding() 返回此流使用的字符编码的名称。 void write(char[] cbuf, int off, int len) 写入字符数组的一部分。 void write(int c) 写一个字符 void write(String str, int off, int len) 写一个字符串的一部分。
三、FileWriter方法的详细讲解：
例1：建立一个文件demo.txt，而后向里面写入字符串abcde
import java.io.*;
class FileWriterDemo
{
public static void main(String[] args) throws IOException
{
//建立一个FileWriter对象。该对象一被初始化就必需要明确被操做的文件。
//并且该文件会被建立到指定目录下。若是该目录下已有同名文件，将被覆盖。
//其实该步就是在明确数据要存放的目的地。
FileWriter fw = new FileWriter("demo.txt");
//调用write方法，将字符串写入到流中。
fw.write("abcde");
//刷新流对象中的缓冲中的数据。
//将数据刷到目的地中。
//fw.flush();
//关闭流资源，可是关闭以前会刷新一次内部的缓冲中的数据。
//将数据刷到目的地中。
//和flush区别：flush刷新后，流能够继续使用，close刷新后，会将流关闭。
fw.close();
}
}
例2：上面的代码中咱们能够看到有异常产生，可是咱们并无处理，而是抛出去了，那么在平常开发中咱们不能直接抛出，因此须要对异常进行处理
/*
IO异常的处理方式。
*/
import java.io.*;
class FileWriterDemo2
{
public static void main(String[] args)
{
FileWriter fw = null;
try
{
fw = new FileWriter("demo.txt");//可能会有异常产生
fw.write("abcdefg");
}
catch (IOException e)
{
System.out.println("catch:"+e.toString());
}
finally
{
try
{
if(fw!=null)
fw.close();//可能会有异常产生
}
catch (IOException e)
{
System.out.println(e.toString());
}
}
}
}
例3：细心的同窗能够注意到，上面的那种方式写入文件时，会将以前的文件覆盖了，以前文件中写的内容不存在了，那么如何在已有的文件后面添加内容
/*
演示对已有文件的数据续写。
*/
import java.io.*;
class FileWriterDemo3
{
public static void main(String[] args) throws IOException
{
//传递一个true参数，表明不覆盖已有的文件。并在已有文件的末尾处进行数据续写。
FileWriter fw = new FileWriter("demo.txt",true);
fw.write("nihao\r\nxiexie");
fw.close();
}
}
BufferedWriter
BufferedWriter 是缓冲字符输出流。它继承于Writer。
BufferedWriter 的做用是为其余字符输出流添加一些缓冲功能，使用BufferedWriter能够提升咱们写入文件的效率。
一、BufferedWriter的构造方法：
BufferedWriter(Writer out) 建立使用默认大小的输出缓冲区的缓冲字符输出流。 BufferedWriter(Writer out, int sz) 建立一个新的缓冲字符输出流，使用给定大小的输出缓冲区。
二、BufferedWriter的方法列表：
void close() 关闭流，先刷新。 void flush() 刷新流。 void newLine() 写一行行分隔符。 void write(char[] cbuf, int off, int len) 写入字符数组的一部分。 void write(int c) 写一个字符 void write(String s, int off, int len) 写一个字符串的一部分。
三、BufferedWriter的方法详解：
例：
import java.io.*;
class BufferWriterDemo{
public static void main(String[] args) throws IOException {
//建立一个字符写入流对象。
FileWriter fw = new FileWriter("buf.txt");
//为了提升字符写入流效率。加入了缓冲技术。
//只要将须要被提升效率的流对象做为参数传递给缓冲区的构造函数便可。
BufferedWriter bw=new BufferedWriter(fw);
char[] c={'a','b','c','d','e'};
bw.write(c,0,4);
//换行
bw.newLine();
//再次写入
bw.write(c,2,2);
//刷新流
bw.flush();
//其实关闭缓冲区，就是在关闭缓冲区中的流对象。
bw.close();
}
}
CharArrayWriter
CharArrayReader 用于写入数据符，它继承于Writer。操做的数据是以字符为单位！
一、CharArrayWriter的构造函数：
CharArrayWriter() 建立一个新的CharArrayWriter。 CharArrayWriter(int initialSize) 用指定的初始大小建立一个新的CharArrayWriter。
二、CharArrayWriter的方法列表：
CharArrayWriter append(char c) 将指定的字符附加到此做者。 CharArrayWriter append(CharSequence csq) 将指定的字符序列附加到此做者。 CharArrayWriter append(CharSequence csq, int start, int end) 将指定字符序列的子序列附加到此做者。 void close() 关闭流。 void flush() 冲洗流。 void reset() 重置缓冲区，以便您能够再次使用它，而不会丢弃已经分配的缓冲区。 int size() 返回缓冲区的当前大小。 char[] toCharArray() 返回输入数据的副本。 String toString() 将输入数据转换为字符串。 void write(char[] c, int off, int len) 将字符写入缓冲区。 void write(int c) 将一个字符写入缓冲区。 void write(String str, int off, int len) 将一部分字符串写入缓冲区。 void writeTo(Writer out) 将缓冲区的内容写入另外一个字符流。
FilterWriter
FilterWriter是字符类型的过滤输出流。
一、FilterWriter的构造函数：
protected FilterWriter(Writer out) 建立一个新的过滤的做者。
二、FilterWriter的方法列表：
void close() 关闭流，先刷新。 void flush() 刷新流。 void write(char[] cbuf, int off, int len) 写入字符数组的一部分。 void write(int c) 写一个字符 void write(String str, int off, int len) 写一个字符串的一部分。
PrintWriter
PrintWriter 是字符类型的打印输出流，它继承于Writer。
一、PrintWriter 的构造方法：
PrintWriter(File file) 使用指定的文件建立一个新的PrintWriter，而不须要自动的线路刷新。 PrintWriter(File file, String csn) 使用指定的文件和字符集建立一个新的PrintWriter，而不须要自动进行线条刷新。 PrintWriter(OutputStream out) 从现有的OutputStream建立一个新的PrintWriter，而不须要自动线路刷新。 PrintWriter(OutputStream out, boolean autoFlush) 从现有的OutputStream建立一个新的PrintWriter。 PrintWriter(Writer out) 建立一个新的PrintWriter，没有自动线冲洗。 PrintWriter(Writer out, boolean autoFlush) 建立一个新的PrintWriter。 PrintWriter(String fileName) 使用指定的文件名建立一个新的PrintWriter，而不须要自动执行行刷新。 PrintWriter(String fileName, String csn) 使用指定的文件名和字符集建立一个新的PrintWriter，而不须要自动线路刷新。
二、PrintWriter 的方法列表：
PrintWriter append(char c) 将指定的字符附加到此做者。 PrintWriter append(CharSequence csq) 将指定的字符序列附加到此做者。 PrintWriter append(CharSequence csq, int start, int end) 将指定字符序列的子序列附加到此做者。 boolean checkError() 若是流未关闭，请刷新流并检查其错误状态。 protected void clearError() 清除此流的错误状态。 void close() 关闭流并释放与之相关联的任何系统资源。 void flush() 刷新流。 PrintWriter format(String format, Object... args) 使用指定的格式字符串和参数将格式化的字符串写入此写入程序。 PrintWriter format(Locale l, String format, Object... args) 使用指定的格式字符串和参数将格式化的字符串写入此写入程序。 void print(boolean b) 打印布尔值。 void print(char c) 打印一个字符 void print(char[] s) 打印字符数组。 void print(double d) 打印双精度浮点数。 void print(float f) 打印浮点数。 void print(int i) 打印一个整数。 void print(long l) 打印一个长整数。 void print(Object obj) 打印一个对象。 void print(String s) 打印字符串。 PrintWriter printf(String format, Object... args) 使用指定的格式字符串和参数将格式化的字符串写入该writer的方便方法。 PrintWriter printf(Locale l, String format, Object... args) 使用指定的格式字符串和参数将格式化的字符串写入该writer的方便方法。 void println() 经过写入行分隔符字符串来终止当前行。 void println(boolean x) 打印一个布尔值，而后终止该行。 void println(char x) 打印一个字符，而后终止该行。 void println(char[] x) 打印字符数组，而后终止行。 void println(double x) 打印双精度浮点数，而后终止行。 void println(float x) 打印一个浮点数，而后终止该行。 void println(int x) 打印一个整数，而后终止该行。 void println(long x) 打印一个长整型，而后终止行。 void println(Object x) 打印一个对象，而后终止该行。 void println(String x) 打印一个字符串，而后终止行。 protected void setError() 表示发生错误。 void write(char[] buf) 写入一个字符数组。 void write(char[] buf, int off, int len) 写一个字符数组的一部分。 void write(int c) 写一个字符 void write(String s) 写一个字符串 void write(String s, int off, int len) 写一个字符串的一部分。
Reader：字符输入流
有输出流那么固然就有输入流，Reader是字符输入流的基类，Reader的方法列表以下：
abstract void close() 关闭流并释放与之相关联的任何系统资源。 void mark(int readAheadLimit) 标记流中的当前位置。 boolean markSupported() 告诉这个流是否支持mark（）操做。 int read() 读一个字符 int read(char[] cbuf) 将字符读入数组。 abstract int read(char[] cbuf, int off, int len) 将字符读入数组的一部分。 int read(CharBuffer target) 尝试将字符读入指定的字符缓冲区。 boolean ready() 告诉这个流是否准备好被读取。 void reset() 重置流。 long skip(long n) 跳过字符
同Writer同样，咱们先来看一下FileReader的基本操做
FileReader
一、FileReader的构造方法：
FileReader(File file) 建立一个新的 FileReader ，给出 File读取。 FileReader(FileDescriptor fd) 建立一个新的 FileReader ，给予 FileDescriptor从中读取。 FileReader(String fileName) 建立一个新的 FileReader ，给定要读取的文件的名称。
二、FileReader的具体使用：
例1：
import java.io.*;
class FileReaderDemo
{
public static void main(String[] args) throws IOException
{
//建立一个文件读取流对象，和指定名称的文件相关联。
//要保证该文件是已经存在的，若是不存在，会发生异常FileNotFoundException
FileReader fr = new FileReader("demo.txt");
//调用读取流对象的read方法。
//read():一次读一个字符。并且会自动往下读。
int ch = 0;
while((ch=fr.read())!=-1)
{
System.out.println("ch="+(char)ch);
}
//关闭流
fr.close();
}
}
例2：
/*
第二种方式：经过字符数组进行读取。
*/
import java.io.*;
class FileReaderDemo2
{
public static void main(String[] args) throws IOException
{
FileReader fr = new FileReader("demo.txt");
//定义一个字符数组。用于存储读到字符。
//该read(char[])返回的是读到字符个数。
char[] buf = new char[1024];
int num = 0;
while((num=fr.read(buf))!=-1)
{
System.out.println(new String(buf,0,num));
}
fr.close();
}
}
BufferedReader
一、BufferedReader的构造方法
BufferedReader(Reader in) 建立使用默认大小的输入缓冲区的缓冲字符输入流。 BufferedReader(Reader in, int sz) 建立使用指定大小的输入缓冲区的缓冲字符输入流。
二、BufferedReader的方法列表：
void close() 关闭流并释放与之相关联的任何系统资源。 Stream<String> lines() 返回一个 Stream ，其元素是从这个 BufferedReader读取的行。 void mark(int readAheadLimit) 标记流中的当前位置。 boolean markSupported() 告诉这个流是否支持mark（）操做。 int read() 读一个字符 int read(char[] cbuf, int off, int len) 将字符读入数组的一部分。 String readLine() 读一行文字。 boolean ready() 告诉这个流是否准备好被读取。 void reset() 将流重置为最近的标记。 long skip(long n) 跳过字符
三、BufferedReader的具体使用：
例1：
/*
字符读取流缓冲区：
该缓冲区提供了一个一次读一行的方法 readLine，方便于对文本数据的获取。
当返回null时，表示读到文件末尾。
readLine方法返回的时候只返回回车符以前的数据内容。并不返回回车符。
*/
import java.io.*;
class BufferedReaderDemo
{
public static void main(String[] args) throws IOException
{
//建立一个读取流对象和文件相关联。
FileReader fr = new FileReader("buf.txt");
//为了提升效率。加入缓冲技术。将字符读取流对象做为参数传递给缓冲对象的构造函数。
BufferedReader bufr = new BufferedReader(fr);
String line = null;
while((line=bufr.readLine())!=null)
{
System.out.print(line);
}
//关闭流
bufr.close();
}
}
例2：经过缓冲区复制文件：
/*
经过缓冲区复制一个.java文件。
*/
import java.io.*;
class CopyTextByBuf
{
public static void main(String[] args)
{
BufferedReader bufr = null;
BufferedWriter bufw = null;
try
{
bufr = new BufferedReader(new FileReader("BufferedWriterDemo.java"));
bufw = new BufferedWriter(new FileWriter("bufWriter_Copy.txt"));
String line = null;
while((line=bufr.readLine())!=null)
{
bufw.write(line);
bufw.newLine();
bufw.flush();
}
}
catch (IOException e)
{
throw new RuntimeException("读写失败");
}
finally
{
try
{
if(bufr!=null)
bufr.close();
}
catch (IOException e)
{
throw new RuntimeException("读取关闭失败");
}
try
{
if(bufw!=null)
bufw.close();
}
catch (IOException e)
{
throw new RuntimeException("写入关闭失败");
}
}
}
}
字节流
字节流的基本操做和字符流类相同，但它不只能够操做字符，还能够操做其余媒体文件
InputStream字节输入流
InputStream类是字节输入流的抽象类，是全部字节输入流的父类，InputStream类具备层次结构以下图所示：
InputStream的经常使用方法：
int available() 从下一次调用此输入流的方法返回可从该输入流读取（或跳过）的字节数，而不会阻塞。 void close() 关闭此输入流并释放与流相关联的任何系统资源。 void mark(int readlimit) 标记此输入流中的当前位置。 boolean markSupported() 测试此输入流是否支持 mark和 reset方法。 abstract int read() 从输入流读取数据的下一个字节。 int read(byte[] b) 从输入流中读取一些字节数，并将它们存储到缓冲器阵列 b 。 int read(byte[] b, int off, int len) 从输入流读取最多 len个字节的数据到字节数组。 byte[] readAllBytes() 从输入流读取全部剩余字节。 int readNBytes(byte[] b, int off, int len) 将所请求的字节数从输入流读入给定的字节数组。 void reset() 将此流从新定位到最后在此输入流上调用 mark方法时的位置。 long skip(long n) 跳过并丢弃来自此输入流的 n字节的数据。 long transferTo(OutputStream out) 从该输入流中读取全部字节，并按读取的顺序将字节写入给定的输出流。
FileInputStream
一、FileInputStream的构造方法：
FileInputStream(File file) 经过打开与实际文件的链接来建立一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。 FileInputStream(FileDescriptor fdObj) 经过使用文件描述符 fdObj建立 FileInputStream ，该文件描述符表示与文件系统中的实际文件的现有链接。 FileInputStream(String name) 经过打开与实际文件的链接来建立一个 FileInputStream ，该文件由文件系统中的路径名 name命名。
二、FileInputStream的方法列表：
int available() 返回今后输入流中能够读取（或跳过）的剩余字节数的估计值，而不会被下一次调用此输入流的方法阻塞。 void close() 关闭此文件输入流并释放与流相关联的任何系统资源。 protected void finalize() 已过期。 finalize方法已被弃用。 为了执行清理而覆盖finalize子类应该修改成使用替代清理机制，并删除覆盖的finalize方法。 当覆盖finalize方法时，其实现必须明确确保按照super.finalize()所述调用super.finalize() 。 有关迁移选项的更多信息，请参阅Object.finalize()的规范。 FileChannel getChannel() 返回与此文件输入流相关联的惟一的FileChannel对象。 FileDescriptor getFD() 返回表示与此 FileInputStream正在使用的文件系统中的实际文件的链接的 FileDescriptor对象。 int read() 从该输入流读取一个字节的数据。 int read(byte[] b) 从该输入流读取最多 b.length个字节的数据到一个字节数组。 int read(byte[] b, int off, int len) 从该输入流读取最多 len个字节的数据到字节数组。 long skip(long n) 跳过并从输入流中丢弃 n字节的数据。
三、FileInputStream的具体使用：
import java.io.*;
class FileStream
{
public static void main(String[] args) throws IOException
{
readFile_3();
}
//打开文件，一次读取刚恰好内容的字节
public static void readFile_3()throws IOException
{
FileInputStream fis = new FileInputStream("fos.txt");
//available()返回今后输入流中能够读取（或跳过）的剩余字节数的估计值，而不会被下一次调用此输入流的方法阻塞。
byte[] buf = new byte[fis.available()];//定义一个刚恰好的缓冲区。不用在循环了。
fis.read(buf);
System.out.println(new String(buf));
fis.close();
}
//打开文件，一次读取多个字节
public static void readFile_2()throws IOException
{
FileInputStream fis = new FileInputStream("fos.txt");
byte[] buf = new byte[1024];
int len = 0;
while((len=fis.read(buf))!=-1)
{
System.out.println(new String(buf,0,len));
}
fis.close();
}
//打开文件，一次读取一个字节
public static void readFile_1()throws IOException
{
FileInputStream fis = new FileInputStream("fos.txt");
int ch = 0;
while((ch=fis.read())!=-1)
{
System.out.println((char)ch);
}
fis.close();
}
}
OutputStream 字节输出流
OutputStream字节输出流的方法：
void close() 关闭此输出流并释放与此流相关联的任何系统资源。 void flush() 刷新此输出流并强制任何缓冲的输出字节被写出。 void write(byte[] b) 将 b.length字节从指定的字节数组写入此输出流。 void write(byte[] b, int off, int len) 从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。 abstract void write(int b) 将指定的字节写入此输出流。
FileOutPutStream
一、FileOutPutStream的构造方法：
FileOutputStream(File file) 建立文件输出流以写入由指定的 File对象表示的文件。 FileOutputStream(FileDescriptor fdObj) 建立文件输出流以写入指定的文件描述符，表示与文件系统中实际文件的现有链接。 FileOutputStream(File file, boolean append) 建立文件输出流以写入由指定的 File对象表示的文件。 FileOutputStream(String name) 建立文件输出流以指定的名称写入文件。 FileOutputStream(String name, boolean append) 建立文件输出流以指定的名称写入文件。
二、FileOutPutStream的方法列表：
void close() 关闭此文件输出流并释放与此流相关联的任何系统资源。 protected void finalize() 已过期。 finalize方法已被弃用。 为了执行清理，覆盖finalize子类应被修改成使用替代的清理机制，并删除覆盖的finalize方法。 当覆盖finalize方法时，其实现必须明确确保按照super.finalize()中所述调用super.finalize() 。 有关迁移选项的更多信息，请参阅Object.finalize()的规范。 FileChannel getChannel() 返回与此文件输出流相关联的惟一的FileChannel对象。 FileDescriptor getFD() 返回与此流相关联的文件描述符。 void write(byte[] b) 将 b.length字节从指定的字节数组写入此文件输出流。 void write(byte[] b, int off, int len) 将 len字节从指定的字节数组开始，从偏移量 off开始写入此文件输出流。 void write(int b) 将指定的字节写入此文件输出流。
三、FileOutPutStream的具体使用：
import java.io.*;
public class FileStreamTest {
private static final String FileName = "file.txt";
public static void main(String[] args) {
testWrite();
}
/**
* FileOutputStream 演示函数
*
* 运行结果：
* 在源码所在目录生成文件"file.txt"，文件内容是“abcdefghijklmnopqrstuvwxyz0123456789”
*
* 加入，咱们将 FileOutputStream fileOut2 = new FileOutputStream(file, true);
* 修改成 FileOutputStream fileOut2 = new FileOutputStream(file, false);
* 而后再执行程序，“file.txt”的内容变成"0123456789"。
* 缘由是：
* (01) FileOutputStream fileOut2 = new FileOutputStream(file, true);
* 它是以“追加模式”将内容写入文件的。即写入的内容，追加到原始的内容以后。
* (02) FileOutputStream fileOut2 = new FileOutputStream(file, false);
* 它是以“新建模式”将内容写入文件的。即删除文件原始的内容以后，再从新写入。
*/
public static void testWrite() {
try {
// 建立文件“file.txt”对应File对象
File file = new File(FileName);
// 建立文件“file.txt”对应的FileOutputStream对象，默认是关闭“追加模式”
FileOutputStream fileOut1 = new FileOutputStream(file);
// 建立FileOutputStream对应的PrintStream，方便操做。PrintStream的写入接口更便利
PrintStream out1 = new PrintStream(fileOut1);
// 向“文件中”写入26个字母
out1.print("abcdefghijklmnopqrstuvwxyz");
out1.close();
// 建立文件“file.txt”对应的FileOutputStream对象，打开“追加模式”
FileOutputStream fileOut2 = new FileOutputStream(file, true);
// 建立FileOutputStream对应的PrintStream，方便操做。PrintStream的写入接口更便利
PrintStream out2 = new PrintStream(fileOut2);
// 向“文件中”写入"0123456789"+换行符
out2.println("0123456789");
out2.close();
} catch(IOException e) {
e.printStackTrace();
}
}
}
File
JavaIo流中还有一个很是经常使用的类：File。
File 是“文件”和“目录路径名”的抽象表示形式。
File 直接继承于Object，实现了Serializable接口和Comparable接口。实现Serializable接口，意味着File对象支持序列化操做。而实现Comparable接口，意味着File对象之间能够比较大小；File能直接被存储在有序集合(如TreeSet、TreeMap中)。
一、File的构造方法：
File(File parent, String child) 从父抽象路径名和子路径名字符串建立新的 File实例。 File(String pathname) 经过将给定的路径名字符串转换为抽象路径名来建立新的 File实例。 File(String parent, String child) 从父路径名字符串和子路径名字符串建立新的 File实例。 File(URI uri) 经过将给定的 file: URI转换为抽象路径名来建立新的 File实例。
二、File的方法列表：
boolean canExecute() 测试应用程序是否能够执行此抽象路径名表示的文件。 boolean canRead() 测试应用程序是否能够读取由此抽象路径名表示的文件。 boolean canWrite() 测试应用程序是否能够修改由此抽象路径名表示的文件。 int compareTo(File pathname) 比较两个抽象的路径名字典。 boolean createNewFile() 当且仅当具备该名称的文件尚不存在时，原子地建立一个由该抽象路径名命名的新的空文件。 static File createTempFile(String prefix, String suffix) 在默认临时文件目录中建立一个空文件，使用给定的前缀和后缀生成其名称。 static File createTempFile(String prefix, String suffix, File directory) 在指定的目录中建立一个新的空文件，使用给定的前缀和后缀字符串生成其名称。 boolean delete() 删除由此抽象路径名表示的文件或目录。 void deleteOnExit() 请求在虚拟机终止时删除由此抽象路径名表示的文件或目录。 boolean equals(Object obj) 测试此抽象路径名与给定对象的相等性。 boolean exists() 测试此抽象路径名表示的文件或目录是否存在。 File getAbsoluteFile() 返回此抽象路径名的绝对形式。 String getAbsolutePath() 返回此抽象路径名的绝对路径名字符串。 File getCanonicalFile() 返回此抽象路径名的规范形式。 String getCanonicalPath() 返回此抽象路径名的规范路径名字符串。 long getFreeSpace() 经过此抽象路径名返回分区 named中未分配字节的数量。 String getName() 返回由此抽象路径名表示的文件或目录的名称。 String getParent() 返回此抽象路径名的父目录的路径名字符串，若是此路径名未命名为父目录，则返回 null 。 File getParentFile() 返回此抽象路径名的父目录的抽象路径名，若是此路径名不指定父目录，则返回 null 。 String getPath() 将此抽象路径名转换为路径名字符串。 long getTotalSpace() 经过此抽象路径名返回分区 named的大小。 long getUsableSpace() 经过此抽象路径名返回分区 named上此虚拟机可用的字节数。 int hashCode() 计算此抽象路径名的哈希码。 boolean isAbsolute() 测试这个抽象路径名是不是绝对的。 boolean isDirectory() 测试此抽象路径名表示的文件是否为目录。 boolean isFile() 测试此抽象路径名表示的文件是否为普通文件。 boolean isHidden() 测试此抽象路径名命名的文件是否为隐藏文件。 long lastModified() 返回此抽象路径名表示的文件上次修改的时间。 long length() 返回由此抽象路径名表示的文件的长度。 String[] list() 返回一个字符串数组，命名由此抽象路径名表示的目录中的文件和目录。 String[] list(FilenameFilter filter) 返回一个字符串数组，命名由此抽象路径名表示的目录中知足指定过滤器的文件和目录。 File[] listFiles() 返回一个抽象路径名数组，表示由该抽象路径名表示的目录中的文件。 File[] listFiles(FileFilter filter) 返回一个抽象路径名数组，表示由此抽象路径名表示的知足指定过滤器的目录中的文件和目录。 File[] listFiles(FilenameFilter filter) 返回一个抽象路径名数组，表示由此抽象路径名表示的知足指定过滤器的目录中的文件和目录。 static File[] listRoots() 列出可用的文件系统根。 boolean mkdir() 建立由此抽象路径名命名的目录。 boolean mkdirs() 建立由此抽象路径名命名的目录，包括任何须需但不存在的父目录。 boolean renameTo(File dest) 重命名由此抽象路径名表示的文件。 boolean setExecutable(boolean executable) 为此抽象路径名设置全部者的执行权限的便利方法。 boolean setExecutable(boolean executable, boolean ownerOnly) 设置该抽象路径名的全部者或每一个人的执行权限。 boolean setLastModified(long time) 设置由此抽象路径名命名的文件或目录的最后修改时间。 boolean setReadable(boolean readable) 一种方便的方法来设置全部者对此抽象路径名的读取权限。 boolean setReadable(boolean readable, boolean ownerOnly) 设置此抽象路径名的全部者或每一个人的读取权限。 boolean setReadOnly() 标记由此抽象路径名命名的文件或目录，以便只容许读取操做。 boolean setWritable(boolean writable) 一种方便的方法来设置全部者对此抽象路径名的写入权限。 boolean setWritable(boolean writable, boolean ownerOnly) 设置此抽象路径名的全部者或每一个人的写入权限。 Path toPath() 返回今后抽象路径构造的一个java.nio.file.Path对象。 String toString() 返回此抽象路径名的路径名字符串。 URI toURI() 构造一个表示此抽象路径名的 file: URI。 URL toURL() 已过期。 此方法不会自动转义URL中非法的字符。 建议在新的代码转换的抽象路径到URL经过先转换成URI，经由toURI方法，而后经由转换URI为URL URI.toURL方法。
三、File的具体使用：
例1：
import java.io.*;
/*
File类常见方法：
1，建立。
boolean createNewFile():在指定位置建立文件，若是该文件已经存在，则不建立，返回false。
和输出流不同，输出流对象一创建建立文件。并且文件已经存在，会覆盖。
boolean mkdir():建立文件夹。
boolean mkdirs():建立多级文件夹。
2，删除。
boolean delete()：删除失败返回false。若是文件正在被使用，则删除不了返回falsel。
void deleteOnExit();在程序退出时删除指定文件。
3，判断。
boolean exists() :文件是否存在.
isFile():
isDirectory();
isHidden();
isAbsolute();
4，获取信息。
getName():
getPath():
getParent():
getAbsolutePath()
long lastModified()
long length()
*/
class FileDemo
{
public static void main(String[] args) throws IOException
{
method_5();
}
public static void method_5()
{
File f1 = new File("c:\\Test.java");
File f2 = new File("d:\\hahah.java");
sop("rename:"+f2.renameTo(f1));
}
public static void method_4()
{
File f = new File("file.txt");
sop("path:"+f.getPath());
sop("abspath:"+f.getAbsolutePath());
//该方法返回的是绝对路径中的父目录。若是获取的是相对路径，返回null。
//若是相对路径中有上一层目录那么该目录就是返回结果。
sop("parent:"+f.getParent());
}
public static void method_3()throws IOException
{
File f = new File("d:\\java1223\\day20\\file2.txt");
//f.createNewFile();
//f.mkdir();
//记住在判断文件对象是不是文件或者目的时，必需要先判断该文件对象封装的内容是否存在。
//经过exists判断。
sop("dir:"+f.isDirectory());
sop("file:"+f.isFile());
sop(f.isAbsolute());
}
public static void method_2()
{
File f = new File("file.txt");
//sop("exists:"+f.exists());
//sop("execute:"+f.canExecute());
//建立文件夹
File dir = new File("abc\\kkk\\a\\a\\dd\\ee\\qq\\aaa");
sop("mkdir:"+dir.mkdirs());
}
public static void method_1()throws IOException
{
File f = new File("file.txt");
sop("create:"+f.createNewFile());
//sop("delete:"+f.delete());
}
//建立File对象
public static void consMethod()
{
//将a.txt封装成file对象。能够将已有的和为出现的文件或者文件夹封装成对象。
File f1 = new File("a.txt");
File f2 = new File("c:\\abc","b.txt");
File d = new File("c:\\abc");
File f3 = new File(d,"c.txt");
sop("f1:"+f1);
sop("f2:"+f2);
sop("f3:"+f3);
File f4 = new File("c:"+File.separator+"abc"+File.separator+"zzz"+File.separator+"a.txt");
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
例2：递归列出指定目录下的文件或者文件夹
/*
列出指定目录下文件或者文件夹，包含子目录中的内容。
也就是列出指定目录下全部内容。
由于目录中还有目录，只要使用同一个列出目录功能的函数完成便可。
在列出过程当中出现的仍是目录的话，还能够再次调用本功能。
也就是函数自身调用自身。
这种表现形式，或者编程手法，称为递归。
递归要注意：
1，限定条件。
2，要注意递归的次数。尽可能避免内存溢出。
*/
import java.io.*;
class FileDemo3
{
public static void main(String[] args)
{
File dir = new File("E:\\Book");
showDir(dir,0);
}
public static String getLevel(int level)
{
StringBuilder sb = new StringBuilder();
sb.append("|--");
for(int x=0; x<level; x++)
{
//sb.append("|--");
sb.insert(0,"| ");
}
return sb.toString();
}
public static void showDir(File dir,int level)
{
System.out.println(getLevel(level)+dir.getName());
level++;
File[] files = dir.listFiles();
for(int x=0; x<files.length; x++)
{
if(files[x].isDirectory())
showDir(files[x],level);
else
System.out.println(getLevel(level)+files[x]);
}
}
}
原文出处：https://www.cnblogs.com/wgblog-code/p/12092326.html
相关文章
- 1. Java IO流基础总结
- 2. Java基础系列：IO流
- 3. java基础知识总结 超详细
- 4. JAVA基础之IO流知识总结（够详细了吗）
- 5. IO流详细总结
- 6. Java基础17：Java IO流总结
- 7. Java基础学习总结（13）——流IO
- 8. java基础：IO流大总结
- 9. java基础学习总结——IO流
- 10. Java基础-20总结,递归,IO流
- 更多相关文章...
- • Spring体系结构详解 - Spring教程
- • Kotlin 基础语法 - Kotlin 教程
- • Java 8 Stream 教程
- • 为了进字节跳动，我精选了29道Java经典算法题，带详细讲解
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
相关文章
- 1. Java IO流基础总结
- 2. Java基础系列：IO流
- 3. java基础知识总结 超详细
- 4. JAVA基础之IO流知识总结（够详细了吗）
- 5. IO流详细总结
- 6. Java基础17：Java IO流总结
- 7. Java基础学习总结（13）——流IO
- 8. java基础：IO流大总结
- 9. java基础学习总结——IO流
- 10. Java基础-20总结,递归,IO流