blocks|key|643628|text|注意：这不是最有效的解决方案。这只是一个简单、直接的解决方案，可以完成这项工作。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|643629|我将首先使用Collections.sort(list)对列表进行排序。|CODE|643630|然后，我会删除已知的项目，并将它们添加到前面。|643631|String+special+=+"PREFA";
if+(list.remove(special)
++++list.add(0,+special);|code-block|syntax|javascript|643632|或者，如果前面有一个包含这些值的数组列表，您可以这样做：|643633|String[]+knownValues+=+{};
for+(String+s:+knownValues)+{
++++if+(list.remove(s))
++++++++list.add(0,+s);
}|643634|entityMap^0|0|3|0|6|M|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Y|8|@$9|Z|A|10|B|H]]|D|@]|E|$]]|$1|I|3|J|5|6|7|11|8|@]|D|@]|E|$]]|$1|K|3|L|5|M|7|12|8|@]|D|@]|E|$N|O]]|$1|P|3|Q|5|6|7|13|8|@]|D|@]|E|$]]|$1|R|3|S|5|M|7|14|8|@]|D|@]|E|$N|O]]|$1|T|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|U|$]]

Note: This is not the most efficient solution. It is just a simple, straightforward solution that gets the job done.

I would first use <code>Collections.sort(list)</code> to sort the list.

Then, I would remove the known items, and add them to the front.

