如何按自定義順序對值進行排序

Question

伙計們，我有最終的值字符串，我將這些值與 DB 中的值匹配。 匹配后，我希望字符串以特定順序出現，如何自定義此排序過程或是否有任何其他方法可以實現此目的。 有關更多信息，請查看下面的代碼。 感謝您的幫助。

 public static final String FRUITS ="Mango|Banana|Pear|Orange"; //want to maintain this order List<String> retriveFruits= getFruitsDAO.fruitsList(); //this gets fruits from DB List<String> afterSortList= new ArrayList<String>(); for(String names: retriveFruits){ if(names.getKeyValue().matches(FRUITS)){ afterSortList.add(names.getKeyValue()); } }

所以排序名稱后應保持 Fruits ="Mango,Banana,Pear,Orange" 的順序； 我如何實現這一目標

Answer 1

假設"Mango|Banana|Pear|Orange"固定的，我會“像那樣”：

import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.TreeSet;

public class Test {

    public static void main(String[] args) {
        System.out.println(sortIndiv());
    }
    // choose "richer" datastructure: fruit name as key, sort order as value:
    public static final Map<String, Integer> VALID_FRUITS = Map.of(
      "Mango", 0, 
      "Banana", 1,
      "Pear", 2,
      "Orange", 3);//want to maintain this order
    // Map.of(k,v,k,v,...) -> java >= 9

    // a "more generalized" result type: Collection<String>
    public static Collection<String> sortIndiv() {
        List<String> retriveFruits = Arrays.asList(
                new String[]{"Pear",
                    "Apple", "Banana", "Orange", "Mango", "Papaya"}
        ); // fix values for test purpose, otherwise ... dao.fruitList ...

        //here "the magic"...
        //A (self-sorting) TreeSet with a custom comparator
        //..using VALID_FRUITS:
        Collection<String> result = new TreeSet<>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return VALID_FRUITS.get(o1).compareTo(VALID_FRUITS.get(o2)); // == FRUITS.get(o1) - FRUITS.get(o2);
            }
        });

        // iterate: O(n)
        for (String fruit : retriveFruits) {
            // filter valids:
            if (VALID_FRUITS.containsKey(fruit)) {
                // add to result O(log(n))!
                result.add(fruit);
            }
            //so after sorting names should maintian the order final String Fruits ="Mango|Banana|Pear|Orange"; how do I achieve this
        }
        //done!
        return result;
    }
}

輸出：

[Mango, Banana, Pear, Orange]

---

如果Collection不是可接受的返回/結果類型（尤其是當結果包含/應該包含重復項時， TreeSet方法是不可接受的），那么ArrayList和sort()可以相對高效地完成工作（並允許重復項）：

import java.util.*;

public class Test {

    public static void main(String[] args) {

        List<String> retriveFruits = Arrays.asList(
                new String[]{"Pear",
                    "Apple", "Banana", "Orange", "Mango", "Papaya", "Mango", "Mango"}
        ); // dao.fruitList ...
        System.out.println(sortIndivSortedSet(retriveFruits));
        System.out.println(sortIndivQuickSort(retriveFruits));
    }
    public static final Map<String, Integer> VALID_FRUITS = Map.of("Mango", 0, "Banana", 1, "Pear", 2, "Orange", 3);
    //want to maintain this order

    private static Comparator<String> customComparator() {
        return new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return VALID_FRUITS.get(o1).compareTo(VALID_FRUITS.get(o2)); // == FRUITS.get(o1) - FRUITS.get(o2);
            }
        };
    }

    public static Collection<String> sortIndivSortedSet(List<String> retriveFruits) {
        Collection<String> result = new TreeSet<>(customComparator());
        for (String fruit : retriveFruits) {
            if (VALID_FRUITS.containsKey(fruit)) {
                result.add(fruit);
            }
        }
        return result;
    }

    public static List<String> sortIndivQuickSort(List<String> retriveFruits) {
       List<String> result = new ArrayList<>(retriveFruits.size());

       // O(n) 
        for (String fruit : retriveFruits) {
            if (VALID_FRUITS.containsKey(fruit)) {
                // x
                // O(1)
                result.add(fruit);
            }
        }
        // +
        // O(n log(n))
        result.sort(customComparator());
        return result;
    }
}

輸出：

[Mango, Banana, Pear, Orange]
[Mango, Mango, Mango, Banana, Pear, Orange]

Answer 2

一些簡單的方法：首先，您只需要一個比較器來定義您的訂單：

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class DefinedComparator implements Comparator<String> {
    List<String> definedOrder = // define your custom order
            Arrays.asList("Mango", "Banana", "Pear", "Orange");

    public int compare(String s1, String s2) {
        return Integer.valueOf(definedOrder.indexOf(s1)).compareTo(Integer.valueOf(definedOrder.indexOf(s2)));

    }
}

假設您有一個列表：

List<String> afterSortLIst= new ArrayList<String>();
        afterSortLIst.add("Orange");
        afterSortLIst.add("Mango");
        afterSortLIst.add("Banana");
        afterSortLIst.add("Pear");

以及帶有比較器的列表：

Collections.sort(afterSortLIst, new DefinedComparator());

輸出將是：

[Mango, Banana, Pear, Orange]

Answer 3

如果用List offruits替換正則表達式，可以按如下方式進行

public static final List<String> FRUITS = Arrays.asList("Mango", "Banana", "Pear", "Orange");

List<String> retriveFruits= getFruitsDAO.fruitsList();
List<String> afterSortList= new ArrayList<String>();

for(String names: retriveFruits){

    if(fruits.contains(names.getKeyValue())){
      afterSortList.add(names.getKeyValue());
    }
}

afterSortList.sort(Comparator.comparingInt(FRUITS::indexOf));

從如何根據另一個列表對列表進行排序

比較器將元素轉換為 List 索引，並基本上執行一種數字0, 1, 2, 3 。 正如我們所知道Comparator.compare(a, b)需要返回0為相等的元素，如果負a < b和正如果a > b ，因此：

"Pear" "Pear"    -> compare(2, 2) = 0
"Banana" "Mango" -> compare(1, 0) = 1
"Pear" "Orange"  -> compare(2, 3) = -1

---

從 xerx593 的回答中可以看出，可以使用不同類型的集合來實現算法，例如TreeSet在添加時執行排序，如果不需要重復，以及Map<String, Integer>執行查找此處使用List.indexOf()完成的索引。

鏈接問題中討論了（理論）性能特征，但這是速記版本。 如果性能是實際測量的問題，則需要在數據庫中完成過濾和排序，這正是為過濾和排序（除其他外）目的而設計的。

Answer 4

你只需要在java中使用sort()函數。 第一次導入：

import java.util.Arrays; 

然后簡單地做：

Arrays.sort(afterSortLIst);