How to sort a list by alfabetical order depending on last letter of word?

Question

So I have this list grades: [exA,exB,exC,inA,inB,inC,orA,orB,orC]. I want to sort that list by the last element in the index by alphabetical order. I want it to look like [exA,inA,orA,exB,inB,orB,exC,inC,orC]. This is what I have tried. I need it in alphabetical order so I can find the best subject. Then I can just say that the first element in the list is the best performance in a subject. If I have duplicates I'll just pick a random subject of those subjects where I got a 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

You can use a custom comparator. For example with a 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);

will print: [exA, exB, exC]

Answer 2

Really quick example, not effective and it only sorts by last char of the item not considering other letters so inA can be before 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

It's not completely clear to me what you're looking for as you duplicated your previous post without providing any additional details, but this will (1) sort by the last character and then (2) apply a traditional sort (ensuring it will appear as "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());