<pre><code>String special = "PREFA";
if (list.remove(special)
 list.add(0, special);
</code></pre>

Or, if you have a list of array of these values you need in the front you could do:

<pre><code>String[] knownValues = {};
for (String s: knownValues) {
 if (list.remove(s))
 list.add(0, s);
}
</code></pre>

blocks|key|2253682|text|我也会使用Collections.sort(list)，但我想我会使用一个比较器，在比较器中你可以定义你自己的规则，例如|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2253683|class+MyComparator+implements+Comparator<String>+{

++++public+int+compare(String+o1,+String+o2)+{
++++++++//+Now+you+can+define+the+behaviour+for+your+sorting.
++++++++//+For+example+your+special+cases+should+always+come+first,+
++++++++//+but+if+it+is+not+a+special+case+then+just+use+the+normal+string+comparison.

++++++++if+(o1.equals(SPECIAL_CASE))+{
++++++++++++//+Do+something+special
++++++++}
++++++++//+etc.
++++++++return+o1.compareTo(o2);
++++}

}|code-block|syntax|javascript|2253684|然后按以下操作进行排序：|2253685|Collections.sort(list,+new+MyComparator());|2253686|entityMap^0|5|M|0|0|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|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

I would also use <code>Collections.sort(list)</code> but I think I would use a Comparator and within the comparator you could define your own rules, e.g.

<pre><code>class MyComparator implements Comparator&lt;String&gt; {

 public int compare(String o1, String o2) {
 // Now you can define the behaviour for your sorting.
 // For example your special cases should always come first, 
 // but if it is not a special case then just use the normal string comparison.

 if (o1.equals(SPECIAL_CASE)) {
 // Do something special
 }
 // etc.
 return o1.compareTo(o2);
 }

}
</code></pre>

Then sort by doing:

<pre><code>Collections.sort(list, new MyComparator());
</code></pre>

blocks|key|645788|text|我会保持不同的列表。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|645789|一个用于已知值和未知值。并分别对它们进行排序，当您需要将它们放在一个列表中时，您可以将它们连接起来。|645790|knownUnsorted.addAll(unsorted.size+-+1,+unknonwUnsorted);|code-block|syntax|javascript|645791|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I would keep separate lists.

One for known values and unknown values. And sort them separately, when you need them in a one list you can just concatenate them.

<pre><code>knownUnsorted.addAll(unsorted.size - 1, unknonwUnsorted);
</code></pre>

blocks|key|2253745|text|我建议使用您的值填充List并使用Collections.sort(...)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2253746|就像这样|2253747|Collections.sort(myList,+new+FunkyComparator());|code-block|syntax|javascript|2253748|使用以下命令：|2253749|class+FunkyComparator+implements+Comparator+{

++++private+static+Map<String,Integer>+orderedExceptions+=
++++++++new+HashMap<String,Integer>(){{+
++++++++++++put("PREFZ",+Integer.valueOf(1));
++++++++++++put("PREFA",+Integer.valueOf(2));
++++++++}};

++++public+int+compare(Object+o1,+Object+o2)+{
++++++++String+s1+=+(String)+o1;
++++++++String+s2+=+(String)+o2;
++++++++Integer+i1+=+orderedExceptions.get(s1);
++++++++Integer+i2+=+orderedExceptions.get(s2);

++++++++if+(i1+!=+null+&&+i2+!=+null)+{
++++++++++++return+i1+-+i2;
++++++++}
++++++++if+(i1+!=+null)+{
++++++++++++return+-1;
++++++++}
++++++++if+(i2+!=+null)+{
++++++++++++return+%2B1;
++++++++}
++++++++return+s1.compareTo(s2);
++++}
}|2253750|entityMap|0|LINK|mutability|MUTABLE|url|http://java.sun.com/j2se/1.5.0/docs/api/java/util/List.html|1|http://java.sun.com/j2se/1.5.0/docs/api/java/util/Collections.html#sort(java.util.List,java.util.Comparator))^0|A|4|0|H|L|1|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]|$A|12|B|13|1|14]]|C|$]]|$1|D|3|E|5|6|7|15|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|16|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|17|8|@]|9|@]|C|$]]|$1|M|3|N|5|H|7|18|8|@]|9|@]|C|$I|J]]|$1|O|3|-4|5|6|7|19|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]|W|$5|R|S|T|C|$U|X]]]]

I suggest filling <a href="http://java.sun.com/j2se/1.5.0/docs/api/java/util/List.html" rel="nofollow noreferrer">List</a> with your values and using <a href="http://java.sun.com/j2se/1.5.0/docs/api/java/util/Collections.html#sort(java.util.List,java.util.Comparator)" rel="nofollow noreferrer">Collections.sort(...)</a>.

Something like

<pre><code>Collections.sort(myList, new FunkyComparator());
</code></pre>

using this:

<pre><code>class FunkyComparator implements Comparator {

 private static Map&lt;String,Integer&gt; orderedExceptions =
 new HashMap&lt;String,Integer&gt;(){{ 
 put("PREFZ", Integer.valueOf(1));
 put("PREFA", Integer.valueOf(2));
 }};

 public int compare(Object o1, Object o2) {
 String s1 = (String) o1;
 String s2 = (String) o2;
 Integer i1 = orderedExceptions.get(s1);
 Integer i2 = orderedExceptions.get(s2);

 if (i1 != null &amp;&amp; i2 != null) {
 return i1 - i2;
 }
 if (i1 != null) {
 return -1;
 }
 if (i2 != null) {
 return +1;
 }
 return s1.compareTo(s2);
 }
}
</code></pre>

blocks|key|3661467|text|因为我是番石榴库的粉丝，所以我想找到一个使用它的解决方案。我不知道它是否有效，如果你发现它和其他解决方案一样简单，但它是这样的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3661468|final+Iterable<String>+all+=+asList("FOO",+"BAR",+"PREFA",+"ZOO",+"PREFOO",+"PREFZ");
final+List<String>+mustAppearFirst+=+asList("PREFZ",+"PREFA");
final+Iterable<String>+sorted+=+
++++++concat(
++++++++++++Ordering.explicit(mustAppearFirst).sortedCopy(filter(all,+in(mustAppearFirst))),
++++++++++++Ordering.<String>natural().sortedCopy(filter(all,+not(in(mustAppearFirst)))));|code-block|syntax|javascript|3661469|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Since I'm a fan of the guava lib, I wanted to find a solution using it. I don't know if it's efficient, neither if you find it as simple as others solution, but it's here:

<pre><code>final Iterable&lt;String&gt; all = asList("FOO", "BAR", "PREFA", "ZOO", "PREFOO", "PREFZ");
final List&lt;String&gt; mustAppearFirst = asList("PREFZ", "PREFA");
final Iterable&lt;String&gt; sorted = 
 concat(
 Ordering.explicit(mustAppearFirst).sortedCopy(filter(all, in(mustAppearFirst))),
 Ordering.&lt;String&gt;natural().sortedCopy(filter(all, not(in(mustAppearFirst)))));
</code></pre>

blocks|key|1388659|text|你特别提到了芭乐；除了Sylvain+M的答案，还有另一种方式(更多的是作为一种学术练习和芭乐灵活性的演示)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1388660|//+List+is+not+efficient+here;+for+large+problems,+something+like+SkipList+
//+is+more+suitable
private+static+final+List<String>+KNOWN_INDEXES+=+asList("PREFZ",+"PREFA");

private+static+final+Function<Object,+Integer>+POSITION_IN_KNOWN_INDEXES+
++++=+new+Function<Object,+Integer>()+{
++public+Integer+apply(Object+in)+{
+++++int+index+=+KNOWN_INDEXES.indexOf(in);
+++++return+index+==+-1+?+null+:+index;
++}+++++
};


...


List<String>+values+=+asList("FOO",+"BAR",+"PREFA",+"ZOO",+"PREFZ",+"PREFOO");

Collections.sort(values,
++Ordering.natural().nullsLast().onResultOf(POSITION_IN_KNOWN_INDEXES).compound(Ordering.natural())
);|code-block|syntax|javascript|1388661|因此，换句话说，按照List.indexOf()返回的Integer的自然顺序进行排序，然后断开与对象本身的自然顺序的关系。|offset|length|style|CODE|1388662|凌乱，也许，但有趣。|1388663|entityMap^0|0|0|A|E|R|7|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]|$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|P|$]]

