IO流（三）

File对象

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

构造函数

四种构造函数的代码示例：

public class FileDemo {    public static void main(String[] args) {        constructorDemo();    }    public static void constructorDemo() {        ///可以将一个已存在的或者不存在的文件或者目录封装成file对象。        File f1 =new File("c:\\a.txt");        File f2 =new File("c:\\","a.txt");        File f=new File("c:\\");        File f3=new File(f,"a.txt");//      File f4=new File("c:"+System.getProperty("file.separator")+"a.txt");        File f4=new File("c:"+File.separator+"a.txt");    }}

常见方法

File对象的常见方法有
1.获取、创建、删除、判断以及重命名。

public class FileMethodDemo {    public static void main(String[] args) throws IOException {/*              File对象的常见方法            1.获取                                     getDemo()                获取文件名称                获取文件路径                获取文件大小                获取文件修改时间            2.创建与删除   boolean           createAndDeleteDemo()            3.判断                        isDemo()             4.重命名                       renameToDemo()*///      getDemo();//      createAndDeleteDemo();//      isDemo();        renameToDemo();    }    public static void renameToDemo() {        File f1=new File("c:\\0.mp3");        File f2=new File("d:\\9.mp3");        boolean b=f1.renameTo(f2);        System.out.println("rename:"+b);    }    public static void isDemo() throws IOException {        File f=new File("a.txt");        boolean b=f.exists();/*              //带.txt的不一定是文件，不带后缀名的也不一定是目录        File f1=new File("aaa.txt");        f1.mkdir();        File f2=new File("aaa");        f2.createNewFile();        */        System.out.println("is exists:"+b);        //最好先判断是否存在，在判断是否目录。文件等        System.out.println(f.isFile());        System.out.println(f.isDirectory());        System.out.println(f.isHidden());        System.out.println(f.isAbsolute());    }    public static void createAndDeleteDemo() throws IOException {        File dir=new File("abc");        boolean d=dir.mkdir();//make directory        System.out.println("create dir:"+d);        System.out.println("delete dir:"+dir.delete());//如果目录里面有内容，则删除不了，因为Windows只能从里往外删除        File dirs=new File("abc\\a\\b\\c\\d\\e");//创建多级目录        boolean d1=dir.mkdirs();//make directorys        System.out.println("create dirs:"+d1);        System.out.println("delete dirs:"+dirs.delete());//删除的的目录e,前面都是父目录//      文件的创建与删除        File file=new File("file.txt");        /*               和输出流不一样，如果文件不存在，则创建，如果存在则不创建        */          boolean b=file.createNewFile();        System.out.println("create:"+b);        boolean b1=file.delete();        System.out.println("delete:"+b1);        }    public static void getDemo(){//      File file=new File("D:\MyEclipse Professional 2014\day22e\a.txt");        File file=new File("a.txt");        String name=file.getName();        String path=file.getAbsolutePath();        String path1=file.getPath();        long len=file.length();        long time=file.lastModified();        Date date=new Date(time);        DateFormat dateFormat=DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG);        String str_time=dateFormat.format(date);        System.out.println("name:"+name);        System.out.println("absPath:"+path);        System.out.println("path:"+path1);        System.out.println("len:"+len);        System.out.println("time:"+time);        System.out.println("str_time:"+str_time);        System.out.println("parent path:"+file.getParent());//当实例化时参数为相对目录时返回空，为绝对目录时返回父目录。    }}

2.获取系统根目录和容量

public class FileMethodDemo {    public static void main(String[] args) throws IOException {        listRootsDemo();    }    public static void listRootsDemo() {        File[] files=File.listRoots();        for(File file:files){            System.out.println(file);        }        File f=new File("d:\\");        System.out.println("FreeSpace:"+f.getFreeSpace());        System.out.println("TotalSpace:"+f.getTotalSpace());        System.out.println("UsableSpace:"+f.getUsableSpace());    }}

输出：
C:\
D:\
E:\
F:\
G:\
FreeSpace:241087184896
TotalSpace:371055390720
UsableSpace:241087184896

3.获取目录内容
调用list方法的File对象中封装的必须是目录，否则会发生NullPointerException。
如果访问的是系统级目录，也会发生空指针异常。
如果目录存在但是没有内容，会返回一个数组，但是长度为0。

public class FileMethodListDemo {    public static void main(String[] args) {        listDemo();    }    public static void listDemo() {        File file=new File("c:\\");        /*        函数功能：当前目录下的文件以及文件夹的名称，包含隐藏文件        */        String[] names=file.list();        for(String name:names){            System.out.println(name);        }    }}

4.过滤器
通过过滤器可以只获取那些带有固定特征的文件或者目录，例如获取后缀为”.java”的文件，或者隐藏文件。

后缀名为”.java”的过滤器：

public class FilterByJava implements FilenameFilter {    @Override    public boolean accept(File dir, String name) {        return name.endsWith(".java");    }}

将后缀名作为参数的过滤器：

public class SuffixFilter implements FilenameFilter {    private String suffix;    public SuffixFilter(String suffix) {        super();        this.suffix = suffix;    }    @Override    public boolean accept(File dir, String name) {        return name.endsWith(suffix);    }}

隐藏文件的过滤器：

public class FilterByHidden implements FileFilter {    @Override    public boolean accept(File pathname) {        return !pathname.isHidden();    }}

使用以上过滤器的实例：

public class FileMethodListDemo {    public static void main(String[] args) {        listDemo_2();        listDemo_3();    }    public static void listDemo_3() {        File dir=new File("c:\\");        File[] files=dir.listFiles(new FilterByHidden());        for(File file:files){            System.out.println(file);        }    }    public static void listDemo_2() {        File dir=new File("c:\\");//      String[] names=dir.list(new FilterByJava());        String[] names=dir.list(new SuffixFilter(".java"));        for(String name:names){            System.out.println(name);        }    }}

深度遍历

需求一：对指定目录进行所有内容的列出（包含子目录的内容）
即进行深度遍历。

public class FileTest {    public static void main(String[] args) {        File dir=new File("E:\\javawork");        listAll(dir,0);    }    public static void listAll(File dir,int level) {//      System.out.println("dir:"+dir.getAbsolutePath());        System.out.println(getSpace(level)+dir.getName());        level++;        //获取指定目录下当前的所有文件夹或者文件对象        File[] files=dir.listFiles();        //        for(int x=0;x<files.length;x++){            if(files[x].isDirectory()){                listAll(files[x],level);            }            else                System.out.println(getSpace(level)+files[x].getName());        }    }    private static String getSpace(int level) {        StringBuilder sb=new StringBuilder();        sb.append("|--");        for(int x=0;x<level;x++){            sb.insert(0,"|  ");        }        return sb.toString();    }}

递归
函数自身直接或间接地调用到自身就是递归。
一个功能在被重复使用，并每次使用时，参与运算的结果和上一次调用有关，这时可以用递归来解决问题。
注意：
1.递归一定要明确条件，否则容易栈溢出。
2.注意递归的次数。

需求二：删除一个带内容的目录。
原理：必须要从最里面往外删，需要进行深度遍历。

public class RemoveDirTest {    public static void main(String[] args) {        File dir=new File("e:\\demodir");        removeDir(dir);    }    public static void removeDir(File dir) {        File[] files=dir.listFiles();        for(File file:files){            if(file.isDirectory()){                removeDir(file);            }            else{                System.out.println(file+":"+file.delete());file.delete();            }        }        System.out.println(dir+":"+dir.delete());    }}

Properties集合

Properties集合是Hashtable集合下的一个子类：
Map–>Hashtable->Properties

Properties表示一个持久的属性集，该集合用于操作以键值对形式存在的配置文件。

Properties集合的特点：
1. 可以保存在流中或者从流中加载。
2. 属性列表中每个键及其对应值都是一个字符串。

Properties集合的常见使用：

public class PropertiesDemo {    public static void main(String[] args) throws IOException {//      propertiesDemo();//      methodDemo_2();//      methodDemo_3();//      methodDemo_4();//      myLoad();        test();    }    //对已有的配置文件中的信息进行修改    /*    读取这个文件    并将这个文件中的键值数据存储到集合中    再通过集合对数据进行修改    再通过流将修改后的数据存储到文件中    */    public static void test() throws IOException{        //读取这个文件        File file=new File("info.txt");        if(!file.exists()){            file.createNewFile();        }        FileReader fr=new FileReader(file);//流与数据相关联//      FileWriter fw=new FileWriter(file);//不能写在这里，因为这样是新创建了一个一个文件，原文件的数据被覆盖了，里面没数据        //创建集合存储配置信息        Properties prop =new Properties();        //将流中的信息存储到集合中        prop.load(fr);//      prop.list(System.out);//      通过集合对数据进行修改        prop.setProperty("marry", "21");//      prop.list(System.out);//      通过流将修改后的数据存储到文件中        FileWriter fw=new FileWriter(file);        prop.store(fw,"info");        fw.close();        fr.close();    }//  模拟load方法    public static void myLoad() throws IOException{        Properties prop=new Properties();        BufferedReader bufr=new BufferedReader(new FileReader("info.txt"));        String line=null;        while((line=bufr.readLine())!=null){            if(line.startsWith("#"))                continue;            String[] arr=line.split("=");//          System.out.println(arr[0]+"::"+arr[1]);            prop.setProperty(arr[0], arr[1]);        }        prop.list(System.out);        bufr.close();    }    public static void methodDemo_4() throws IOException {        Properties prop=new Properties();        /*        集合中的数据来自一个文件        注意：必须保证该文件的数据是键值对        需要使用到读取流        */        FileInputStream fis=new FileInputStream("info.txt");        //使用load方法        prop.load(fis);        prop.list(System.out);    }    public static void methodDemo_3() throws IOException {        Properties prop=new Properties();        //存储元素        prop.setProperty("marry", "28");        prop.setProperty("tom", "14");        prop.setProperty("jerry", "12");        prop.setProperty("lisa", "24");        /*         * 想要将这些集合中的字符串键值信息持久化存储到文件中         * 需要关联输出流         *          * */        FileOutputStream fos=new FileOutputStream("info.txt");        //将集合中的数据存储到文件中，使用store方法        prop.store(fos, "name+age");        fos.close();    }    /*    演示Properties集合和流对象相结合的功能    */    public static void methodDemo_2(){        Properties prop=new Properties();        //存储元素        prop.setProperty("marry", "28");        prop.setProperty("tom", "14");        prop.setProperty("jerry", "12");        prop.setProperty("lisa", "24");        //public void list(PrintStream out):将属性列表输出到指定的输出流        prop.list(System.out);//集合中的数据输出到输出流控制台上。调试用，开发用得少        Properties prop1=System.getProperties();        prop1.list(System.out);    }    /*    Properties集合的存和取    */    public static void propertiesDemo(){        //创建一个Properties集合        Properties prop=new Properties();        //存储元素        prop.setProperty("marry", "28");        prop.setProperty("tom", "14");        prop.setProperty("jerry", "12");        prop.setProperty("lisa", "24");        //修改元素        prop.setProperty("marry", "18");        //取出所有元素        Set<String> names=prop.stringPropertyNames();        for(String name:names)        {            String value=prop.getProperty(name);            System.out.println(name+":"+value);        }    }}

Properties集合练习
需求：定义功能，获取一个应用程序运行的次数，如果超过5次，给出使用次数已到请注册的提示，并且不要再运行程序。
思路：
1.应该有计数器；
每次程序启动都需要计数一次，并且是在原有的次数上进行计数。
2.计数器就是一个变量，程序启动时进行计数，计数器必须存在于内存中并进行运算。
但是程序一旦结束，计数器消失了，再次启动该程序的时候，计数器又重新被初始化了。

然而我们需要多次启动同一个应用程序，使用的是同一个计数器。
这就需要计数器的生命周期变长，从内存存储到硬盘文件中。

3.如何使用这个计数器：
首先，程序启动时，应该先读取这个用于记录计数器信息的配置文件。
获取上一次计数器次数，并进行试用次数的判断。
其次，对该次数进行自增，并将自增后的次数重新存储到配置文件中。

4.文件中的信息该如何进行存储并体现：
直接存储此数值可以，但是不明确该数据的含义，所以应该起一个名字。
（简单数据可以这么体现，用键值对。但是复杂数据不可以，要想进行更贴切的描述，应该用xml文件。）
这就有了名字和值的对应，所以可以使用键值对。
可以应用有映射关系的map集合搞定，又需要读取硬盘上的数据，所以map+io=Properties。

public class PropertiesTest {    public static void main(String[] args) throws IOException {        getAppCount();    }    public static void getAppCount() throws IOException{        //将配置文件封装成File对象//      .ini在Windows或者常见应用软件里比较常用，对于java制作的软件的键值对的配置信息用.properties作为扩展名        File confile=new File("count.ini");        if(!confile.exists()){            confile.createNewFile();        }        FileInputStream fis=new FileInputStream(confile);        Properties prop=new Properties();        prop.load(fis);        //从集合中通过键获取次数        String value=prop.getProperty("time");        //定义计数器，记录获取到的次数        int count=0;        if(value!=null){            count =Integer.parseInt(value);            if(count>=5){//              System.out.println("使用次数已到,请注册");//              return;                throw new RuntimeException("使用次数已到,请注册");            }        }        count++;        //将改变后的次数重新存储到集合中        prop.setProperty("time", count+"");        FileOutputStream fos=new FileOutputStream(confile);        prop.store(fos,"");        fos.close();        fis.close();    }}

综合练习

需求：获取指定目录下，指定扩展名的文件（包含子目录中的）这些文件的绝对路径写入到一个文本文件中。简单说，就是建立一个指定扩展名的文件的列表。

思路：
1.必须进行深度遍历；
2.要在遍历的过程中进行过滤，将符合条件的内容都存储到容器中；
3.对容器中的内容进行遍历并将绝对路径写入到文件中。

public class Test {    public static void main(String[] args) throws IOException {        File dir=new File("e:\\javawork");        FilenameFilter filter=new FilenameFilter(){            @Override            public boolean accept(File dir, String name) {                return name.endsWith(".java");            }        };        List<File> list=new ArrayList<File>();        getFiles(dir,filter,list);        File destFile=new File(dir,"javalist.txt");        write2File(list,destFile);    }/** * 对指定目录中的内容进行深度遍历，并按照指定的过滤器进行过滤，将过滤后的内容存储到指定容器list中 * @param dir * @param filter * @param list */    public static void getFiles(File dir,FilenameFilter filter,List<File> list){        File[] files=dir.listFiles();        for(File file:files){            if(file.isDirectory()){                //递归                getFiles(file,filter,list);            }else{                //对遍历到的文件文件进行过滤器的过滤，将符合条件的File对象，存储到List集合中。                if(filter.accept(dir, file.getName())){                    list.add(file);                }            }        }    }    public static void write2File(List<File> list,File destFile) throws IOException{        BufferedWriter bufw=null;        try {            bufw=new BufferedWriter(new FileWriter(destFile));            for(File file:list){                bufw.write(file.getAbsolutePath());                bufw.newLine();                bufw.flush();            }        } /*catch (IOException e) {//catch或者抛出            throw new RuntimeException("写入失败");        }*/finally{            if(bufw!=null)                try{                    bufw.close();                }catch(IOException e){                    throw new RuntimeException("关闭失败");                }        }    }}