JAVA基础 day22 File类的方法和应用 利用递归获取目录下的所有文件 Properties类的应用（和IO技术结合，存取配置文件） 打印流和合并流等功能类的学习应用 切割文件练习

File类
将已存在的或者未存在的文件封装成对象。
封装文件的三种构造方法，只是封装，并不创建。

import java.io.*;
class FileDemo1
{
    public static void main(String[]args)
    {
        File f1=new File("file1.txt");
        File f2=new File("c:\\a","file2.txt");
        File p=new File("c:\\b");
        File f3=new File(p,"file3.txt");
        System.out.println(f1);
    }
}

创建和删除文件方法

createNewFile（），创建文件
delete（），删除文件
deleteOnExit（），程序退出时删除文件
mkdir（），创建文件夹，但只能创建一级文件夹
mkdirs（），可以创建多级文件夹

import java.io.*;
class FileDemo1
{
    public static void main(String[]args)throws IOException
    {
        File f1=new File("file1.txt");

        System.out.println(f1.createNewFile());
        System.out.println(f1.delete());
        f1.deleteOnExit();//当程序退出时删除。
    }

}

File对象判断方法
canExecute()，判断该文件能否运行。
exists()，判断文件是否存在。
isDirectory()，判断是不是目录
isFile()，判断是不是文件
isHidden()，判断是不是隐藏文件

File对象获取方法：
getPath（），获取相对路径
getAbsolutePath()，获得绝对路径
getName（），获取文件名字
getParent（），获取绝对路径中的文件父目录，如果此路径名没有指定父目录，则返回null。
length（），获取文件大小
lastModified()，获取文件最后一次修改的时间

renameTo（）重命名文件名。

import java.io.*;
class RenameDemo
{
    public static void main(String []args)throws IOException
    {
        File f1=new File("d:\\java\\test\\mul.java");
        File f2=new File("d:\\java\\test\\rename.java");
        System.out.println(f1.renameTo(f2));
    }

}

file对象文件列表：
获取某目录下文件列表的方法：

import java.io.*;
class FileListDemo
{
    public static void main(String[]args)
    {
        /*File[] fl=f.listRoots();//listRoots 获取系统盘符列表
        for (File s:fl)
        {
            System.out.println(s);
        }

        String[] arr=f.list();//list()获取当前目录下的文件列表
        for (String a:arr)
        {
            System.out.println(a);
        }
        */

        File f=new File("D:\\java\\test");//加一个文件过滤器实现只打印.java后缀名的文件
        FilterDemo fd=new FilterDemo();


        String []arr1=f.list(fd);
        for(String b:arr1)
        {
            System.out.println(b);
        }
    }
}
class FilterDemo implements FilenameFilter
{
    public boolean accept(File dir,String name)
    {
        if(name.endsWith(".java"))
            return true;
        return false;
    }

}

通过递归的方法实现打印某一文件夹里的所有文件，遇到文件夹就继续打印文件夹里的文件

import java.io.*;
class FileListTest
{
    public static void main(String[]args)
    {
        File f=new File("D:\\java\\test");
        showDir(f);
    }
    public static void showDir(File Dir)
    {
        System.out.println(Dir);
        FileFilterDemo ffd=new FileFilterDemo();
        File[]f=Dir.listFiles(ffd);
        for (int x=0;xif(f[x].isDirectory())//当获得的文件是文件夹时，递归运行，如果需要只挑选特定类型的文件，加一个过滤器即可
                showDir(f[x]);
            else{
            System.out.print("  ");
            System.out.println(f[x]);
            }
        }
    }
}
/*
过滤器，可以实现挑选出所有.java文件
class FileFilterDemo implements FilenameFilter
{
    public boolean accept(File dir,String name)
    {
        if(name.endsWith(".java"))
            return true;
        return false;

    }
}
*/

编程：将某个目录下的所有java文件的绝对路径输入到一个文件中

遍历某个目录所有的文件时，一定要记住判断是否有不可访问的文件或者文件夹或者空的文件夹，因为读这些文件时，如果未读取成功或者是读取了控文件夹，就返回null，然后就会造成空指针异常的情况。

import java.io.*;
import java.util.*;
class FilePathDemo
{
    public static void main(String []args)throws IOException
    {
       File file=new File("D:\\");
       ArrayList al=new ArrayList();

       FilePath(file,al);
       ListToFile(al,"javafilelist.txt");      
    }
    public static void FilePath(File dir,List l)//遍历所有文件，判断是否是java文件，是的话添加到集合里面
    {

        File[] f=dir.listFiles();


        for (int x=0;xif(f[x].isDirectory())
                FilePath(f[x],l);
            else
            {
                if(f[x].getName().endsWith(".java"))
                    l.add(f[x]);
            }               
        }

    }
    public static void ListToFile(List l,String name)throws IOException//把集合里的文件的绝对路径写入到文本文档中的方法
    {
        BufferedWriter bw=new BufferedWriter(new FileWriter(name));
        for(File li:l)
        {
            bw.write(li.getAbsolutePath());
            bw.newLine();
        }
        bw.close();
    }
}

