IO学习笔记（三）

------- android培训、java培训、期待与您交流！ ----------

File类
用来将文件或者文件夹封装成对象；
方便对文件与文件夹的属性信息进行操作；
file对象可以作为参数传递给流的构造函数；

流对象不能操作文件夹以及属性信息，只能操作数据，而想要操作被数据封装成文件的对象，只能用File类。

File类常见方法：
1、创建。
boolean   createNewFile（）：在指定位置创建文件，如果该文件已经存在，则不创建，返回false。和输出流不一样，输出流对象一建立就创建文件，而且文件已经存在，会覆盖。
boolean  mkdir（）：创建文件夹，并只能创建一级目录。
boolean  mkdirs（）：创建多级目录。

用来将文件或者文件夹封装成对象；
方便对文件与文件夹的属性信息进行操作；
file对象可以作为参数传递给流的构造函数；

流对象不能操作文件夹以及属性信息，只能操作数据，而想要操作被数据封装成文件的对象，只能用File类。

File类常见方法：
1、创建。
boolean   createNewFile（）：在指定位置创建文件，如果该文件已经存在，则不创建，返回false。和输出流不一样，输出流对象一建立就创建文件，而且文件已经存在，会覆盖。
boolean  mkdir（）：创建文件夹，并只能创建一级目录。
boolean  mkdirs（）：创建多级目录。

2、删除。

boolean   delete（）：删除失败返回false。如果文件正在被使用，则删除不了返回false。
如果此路径名表示一个目录，则该目录必须为空才能删除。 
void  deleteOnExit（）：在程序退出时删除指定文件。

3、判断。

boolean canExecute（）：文件是否能执行。
boolean exists（）：文件是否存在。
boolean isDirectory(): 判断文件对象是否是目录。
boolean  isFile（）：判断文件对象是否是文件。
boolean   isHidden(): 是否是隐藏文件夹。
boolean  isAbsolute()：判断是否是绝对路径。

4、获取信息。

getName():
getPath():  放回抽象路径名字符串。
getAbsolutePath(): 返回此抽象路径名的绝对路径名形式。
getParent(): 返回此抽象路径名父目录的路径名字符串；如果封装的不是绝对路径则返回null。如果相对目录中有上一层目录，该返回结果就是上一级目录。
long  length(): 获取文件大小
long  lastmodified()：返回文件最后一次修改时间。
renameTo()：重新命名此抽象路径名的文件。

listRoots(): 静态方法，返回系统的可用盘符。

import java.io.*;

public class FileDemo {
    public static void main(String[] args) throws IOException {
        //method();
        //method_2();
        //method_3();
        method_4();
    }


    //修改文件及文件路径。相当于剪切的效果。
    public static void method_4() {
        File f1 = new File("C:\\Test.txt");
        File f2 = new File("D:\\Test.java");
        f2.renameTo(f1);
    }
    public static void method_3() throws IOException {
        // TODO Auto-generated method stub
        File f = new File("C:\\file.txt");
        //创建file.txt文件夹
        f.mkdir();
        //f.createNewFile();
        System.out.println(f.exists());

        //如果直接判断，两个结果都是false。要求我们在判断文件对象是否是目录或者文件
        //之前，必须要先判断该文件对象内封装的内容是否存在，用exists（）判断。
        //即使是存在，也不能直观的认为是文件，
        System.out.println("isDirectory :" + f.isDirectory() );
        System.out.println("isFile :" + f.isFile() );
        //判断路径是否是绝对路径，判断是即使文件不存在也返回true。
        System.out.println(f.isAbsolute());

    }


    //File类中常用方法
    public static void method_2() throws IOException {
        File file = new File("C:\\abc.txt");
        //创建一个txt文件。
        file.createNewFile();
        /**
         * 删除文件，但是如果在这之前文件发生IO异常，delete方法将不能执行。
         *也可以放在fianlly语句块中，但这样，有可能会发生文件正在被使用，不能删除。
         *这是就用到了deleteOnExit（）方法，即在程序退出时删除文件。
         */
        //file.delete();
        //判断文件是否存在。返回true则文件存在。
        System.out.println(file.exists());

    }

    //创建File对象
    public static void method()  throws IOException {
        //将C:\\a.txt封装成file对象。可以将已有的和未出现的文件或者文件夹封装成对象。
        //有三种构造方式均可完成。
        //separator 为分隔符，这样写有利用程序的跨平台使用。
        File file1 = new File("C:" + File.separator + "a.txt");
        //File file1 = new File("D:\\abc\\a.txt");
        //c盘没有abc这个文件夹，无法创建文件。
        File file2 = new File("C:\\abc", "b.txt");
        File f = new File("C:\\abc");
        File file3 = new File(f, "c.txt");
        file1.createNewFile();

        //创建一级目录，即创建的目录之前的路径必须存在。创建完成后就可以在此路径下
        //创建新的文件。
        System.out.println("mkdir：" + f.mkdir());
        file3.createNewFile();

        //如需要创建多级目录就要用到mkdirs（）方法。
        File file4 = new File("C:\\aaa\\bbb\\ccc");
        file4.mkdirs();


    }
}

list()：返回目录中的文件和目录。调用list方法时，File对象必须是封装了一个目录。该目录还必须存在。
list(FilenameFilter filter)方法可以对返回的文件名称进行过滤，返回的是String数组。
listFiles() 返回一个抽象路径名数组，返回的是File数组。

import java.io.*;

public class FileDemo2 {

