黑马程序员_Java基础_IO流_File类,列出(删除)目录下内容,Properties类,付费软件提示原理

  一， File 类

1，File类是文件和目录的抽象表示形式。

public class Fileextends Objectimplements Serializable, Comparable<File>

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

2，常用的构造方法：

          File(File parent, String child) 

          根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。 

          File(String pathname) 

          通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。 

          File(String parent, String child) 

          根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。

 

3，常见方法操作

    1，创建：

    boolean creatNewFile()：在指定路径创建一个新文件，当该路径存在同名文件时，则创建失败，和输出流不同

输出流会每次创建时都重新建立，当存在同名时会覆盖原文件；

 

    boolean mkdir();创建文件夹，只能创建一级

    boolean mkdirs();创建多级文件夹

 

    2，删除：

    boolean delete();删除失败返回假；

    boolean deleteOnExit();//当该方法前面可能出现异常时，如果出现异常则会停止，使用delete会无法删除文件

所以该方法在程序结束时，即使前面遇到异常在退出时也会删除指定文件；

 

    3，判断：

    boolean exists();文件是否存在

    isFile();//是不是文件

    isDirectory();//是不是路径

    isHidden();//判断文件是否是影藏文件

    isAbsoulute();//是否是绝对路径

 

    4，获取信息。

    getName():

    getPath():

    getParent()://获取绝对路径的父目录，如果获取的是相对路径返回null,只要有上一层目录，该目录就是返回结果

 

    getAbsolutePath() //获取绝对路径，返回的是字符串（new File()一下就可以转换为File对象）

    getAbsoluteFile()//获取绝对路径，返回的是File对象（可以与字符串相互转换toString()）

    long lastModified() //返回抽象路径最后一次被修改的时间

    long length() 

 

需求：常见方法的基本使用示例

import java.io.*;
public class FileDemo1
{
    public static void main(String[] args) throws IOException {
        method_4();
    }
    public static void method_4() {
        File f1 = new File("c:\\hwsig.log");
        File f2 = new File("D:\\haha.log");
        f1.renameTo(f2);//将c盘目录下的hwsig.log文件重命名为haha.log并放到d盘目录，类似于移动并重命名；
    }
    public static void method_1()  throws IOException {
        File f1 = new File("demo.txt");
        sop("Create:" + f1.createNewFile());
        //sop("Delete:" + f1.delete());//当文件已删除后，再次运行会返回false
        f1.deleteOnExit();
    /*  
        File f2 = new File("C:\\abc\\Demo.java");
        File f3 = new File("C:\\abc","Demo.java");
        File d = new File("C:\\abc");
        File f4 = new File(d,"Demo.java");//f2,f3,f4这几个的结果是一样的，但是能操作的方式不同；
        
        由于Java的跨平台性，在windows平台下\\代表路径分隔符，但是在Linux下不是这样的，所以
        为了能让文件跨平台，所以File类中有一个方法代表跨平台的路径分隔符；
        
        File f4 = new File("C:" + File.separator + "abc" + File.separator + "Demo.java" );
        sop(f1);
        sop(f2);
        sop(f3);
        sop(f4);
        */
    }
    public static void method_2() throws IOException {
        File mkd = new File("Demo.txt");
        //mkd.mkdir();//必须要存在Demo时才能创建hah
        //mkd.mkdirs();//创建多级目录
        sop(mkd.exists());
    }
    public static void method_3() throws IOException {
        File f = new File("java\\hah");//这是相对路径
    /*  f.createNewFile();
        sop(f.isFile());
        sop(f.isDirectory());*/
        //sop(f.isHidden());
        sop(f.isAbsolute());//完整路径是绝对的
    }
    public static void sop(Object obj) {
        System.out.println(obj);
    }
}

二，File类的list方法

（1）public static File[] listRoots()列出可用的文件系统根

（2）public String[] list()返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录

（3）public String[] list(FilenameFilter filter)返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录。

（4）public File[] listFiles()返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。 

（5）public File[] listFiles(FileFilter filter)返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。

（6）public File[] listFiles(FilenameFilter filter)返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。

 

方法二，三返回的是字符串数组，返回的只是当前目录的所有文件名。其他几个方法返回的是File文件对象，包括完整的路径名和当前目录下的文件名称。

 

需求：测试以上几个方法的结果

