从目录中获得最高的数字文件名（INT） - Java的

Question

给定一个File dir我需要找到的最高的数字文件名（如果有的话）

我的方法：

// get the highest numeric file name(as int) from given directory 
public static final int getHighestNumericFileName(File dir) { 
    int result = -1; 

    for (File f : dir.listFiles()) { 
     String name = f.getName(); 
     name = name.substring(0, name.indexOf('.')); 
     if (StringUtils.isNumeric(name)) { 
      int val = Integer.parseInt(name); 
      if (val > result) 
       result = val; 
     } 
    } 

    return result; 
} 

考虑文件夹中的文件数可能会相当大（300k +），我担心的是与性能有关。

这是一个可以接受的解决方案吗？还有更好的方法吗？

Answer 1

您可以使用Java NIO 7的DirectoryStream使用过滤器，以确保你忽略不是与您相关的文件，通过您的文件中去。

这里是过滤器：

class NumericFilter implements DirectoryStream.Filter<Path> { 

    private static final Pattern PATTERN = Pattern.compile("\\d+|\\d+\\..*"); 

    @Override 
    public boolean accept(Path entry) throws IOException { 
     return PATTERN.matcher(entry.getFileName().toString()).matches(); 
    } 

} 

这里是使用它的代码：

try (DirectoryStream<Path> stream = Files.newDirectoryStream(Paths.get(dir), new NumericFilter())) { 
    for (Path path : stream) { 
     // do what you want 
    } 
} 

这只会经过文件具有完全数字的名字（有或没有任何扩展名）。

---

只是为了记录在案，这里是一个稍微简单的做同样的与Java 8路：

final Pattern pattern = Pattern.compile("\\d+\\..*"); 
try (DirectoryStream<Path> stream = Files.newDirectoryStream(Paths.get(dir), 
     entry -> pattern.matcher(entry.getFileName().toString()).matches())) { 
    for (Path path : stream) { 
     // do what you want 
    } 
} 

Answer 2

我建议你排序文件，并采取第一个条目或最后一个条目。

FileFilter fileFilter = new WildcardFileFilter("\\d+.txt"); 
File[] files = dir.listFiles(fileFilter); 
Arrays.sort(files);//sorts lexicographically 

Answer 3

对于大量的数字，排序它们的最佳方法是使用Heap Sort。例如

int[] yourFiles = {} //Puts all file names in array 
HeapSort.sort(yourFiles); 
result = yourFiles[yourFilens.length-1]; 

堆排序

public class HeapSort 
{ 
    private static int[] a; 
    private static int n; 
    private static int left; 
    private static int right; 
    private static int largest; 


    public static void buildheap(int []a) 
    { 
     n=a.length-1; 
     for(int i=n/2;i>=0;i--) 
     { 
      maxheap(a,i); 
     } 
    } 

    public static void maxheap(int[] a, int i) 
    { 
     left=2*i; 
     right=2*i+1; 
     if(left <= n && a[left] > a[i]) 
     { 
      largest=left; 
     } 
     else 
     { 
      largest=i; 
     } 

     if(right <= n && a[right] > a[largest]) 
     { 
      largest=right; 
     } 

     if(largest!=i) 
     { 
      exchange(i,largest); 
      maxheap(a, largest); 
     } 
    } 

    public static void exchange(int i, int j) 
    { 
     int t=a[i]; 
     a[i]=a[j]; 
     a[j]=t; 
    } 

    public static void sort(int[] a0) 
    { 
     a=a0; 
     buildheap(a); 

     for(int i=n;i>0;i--) 
     { 
      exchange(0, i); 
      n=n-1; 
      maxheap(a, 0); 
     } 
    } 
} 

这方面的一个例子实现将是。

import java.util.Arrays; 
public class Test 
{ 
    public static void main(String[] args) 
    { 
     int[] test = {1,5,6,8,6,41}; 
     HeapSort.sort(test); 
     System.out.println(Arrays.toString(test)); 
    } 
}