为了保持可读性，我不会将比较放在流管道中，而是在比较器中提取它

public List<PRDto> present(List<ParticipantReference> participants) {

    Comparator<PRDto> byType = Comparator.comparing(o -> !o.getType().equals(ParticipantType.S));

    Comparator<PRDto> byName = Comparator.comparing(PRDto::getName);

    return participants.stream().sorted(byType.thenComparing(byName)).collect(toList());
}

我的回答有多余的逻辑，霍尔格谢天谢地向我指出了这一点。这也可以内联，因为霍尔格在评论中提到：

return participants.stream().sorted(
                   Comparator.comparing((PRDto o) -> !o.getType().equals(ParticipantType.S))
                             .thenComparing(PRDto::getName))
            .collect(toList());

请注意，如果要先按类型排序，然后按名称排序，则需要这样做。反之，则需要排序算法来保持相等元素的现有顺序，这可能并不总是有保证的。
将枚举Map到表示order和let的整数也会更容易 Comparator 做这项工作。
所以你的代码可以是这样的：

...
.sorted(Comparator.comparingInt(p -> { //first compare by mapped type
     switch( p.getParticipantType() ) {
       case S: return 0;
       default: return Integer.MAX_VALUE; //so you could insert other enum values if needed
     }
   }).thenComparing(PRDto::getName) //then compare by name
)
...

如果您使用这样的复合比较器，它会将元素类型 S 在顶端。如果你把比较器写成“旧”的样子，它可能是这样的：

compare(PRDto left, PRDto right) {
  int typeOrderLeft = mapToInt(left.getParticipantType()); //mapToInt contains the mapping expression, i.e the switch in the example above
  int typeOrderRight = mapToInt(right.getParticipantType());

  //first order by type
  int result = Integer.compare(typeOrderLeft, typeOrderRight);

  //if the type order is the same, i.e. both have S or non-S, sort by name
  if( result == 0 ) { 
    result = String.compare(left.getName(), right.getName());
  }

  return result; 
}

示例（已订购）：

type  name
---------------
S     zulu      //S < F and S < D_F due to the mapping, name is irrelevant here
D_F   alpha     //F and D_F are considered equal, so names are compared
F     bravo