import java.io.*;
public class FileDemo2
{
    public static void main(String[] args) {
        method_1();
    }
    public static void method_4() {
        File files = new File("e:\\java\\javaBase\\day20");
        File[] f = files.listFiles();//返回抽象路径下的所有文件；包括完整的抽象路径和文件名；
        for(File fil: f)  {
            sop(fil);
        }
    }
    public static void method_3() {
        File dir = new File("e:\\java\\day19");
        String[] arr = dir.list(new FilenameFilter() {
            public boolean accept(File dir, String name) {
                //dir指的是你指定的路径，name指的是路径下上所有的文件；
                //比如要返回所有.java的文件
                return name.endsWith(".java");
                //return true;
            }
        });
        sop(arr.length);
        for(String name1: arr) {
            sop(name1);
        }
    }
    public static void method_1() {
        File file = new File("e:\\java\\javaBase");
        String[] s = file.list();//显示当前目录所有文件名，包括隐藏的文件；该路径必须存在
        for(String m: s)
        {
            sop(m);
        }
    }
    public static void method_2() {
        File[] f = File.listRoots();//显示磁盘目录
        for(File f1: f) {
            sop(f1);
        }
    }
    public static void sop(Object obj) {
        System.out.println(obj);
    }
}

三，综合应用示例

需求：列出指定目录下的所有内容。

import java.io.*;
public class DirDemo {
    public static void main(String[] args) {
        File f= new File("e:\\java\\javaBase");
        
        getFile(f);
    }
    public static void getFile(File f) {
        File files[] = f.listFiles();
        for(File file : files) {
            if(file.isDirectory()) {
                getFile(file);
            }
            else {
                System.out.println(file);
            }
        }
    }
}

需求：自定义一个方法删除目录以及目录下面的文件和文件夹； 

删除原理是：从里往外删除；所以要用到递归；

import java.io.*;
public class MyRemoveDemo
{
    public static void main(String[] args) {
        File fir = new File("e:\\hehe");
        remove_1(fir);
    }
    public static void remove_1(File dir) {
        File[] files = dir.listFiles();
        for (int i=0;i<files.length ;i++ )
        {
            if(files[i].isDirectory())
                remove_1(files[i]);
            else
                System.out.println(files[i] + ":::::" + files[i].delete());
        }//循环结束之后删除的是dir这个目录下的所有文件，但是这个文件夹还没有被删除，所以还要删除这个文件夹；
        System.out.println(dir.delete());
    }
}

四，将指定文件的路径存储到文件中

需求：讲一个指定目录下的所有.java文件的绝对路径存储到一个文件中；

建立一个Java文件列表文件。

 

思路：

    1，对指定的目录进行递归；

    2，获取递归过程中的所有Java文件的路径；

    3，将这些路径存储到集合中；

    4，将集合中的数据存储到一个文件中；

import java.io.*;
import java.util.*;
public class JavaFileList
{
    public static void main(String[] args) throws IOException {
        File dir = new File("E:\\java");
        List<File> list = new ArrayList<>();
        gotPath(dir,list);
        writeToFile(list,"c:\\Demo.txt");
    }
    //递归获取路径，如果是java文件，存储到List集合
    public static void gotPath(File dir,List<File> list) {
        File[] file = dir.listFiles();
        for(File s: file) {
            if(s.isDirectory())
                gotPath(s,list);
            else
            {
                if(s.getName().endsWith(".java"))
                    list.add(s);
            }
        }
    }
    
    //将List中存储的内容写到文件中
    public static void writeToFile(List<File> list,String javaFile) throws IOException {
        BufferedWriter bufW = null;
        try
        {
            bufW = new BufferedWriter(new FileWriter(javaFile));
            for(File f: list) {
                String str = f.getAbsolutePath();
                bufW.write(str);
                bufW.newLine();
                bufW.flush();
            }
        }
        catch (IOException e)
        {
            throw e;
        }
        finally
        {
            try
            {
                if(bufW != null)
                bufW.close();
            }
            catch (IOException et)
            {
                throw et;
            }
            
        }
    }
}

五，Properties类

Properties类就是与属性相关的类，他是HashTable的子类，所以他具有Map集合的特点。它是集合中与ＩＯ流技术相结合的容器。该类可以用于对键值对形式的配置文件进行操作。在加载数据时需要数据有固定格式：键＝＝值。

