黑马程序员——Java基础---File、Properties、序列流

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

File类常见方法：

1：创建。
boolean createNewFile()：在指定目录下创建文件，如果该文件已存在，则不创建。而对操作文件的输出流而言，输出流对象已建立，就会创建文件，如果文件已存在，会覆盖。除非续写。
boolean mkdir()：创建此抽象路径名指定的目录。
boolean mkdirs()：创建多级目录。
2：删除。
boolean delete()：删除此抽象路径名表示的文件或目录。
void deleteOnExit()：在虚拟机退出时删除。
注意：在删除文件夹时，必须保证这个文件夹中没有任何内容，才可以将该文件夹用delete删除。
window的删除动作，是从里往外删。注意：java删除文件不走回收站。要慎用。
3：获取.
long length()：获取文件大小。
String getName()：返回由此抽象路径名表示的文件或目录的名称。
String getPath()：将此抽象路径名转换为一个路径名字符串。
String getAbsolutePath()：返回此抽象路径名的绝对路径名字符串。
String getParent()：返回此抽象路径名父目录的抽象路径名，如果此路径名没有指定父目录，则返回 null。
long lastModified()：返回此抽象路径名表示的文件最后一次被修改的时间。
File.pathSeparator：返回当前系统默认的路径分隔符，windows默认为 “；”。
File.Separator：返回当前系统默认的目录分隔符，windows默认为 “\”。
4：判断：
boolean exists()：判断文件或者文件夹是否存在。
boolean isDirectory()：测试此抽象路径名表示的文件是否是一个目录。
boolean isFile()：测试此抽象路径名表示的文件是否是一个标准文件。
boolean isHidden()：测试此抽象路径名指定的文件是否是一个隐藏文件。
boolean isAbsolute()：测试此抽象路径名是否为绝对路径名。
5：重命名。
boolean renameTo(File dest)：可以实现移动的效果。剪切+重命名。

代码演示

    public static void file_1() throws Exception {

        File f= new File("lizi\\abc\\dd\\ee\\FileDemo.txt");
        System.out.println(f.exists());
        if(f.exists()){
            System.out.println(f.delete());
//删除此抽象路径名表示的文件或目录。如果此路径名表示一个目录，则该目录必须为空才能删除。
            System.out.println(f.getParentFile().delete());         
        }
        if(!(f.exists())){
//返回此抽象路径名父目录的抽象路径名；如果此路径名没有指定父目录，则返回 null
            File f1 = f.getParentFile();
            System.out.println(f1);//lizi\abc\dd\ee

//  返回此抽象路径名的绝对路径名形式。等同于 new File(this.getAbsolutePath())。 
            System.out.println(f.getAbsolutePath());
//          创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。
//          注意，此操作失败时也可能已经成功地创建了一部分必需的父目录。
            System.out.println( f1.mkdirs());
//当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。
            System.out.println(f.createNewFile());
//          在指定目录中创建一个新的空文件，使用给定的前缀和后缀字符串生成其名称
            File.createTempFile("abc",".txt", f1);
        }

        System.out.println(f.exists());

    }

String[] list()：
列出指定目录下的当前的文件和文件夹的名称。包含隐藏文件。
如果调用list方法的File 对象中封装的是一个文件，那么list方法返回数组为null。如果封装的对象不存在也会返回null。只有封装的对象存在并且是文件夹时，这个方法才有效。

递归：就是函数自身调用自身。
什么时候用递归呢？
当一个功能被重复使用，而每一次使用该功能时的参数不确定，都由上次的功能元素结果来确定。
简单说：功能内部又用到该功能，但是传递的参数值不确定。(每次功能参与运算的未知内容不确定)。

递归的注意事项：
1：一定要定义递归的条件。
2：递归的次数不要过多。容易出现 StackOverflowError 栈内存溢出错误。
其实递归就是在栈内存中不断的加载同一个函数。

递归及List演示

package XianChen;

import java.io.File;
import java.io.PrintWriter;
import java.util.*;


