黑马程序员--IO流

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、概念

流：IO流用来处理设备之间的数据传输。 Java对数据的操作是通过流的方式。 Java用于操作流的对象都在IO包中。

二、流的分类

流按操作数据分为两种：字节流于字符流。

流按流向分为：输入流与输出流。

三、IO流常用基类

字节流：InputStream OutputStream

字符流：Reader  Writer

在这四个系统中，它们的子类，都有一个共性特点：子类名后缀都是父类名，前缀名都是这个子类的功能名称

如： InputStream的子类FileInputStream。
如： Reader的子类FileReader。

四、Writer类

Writer：写入字符流的抽象类。

    |---BufferedWriter：将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。

    |---OutputStreamWriter：是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。

       |---FileWriter：用来写入字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的。要自己指定这些值，可以先在 FileOutputStream 上构造一个 OutputStreamWriter。

    |---PrintWriter：

    |---CharArrayWriter：

    |---StringWriter：

 

1、 Writer中的方法

write();写入流

append();

flush();刷新流中缓冲数据

close();关闭流

close()和flush()的区别：

flush()：将缓冲区的数据刷到目的地中后，流可以使用。

close()：将缓冲区的数据刷到目的地中后，流就关闭了，该方法主要用于结束调用的底层资源。这个动作一定做。

 

2、 FileWriter

示例：将一些文字存储到硬盘一个文件中

