文件类功能 与 排序类功能 汇总总结

依照一定的规则处理指定目录下文件。

1. 获取指定目录下所有文件。  参见： http://blog.csdn.net/lj_pyt/article/details/44830761

public class java.io.File   implements Serializable, Comparable<File>  主要涉及了文件与文件夹路径操作。

String[]  list(FilenameFilter filter)

FilenameFilter filter是一个目录过滤器。list(FilenameFilter filter)方法会选择符合条件的文件或文件夹。

 <span style="font-size:12px;">public String[] list(FilenameFilter filter) {
	String names[] = list();  //首先还是调用list()方法，获取指定目录下的全部文件（夹）名字
	if ((names == null) || (filter == null)) { filter == null说明没有过滤条件
	   return names;
	}
	ArrayList v = new ArrayList();
	for (int i = 0 ; i < names.length ; i++) { //遍历names[]数组中的所有文件（夹）名字
	    if (filter.accept(this, names[i])) {   //如果accept()方法返回真，则添加到ArrayList中
		v.add(names[i]);
	    }
	}
	return (String[])(v.toArray(new String[v.size()])); //将ArrayList转换成String[]类型返回
 }

</span>

<span style="font-size:12px;"> public File[] listFiles(FilenameFilter filter) {
	String ss[] = list();
	if (ss == null) return null;
	ArrayList v = new ArrayList();
	for (int i = 0 ; i < ss.length ; i++) {
	    if ((filter == null) || filter.accept(this, ss[i])) {
		v.add(new File(ss[i], this));
	    }
	}
	return (File[])(v.toArray(new File[v.size()]));
 }</span>

list()和listFiles()方法的区别在于：

list()返回的是一个String类型数组，它只是一个数组，仅仅只是一个文件（文件夹）的名字而已；
而listFiles()方法返回的是一个File类的引用，它具有类的所有属性和方法。

    使用FileNameFilter匿名类 完成目录下文件选择。

private File GetOneFile(String logDir2) {        
// TODO Auto-generated method stub            
    File dir = new File(logDir2);      
    if( dir != null && dir.isDirectory()){ 
           /*。*/
           String[] sfs = dir.list(new FilenameFilter(){ 
               public boolean accept(File dir, String name) {
              // TODO Auto-generated method stub 
                   return name.endsWith(".log");
               }                            
           });
           return sfs[0];
    }

}

2.对目录下文件进行排序，返回“符合条件”的。

Java中有一个Arrays类，专门用来操作array。（注意Arrays 与Array的不同）
Arrays中拥有一组static函数，

• equals()：比较两个array是否相等。array拥有相同元素个数，且所有对应元素两两相等。
• fill()：将值填入array中。
• sort()：用来对array进行排序。
• binarySearch()：在排好序的array中寻找元素。
• System.arraycopy()：array的复制。

Collections是针对集合类的一个帮助类。提供了一系列静态方法实现对各种集合的搜索、排序、线程完全化等操作。
相当于对Array进行类似操作的类——Arrays。
如，Collections.max(Collection coll); 取coll中最大的元素。       Collections.sort(List list); 对list中元素排序.

排序方法：

2.1 数组排序(Arrays.sort)

• 数字排序 

int[] intArray = new int[] { 4, 1, 3, -23 };

Arrays.sort(intArray); 　　输出： [-23, 1, 3, 4]

• 字符串排序，先大写后小写
  

          String[] strArray = new String[] { "z", "a", "C" };

　　    Arrays.sort(strArray);   　　输出： [C, a, z]

• 严格按字母表顺序排序，也就是忽略大小写排序 Case-insensitive sort
  

          String[] strArray = new String[] { "z", "a", "C" };

　　    Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);　　输出： [a, C, z]

• 反向排序， Reverse-order sort
  

          String[] strArray = new String[] { "z", "a", "C" };

　　    Arrays.sort(strArray, Collections.reverseOrder());　　                输出：[z, a, C]     

• 忽略大小写反向排序 Case-insensitive reverse-order sort
  

          String[] strArray = new String[] { "z", "a", "C" };

　　    Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);

    　　Collections.reverse(Arrays.asList(strArray));                                  输出： [z, C, a]

2.2  list排序  http://www.cnblogs.com/huangfox/archive/2012/07/05/2577306.html

list排序可以直接采用Collections的sort方法，也可以使用Arrays的sort方法，归根结底Collections就是调用Arrays的sort方法。