public class LiZi {
//  定义输出流
    static PrintWriter ps = null;
    public static void main(String[] args) throws Exception {
//      file_1();
//      定义集合
        ArrayList<String> li = new ArrayList<String>();

        file_2("F:\\workspace",li);
        try{
            ps = new PrintWriter("PrintDemo.txt");
            for(String name:li){
                ps.write(name+"\r\n");
            ps.close();
            }
        }catch(Exception e){}

    }
//  遍历传入的路径，将内容保存在集合中
    public static void file_2(String dir,ArrayList<String> li) {
//      封装 文件对象
        File f = new File(dir);
//      加入集合
        li.add(dir);
//      获取当前目录下的文件列表
        File[] names =f.listFiles();
//      遍历目录
        for(File name: names){
//          判断目录是否是隐藏文件
            if(!(name.isHidden())){
//              判断是否是目录
                if(name.isDirectory())
//                  递归，再次调用自身
                    file_2(name.toString(),li);
                else
//                  将文件存入集合
                    li.add(name.toString());            
            }
        }   
    }

Properties：

一个可以将键值进行持久化存储的对象。
Map–Hashtable的子类。
Map
|–Hashtable
|–Properties：用于属性配置文件，键和值都是字符串类型。
特点：1：可以持久化存储数据。2：键值都是字符串。3：一般用于配置文件。

|– load()：将流中的数据加载进集合。
原理：其实就是将读取流和指定文件相关联，并读取一行数据，因为数据是规则的key=value，所以获取一行后，通过 = 对该行数据进行切割，左边就是键，右边就是值，将键、值存储到properties集合中。
|– store()：写入各个项后，刷新输出流。
|– list()：将集合的键值数据列出到指定的目的地。

SequenceInputStream：

序列流，作用就是将多个读取流合并成一个读取流。实现数据合并。
表示其他输入流的逻辑串联。它从输入流的有序集合开始，并从第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。
这样做，可以更方便的操作多个读取流，其实这个序列流内部会有一个有序的集合容器，用于存储多个读取流对象。
该对象的构造函数参数是枚举，想要获取枚举，需要有Vector集合，但不高效。需用ArrayList，但ArrayList中没有枚举，只有自己去创建枚举对象。
但是方法怎么实现呢？因为枚举操作的是具体集合中的元素，所以无法具体实现，但是枚举和迭代器是功能一样的，所以，可以用迭代替代枚举。

合并原理：多个读取流对应一个输出流。
切割原理：一个读取流对应多个输出流。

import java.io.*;
import java.util.*;
class  SplitFileDemo{
    private static final String CFG = ".properties";
    private static final String SP = ".part";
    public static void main(String[] args) throws IOException{
        File file = new File("c:\\0.bmp");
        File dir = new File("c:\\partfiles");
        meger(dir);
    }
    //数据的合并。
    public static void meger(File dir)throws IOException{
        if(!(dir.exists() && dir.isDirectory()))
            throw new RuntimeException("指定的目录不存在，或者不是正确的目录");
        File[] files = dir.listFiles(new SuffixFilter(CFG));
        if(files.length==0)
            throw new RuntimeException("扩展名.proerpties的文件不存在");
        //获取到配置文件
        File config = files[0];
        //获取配置文件的信息。
        Properties prop = new Properties();
        FileInputStream fis = new FileInputStream(config);
        prop.load(fis);
        String fileName = prop.getProperty("filename");
        int partcount = Integer.parseInt(prop.getProperty("partcount"));
        //--------------------------
        File[] partFiles = dir.listFiles(new SuffixFilter(SP));
        if(partFiles.length!=partcount)
            throw new RuntimeException("缺少碎片文件");
        //---------------------
        ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
        for(int x=0; x<partcount; x++){
            al.add(new FileInputStream(new File(dir,x+SP)));
        }
        Enumeration<FileInputStream> en = Collections.enumeration(al);
        SequenceInputStream sis = new SequenceInputStream(en);
        File file = new File(dir,fileName);
        FileOutputStream fos = new FileOutputStream(file);
        byte[] buf = new byte[1024];
        int len = 0;
        while((len=sis.read(buf))!=-1){
            fos.write(buf,0,len);
        }
        fos.close();
        sis.close();
    }
    //带有配置信息的数据切割。
    public static void splitFile(File file)throws IOException{
        //用一个读取流和文件关联。
        FileInputStream fis = new FileInputStream(file);
        //创建目的地。因为有多个。所以先创建引用。
        FileOutputStream fos = null;
        //指定碎片的位置。
        File dir = new File("c:\\partfiles");
        if(!dir.exists())
            dir.mkdir();
        //碎片文件大小引用。
        File f = null;
        byte[] buf = new byte[1024*1024];
        //因为切割完的文件通常都有规律的。为了简单标记规律使用计数器。
        int count = 0;
        int len = 0;
        while((len=fis.read(buf))!=-1){
            f = new File(dir,(count++)+".part");
            fos = new FileOutputStream(f);
            fos.write(buf,0,len);
            fos.close();
        }
        //碎片文件生成后，还需要定义配置文件记录生成的碎片文件个数。以及被切割文件的名称。
        //定义简单的键值信息，可是用Properties。
        String filename = file.getName();
        Properties prop = new Properties();
        prop.setProperty("filename",filename);
        prop.setProperty("partcount",count+"");
        File config = new File(dir,count+".properties");
        fos = new FileOutputStream(config);
        prop.store(fos,"");
        fos.close();
        fis.close();
    }
}
class SuffixFilter implements FileFilter{
    private String suffix;
    SuffixFilter(String suffix){
        this.suffix  = suffix;
    }
    public boolean accept(File file){
        return  file.getName().endsWith(suffix);
    }
}

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