package fuxi;/* * 示例：将一些文字存储到硬盘一个文件中 * 分析：如果要操作文字数据， 建议优先考虑字符流。而且要将数据从内存写到硬盘上， 要使用字符流中的输出流： Writer。 *      硬盘的数据基本体现是文件， 希望找到一个可以操作文件的Writer： FileWriter。 * 步骤1.创建一个可以往文件中写入字符数据的字符输入流对象，既然是往一个文件中写入文件数据， *       那么在创建对象时，就必须明确该文件（用于存储数据的目的地） * 如果文件不存在，则会自动创建 * 如果文件存在，则会被覆盖 * 如果构造函数中加入true，可以实现对文件进行续写 * 2.调用Writer对象中的writer（string）方法，写入数据，其实数据写入到了临时存储缓冲区中 * 3.进行刷新，将数据直接写到目的地中 * 4.关闭资源，在关闭前会调用flush刷新缓冲区中的数据到目的地中 * 注意：流关闭以后不能再调用write方法，否则会报异常错误 */import java.io.FileWriter;import java.io.IOException;public class FileWriterDemo {public static void main(String[] args)  {// 创建一个可以往文件中写入字符数据的字符输入流对象FileWriter fw = null;try {fw = new FileWriter("fw.txt",true);fw.write("abcd"); //调用Writer对象中的writer（string）方法，写入数据，其实数据写入到了临时存储缓冲区中fw.write("你好");fw.flush(); //进行刷新，将数据直接写到目的地中} catch (IOException e) {System.out.println(e.toString());}finally{try {fw.close();//关闭资源，在关闭前会调用flush刷新缓冲区中的数据到目的地中} catch (IOException e) {throw new RuntimeException("关闭失败");}}}}

3、 IO流的异常处理方式

为了防止代码异常导致流无法关闭，因此在finally中对流进行关闭  

 

4、 BufferedWriter

示例：将一些文字存储到硬盘一个文件中

package fuxi;import java.io.BufferedWriter;import java.io.FileWriter;import java.io.IOException;public class BufferedWriterDemo {public static void main(String[] args) throws IOException {FileWriter fw = new FileWriter("buf.txt");// 创建了一个字符写入流的缓冲区对象，并和指定要被缓冲的流对象相关联BufferedWriter bufw = new BufferedWriter(fw);//使用缓冲区的写入方法将数据先写入到缓冲区中bufw.write("asasaf");bufw.newLine();//写入一个换行符，这个换行符可以依据平台的不同写入不同的换行符。bufw.write("hahaha");//使用缓冲区的刷新方法将数据刷目的地中bufw.flush();//关闭缓冲区。其实关闭的就是被缓冲的流对象。bufw.close();}}

五、Reader类

Reader：用于读取字符流的抽象类。

    |---BufferedReader：从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。 可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。

       |---LineNumberReader：跟踪行号的缓冲字符输入流。此类定义了方法 setLineNumber(int)和getLineNumber()，它们可分别用于设置和获取当前行号。

    |---InputStreamReader：是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。

       |---FileReader：用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。要自己指定这些值，可以先在 FileInputStream 上构造一个 InputStreamReader。

    |---CharArrayReader：

    |---StringReader：

1、Reader类中的方法

read()；读取单个字符

read(char[],int, int)将字符读入数组的某一部分

close()；关闭流

2、  FileReader

示例：读取一个文文件，将读取到的字符打印到控制台。(使用FileReader)

步骤：1.创建读取字符数据的流对象，在创建读取流对象时，必须要明确被读取的文件。一定要确定该文件是存在的，用一个读取流关联一个已存在文件

2.读取内容

3.关闭资源

package fuxi;import java.io.FileNotFoundException;import java.io.FileReader;import java.io.IOException;//需求：读取一个文本文件。将读取到的字符打印到控制台public class FileReaderDemo {public static void main(String[] args) throws IOException {// 创建读取字符数据的流对象FileReader fr = new FileReader("fw.txt");//用Reader中的read方法读取字符int ch = 0;while ((ch = fr.read())!=-1) {System.out.println((char)ch);}//使用read(char[])读取文本文件数据，先创建字符数组。char[] buf = new char[1024];//一般数组的长度都是1024的整数倍int len = 0;while ((len = fr.read(buf))!=-1) {System.out.println(new String(buf,0,len));}fr.close();}}

3、BufferedReader

示例：读取一个文文件，将读取到的字符打印到控制台。

步骤：1.创建读取字符数据的流对象，在创建读取流对象时，必须要明确被读取的文件。一定要确定该文件是存在的，用一个读取流关联一个已存在文件

2.建立一个缓冲区对象，并和指定要被缓冲的流关联

3..读取内容

4.关闭资源

package fuxi;import java.io.BufferedReader;import java.io.FileNotFoundException;import java.io.FileReader;import java.io.IOException;public class BufferedReaderDemo {public static void main(String[] args) throws IOException {// 创建一个读取流对象FileReader fr = new FileReader("fw.txt");//建立一个缓冲区对象，并和指定要被缓冲的流关联BufferedReader bufr = new BufferedReader(fr);String line = null;while ((line =bufr.readLine())!=null) {//readLine方法返回的时候是不带换行符的。System.out.println(line);}bufr.close();}}

六、InputStream

InputStream：是表示字节输入流的所有类的超类。

    |--- FileInputStream：从文件系统中的某个文件中获得输入字节。哪些文件可用取决于主机环境。FileInputStream 用于读取诸如图像数据之类的原始字节流。要读取字符流，请考虑使用 FileReader。

    |--- FilterInputStream：包含其他一些输入流，它将这些流用作其基本数据源，它可以直接传输数据或提供一些额外的功能。

       |--- BufferedInputStream：该类实现缓冲的输入流。

       |--- Stream：

    |--- ObjectInputStream：

    |--- PipedInputStream：

 

七、OutputStream

OutputStream：此抽象类是表示输出字节流的所有类的超类。

    |--- FileOutputStream：文件输出流是用于将数据写入 File 或 FileDescriptor 的输出流。

    |--- FilterOutputStream：此类是过滤输出流的所有类的超类。

       |--- BufferedOutputStream：该类实现缓冲的输出流。

       |--- PrintStream：

       |--- DataOutputStream：

    |--- ObjectOutputStream：

    |--- PipedOutputStream：

 

八、转换流

转换流可以将字节转成字符，原因在于，将获取到的字节通过查编码表获取到指定对应字符。

转换流的最强功能就是基于 字节流 + 编码表 。没有转换，没有字符流。

转换流

InputStreamReader:字节到字符的桥梁， 解码

    |--FileReader

OutputStreamWriter:字符到字节的桥梁， 编码

    |--FileWrier

 

想要操作文本文件，必须要进行编码转换，而编码转换动作转换流都完成了。所以操作文件的流对象只要继承自转换流就可以读取一个字符了。

但是子类有一个局限性，就是子类中使用的编码是固定的，是本机默认的编码表，对于简体中文版的系统默认码表是GBK。

FileReader fr = new FileReader("a.txt");

InputStreamReader isr = newInputStreamReader(new FileInputStream("a.txt"),"gbk");

以上两句代码功能一致，

如果仅仅使用平台默认码表，就使用FileReader fr = newFileReader("a.txt"); //因为简化。

如果需要制定码表，必须用转换流。

转换流 = 字节流+编码表。

转换流的子类File = 字节流 + 默认编码表。

凡是操作设备上的文本数据，涉及编码转换，必须使用转换流。

package fuxi;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;import java.io.InputStreamReader;import java.io.OutputStreamWriter;/* * 任何Java识别的字符数据使用的都是Unicode码表， 但是FileWriter写入本地文件使用的是本地编码， *也就是GBK码表。 *而OutputStreamWriter可使用指定的编码将要写入流中的字符编码成字节。 *UTF-8编码， 一个中文三个字节 */public class TransStreamDemo {public static void main(String[] args) throws IOException {//writeText();readText();}public static void writeText() throws IOException {//FileWriter fw = new FileWriter("fww.txt");//指定码表就要用到转换流OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("fwww.txt"), "UTF-8");  //fw.write("你好");//fw.flush();//fw.close();osw.write("你好");osw.flush();osw.close();}public static void readText() throws IOException {//FileReader fr = new FileReader("fwww.txt"); //默认码表//对于指定码表的文件就要用转换流InputStreamReader isr = new InputStreamReader(new FileInputStream("fwww.txt"), "UTF-8");char[] buf = new char[1024];int len=0;while ((len=isr.read(buf))!=-1) {System.out.println(new String(buf,0,len));}isr.close();}}

九、流操作的规律

1，明确源和目的。

    数据源：就是需要读取，可以使用两个体系：InputStream、Reader；

   数据目的：就是需要写入，可以使用两个体系：OutputStream、Writer；

2，操作的数据是否是纯文本数据？

    如果是：数据源：Reader

            数据目的：Writer

    如果不是：数据源：InputStream

              数据目的：OutputStream

3，明确操作的数据设备

    数据源对应的设备：硬盘(File)，内存(数组)，键盘(System.in)，网络：Socket流

    数据目的对应的设备：硬盘(File)，内存(数组)，控制台(System.out)，网络：Socket流。

4，是否需要其他额外功能比如缓冲

    如果需要就进行装饰。

十、流的应用

package fuxi;import java.io.BufferedReader;import java.io.BufferedWriter;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.FileWriter;import java.io.IOException;import java.io.InputStream;import java.io.InputStreamReader;import java.io.OutputStream;import java.io.OutputStreamWriter;/* *  读取一个键盘录入的数据，并打印在控制台上 *   键盘本身就是一个标准的输入设备 *   对于java而言，对于这种输入设备都有对应的对象 *    并将数据变成大写显示在控制台上， *  如果用户输入的是over，结束键盘录入。 *  思路： * 1，因为键盘录入只读取一个字节，要判断是否是over，需要将读取到的字节拼成字符串。 * 2，那就需要一个容器。StringBuilder. * 3，在用户回车之前将录入的数据变成字符串判断即可。 */public class ReadKey {public static void main(String[] args) throws IOException   {readKey();  //字节流实现readKey_1();  //字节流实现readKey_2();    //转换流实现readKey_3();  //将键盘录入的数据写到一个文件中，转换流实现readKey_4();}public static void readKey() throws IOException {//1，创建一个容器StringBuilder sb = new StringBuilder();//2.创建键盘读取流InputStream in = System.in;//3,定义变量记录读取到的字节，并循环获取int ch = 0;while ((ch = in.read())!=-1) {//在存储之前要判断是否是换行标记，因为换行标记不存储if (ch=='\r') {continue;}if (ch=='\n') {String temp = sb.toString();if ("over".equals(temp)) {break;}System.out.println(temp.toUpperCase());sb.delete(0,sb.length());} else {//将读到的字节存储到StringBuilder中sb.append((char)ch);//System.out.println(ch);}}}public static void readKey_1() throws IOException {InputStream in = System.in;int ch = in.read();System.out.println(ch);ch = in.read();System.out.println(ch);ch = in.read();System.out.println(ch);in.close();}//转换流例子public static void readKey_2() throws IOException {//字节流InputStream in = System.in;//将字节转换成字符的桥梁，转换流InputStreamReader isr = new InputStreamReader(in);//对字符流进行高效装饰，缓冲区BufferedReader bufr = new BufferedReader(isr);//简化代码//BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));//字节流，字节数据OutputStream out = System.out;//数据到了osw，目的地out控制台OutputStreamWriter osw = new OutputStreamWriter(out);//缓冲区BufferedWriter bufw = new BufferedWriter(osw);//简化代码//BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));String line = null;//读取到了字符串数据while ((line = bufr.readLine())!=null) {if ("over".equals(line)) {break;}//将字符数据用缓冲区对象将数据写入缓冲区，目的地是oswbufw.write(line.toUpperCase());bufw.newLine();//osw.write(line.toUpperCase()+"\r\n");   //可以替代上面两行代码bufw.flush();//System.out.println(line.toUpperCase());}}//将键盘录入的数据写到一个文件中，转换流实现private static void readKey_3() throws IOException {//源BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));//目的地//BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("11.txt")));BufferedWriter bufw = new BufferedWriter(new FileWriter("111.txt"));  //如果使用默认码表，可以这样写String line = null;//读取字符串数据while ((line = bufr.readLine())!=null) {if ("over".equals(line)) {break;}bufw.write(line.toUpperCase());bufw.newLine();bufw.flush();}}//将文本文件中的内容复制到另一个文件中，转换流实现private static void readKey_4() throws IOException {//源BufferedReader bufr = new BufferedReader(new InputStreamReader(new FileInputStream("1111.txt")));//目的地BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("a.txt")));//BufferedWriter bufw = new BufferedWriter(new FileWriter("111.txt"));  //如果使用默认码表，可以这样写String line = null;//读取字符串数据while ((line = bufr.readLine())!=null) {if ("over".equals(line)) {break;}bufw.write(line.toUpperCase());bufw.newLine();bufw.flush();}}}

十一、File类

将文件系统中的文件和文件夹封装成了对象。提供了更多的属性和行为可以对这些文件和文件夹进行操作。这些是流对象办不到的，因为流只操作数据。

1、File类常见方法

1：创建。

    booleancreateNewFile()：在指定目录下创建文件，如果该文件已存在，则不创建。而对操作文件的输出流而言，输出流对象已建立，就会创建文件，如果文件已存在，会覆盖。除非续写。

    booleanmkdir()：创建此抽象路径名指定的目录。

    booleanmkdirs()：创建多级目录。

2：删除。

    booleandelete()：删除此抽象路径名表示的文件或目录。

    voiddeleteOnExit()：在虚拟机退出时删除。

注意：在删除文件夹时，必须保证这个文件夹中没有任何内容，才可以将该文件夹用delete删除。

    window的删除动作，是从里往外删。注意：java删除文件不走回收站。要慎用。

3：获取.

    longlength()：获取文件大小。

    StringgetName()：返回由此抽象路径名表示的文件或目录的名称。

    StringgetPath()：将此抽象路径名转换为一个路径名字符串。

    StringgetAbsolutePath()：返回此抽象路径名的绝对路径名字符串。

    StringgetParent()：返回此抽象路径名父目录的抽象路径名，如果此路径名没有指定父目录，则返回 null。

longlastModified()：返回此抽象路径名表示的文件最后一次被修改的时间。

File.pathSeparator：返回当前系统默认的路径分隔符，windows默认为 “：”。

File.Separator：返回当前系统默认的目录分隔符，windows默认为 “\\”。

4：判断：

    booleanexists()：判断文件或者文件夹是否存在。

    booleanisDirectory()：测试此抽象路径名表示的文件是否是一个目录。

    booleanisFile()：测试此抽象路径名表示的文件是否是一个标准文件。

    booleanisHidden()：测试此抽象路径名指定的文件是否是一个隐藏文件。

    booleanisAbsolute()：测试此抽象路径名是否为绝对路径名。

5：重命名。

     boolean renameTo(File dest)：可以实现移动的效果。剪切+重命名。

String[] list()：列出指定目录下的当前的文件和文件夹的名称。包含隐藏文件。

如果调用list方法的File 对象中封装的是一个文件，那么list方法返回数组为null。如果封装的对象不存在也会返回null。只有封装的对象存在并且是文件夹时，这个方法才有效。

package fuxi;import java.io.File;import java.io.FilenameFilter;import java.io.IOException;import java.text.DateFormat;import java.util.Date;/* * File类用来将文件或者文件夹封装成对象， 方便对文件与文件夹的属性信息进行操作 * File对象可以作为参数传递给流的构造函数 */public class FileDemo {public static void main(String[] args) throws IOException {constructorDemo();getDemo();  //获取createAndDeleteDemo();  //创建和删除isDemo();   //判断renameToDemo(); //重命名listRootsDemo();   //系统根目 录和容量获取listDemo();   //获取目 录下的文件以及文件夹的名称listDemo_2();  //获取目 录下后缀名为java的文件listDemo_3();   //获取c盘目录下的隐藏文件}public static void constructorDemo() {//可以将一个已存在的， 或者不存在的文件或者目 录封装成file对象//方式一File f1 = new File("e:\\demo\\a.txt");//方式二File f2 = new File("e:\\demo","a.txt");//方式三File f = new File("e:\\demo");File f3 = new File(f,"a.txt");//考虑到Windows和Linux系统通用File f4 = new File("e:"+File.separator+"demo"+File.separator+"a.txt");}//获取public static void getDemo() {File f1 = new File("a.txt");File f2 = new File("e:\\demo\\a.txt");String name = f2.getName();  //返回由此抽象路径名表示的文件或目录的名称String absPath = f2.getAbsolutePath(); //绝对路径String path1 = f1.getPath();  //将此抽象路径名转换为一个路径名字符串String path2 = f2.getPath(); long len = f2.length();    //获取文件大小long time = f2.lastModified();  //返回此抽象路径名表示的文件最后一次被修改的时间//相对路径不同， 父目 录不同//如果此路径名没有指定父目 录， 则返回 nullString parent1 = f1. getParent() ;//返回此抽象路径名父目录的抽象路径名，如果此路径名没有指定父目录，则返回 nullString parent2 = f2. getParent() ;Date date = new Date(time) ;DateFormat df =DateFormat. getDateTimeInstance(DateFormat.LONG, DateFormat.LONG);String str_time = df.format(date);System. out. println( "name: " + name) ;System. out. println( "absPath: " + absPath) ;System. out. println( "path1: " + path1);System. out. println( "path2: " + path2);System. out. println( "len: " + len);System. out. println( "str_time: " + str_time);System. out. println( "parent1: " + parent1) ;System. out. println( "parent2: " + parent2) ;}//创建和删除public static void createAndDeleteDemo() throws IOException {File f = new File("file.txt");//创建如果文件不存在，则创建，如果文件存在，则不创建boolean b1 = f.createNewFile();System.out.println("b1="+b1);//使用delete方法删除文件夹的时候， 如果文件夹中有文件， 则会删除失败boolean b2 = f.delete();System.out.println("b2="+b2);//使用mkdirs可以创建多级目 录File dir = new File("abc\\ab");boolean b3 = dir.mkdirs();System.out.println("b3="+b3);//最里层目 录被干掉， dir代表的是最里层的目 录boolean b4 = dir.delete();System.out.println("b4="+b4);}//判断public static void isDemo() throws IOException {File f = new File("aaa.txt");//判断文件是否存在boolean b1 = f.exists();System.out.println("b1="+b1);//判断测试此抽象路径名表示的文件是否是一个目录boolean b2 = f.isDirectory();System.out.println("b2="+b2);//测试此抽象路径名表示的文件是否是一个标准文件boolean b3 = f.isFile();System.out.println("b3="+b3);//不存在创建if (!f.exists()) {f.createNewFile();}//存在打印信息if (f.exists()) {System.out.println(f.isFile());System.out.println(f.isDirectory());}f = new File("aa\\bb");f.mkdirs();if (f.exists()) {System.out.println(f.isFile());System.out.println(f.isDirectory());}}//重命名   相当于剪切+重命名public static void renameToDemo() {File f1 = new File("E:\\黑马复习\\20151022\\fuxi\\bbb.txt");File f2 = new File("E:\\黑马复习\\20151022\\aaa.txt");boolean b = f1.renameTo(f2);System.out.println("b="+b);}//系统根目 录和容量获取public static void listRootsDemo() {//列出可用的文件系统根File[] files = File.listRoots();for (File file : files) {System.out.println(file);  //c:\,d:\}File file = new File("d:\\");System.out.println("getFreeSpace:"+file.getFreeSpace());   //返回此抽象路径名指定的分区中未分配的字节数。System.out.println("getTotalSpace:"+file.getTotalSpace());   //返回此抽象路径名指定的分区大小。System.out.println("getUsableSpace:"+file.getUsableSpace());   //返回此抽象路径名指定的分区上可用于此虚拟机的字节数。}//获取目 录下的文件以及文件夹的名称public static void listDemo() {File file = new File("c:\\");//获取目 录下的文件以及文件夹的名称， 包含隐藏文件//调用list方法的File对象中封装的必须是目录， 否则会产生NullPointerException//如果访问的是系统级目 录也会发生空指针异常//如果目 录存在但是没有内容， 会返回一个数组， 但是长度为0String[] names = file.list();for (String name : names) {System.out.println(name);}}//获取E:\黑马复习\20151022\fuxi\src\fuxi目 录下后缀名为java的文件//  String[] list(FilenameFilter filter)  返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录。public static void listDemo_2() {File file = new File("E:\\黑马复习\\20151022\\fuxi\\src\\fuxi");String[] names = file.list(new SuffixFilter("java"));for (String name : names) {System.out.println(name);}}//获取c盘目录下的隐藏文件。public static void listDemo_3() {File dir = new File("c:\\");File[] files = dir.listFiles(new FilterByHidden());for (File file : files) {System.out.println(file);}}}//实现接口 FilenameFilter的类实例可用于过滤器文件名class FilterByjava implements FilenameFilter {public boolean accept(File dir, String name) {return name.endsWith("java");    //测试此字符串是否以指定的后缀结束}}//实现接口 FilenameFilter的类实例可用于过滤器文件名class SuffixFilter implements FilenameFilter {private String suffix;public SuffixFilter(String suffix) {super();this.suffix=suffix;}public boolean accept(File dir, String name) {return name.endsWith(suffix);}}//实现接口 FilenameFilter的类实例可用于过滤器文件名class FilterByHidden implements FilenameFilter {public boolean accept(File dir, String name) {// TODO Auto-generated method stubreturn dir.isHidden();}}

十二、递归

就是函数自身调用自身。

一个功能在被重复使用，并每次使用时，参与运算的结果和上一次调用有关。这时可以用递归来解决问题。

 递归的注意事项：

1：一定要定义递归的条件。

2：递归的次数不要过多。容易出现 StackOverflowError 栈内存溢出错误。

其实递归就是在栈内存中不断的加载同一个函数。

如果想打印文件夹中各子文件中的内容就用递归。

package fuxi;import java.io.File;public class DiGuiDemo {public static void main(String[] args) {// TODO Auto-generated method stubfileListDemo();}//对指定目录进行所有内容的列出（包含子目录中的内容），也可以理解为深度遍历public static void fileListDemo() {File dir = new File("F:\\java\\复习\\新建文件夹");listAll(dir,0);}public static void listAll(File dir, int level) {System.out.println(getSpace(level)+"dir"+dir.getAbsolutePath());//获取指定目录下当前的所有文件夹或者文件对象level++;File[] files= dir.listFiles();for (int x = 0; x < files.length; x++) {if (files[x].isDirectory()) {   //测试此抽象路径名表示的文件是否是一个目录。listAll(files[x],level);}System.out.println(getSpace(level)+"file:"+files[x].getAbsolutePath());}}public static String getSpace(int level) {StringBuilder sb = new StringBuilder();sb.append("|--");for (int x = 0; x <level; x++) {sb.append("|");}return sb.toString();}}