common-io之Comparator阅读

 

1.  首先我们来查看AbstractFileComparator这个抽象类

 首先我们来看一下IO包里面的Comparator，这个都比较好理解，首先是AbstractFileComparator这个类，他提供了两个接口，可以实现对Array和Collection的sort功能。

 

// 实现了对File数组的排序功能 public File[] sort(File... files) { if (files != null) { Arrays.sort(files, this); } return files; }

  // 实现对collection的排序

public List<File> sort(List<File> files) {
        if (files != null) {
            Collections.sort(files, this);
        }
        return files;
    }

 2. CompositeFileComparator类的实现

   这个类的主要意图是使用里面的delegate file comparator来进行File的排序。首先看一下构造函数：

 

public CompositeFileComparator(Comparator<File>... delegates) {
        if (delegates == null) {
            this.delegates = (Comparator<File>[]) NO_COMPARATORS;//1
        } else {
            this.delegates = (Comparator<File>[]) new Comparator<?>[delegates.length];//2
            System.arraycopy(delegates, 0, this.delegates, 0, delegates.length);
        }
    }

 

在构造函数里面如果delegates是null的话，就设置成空的comparators，负责就直接赋值给delegates属性。

 

 

public CompositeFileComparator(Iterable<Comparator<File>> delegates) {
        if (delegates == null) {
            this.delegates = (Comparator<File>[]) NO_COMPARATORS; //1
        } else {
            List<Comparator<File>> list = new ArrayList<Comparator<File>>();
            for (Comparator<File> comparator : delegates) {
                list.add(comparator);
            }
            this.delegates = (Comparator<File>[]) list.toArray(new Comparator<?>[list.size()]); //2
        }
    }

 

这个也很好理解，就是为空的时候直接赋个空的comparator，负责的话构造一个ArrayList，遍历Iterator，把结果集放到list里面，然后讲list转化成数组。

 

 

 public int compare(File file1, File file2) {
        int result = 0;
        for (Comparator<File> delegate : delegates) {
            result = delegate.compare(file1, file2);
            if (result != 0) {
                break;
            }
        }
        return result;
    }

 

这个函数也就是关键，这个是遍历delegates，并对它们进行一一比较，一旦分出胜负就break掉，并返回。

 

3. DefaultFileComparator类的实现

      这个类故名思意就是使用File的compare方法进行两个File的比较，这个里面需要注意的是里面提供了两个常量的Comparator，一个是ReverseComparator，这个会在后面讲到。

 

/** Singleton default comparator instance */
    public static final Comparator<File> DEFAULT_COMPARATOR = new DefaultFileComparator();

    /** Singleton reverse default comparator instance */
    public static final Comparator<File> DEFAULT_REVERSE = new ReverseComparator(DEFAULT_COMPARATOR);

 

4.  DirectoryFileComparator类的实现

    这个类也比较好理解，就是实现了Directory和File进行比较的函数，看到下面的函数的实现，我们就可以看到它的实现了。

 

 public int compare(File file1, File file2) {
        return (getType(file1) - getType(file2));
    }

    /**
     * Convert type to numeric value.
     *
     * @param file The file
     * @return 1 for directories and 2 for files
     */
    private int getType(File file) {
        if (file.isDirectory()) {
            return 1;
        } else {
            return 2;
        }
    }

 我们可以看出，如果是directory的话是返回1的，如果是file的话是返回2. 就是directory永远小于file，真的不知道这个类在什么时候会用到。

 

4.  ExtensionFileComparator类的实现

     这个类从名称上应该可以看出是用来比较File的extension的，这个很好理解，但是在这里面有一个比较关键的就是比较的时候是case sensitive的还是insensitive的，这个里面在IO里面它实现了一个CaseSensitive这个类来实现的。我们下来分析一下这个类的实现：

       构造函数是可以传递一个IOCase对象，用来标记是Case Sensitive，默认是Case Sensitive的。

 

   public ExtensionFileComparator() {
        this.caseSensitivity = IOCase.SENSITIVE;
    }

   
    public ExtensionFileComparator(IOCase caseSensitivity) {
        this.caseSensitivity = caseSensitivity == null ? IOCase.SENSITIVE : caseSensitivity;
    }

       这下面就是这个类比较关键的地方，就是获得文件的后缀名，然后使用caseSensitivity来比较文件的后缀名的。

 

public int compare(File file1, File file2) {
        String suffix1 = FilenameUtils.getExtension(file1.getName());
        String suffix2 = FilenameUtils.getExtension(file2.getName());
        return caseSensitivity.checkCompareTo(suffix1, suffix2);
    }

 

5.  LastModifiedFileComparator类的实现

 

  这个类也比较好理解，就是用来比较文件的最后修改时间的，然后比较最后修改时间。

 

public int compare(File file1, File file2) {
        long result = file1.lastModified() - file2.lastModified();
        if (result < 0) {
            return -1;
        } else if (result > 0) {
            return 1;
        } else {
            return 0;
        }
    }

 6.  NameFileComparator类的实现

 

   这个类其实也比较好理解，就是对文件名进行比较，凡是牵扯到字符串比较的，都有Case Sensitenvity的问题，所以在这个类的构造函数里面也会传递一个IOCase对象，在compareTo函数获得两个文件的文件名后直接使用文件名进行比较即可。这个代码我就不贴了，特别好理解。

 

 7 .  PathFileComparator类的实现

 

   这个类也比较好理解，就是对file的path进行比较，这个同样也有case sensitivity的问题，所以会在构造函数里面传递一个IOCase对象，在compareTo函数里面分别获取两个文件的path，然后调用IOCase进行比较。

 

 8 .  ReverseComparator类的实现

 

      这个类其实用的比较多，主要是想返回right和left的比较结果，所以在设计上也稍微比较高明一些，就是有一个delegate，然后在compareTo函数里面调用delegate的compareTo函数，不过把参数修改后compareTo（right,left），我想大家应该都明白怎么回事了，代码我就不贴上来了。

 

 

 9 .  SizeFileComparator类的实现

      这个类其实也比较好理解就是比较两个文件的大小，我们知道在Java里面File即可以是一个真实的File，也可以是一个Directory，所以遇到directory的时候我们到底要不要统计它的子元素的大小，所以他在设计的时候就考虑到了，专门设计了一个sumDirectoryContents变量，用来统计是不是计算directory里面文件的大学的总和。我们来具体的看一下代码：

public int compare(File file1, File file2) {
        long size1 = 0;
        if (file1.isDirectory()) {
            size1 = sumDirectoryContents && file1.exists() ? FileUtils.sizeOfDirectory(file1) : 0;
        } else {
            size1 = file1.length();
        }
        long size2 = 0;
        if (file2.isDirectory()) {
            size2 = sumDirectoryContents && file2.exists() ? FileUtils.sizeOfDirectory(file2) : 0;
        } else {
            size2 = file2.length();
        }
        long result = size1 - size2;
        if (result < 0) {
            return -1;
        } else if (result > 0) {
            return 1;
        } else {
            return 0;
        }
    }

首先这个方法是写对了，但是感觉写的有点啰嗦，为什么不抽取出一个函数来呢，在这里写了两次。实现的当然是没有问题了。

到此，我们就讲Commons IO里面的comparator都讲完了，希望对大家有所帮助。