blocks|key|2315256|text|构建一个比较器，该比较器对所需的订单进行查找：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2315257|Comparator<String>+sizeOrder+=+Comparator.comparingInt(desiredOrder::indexOf);|code-block|syntax|javascript|2315258|哪里|2315259|desiredOrder+=+Arrays.asList("S",+"M",+"L",+"XL",+"2XL",+"3XL",+"4XL",+"5XL",+"6XL");|2315260|然后：|2315261|yourList.sort(sizeOrder);|2315262|如果需要，可以为查找构建一个Map<String,+Integer>：|offset|length|style|CODE|2315263|Map<String,+Integer>+lookup+=
++++IntStream.range(0,+desiredOrder.length())
++++++++.boxed()
++++++++.collect(Collectors.toMap(desiredOrder::get,+i+->+i));|2315264|然后做：|2315265|Comparator<String>+sizeOrder+=+Comparator.comparing(lookup::get);|2315266|我不认为这比使用List.indexOf更具有性能，因为desiredOrder列表太小了。|2315267|与所有性能相关的内容一样:使用您认为最易读的；配置文件，如果您认为这是性能瓶颈，然后尝试其他方法。|2315268|entityMap^0|0|0|0|0|0|0|E|K|0|0|0|0|8|C|S|C|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|18|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|1A|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|1B|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|1C|8|@$Q|1D|R|1E|S|T]]|9|@]|A|$]]|$1|U|3|V|5|D|7|1F|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1G|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|1H|8|@]|9|@]|A|$E|F]]|$1|10|3|11|5|6|7|1I|8|@$Q|1J|R|1K|S|T]|$Q|1L|R|1M|S|T]]|9|@]|A|$]]|$1|12|3|13|5|6|7|1N|8|@]|9|@]|A|$]]|$1|14|3|-4|5|6|7|1O|8|@]|9|@]|A|$]]]|15|$]]

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

<pre><code>Comparator&lt;String&gt; sizeOrder = Comparator.comparingInt(desiredOrder::indexOf);
</code></pre>

where

<pre><code>desiredOrder = Arrays.asList("S", "M", "L", "XL", "2XL", "3XL", "4XL", "5XL", "6XL");
</code></pre>

Then:

<pre><code>yourList.sort(sizeOrder);
</code></pre>

<hr>

If you want, you can build a <code>Map&lt;String, Integer&gt;</code> for the lookup:

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

And then do:

<pre><code>Comparator&lt;String&gt; sizeOrder = Comparator.comparing(lookup::get);
</code></pre>

I'm not convinced that this will be any more performant than using <code>List.indexOf</code>, because the <code>desiredOrder</code> 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.

blocks|key|899497|text|使用可能更高效、更清晰的enum路由的替代方案。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|899498|//+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);
}|code-block|syntax|javascript|899499|entityMap^0|C|4|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

An alternative using the probably more efficient and certainly clearer <code>enum</code> route.

<pre><code>// 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&lt;String,Size&gt; lookup = Arrays.asList(values()).stream()
 .collect(Collectors.toMap(
 // Key is the indicator.
 s -&gt; s.indicator,
 // Value is the size.
 s-&gt; s));

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

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

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

blocks|key|899578|text|一种通用方法将重点放在大小字符串背后的模式上，而不仅仅是修改示例输入。您有一个由S、M或L表示的基本方向，以及它之前的可选修饰符(除非是M)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|899579|static+Pattern+SIZE_PATTERN=Pattern.compile("((\\d%2B)?X)?[LS]%7CM",+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;
}|code-block|syntax|javascript|899580|然后，您可以对一个大小列表进行排序，例如|899581|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());|899582|应该将Q48298432替换为包含numerical方法的类的名称。|899583|entityMap^0|14|1|16|1|18|1|1W|1|0|0|0|0|3|9|H|9|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|12|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|R|$]]

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

<pre><code>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)&gt;=0) n *= 2;
 if(m.start(2)&gt;=0) n *= Integer.parseInt(m.group(2));
 return n;
}
</code></pre>

Then, you can sort a list of sizes like

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

where <code>Q48298432</code> should be replaced with the name of the class containing the <code>numerical</code> method.

blocks|key|899594|text|另一种方式可能是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|899595|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());|code-block|syntax|javascript|899596|或|899597|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());|899598|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Another way could be this:

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

List&lt;String&gt; set= Stream.of(array).filter(Objects::nonNull).collect(Collectors.toList());
</code></pre>

Or 

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

 List&lt;String&gt; sortedItems = integers.stream()
 .sorted()
 .map(i-&gt;desiredOrder.get(i))
 .collect(Collectors.toList());
</code></pre>

blocks|key|4353723|text|这是完成大小排序的基本算法。该算法的基本思想是将大小的各个部分(number、modifier、unit)分解为相应的区域([0,+1000)、[1000,+1000_000)、[1000_000,+reset])，然后用dir确定modifier的方向。例如：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4353724|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%2B%2B)+:+'1';
++++int+modifier+=+i+%2B+1+<+n+?+size.charAt(i)+:+0;
++++++++return+-1+*+(unit+*+1000_000+%2B+dir+*+(modifier+*+1000+%2B+number));
++}
}|code-block|syntax|javascript|4353725|上面的解决方案只是针对简单的情况，对于复杂的情况，您需要解析number+&+modifier并决定如何划分region。然后，您可以按照以下代码按Comparator对大小进行排序：|4353726|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);
//++++++++++++++++++%5E---+[
//+++++++++++++++++++++++++"3XS",+"2XS",+"XS",
//+++++++++++++++++++++++++"3S",+"2S",+"S",
//+++++++++++++++++++++++++"M",+"2M",+"5M",
//+++++++++++++++++++++++++"L",+"2L",+"5L",
//+++++++++++++++++++++++++"XL",+"2XL",+"3XL"
//+++++++++++++++++++++++]|4353727|entityMap^0|W|6|13|8|1C|4|1Q|9|20|G|2H|H|33|3|38|8|0|0|U|6|13|8|1I|6|22|A|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|17|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|18|8|@$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|1H|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|1I|8|@]|D|@]|E|$]]]|P|$]]

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