public static <T> void sort(List<T> list, Comparator<? super T> c) {
    Object[] a = list.toArray();
    Arrays.sort(a, (Comparator)c);
    ListIterator i = list.listIterator();
    for (int j=0; j<a.length; j++) {
        i.next();
        i.set(a[j]);
    }
 }

如果是自定义对象，一种是实现Comparable接口使得对象自身就有“比较”的功能，另外一种是外部使用Comparator来规定其排序。

重写compare

List<User> us = new LinkedList<User>();

Collections.sort(us, new Comparator<User>() {
   @Override
   public int compare(User o1, User o2) {
       if (o1.getAge() < o2.getAge())
           return -1;
        else if (o1.getAge() > o2.getAge())
            return 1;
        else
            return o1.getName().compareTo(o2.getName());
   }
});

实现接口：

public class ComparatorUser implements Comparator{

 public int compare(Object arg0, Object arg1) {
  User user0=(User)arg0;
  User user1=(User)arg1;
   //首先比较年龄，如果年龄相同，则比较名字
  int flag=user0.getAge().compareTo(user1.getAge());
  if(flag==0){
   return user0.getName().compareTo(user1.getName());
  }else{
   return flag;
  }  
 }
}
XXXX
{
  List userlist=new ArrayList();

  ComparatorUser comparator=new ComparatorUser();
  Collections.sort(userlist, comparator);
} 

2.3 set排序

set包括HashSet和TreeSet，HashSet是基于HashMap的，TreeSet是基于TreeMap的。

HashSet是基于Hash算法实现的，其性能通常优于TreeSet。我们通常都应该使用HashSet。

TreeMap是用红黑树实现，天然就具有排序功能，“天然就具有排序功能”是指它拥有升序、降序的迭代器。

那么HashSet怎么排序呢？我们可以将HashSet转成List，然后用List进行排序。

 Set<User> us = new HashSet<User>();
 us.add(new User("f5", 12));

  us.add( new User( "f2" , 22 ));

  us.add( new User( "f3" , 2 ));

  // set -> array

  List<User> list = new ArrayList<User>(us);

  Collections.sort(list);  //也可以将HashSet转换成数组用Arrays排序。


如果我们自己定义的一个类的对象要加入到TreeSet当中，那么这个类必须要实现Comparable接口。


那么在使用TreeSet对加入到其中的元素进行排序的时候可以传入一个比较器吗

   
   

    
        
    
    public
    
     TreeSet(Comparator
    
    <?
    
     
    
    super
    
     E
    
    >
    
     comparator) {
        
    
    this
    
    (
    
    new
    
     TreeMap
    
    <
    
    E,Object
    
    >
    
    (comparator));
    }
   
   

通过查看它的构造方法就知道可以传入一个比较器。

2.4 map排序

map包括HashMap和TreeMap，上面已经提过，TreeMap用红黑树实现，天然具有排序功能。

那么HashMap怎么按“key”排序呢？方法很简单，用HashMap来构造一个TreeMap。

Map<String, Integer> us = new HashMap<String, Integer>();

  us.put( "f1" , 12 );

  us.put( "f2" , 13 );

  us.put( "f5" , 22 );
 System.out.println(new TreeMap<String, Integer>(us));



// 按照value排序

  Set<Entry<String, Integer>> ks = us.entrySet();

  List<Entry<String, Integer>> list = new ArrayList<Map.Entry<String, Integer>>( ks);

  Collections.sort(list, new Comparator<Entry<String, Integer>>() {

     @Override

     public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) {

        if (o1.getValue() < o2.getValue())

            return - 1 ;

        else if (o1.getValue() > o2.getValue())

            return 1 ;

        return 0 ;

     }


  });

  System.out.println(list);

将map的Entry提出成set结构，然后将set转成list，最后按照list进行排序。

本例中的是实现：

String[] sfs = dir.list(new FilenameFilter(){
         public boolean accept(File dir, String name) {
	     // TODO Auto-generated method stub
	     return name.endsWith(".log");
	}				
});
if (sfs.length > 0){
    Arrays.sort(sfs, String.CASE_INSENSITIVE_ORDER);
     //java.util.List<String> filenames = Arrays.asList(sfs);
    return new File(logDir2+"/"+sfs[0]);
}

--------------------------------------------