我在一个文件夹中有一组文件，除了一个文件外，所有文件都以类似名称开头。这是一个例子：
Coordinate.txt
Spectrum_1.txt
Spectrum_2.txt
Spectrum_3.txt
.
.
.
Spectrum_11235
我能够列出指定文件夹中的所有文件，但列表不是频谱号的升序。示例：执行程序时，我得到以下结果：
Spectrum_999.txt
Spectrum_9990.txt
Spectrum_9991.txt
Spectrum_9992.txt
Spectrum_9993.txt
Spectrum_9994.txt
Spectrum_9995.txt
Spectrum_9996.txt
Spectrum_9997.txt
Spectrum_9998.txt
Spectrum_9999.txt
但这个顺序不正确。 Spectrum_999.txt之后应该有Spectrum_1000.txt文件。有人可以帮忙吗？这是代码：
import java.io.*;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;
public class FileInput {
public void userInput()
{
Scanner scanner = new Scanner( System.in );
System.out.println("Enter the file path: ");
String dirPath = scanner.nextLine(); // Takes the directory path as the user input
File folder = new File(dirPath);
if(folder.isDirectory())
{
File[] fileList = folder.listFiles();
Arrays.sort(fileList);
System.out.println("\nTotal number of items present in the directory: " + fileList.length );
// Lists only files since we have applied file filter
for(File file:fileList)
{
System.out.println(file.getName());
}
// Creating a filter to return only files.
FileFilter fileFilter = new FileFilter()
{
@Override
public boolean accept(File file) {
return !file.isDirectory();
}
};
fileList = folder.listFiles(fileFilter);
// Sort files by name
Arrays.sort(fileList, new Comparator()
{
@Override
public int compare(Object f1, Object f2) {
return ((File) f1).getName().compareTo(((File) f2).getName());
}
});
//Prints the files in file name ascending order
for(File file:fileList)
{
System.out.println(file.getName());
}
}
}
}
答案 0 :(得分：29)
您要求的是数字排序。您需要实现Comparator并将其传递给Arrays#sort方法。在比较方法中，您需要从每个文件名中提取数字，然后比较数字。
您现在获得输出的原因是排序发生alphanumerically
这是一种非常基本的方式。此代码使用简单的String - 操作来提取数字。如果您知道文件名的格式，则可以使用Spectrum_<number>.txt。更好的提取方法是使用regular expression。
public class FileNameNumericSort {
private final static File[] files = {
new File("Spectrum_1.txt"),
new File("Spectrum_14.txt"),
new File("Spectrum_2.txt"),
new File("Spectrum_7.txt"),
new File("Spectrum_1000.txt"),
new File("Spectrum_999.txt"),
new File("Spectrum_9990.txt"),
new File("Spectrum_9991.txt"),
};
@Test
public void sortByNumber() {
Arrays.sort(files, new Comparator<File>() {
@Override
public int compare(File o1, File o2) {
int n1 = extractNumber(o1.getName());
int n2 = extractNumber(o2.getName());
return n1 - n2;
}
private int extractNumber(String name) {
int i = 0;
try {
int s = name.indexOf('_')+1;
int e = name.lastIndexOf('.');
String number = name.substring(s, e);
i = Integer.parseInt(number);
} catch(Exception e) {
i = 0; // if filename does not match the format
// then default to 0
}
return i;
}
});
for(File f : files) {
System.out.println(f.getName());
}
}
}
<强>输出
Spectrum_1.txt
Spectrum_2.txt
Spectrum_7.txt
Spectrum_14.txt
Spectrum_999.txt
Spectrum_1000.txt
Spectrum_9990.txt
Spectrum_9991.txt
答案 1 :(得分：3)
Commons IO库中可用的NameFileComparator类，具有按名称，最后修改日期，大小等等对文件数组进行排序的功能。文件可以按升序和降序排序，区分大小写或不区分大小写
导入：
org.apache.commons.io.comparator.NameFileComparator
代码：
File directory = new File(".");
File[] files = directory.listFiles();
Arrays.sort(files, NameFileComparator.NAME_COMPARATOR)
答案 2 :(得分：3)
currently accepted answer仅对始终称为相同名称的文件的数字后缀（即忽略前缀）执行此操作。
A much more generic solution, which I blogged about here，适用于任何文件名，在段中拆分名称并以数字方式对段进行排序（如果两个段都是数字）或按字典顺序排序，否则。 Idea inspired from this answer：
public final class FilenameComparator implements Comparator<String> {
private static final Pattern NUMBERS =
Pattern.compile("(?<=\\D)(?=\\d)|(?<=\\d)(?=\\D)");
@Override public final int compare(String o1, String o2) {
// Optional "NULLS LAST" semantics:
if (o1 == null || o2 == null)
return o1 == null ? o2 == null ? 0 : -1 : 1;
// Splitting both input strings by the above patterns
String[] split1 = NUMBERS.split(o1);
String[] split2 = NUMBERS.split(o2);
for (int i = 0; i < Math.min(split1.length, split2.length); i++) {
char c1 = split1[i].charAt(0);
char c2 = split2[i].charAt(0);
int cmp = 0;
// If both segments start with a digit, sort them numerically using
// BigInteger to stay safe
if (c1 >= '0' && c1 <= '9' && c2 >= 0 && c2 <= '9')
cmp = new BigInteger(split1[i]).compareTo(new BigInteger(split2[i]));
// If we haven't sorted numerically before, or if numeric sorting yielded
// equality (e.g 007 and 7) then sort lexicographically
if (cmp == 0)
cmp = split1[i].compareTo(split2[i]);
// Abort once some prefix has unequal ordering
if (cmp != 0)
return cmp;
}
// If we reach this, then both strings have equally ordered prefixes, but
// maybe one string is longer than the other (i.e. has more segments)
return split1.length - split2.length;
}
}
这也可以处理带有颠覆的版本，例如：像version-1.2.3.txt
答案 3 :(得分：2)
您可以在上面的评论中找到问题的解决方案，但考虑到只发布了链接，我正在从该网站提供代码。工作得很好。
您需要创建自己的字母数字比较器。
import java.io.File;
import java.util.Comparator;
public class AlphanumFileComparator implements Comparator
{
private final boolean isDigit(char ch)
{
return ch >= 48 && ch <= 57;
}
private final String getChunk(String s, int slength, int marker)
{
StringBuilder chunk = new StringBuilder();
char c = s.charAt(marker);
chunk.append(c);
marker++;
if (isDigit(c))
{
while (marker < slength)
{
c = s.charAt(marker);
if (!isDigit(c))
break;
chunk.append(c);
marker++;
}
} else
{
while (marker < slength)
{
c = s.charAt(marker);
if (isDigit(c))
break;
chunk.append(c);
marker++;
}
}
return chunk.toString();
}
public int compare(Object o1, Object o2)
{
if (!(o1 instanceof File) || !(o2 instanceof File))
{
return 0;
}
File f1 = (File)o1;
File f2 = (File)o2;
String s1 = f1.getName();
String s2 = f2.getName();
int thisMarker = 0;
int thatMarker = 0;
int s1Length = s1.length();
int s2Length = s2.length();
while (thisMarker < s1Length && thatMarker < s2Length)
{
String thisChunk = getChunk(s1, s1Length, thisMarker);
thisMarker += thisChunk.length();
String thatChunk = getChunk(s2, s2Length, thatMarker);
thatMarker += thatChunk.length();
/** If both chunks contain numeric characters, sort them numerically **/
int result = 0;
if (isDigit(thisChunk.charAt(0)) && isDigit(thatChunk.charAt(0)))
{
// Simple chunk comparison by length.
int thisChunkLength = thisChunk.length();
result = thisChunkLength - thatChunk.length();
// If equal, the first different number counts
if (result == 0)
{
for (int i = 0; i < thisChunkLength; i++)
{
result = thisChunk.charAt(i) - thatChunk.charAt(i);
if (result != 0)
{
return result;
}
}
}
} else
{
result = thisChunk.compareTo(thatChunk);
}
if (result != 0)
return result;
}
return s1Length - s2Length;
}
}
<强> 2。根据此课程对文件进行排序。
File[] listOfFiles = rootFolder.listFiles();
Arrays.sort(listOfFiles, new AlphanumFileComparator() );
...to sth with your files.
希望它有所帮助。它对我有用，就像一个魅力。
解决方案来自：http://www.davekoelle.com/files/AlphanumComparator.java here
答案 4 :(得分：2)
只需使用：
升序：Collections.sort（列表）
用于降序：Collections.sort（List，Collections.reverseOrder（））
答案 5 :(得分：1)
Arrays.sort(fileList, new Comparator()
{
@Override
public int compare(Object f1, Object f2) {
String fileName1 = ((File) f1).getName();
String fileName2 = ((File) f1).getName();
int fileId1 = Integer.parseInt(fileName1.split("_")[1]);
int fileId2 = Integer.parseInt(fileName2.split("_")[1]);
return fileId1 - fileId2;
}
});
确保处理名称
中没有_的文件答案 6 :(得分：0)
发现here是由Ivan Gerasimiv最佳实现的智能AlphaDecimal比较器。它被提议作为标准JDK比较器here的扩展，并在线程here中进行了讨论。
不幸的是，据我所知，此更改仍未进入JDK。但是您可以使用第一个链接中的代码作为解决方案。对我来说，它就像一种魅力。
答案 7 :(得分：0)
我的 kotlin 版本算法。该算法用于按名称对文件和目录进行排序。
import kotlin.Comparator
const val DIFF_OF_CASES = 'a' - 'A'
/** File name comparator. */
class FileNameComparator(private val caseSensitive: Boolean = false) : Comparator<String> {
override fun compare(left: String, right: String): Int {
val csLeft = left.toCharArray()
val csRight = right.toCharArray()
var isNumberRegion = false
var diff = 0; var i = 0; var j = 0
val lenLeft = csLeft.size; val lenRight = csRight.size
while (i < lenLeft && j < lenRight) {
val cLeft = getCharByCaseSensitive(csLeft[i])
val cRight = getCharByCaseSensitive(csRight[j])
val isNumericLeft = cLeft in '0'..'9'
val isNumericRight = cRight in '0'..'9'
if (isNumericLeft && isNumericRight) {
// Number start!
if (!isNumberRegion) {
isNumberRegion = true
// Remove prefix '0'
while (i < lenLeft && cLeft == '0') i++
while (j < lenRight && cRight == '0') j++
if (i == lenLeft || j == lenRight) break
}
// Diff start: calculate the diff value.
if (cLeft != cRight && diff == 0) diff = cLeft - cRight
} else {
if (isNumericLeft != isNumericRight) {
// One numeric and one char: the longer one is backwards.
return if (isNumberRegion) { if (isNumericLeft) 1 else -1 } else cLeft - cRight
} else {
// Two chars: if (number) diff don't equal 0, return it (two number have same length).
if (diff != 0) return diff
// Calculate chars diff.
diff = cLeft - cRight
if (diff != 0) return diff
// Reset!
isNumberRegion = false
diff = 0
}
}
i++; j++
}
if (i == lenLeft) i--
if (j == lenRight) j--
return csLeft[i] - csRight[j]
}
private fun getCharByCaseSensitive(c: Char): Char
= if (caseSensitive) c else if (c in 'A'..'Z') (c + DIFF_OF_CASES) else c
}
例如，对于输入，
"A__01__02",
"A__2__02",
"A__1__23",
"A__11__23",
"A__3++++",
"B__1__02",
"B__22_13",
"1_22_2222",
"12_222_222",
"2222222222",
"1.sadasdsadsa",
"11.asdasdasdasdasd",
"2.sadsadasdsad",
"22.sadasdasdsadsa",
"3.asdasdsadsadsa",
"adsadsadsasd1",
"adsadsadsasd10",
"adsadsadsasd3",
"adsadsadsasd02"
它会将它们排序为，
1.sadasdsadsa 1_22_2222 2.sadsadasdsad 3.asdasdsadsadsa 11.asdasdasdasdasd 12_222_222 22.sadasdasdsadsa 2222222222 A__01__02 A__1__23 A__2__02 A__3++++ A__11__23 adsadsadsasd02 adsadsadsasd1 adsadsadsasd3 adsadsadsasd10 B__1__02 B__22_13
答案 8 :(得分：-1)
您可以使用Collections.sort(fileList);对arraylist进行排序。
然后使用
for(File file:fileList)
System.out.println(file.getName());
答案 9 :(得分：-1)
只是另一种方法，但使用java8的力量
List<Path> x = Files.list(Paths.get("C:\\myPath\\Tools"))
.filter(p -> Files.exists(p))
.map(s -> s.getFileName())
.sorted()
.collect(Collectors.toList());
x.forEach(System.out::println);