    public static void main(String[] args) {
        //listDemo();
        listDemo_2();

    }
    public  static void listDemo_2() {
        File f = new File("C:\\");
        //用listFiles（）方法返回抽象路径名数组。
        File[] files = f.listFiles();
        for (File file : files) {
            System.out.println(file.getName() + "::" + file.length());
        }

    }

    //直接用list（）返回所有对象，用list（FilenameFilter Filter）可以过滤文件
    //用到了匿名内部类。
    public  static void listDemo() {
        File f = new File("C:\\");
        //String[] names = f.list();
        String[] names = f.list(new FilenameFilter() {
            public boolean accept(File f, String name) {
                //可以直接返回
                return name.endsWith(".txt");
                /*if (name.endsWith(".txt"))
                  return true;
                else
                  return false;*/
            }
        });
        for (String name : names) {
            System.out.println(name);
        }
    }

}

递归
当一个功能被重复使用，而每一次使用该功能时的参数都不确定，
都有上次的功能元素结果来确定，即功能内部又用到该功能，但是传递的参数值不确定。
需注意的事项：
1、一定要定义递归地条件。
2、递归次数不要过多 ，容易出现栈内存溢出错误。

下面这个程序就是利用递归的原理，遍历出一个文件夹内的所有文件夹和文件。

import java.io.*;
public class FileDemo3 {

    public static void main(String[] args) {
        File f = new File("E:\\test-git");
        method(f);
    }

    public static void method(File file) {
        System.out.println(file);
        //用listFiles()方法返回一个抽象路径名数组
        File[] files = file.listFiles();
        //对所包含的文件夹进行遍历
        for (int i = 0; i < files.length; i++) {
            //利用递归地原理，如果符合条件就继续调用只身方法，
            //对文件夹内的内容进行再次循环
            if (files[i].isDirectory()) {
                method(files[i]);
            } else
                System.out.println(files[i]);
        }
    }
}

删除带内容的目录
删除原理：
在window中，删除目录从里面往外删除的。 
可以利用递归进行删除。

import java.io.*;

public class Delete {
  public static void main(String[] args) {
    File file = new File("E:\\sour");
    deleteDemo(file);
  }

  public static void deleteDemo(File file) {
    //返回一个抽象路径名数组，包括目录路径下的文件
    File[] files  = file.listFiles();
    for(int x = 0;x<files.length; x++) {
      //如果是目录对象的话，则递归直至全是文件。
      if(files[x].isDirectory()) {
        deleteDemo(files[x]);
      } else 
        //判断是否删除成功
        System.out.println(files[x].toString() +":::" +files[x].delete());
    }
    //如果文件夹是空的话，files.length==0，此次for循环结束，支持这句删除空文件夹。
    System.out.println(file.toString() +"......" +file.delete());
  }
}

Properties
Properties是haahtable的子类。
也就是说它具备map集合的特点，而且它里面存储的键值对都是字符串；
是集合中和IO技术相结合的集合容器；
该对象的特点：可以用于键值对形式的配置文件。
load（）：将流中的数据加载进集合。
原理：将读取流和指定文件相关联，并读取一行数据，因为数据是规则的key= value，所以获取一行后，通过“=”对该行数据进行切割，左边是键，右边是指，将键和值存储到properties集合中。
store（）：写入各项后，刷新输出流。
list（）：将集合的键值数据列出到指定的目的地。 
 

打印流：
该流提供了打印方法，可以将各种数据类型的数据都原样打印。
字节打印流
PrintSream
构造函数可以接收的参数类型
1、file对象。File
2、字符串路径。String
3、字节输出流。OutputStream

字符打印流
PrintWriter
构造函数可以接收的参数类型
1、file对象。File
2、字符串路径。String  
3、字节输出流。OutputStream，可以在构造方法后加true，这样println就直接可以换行
4、字符输出流。Writer

序列流：
将多个读取流合并成一个读取流，如果是多个流，就要用到Vector集合

/*
 *要求：将三个txt文件合并成一个。
 *
 *思路：1、这就要用到序列流，由于是三个对象，就要用构造函数
 *      SequenceInputStream(Enumeration<? extends InputStream> e)，Enumeration是Vector集合
 *      集合的一种遍历方式，就想到可以用Vector集合。
 *      2、建立Vector集合，添加三个读取流对象。
 *      3、对Vertor集合进行枚举，将结果添加到序列流。
 *      4、写入。
*/


import java.io.*;
import java.util.*;

public class Sequence {
    public static void main(String[] args) throws IOException {
        //创建Vector集合，
        Vector<FileInputStream> v = new Vector<FileInputStream>();
        v.add(new FileInputStream("C:\\1.txt"));
        v.add(new FileInputStream("C:\\2.txt"));
        v.add(new FileInputStream("C:\\3.txt"));
        //对Vertor集合进行枚举
        Enumeration<FileInputStream> en = v.elements();
        //将结果添加到序列流
        SequenceInputStream sis = new SequenceInputStream(en);
        FileOutputStream fos = new FileOutputStream("C:\\4.txt");
        byte[] b = new byte[1024];
        int i = 0;
        while ((i = sis.read(b)) != -1) {
            fos.write(b, 0, i);
        }
        fos.close();
        sis.close();

    }
}

由于使用Vector效率比较低，可以用ArrayList集合，再调用Collections中的
enumeration()方法。


上面的程序可以改为：
ArrayList<FileInputStream> v = new ArrayList<FileInputStream>();
        v.add(new FileInputStream("C:\\1.txt"));
        v.add(new FileInputStream("C:\\2.txt"));
        v.add(new FileInputStream("C:\\3.txt"));
      
        Enumeration<FileInputStream> en = Collections.enumertion(v);