如何根據單詞的最后一個字母按字母順序對列表進行排序？

Question

所以我有這個列表等級：[exA，exB，exC，inA，inB，inC，orA，orB，orC]。 我想按字母順序按索引中的最后一個元素對該列表進行排序。 我希望它看起來像 [exA,inA,orA,exB,inB,orB,exC,inC,orC]。 這是我嘗試過的。 我需要它按字母順序排列，這樣我才能找到最好的主題。 那么我只能說列表中的第一個元素是一個主題中的最佳表現。 如果我有重復，我會從那些我得 A 的科目中隨機選擇一個科目。

private List <String> bestSubjectsList = new ArrayList <>();
private List <String> bestDuplicateGrades = new ArrayList <>();

private String bestSubjectId;
private String bestSubjectCode;



public void setBestSubject(List <String> grades) {
        bestSubjectsList.clear();
        bestDuplicateGrades.clear();
        bestSubjectId = "";
        bestSubjectCode = "NO BEST!";
        
    if (!grades.isEmpty()) {
        for (int i = 0; i < grades.size(); i++) {
            if (grades.get(i).contains("A")) {
                bestSubjectsList.add(grades.get(i));
                bestDuplicateGrades.add("A");
            }
            else if (!bestSubjectsList.contains("A") && grades.get(i).contains("B")) {
                bestSubjectsList.add(grades.get(i));
                bestDuplicateGrades.add("B");
            }
            else if (!bestSubjectsList.contains("B") && grades.get(i).contains("C")) {
                bestSubjectsList.add(grades.get(i));
                bestDuplicateGrades.add("C");
            }
            else if (!bestSubjectsList.contains("C") && grades.get(i).contains("D")) {
                bestSubjectsList.add(grades.get(i));
                bestDuplicateGrades.add("D");
            }
            else if (!bestSubjectsList.contains("D") && grades.get(i).contains("E")) {
                bestSubjectsList.add(grades.get(i));
                bestDuplicateGrades.add("E");
            }
            else if (!bestSubjectsList.contains("E") && grades.get(i).contains("F")) {
                bestSubjectsList.add(grades.get(i));
                bestDuplicateGrades.add("F");
            }
        }
    
        Random rand = new Random();
        Set<String> set = new HashSet<>(bestDuplicateGrades);
        
        // Sjekker duplikater
        if(set.size() < bestDuplicateGrades.size() && !bestDuplicateGrades.get(0).equals("F")){
            bestSubjectId = bestSubjectsList.get(rand.nextInt(bestSubjectsList.size()));            
        }
        
        else {
            bestSubjectId = bestSubjectsList.get(bestSubjectsList.size() - 1);
            if (bestSubjectId.contains("F")){
                    bestSubjectId = "";
            }
        }
        if (!bestSubjectsList.isEmpty() && !bestSubjectId.equals("")) {
            String reducedId = bestSubjectId.substring(0, bestSubjectId.length() - 1);
            if (reducedId.equals("ex")) {
                bestSubjectCode = "EXPH0300";
            }
    
            else if (reducedId.equals("in")) {
                bestSubjectCode = "TDT4109";
            }
    
            else if (reducedId.equals("ma")) {
                bestSubjectCode = "TMA4100";
            }
    
            else if (reducedId.equals("di")) {
                bestSubjectCode = "TMA4140";
            }
    
            else if (reducedId.equals("ob")) {
                bestSubjectCode = "TDT4100";
            }
    
            else if (reducedId.equals("or")) {
                bestSubjectCode = "TIØ4101";
            }
    
            else if (reducedId.equals("ma3")) {
                bestSubjectCode = "TMA4115";
            }
    
            else if (reducedId.equals("kom")) {
                bestSubjectCode = "TTM4100";
            }
    
            else {
                bestSubjectCode = "NO BEST!";
            }
        }
        
        else {
            bestSubjectCode = "NO BEST!";
        }
    }
    
    System.out.println(bestSubjectsList);
    System.out.println(bestDuplicateGrades);
    System.out.println(bestSubjectId);
    System.out.println(bestSubjectCode);
    System.out.println(bestSubjectsList);
    System.out.println();
}

Answer 1

您可以使用自定義比較器。 例如，使用 Stream：

    List<String> list = List.of("exB", "exC", "exA");

    List<String> sorted = list.stream()
        .sorted(Comparator.comparing(s -> s.charAt(s.length() - 1)))
        .collect(Collectors.toList());

    Assertions.assertThat(sorted).containsExactly("exA","exB","exC");
    System.out.println(sorted);

將打印：[exA，exB，exC]

Answer 2

非常簡單的示例，無效，它僅按項目的最后一個字符排序，不考慮其他字母，因此inA可以在exA之前。

import org.assertj.core.util.Lists;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

import java.util.stream.Collectors;

public class TestOrder {

    @Test
    public void test() {
        // given
        var input = Lists.list("exA", "exB", "exC", "inA", "inB", "inC", "orA", "orB", "orC");

        // when
        var result = input.stream().sorted((word1, word2) -> {
            char lastLetterOfFirstWord = word1.charAt(word1.length() - 1);
            char lastLetterOfSecondWord = word2.charAt(word2.length() - 1);

            return lastLetterOfFirstWord - lastLetterOfSecondWord;
        }).collect(Collectors.toList());

        // then
        var expectedOutput = Lists.list("exA", "inA", "orA", "exB", "inB", "orB", "exC", "inC", "orC");
        Assertions.assertEquals(expectedOutput, result);
    }
}

Answer 3

我並不完全清楚您在尋找什么，因為您復制了之前的帖子而沒有提供任何其他詳細信息，但這將 (1) 按最后一個字符排序，然后 (2) 應用傳統排序（確保它將顯示為“exA”、“inA”、“orA”）。

List<String> list = Arrays.asList("exB", "inA", "inC", "inB", "exC", "orA", "orB", "exA", "orC");
List<String> sortedList = list.stream()
        .sorted(Comparator.comparing((String string) -> string.charAt(string.length() - 1))
                .thenComparing(Comparator.naturalOrder()))
        .collect(Collectors.toList());