public void list(PrintStream out)

public void list(PrintWriter out)

public void load(InputStream inStream)

public void load(Reader reader)

public Set<String> stringPropertyNames()

public Enumeration<?> propertyNames()

 

１，基本使用方法：

import java.io.*;
import java.util.*;
public class PropertiesDemo
{
    public static void main(String[] args) throws IOException {
        Properties pro = new Properties();
        //基本方法的使用
        pro.setProperty("zhangsan","24");
        pro.setProperty("lisi","23");
        pro.setProperty("wangwu","21");
        sop(pro);
        sop(pro.getProperty("zhangsan"));//根据键查找对应的值
        Set<String> st = pro.stringPropertyNames();
        for (String str: st)
        {
            sop(str + "::" + pro.getProperty(str));
        }
        method_3(pro);
    }
    //在Properties类中提供了load方法，和method_2功能一样，method_2是load方法的原理；
    //void load(InputStream inStream) 
    public static void method_3(Properties pro) throws IOException {
        FileInputStream fis = new FileInputStream("info.txt");
        pro.load(fis);
        //sop(pro);
        //发现wangwu的年龄错了，需要修改：
        pro.setProperty("wangwu","39");//这只是修改了在内存中的数据，但是info.txt文件中的并没有被修改
                        //所以需要将内存中的内容加载到文件中；
                        // void store(OutputStream out, String comments)。comment是说明可写可不写  
        FileOutputStream fos = new FileOutputStream("info.txt");
        //sop(pro);
        pro.store(fos,"说明");
        pro.list(System.out);
    }
    /*
    想要将键值对的数据存储到集合中进行操作；讲一个info.txt文件中的配置信息数据存储到集合中；
    思路：
        1，用一个流和info.txt文件进行关联；
        2，用split方法对"="进行切割；
        3，等号左边的值作为键，右边的值作为值存储到Properties中；
    */
    public static void method_2(Properties pro) throws IOException {
        //源：纯文本，文件文本，需要提高读取效率
        BufferedReader  bufr = new BufferedReader(new FileReader("info.txt"));
        String buf = null;
        while ((buf = bufr.readLine())!=null)
        {
            String[] arr = buf.split("=");
            //sop(arr[0] + "-----" + arr[1]);
            pro.setProperty(arr[0],arr[1]);
        }
        sop(pro);
        bufr.close();
    }
    public static void sop(Object obj) {
        System.out.println(obj);
    }
}

２，付费软件提示注册原理

    需求：记录程序的运行次数，当运行次数达到5次以上时，提示用户付费注册；

 

    思路：首先想到的是要定义一个计数器。但是如果只用计数器技术，那么每次运行时计数器就会变零，每次重新启动时不能达到计数的目的，不是我们所要的。

 

    该配置文件应该以键值对的形式存在，这样便于操作和阅读；

    键值对数据是Map集合，而数据是以文件形式存储，使用IO技术；

    那么Map+IO--->Properties  

import java.io.*;
import java.util.*;
public class PropertiesTest
{
    public static void main(String[] args) throws IOException {
        //建立Properties对象，操作键值对
        Properties pro = new Properties();
        //用于每次运行程序时能存储操作数据，避免程序退出后，再次运行数据恢复；
        File file = new File("info.ini");
        if(!file.exists())
            file.createNewFile();//当文件记录数据文件不存在时，创建新的配置文件
        FileInputStream fis = new FileInputStream(file);//将配置文件信息加载到流中
        pro.load(fis);//从流中加载配置信息数据到内存，记录操作次数
        int count = 0;//记录程序运行的次数，也就是值
        String value = pro.getProperty("time");//time为键，对应次数；通过键time获取键所对应的值，即次数
        if(value!=null)//值为空时，就是程序一次也没有执行过；
            count = Integer.parseInt(value);//将键（字符串）转换成整数计数
        count++;
        if(count>=5) {
            System.out.println("运行次数已到达，请注册");
            return ;
        }
        pro.setProperty("time",count+"");//设置配置文件的键值对
        FileOutputStream fos = new FileOutputStream("info.ini");//将内存中新的配置文件数据保存到硬盘中的配置文件info.ini
        pro.store(fos,"");
        fis.close();
        fos.close();
    }
}