0

有一个字符串列表，每个字符串都有 4 组值，它们将根据这些值进行排序。
1. 序列号
2. 状态示例：应按顺序排列（“cooked”、“boiled”、“fresh”、“raw”）
3. 日期（完整 ISO-8601 日期）
4. 按字母顺序

我首先想按序列号对列表进行排序。然后，如果两个或多个值具有相同的序列号，我想按已经定义的字符串顺序（STATE HERE）对它们进行排序。现在按日期和时间对状态的每个重复类别进行排序。现在按字母顺序对每个重复的日期/时间进行排序。

所以基本上需要4级排序。
我首先是这样排序的。我不确定如何前进。 

    List<String> allStrings= new ArrayList<String>();
        List<String> rankList= new ArrayList<String>();
        List<String> stateList= new ArrayList<String>();
        List<String> dateList= new ArrayList<String>();

        List<String> rankListCopy = new ArrayList<String>(rankList.size());
        rankListCopy.addAll(rankList); 
        Collections.sort(rankListCopy,Collections.reverseOrder()); 
         for(String el: rankListCopy) {
                        System.out.println(el);
                        }
         if(rankList.equals(rankListCopy)) {
System.out.println("CARDS ARE ARRANGED IN serial ORDER");
}
else{
System.out.println("CARDS ARE NOT ARRANGED IN serial ORDER");                    }

例子： 

        String  rank  state  date                   alphabetically    
        Europe    2    raw    2019-06-12T09:00:00Z
        India     5    raw    2018-06-12T09:00:00Z
        new york  5    boiled 2020-07-12T09:00:00Z
        US        0    cooked 2020-06-12T09:00:00Z
        china     0    cooked 2020-06-12T09:00:00Z

输出： 

        Europe
        newyork
        india
        china
        US
4

1 回答 1

-1

我不确定这是否是您需要的。但是，如果您可以将您尝试排序的那个东西表示为具有属性的对象的集合，那么您可以做类似的事情。您可以在 Comparator 中编写所需的比较逻辑，或者使您的类 Comparable 并覆盖 compareTo() 方法。无论如何，这里有一个 Comparator 的命题。使用了一个小技巧，即枚举自然顺序是定义枚举元素的顺序。在您的情况下，枚举字段应按以下顺序排列： ("cooked","boiled","fresh","raw")

public class Main {

    public static void main(String[] args) {

        DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm'Z'");
        String dateAsString = df.format(new Date());

        List<String> allStrings = Arrays.asList("Europe", "India", "New York", "US", "China");
        List<String> rankList = Arrays.asList("2", "5", "5", "0", "0");
        List<String> stateList = Arrays.asList("RAW", "RAW", "BOILED", "COOKED", "COOKED");
        List<String> dateList = Arrays.asList(dateAsString, dateAsString, dateAsString, dateAsString, dateAsString);

        List<YourSortableEntity> inputData = new ArrayList<>();
        for(int i =0; i < allStrings.size(); i++) {
            try {
                Date date = df.parse(dateList.get(i));
                inputData.add(new YourSortableEntity(
                        allStrings.get(i),
                        Integer.valueOf(rankList.get(i)),
                        State.valueOf(stateList.get(i)),
                        date
                ));
            } catch (ParseException e) {
                throw new RuntimeException("Could not parse string into date: " + dateList.get(i), e);
            }

        }

        Comparator<YourSortableEntity> comparator = Comparator.comparing(it -> it.getString());
        comparator = comparator.thenComparing(it -> it.getRank()).thenComparing(it -> it.getState()).thenComparing(it -> it.getDate());

        TreeSet<YourSortableEntity> treeSet = new TreeSet<>(comparator);
        treeSet.addAll(inputData);

        System.out.println(treeSet);
    }

    public static class YourSortableEntity {
        private final String string;
        private final int rank;
        private final State state;
        private final Date date;

        public YourSortableEntity(String string, int rank, State state, Date date) {
            this.string = string;
            this.rank = rank;
            this.state = state;
            this.date = date;
        }

        public String getString() {
            return string;
        }

        public int getRank() {
            return rank;
        }

        public State getState() {
            return state;
        }

        public Date getDate() {
            return date;
        }

        @Override
        public String toString() {
            return string;
        }
    }

    public enum State {
        COOKED,
        BOILED,
        FRESH,
        RAW
    }

}
于 2019-09-04T12:13:05.380 回答