<pre><code>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 &amp; extra modifier if needed
 int i = 0;
 int number = n &gt; 1&amp;&amp;Character.isDigit(size.charAt(i)) ? size.charAt(i++) : '1';
 int modifier = i + 1 &lt; n ? size.charAt(i) : 0;
 return -1 * (unit * 1000_000 + dir * (modifier * 1000 + number));
 }
}
</code></pre>

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

<pre><code>Comparator&lt;String&gt; sizeComparator = Comparator.comparingInt(Size::sizeToInt);

List&lt;String&gt; 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"
// ]
</code></pre>

blocks|key|4353765|text|创建一个包含所有可能大小的Enum类，并向其添加getEnum方法以支持以数字开头的大小：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4353766|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());
++++}
}|code-block|syntax|javascript|4353767|在比较器中使用SizeEnum类：|4353768|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));|4353769|entityMap^0|O|7|0|0|7|8|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|P|$]]

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

<pre><code>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 -&gt; v.getValue().equalsIgnoreCase(value))
 .findAny()
 .orElseThrow(() -&gt; new IllegalArgumentException());
 }
}
</code></pre>

Use the <code>SizeEnum</code> class in the comparator:

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

blocks|key|4353790|text|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%2B%2B){
++++++++boolean++matchFlag+=+false;
++++++++for(int+j=0;+j<+sortedRadixArr.length;+j%2B%2B){
++++++++++++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]%2B%2B;
++++++++++++++++matchFlag+=+true;
++++++++++++++++break;
++++++++++++}
++++++++}
++++++++if(!matchFlag){
++++++++++++throw+new+Exception("Invalid+size+found!");
++++++++}
++++}
++++int+count+=+0;
++++for(int+k+=+0;+k+<+intRadix.length;+k%2B%2B){
++++++++//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%2B%2B]+=+sortedRadixArr[k];
++++++++++++intRadix[k]--;
++++++++}
++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|4353791|}|unstyled|4353792|在这里，sortedRadixArr是基数组，即包含所有可能值的值：|offset|length|style|CODE|4353793|["S",+"M",+"L",+"XL",+"2XL",+"3XL",+"4XL",+"5XL",+"6XL"]|4353794|sizes是您想要排序的数组：|4353795|["2XL",+"3XL",+"4XL",+"5XL",+"6XL",+"L",+"M",+"S",+"XL"]|4353796|它接受重复的值。|4353797|entityMap^0|0|0|4|E|0|0|0|5|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|X|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|Y|8|@$I|Z|J|10|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$B|C]]|$1|O|3|P|5|F|7|12|8|@$I|13|J|14|K|L]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|15|8|@]|9|@]|A|$B|C]]|$1|S|3|T|5|F|7|16|8|@]|9|@]|A|$]]|$1|U|3|-4|5|F|7|17|8|@]|9|@]|A|$]]]|V|$]]

<pre><code>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] ----&gt; [&quot;S&quot;,&quot;M&quot;,&quot;L&quot;,&quot;XL&quot;,&quot;2XL&quot;] 

 int [] intRadix = new int[sortedRadixArr.length];
 
 for(int i = 0; i &lt; sizes.length; i++){
 boolean matchFlag = false;
 for(int j=0; j&lt; 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 &quot;S&quot;. 
 //We can't do that with sortedRadixArr as it is a String array.
 intRadix[j]++;
 matchFlag = true;
 break;
 }
 }
 if(!matchFlag){
 throw new Exception(&quot;Invalid size found!&quot;);
 }
 }
 int count = 0;
 for(int k = 0; k &lt; 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] &gt; 0){
 sizes[count++] = sortedRadixArr[k];
 intRadix[k]--;
 }
 }
}
</code></pre>
}
Here, <code>sortedRadixArr</code> is the radix array i.e. values with all possible values:
<pre><code>[&quot;S&quot;, &quot;M&quot;, &quot;L&quot;, &quot;XL&quot;, &quot;2XL&quot;, &quot;3XL&quot;, &quot;4XL&quot;, &quot;5XL&quot;, &quot;6XL&quot;]
</code></pre>
<code>sizes</code> is the array that you wanna sort:
<pre><code>[&quot;2XL&quot;, &quot;3XL&quot;, &quot;4XL&quot;, &quot;5XL&quot;, &quot;6XL&quot;, &quot;L&quot;, &quot;M&quot;, &quot;S&quot;, &quot;XL&quot;]
</code></pre>
It accepts duplicate values.

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

<pre><code>["2XL", "3XL", "4XL", "5XL", "6XL", "L", "M", "S", "XL"]
</code></pre>

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.

How can I sort a list of clothing sizes (e.g. 4XL, S, 2XL)?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我需要你的帮助跟踪查询。鉴于以下清单：["2XL", "3XL", "4XL", "5XL", "6XL", "L", "M", "S", "XL"]我怎样才能把它按这个顺序分类呢？"S“、"M”、"L“、"XL”、“2 XL”、“3 XL”、“4 XL”、“5 XL”、“6 XL”请注意，每个大小并不总是存在的。

问我如何对服装尺寸的列表(例如4 2XL，S，2 2XL)进行排序？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问我如何对服装尺寸的列表(例如4 2XL，S，2 2XL)进行排序？EN