Java按名称对对象列表进行排序，但一个对象应始终位于顶部

我的代码：

None
Jhon
Nancy
Paul

列表名称=新列表（）；
姓名。添加（“罗伯特”）；
姓名。添加（“保罗”）；
名称。添加（“无”）；
姓名。添加（“南希”）；
名称。添加（“Jhon”）；
name.stream（）.sorted（）.collect（Collectors.toList（））；

---

字符串必须始终放在第一位。

一种方法是过滤掉

中的“无”

，并将其预先挂起到排序列表中：

List<String> names = new List<String>();
names.add("Robert");
names.add("Paul");
names.add("None");
names.add("Nancy");
names.add("Jhon");


names.stream().sorted().collect(Collectors.toList());

List ordered=Stream.concat(
name.stream（）.filter（s->s.equals（“无”））
，names.stream（）.filter（s->！s.equals（“无”））.sorted（）
).collect（Collectors.toList（））；

---

您可以将comparator对象传递给定义标准的

排序的中间方法，如下所示：

List<String> ordered = Stream.concat(
    names.stream().filter(s -> s.equals("None"))
,   names.stream().filter(s -> !s.equals("None")).sorted()
).collect(Collectors.toList());

列表结果集=
names.stream（）
.已排序（（e，a）->“无”。等于（e）？-1：
“无”。等于（a）？1:e.与（a）相比
.collect（Collectors.toList（））；
看看这个

List<String> resultSet = 
         names.stream()
              .sorted((e, a) -> "None".equals(e) ? -1:
                              "None".equals(a) ? 1 : e.compareTo(a))
              .collect(Collectors.toList());

使用
排序
和
分区方式

   names.stream()
                        .sorted((o1, o2) ->
                                {
                                    if("None".equals(o1.getName()) && "None".equals(o2.getName())) return 0;
                                    return "None".equals(o1.getName()) ? -1:
                                            "None".equals(o2.getName()) ? 1 : o1.getName().compareTo(o2.getName());
                                }
                        ).collect(Collectors.toList());

List sorted=names.stream（）
.排序（（o1，o2）->o1==null？
-1 :
o2==null？
1 :
o1.等于（“无”）？
-1 :
o2.等于（“无”）？
1 :
o1.比较（o2））
.collect（Collectors.toList（））；
您可以使用

List<String> sorted = names.stream()
                .sorted((o1, o2) -> o1 == null ?
                        -1 :
                        o2 == null ?
                                1 :
                                o1.equals("None") ?
                                        -1 :
                                        o2.equals("None") ?
                                                1 :
                                                o1.compareTo(o2))
                .collect(Collectors.toList());

要就地排序，可以使用像
ArrayList
这样的可变列表，这是我的贡献：尽量使其具有良好的格式/外观。
请注意，这将失败

names.sort(Comparator.comparing(Manager::getName,
              Comparator.comparing((String s) -> !s.equals("None"))
                        .thenComparing(Comparator.naturalOrder())));

未排序列表=。。。不管怎样。。。；
// ... 
List sorted=unsorted.stream（）
.filter（Objects:：nonNull）//可选：在下面抛出异常之前除去null。
.sorted（（a，b）->Objects.equals（a，b）→0
：“无”。等于（a）？-1
：“无”。等于（b）？1
：a.与（b）相比
.distinct（）//可选：如果要消除重复。
.collect（Collectors.toList（））；
添加自定义比较器如果您使用
Comparator.nullsFirst（Comparator.naturalOrder（））
将
None
更改为
null
将很容易。您能在排序后将None作为第一个对象插入吗？@tim.paetz我猜列表中可能有动态数量的“None”条目（0到XXX）上面的代码只是一个例子。Java中没有
new List（）
，抱歉，您的比较器不工作。让我们用一个类似于
list names=Arrays.asList（“Eric”、“None”、“Paul”）我们将有以下输出
[Eric，None，Paul]
。无论无是s1还是s2，您都不能返回相同的内容，我不理解if和else if子句中的第二个谓词可以用方法引用替换lambda的原因：
“None”：：等于
。谢谢，使用方法引用更改谢谢我们如何使用相同的方法对管理器对象列表进行排序behavior@ssl在过滤器中使用
filter（m->m.getName（）.equals（“None”））
，并使用
排序（Comparator.comparing（Manager:：getName）
。感谢您的输入。如何在管理器对象上执行上述逻辑？如果两个参数均
“无”，则此比较器无效
，它应该返回
0
。谢谢，它工作得很好。我们如何应用相同的逻辑在列表底部显示“无”呢？您可以通过删除not（
！
）操作符将它们放在末尾而不是开头。
[None, Jhon, Nancy, Paul, Robert]

List<String> sorted = names.stream()
                .sorted((o1, o2) -> o1 == null ?
                        -1 :
                        o2 == null ?
                                1 :
                                o1.equals("None") ?
                                        -1 :
                                        o2.equals("None") ?
                                                1 :
                                                o1.compareTo(o2))
                .collect(Collectors.toList());

List<Manager> sorted = names.stream()
    .sorted(Comparator.comparing(Manager::getName,
              Comparator.comparing((String s) -> !s.equals("None"))
                        .thenComparing(Comparator.naturalOrder())))
    .collect(Collectors.toList());

names.sort(Comparator.comparing(Manager::getName,
              Comparator.comparing((String s) -> !s.equals("None"))
                        .thenComparing(Comparator.naturalOrder())));

 List<String> unsorted = ... what-ever ...;
 // ... 
 List<String> sorted = unsorted.stream()
    .filter(Objects::nonNull) // optional: get rid of nulls before an exception is thrown bellow.
    .sorted((a, b) -> Objects.equals(a, b) ? 0 
                  : "None".equals(a) ? -1
                  : "None".equals(b) ? 1 
                  : a.compareTo(b))
    .distinct()  // optional: if you want to get rid of repeats.
    .collect(Collectors.toList());