You specifically mentioned guava; along with Sylvain M's answer, here's another way (more as an academic exercise and demonstration of guava's flexibility than anything else)

<pre><code>// List is not efficient here; for large problems, something like SkipList 
// is more suitable
private static final List&lt;String&gt; KNOWN_INDEXES = asList("PREFZ", "PREFA");

private static final Function&lt;Object, Integer&gt; POSITION_IN_KNOWN_INDEXES 
 = new Function&lt;Object, Integer&gt;() {
 public Integer apply(Object in) {
 int index = KNOWN_INDEXES.indexOf(in);
 return index == -1 ? null : index;
 } 
};


...


List&lt;String&gt; values = asList("FOO", "BAR", "PREFA", "ZOO", "PREFZ", "PREFOO");

Collections.sort(values,
 Ordering.natural().nullsLast().onResultOf(POSITION_IN_KNOWN_INDEXES).compound(Ordering.natural())
);
</code></pre>

So, in other words, sort on natural order of the <code>Integer</code> returned by <code>List.indexOf()</code>, then break ties with natural order of the object itself.

Messy, perhaps, but fun.

Assuming I have 

<pre><code>final Iterable&lt;String&gt; unsorted = asList("FOO", "BAR", "PREFA", "ZOO", "PREFZ", "PREFOO");
</code></pre>

What can I do to transform this unsorted list into this:

<pre><code>[PREFZ, PREFA, BAR, FOO, PREFOO, ZOO]
</code></pre>

(a list which begin with known values that must appears first (here "PREFA" and "PREFZ") and the rest is alphabetically sorted)

I think there are some usefull classes in guava that can make the job (Ordering, Predicates...), but I have not yet found a solution...

List Sorting puzzle

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

假设我有final Iterable<String> unsorted = asList("FOO", "BAR", "PREFA", "ZOO", "PREFZ", "PREFOO");我可以做些什么将这个未排序的列表转换成这个列表：[PREFZ, PREFA, BAR, FOO, PREFOO, ZOO](该列表以...

问列表排序难题
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问列表排序难题EN