如何对服装尺码列表进行排序（例如 4XL、S、2XL）？

Question

I need your help follow query. Given the following List:

["2XL", "3XL", "4XL", "5XL", "6XL", "L", "M", "S", "XL"]

How do I sort it so that it is in this order?

["S", "M", "L", "XL", "2XL", "3XL", "4XL", "5XL", "6XL"]

Note that every size is not always present.

Answer 1

Build a comparator which does a lookup on your desired order:

Comparator<String> sizeOrder = Comparator.comparingInt(desiredOrder::indexOf);

where

desiredOrder = Arrays.asList("S", "M", "L", "XL", "2XL", "3XL", "4XL", "5XL", "6XL");

Then:

yourList.sort(sizeOrder);

---

If you want, you can build a Map<String, Integer> for the lookup:

Map<String, Integer> lookup =
    IntStream.range(0, desiredOrder.length())
        .boxed()
        .collect(Collectors.toMap(desiredOrder::get, i -> i));

And then do:

Comparator<String> sizeOrder = Comparator.comparing(lookup::get);

I'm not convinced that this will be any more performant than using List.indexOf , because the desiredOrder list is so small.

As with everything performance-related: use the one which you find most readable; profile if you think this is a performance bottleneck, and only then try alternatives.

Answer 2

A general approach would focus on the pattern behind the size strings rather than just accommodating the sample input. You have a fundamental direction denoted by S , M , or L and optional modifiers before it (unless M ) altering the magnitude.

static Pattern SIZE_PATTERN=Pattern.compile("((\\d+)?X)?[LS]|M", Pattern.CASE_INSENSITIVE);
static int numerical(String size) {
    Matcher m = SIZE_PATTERN.matcher(size);
    if(!m.matches()) throw new IllegalArgumentException(size);
    char c = size.charAt(m.end()-1);
    int n = c == 'S'? -1: c == 'L'? 1: 0;
    if(m.start(1)>=0) n *= 2;
    if(m.start(2)>=0) n *= Integer.parseInt(m.group(2));
    return n;
}

Then, you can sort a list of sizes like

List<String> sizes = Arrays.asList("2XL", "5XL", "M", "S", "6XL", "XS", "3XS", "L", "XL");
sizes.sort(Comparator.comparing(Q48298432::numerical));
System.out.print(sizes.toString());

where Q48298432 should be replaced with the name of the class containing the numerical method.

Answer 3

An alternative using the probably more efficient and certainly clearer enum route.

// Sizes in sort order.
enum Size {
    SMALL("S"),
    MEDIUM("M"),
    LARGE("L"),
    EXTRA_LARGE("XL"),
    EXTRA2_LARGE("2XL"),
    EXTRA3_LARGE("3XL"),
    EXTRA4_LARGE("4XL"),
    EXTRA5_LARGE("5XL"),
    EXTRA6_LARGE("6XL");
    private final String indicator;

    Size(String indicator) {
        this.indicator = indicator;
    }

    static final Map<String,Size> lookup = Arrays.asList(values()).stream()
            .collect(Collectors.toMap(
                    // Key is the indicator.
                    s -> s.indicator,
                    // Value is the size.
                    s-> s));

    public static Size lookup(String s) {
        return lookup.get(s.toUpperCase());
    }

    // Could be improved to handle failed lookups. 
    public static final Comparator<String> sizeOrder = (o1, o2) -> lookup(o1).ordinal() - lookup(o2).ordinal();
}

public void test(String[] args) {
    List<String> test = Arrays.asList("S","6XL", "L");
    Collections.sort(test, Size.sizeOrder);
    System.out.println(test);
}

Answer 4

Another way could be this:

List<String> desiredOrder = Arrays.asList("S", "M", "L", "XL", "2XL", "3XL", "4XL", "5XL", "6XL");
 String [] array = new String[desiredOrder.size()];
   list.forEach(s->{
       if (desiredOrder.indexOf(s) != -1)
             array[desiredOrder.indexOf(s)] = s;
   });

List<String> set= Stream.of(array).filter(Objects::nonNull).collect(Collectors.toList());

Or

Set<Integer> integers = new HashSet<>();
    list.forEach(s -> {
        if (desiredOrder.indexOf(s) != -1) {
            integers.add(desiredOrder.indexOf(s));
        }
    });

    List<String> sortedItems = integers.stream()
                                       .sorted()
                                       .map(i->desiredOrder.get(i))
                                       .collect(Collectors.toList());