Properties简述：
Properties是hashtable的子类，具备map集合的特点，里面存储的键值对都是字符串，所以不需要泛型。

是集合中和IO技术相结合的集合容器。

可以用于键值对形式的配置信息。

Properties存取方法：

import java.util.*;
class PropDemo
{
    public static void main(String[]args)
    {
        setAndGet();
    }
    public static void setAndGet()
    {
        Properties prop=new Properties();
        prop.setProperty("张三","50");//存值
        prop.setProperty("李四","30");
        System.out.println(prop);
        String value=prop.getProperty("张三");//根据键取值
        System.out.println(value);
        Set s=prop.stringPropertyNames();//获得键的集合，通过for循环取值
        for (String a:s)
        {
            System.out.println(a+"::"+prop.getProperty(a));
        }
    }
}

编程：Properties存取配置文件

import java.util.*;
import java.io.*;
class PropDemo1
{
    public static void main(String[]args)throws IOException
    {
        method_1();
    }

    public static void method_1()throws IOException
    {
        FileInputStream fis=new FileInputStream("info.ini");
        FileOutputStream fos=new FileOutputStream("info.ini");
        Properties prop=new Properties();
        prop.load(fis);//加载文件中的配置信息，然后存到properties集合中
        prop.setProperty("王五","100");
        prop.store(fos,"注释");//该方法可以将修改过的信息存储到文件中。
        System.out.println(prop);
    }
    public static void method()throws IOException//自己实现load方法，读取文件中的配置信息，并存储到Properties集合中
    {
        BufferedReader br=new BufferedReader(new FileReader("info.ini"));
        Properties prop=new Properties();
        String s=null;
        while ((s=br.readLine())!=null)
        {
            int num=s.indexOf('=');
            String s1=null,s2=null;
            s1=s.substring(0,num);
            s2=s.substring(num+1,s.length());
            prop.setProperty(s1,s2);
        }
        System.out.println(prop);
    }
}

编程：程序运行五次时就不能再运行，并且提示注册

import java.io.*;
import java.util.*;
class PaySofDemo
{
    public static void main(String[]args)throws IOException
    {
        File f=new File("sof.ini");//将文件进行封装
        if(!f.exists())//判断文件是否存在，不存在就创建
            f.createNewFile();
        FileInputStream fis=new FileInputStream(f);
        Properties prop=new Properties();
        prop.load(fis);//将输出流的键值对读取到集合中
        String s=prop.getProperty("times");
        int count=0;
        if(s!=null)//判断键值对是否存在，存在就取值
        {
            count=Integer.parseInt(s);
            if(count>=5)
            {
                System.out.println("对不起，使用次数已到,请注册");
                return ;
            }
        }
         count++;
        FileOutputStream fos=new FileOutputStream(f);
        prop.setProperty("times",count+"");//将新的值写入
        prop.store(fos,"注释");

    }
}

打印流:
字节打印流PrintStream和字符打印流 PrintWriter

PrintStream：
构造函数可以接受的参数类型：
File对象：File
字符串路径：String
字节输出流：OutputStream

import java.io.*;
class PrintWriterDemo
{
    public static void main(String[]args)throws IOException
    {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out=new PrintWriter(System.out);//可以接收OutputStream的参数
        String line=null;
        while((line=br.readLine())!=null)
        {
            out.println(line);
            out.flush();
        }

    }
}

合并流：
SequenceInputStream
编程将三个文件的内容打印到一个文件中

import java.io.*;
import java.util.*;
class SequenceDemo
{
    public static void main(String[]args)throws IOException
    {
        Vector v=new Vector();//Vector集合可以将元素变为Enum枚举类型
        v.add(new FileInputStream("1.txt"));
        v.add(new FileInputStream("2.txt"));
        v.add(new FileInputStream("3.txt"));
        Enumeration en=v.elements();//将Vector变成枚举集合
        SequenceInputStream sis=new SequenceInputStream(en);//需要接收一个枚举集合
        FileOutputStream f=new FileOutputStream("4.txt");
        int num=0;
        byte[]b=new byte[1024];
        while((num=sis.read(b))!=-1)
        {
            f.write(b,0,num);
        }
    sis.close();
    f.close(); 
    }  

}

编程:切割文件

import java.io.*;
class SplitFileDemo
{
    public static void main(String[]args)throws IOException
    {
        SplitFile();
    }
    public static void SplitFile()throws IOException
    {
        FileInputStream fis=new FileInputStream("d:\\java\\test\\1.mp3");
        FileOutputStream fos=null;
        int len=0;
        byte[]b=new byte[1024*1024];
        int count=1;
        while ((len=fis.read(b))!=-1)//每循环一次，就创建一个新的文件
        {
            fos=new FileOutputStream("d:\\java\\test\\mp3\\"+count+".mp3");
            fos.write(b,0,len);
            count++;
        }
        fis.close();
        fos.close();
    }
}