使用Bi谓词排序数组

Question

我试图获取一个已排序的<代码>文件[] 数组（对其应用了特定的排序条件），并尝试对具有与第一次排序相似的排序结果的不同对象应用额外的排序（例如，文件大小）。

我编写了以下代码，但不起作用：

private static void sameValueHandler(File[] orderedFiles, BiPredicate<File,File> sortingCondition){ 
        for(int i = 0; i < orderedFiles.length - 1; i++){
            int j;
            for (j = i + 1; j < orderedFiles.length ; j++){
                if (!sortingCondition.test(orderedFiles[i],orderedFiles[j])){
                    if (j - i - 1> 1){
                        File[] sameFiles = new File[j - i - 1];
                       System.arraycopy(orderedFiles, i, sameFiles, 0,j - i - 1);
                       sameFiles = MainOrder.defaultOrd(sameFiles); // Calls a method that sorts (files by file.getAbsolutePath())

                       System.arraycopy(sameFiles, 0, orderedFiles, i,j - i - 1);
                   }else{
                       break;
                   }
                }
            }
            i = j;

        }
    }

基本上，所有我试图做的，是检查哪些文件从orderedFiles共享相同的sorting条件从给定的BiPredicate，并排序这些文件与MainOrder.defaultOrd（）排序按file.getAbsoltePath（），所以结果应该是一个排序数组，用给定的BiPredicate进行初始排序（假设File[]orderedFiles已经排序）-然后使用deafaultOrd方法调用共享相同排序条件的文件AGAIN，同时保留具有唯一排序条件结果的原始文件。

例如：

假设我在orderedFiles中有以下文件：

-文件2.txt

-file1.txt

-文件5.txt

-文件6.txt

和file1和file2共享相同的文件大小，但file2.getABSOLTEPath（）. compareTo（file1.getAbSOLTEPath（））

我希望使用数组，以便file2出现在file1之后：

-file1.txt

-文件2.txt

-文件5.txt

-文件6.txt

希望我说得够清楚了。谢谢！

编辑：

还尝试使用冒泡排序，但效果不佳：

 private static void sameValueHandler(File[] orderedFiles, BiPredicate<File,File> sortingCondition){
        //TODO fix.
        int arrLength = orderedFiles.length;
        for(int i = 0; i<arrLength-1; i++){
            for(int j=0; j<arrLength-i-1;j++){
                if(sortingCondition.test(orderedFiles[j],orderedFiles[j+1])){
                    if(orderedFiles[j].getAbsolutePath().compareTo(orderedFiles[j+1].getAbsolutePath()) > 0){
                        File temp = orderedFiles[j];
                        orderedFiles[j] = orderedFiles[j+1];
                        orderedFiles[j+1] = temp;

                    }
                }
            }
        }




Answer 1

您可以使用单一排序来执行此操作。您需要对数组进行如下排序：

    Arrays.sort(orderedFiles,
                Comparator.comparing(File::length)
                        .thenComparing(
                                File::getAbsolutePath));

数组的第二个参数。sort是一个比较器，可以在JavaDocs中阅读。

首先，它按长度排序，如果长度相等，则按路径排序。您可以根据需要链接任意多个方法，然后进行比较。如果文件已在第一个字段上排序，则影响最小。它仍然可以正常工作。或者，您可以按以下方式执行：

     Arrays.sort(orderedFiles,
             Comparator.comparing(File::getAbsolutePath));
                        .

下面是一个it处理一些虚构数据的示例。当您运行它并打印出排序列表时，您可以看到它是如何首先对名称的值进行排序，然后再对名称的长度进行排序的。

        List<Example> data = new ArrayList<>(
                List.of(new Example(20, "watermelon"),
                        new Example(20, "apple"),
                        new Example(20, "peaches"),
                        new Example(10, "grapes"),
                        new Example(100, "house"),
                        new Example(100, "apartment")));
        data.sort(Comparator.comparing(Example::getValue)
                .thenComparing(a -> a.getName().length()));

        data.forEach(System.out::println);



    class Example {
        private int value;
        private String name;

        public Example(int value, String name) {
            this.value = value;
            this.name = name;
        }

        public String getName() {
            return name;
        }

        public int getValue() {
            return value;
        }

        public String toString() {
            return value + " " + name;
        }

Answer 2

首先，您必须了解comparator的工作原理（来自Java文档）：

if file1 > file2, it returns positive number  
if file1 < file2, it returns negative number  
if file1 == file2, it returns 0  

说：

    public static Comparator<File> secondSort = (f1, f2) -> {
        // apply the second sort rules and return -1, 0, 1 based on Comparator returns
        return 0; // -1, 0, 1
    };

    public static Comparator<File> sortIt = (f1, f2) -> {
        // check if files are equals base in your first rule
        boolean filesAreEquals = true;

        if (filesAreEquals) {
            return secondSort.compare(f1, f2);
        }
        return 0;
    };

    private static void sameValueHandler(File[] orderedFiles) 
    {        
        List<File> ordered = Arrays.
                stream(orderedFiles).
                sorted(sortIt::compare).
                collect(Collectors.toList());
    }

它允许您将不同的比较器传递给您的方法并更改元素的排序方式。

Answer 3

匿名用户

您可以使用数组。使用以下比较器排序（T[]，Comparator），首先按文件长度排序，然后按文件路径排序（如果文件长度相等）：

File[] files = ...;
Arrays.sort(files, new Comparator<File>() {
    @Override
    public int compare(File f1, File f2) {
        int result = Long.compare(f1.length(), f2.length());
        if(result == 0) {
            result = f1.getAbsolutePath().compareTo(f2.getAbsolutePath());
        }
        return result;
    }
});