Answer 5

This is a basic algorithm to complete the size sorting. the basic idea of this algorithm is break each parts ( number , modifier , unit ) of size into the corresponding regions ( [0, 1000) , [1000, 1000_000) , [1000_000, reset] ), and then use dir to decide the direction of the modifier . for example:

class Size {
  public static int sizeToInt(String size) {
    int n = size.length(), unit = size.charAt(n - 1), dir = unit == 'S' ? 1 : -1;
    //use a separate method to parse the number & extra modifier if needed
    int i = 0;
    int number = n > 1&&Character.isDigit(size.charAt(i)) ? size.charAt(i++) : '1';
    int modifier = i + 1 < n ? size.charAt(i) : 0;
        return -1 * (unit * 1000_000 + dir * (modifier * 1000 + number));
  }
}

The solution above is just for the simple case as yours, for the complex case you need to parse number & modifier and decide how to partition the region s. Then you can sort sizes by Comparator as following code:

Comparator<String> sizeComparator = Comparator.comparingInt(Size::sizeToInt);

List<String> sizes = Arrays.asList(
    "3XL", "2XL", "XL",
    "5L", "2L", "L",
    "5M", "2M", "M",
    "S", "2S", "3S",
    "XS", "2XS", "3XS"
);


sizes.sort(sizeComparator);

System.out.println(sizes);
//                  ^--- [
//                         "3XS", "2XS", "XS",
//                         "3S", "2S", "S",
//                         "M", "2M", "5M",
//                         "L", "2L", "5L",
//                         "XL", "2XL", "3XL"
//                       ]

Answer 6

Create an Enum class with all the possible sizes and add to it the getEnum method to support the sizes that start by number:

public enum SizeEnum
{
    S("S"), M("M"), L("L"), XL("XL"), TWO_XL("2XL"), THREE_XL("3XL"), FOUR_XL("4XL"), FIVE_XL("5XL"), SIX_XL("6XL");

    private String value;

    SizeEnum(String value){
        this.value = value;
    }

    public String getValue() {
        return value;
    }

    public static SizeEnum getEnum(String value) {
        return Arrays.stream(values())
                .filter(v -> v.getValue().equalsIgnoreCase(value))
                .findAny()
                .orElseThrow(() -> new IllegalArgumentException());
    }
}

Use the SizeEnum class in the comparator:

List<String> sizes = Arrays.asList("2XL", "3XL", "4XL", "5XL", "6XL", "L", "M", "S", "XL");
sizes.sort(Comparator.comparing(v -> SizeEnum.getEnum(v.toUpperCase())));
sizes.stream().forEach(l -> System.out.println(l));

Answer 7

public static void SortSizes(String [] sizes, String [] sortedRadixArr) throws Exception{
    
    //creating an int array with same length as sortedRadixArr
    //Here each index of intRadix array is mapped to the index of sortedRadixArr
    //Eg:           intRadix = [0,0,0,0,0]  ----> ["S","M","L","XL","2XL"]  

    int [] intRadix = new int[sortedRadixArr.length];
    
    for(int i = 0; i < sizes.length; i++){
        boolean  matchFlag = false;
        for(int j=0; j< sortedRadixArr.length; j++){
            if(sizes[i] == sortedRadixArr[j]){
                //Whenever the String is matched with the String of sortedRadixArr array, 
                //increment the value of intRadix array at the equivalent index of sortedRadixArr.
                //This helps us to count number same strings(sizes). like two or more "S". 
                //We can't do that with sortedRadixArr as it is a String array.
                intRadix[j]++;
                matchFlag = true;
                break;
            }
        }
        if(!matchFlag){
            throw new Exception("Invalid size found!");
        }
    }
    int count = 0;
    for(int k = 0; k < intRadix.length; k++){
        //Loop thru intRadix array. It contains count of respective sizes(Strings) at each index. 
        //We will re-write sizes array in sorted order with help of intRadix as below.
        while(intRadix[k] > 0){
            sizes[count++] = sortedRadixArr[k];
            intRadix[k]--;
        }
    }
}

}

Here, sortedRadixArr is the radix array ie values with all possible values:

["S", "M", "L", "XL", "2XL", "3XL", "4XL", "5XL", "6XL"]

sizes is the array that you wanna sort:

["2XL", "3XL", "4XL", "5XL", "6XL", "L", "M", "S", "XL"]

It accepts duplicate values.