Java中带两个异常的排序数组

我有一个

字符串的
数组
，我需要在返回它之前对它进行排序。问题是其中两个价值观必须放在第一位。我尝试了一些事情（包括下面的内容），但我似乎无法理解

下面的内容显然不起作用，因为在某些情况下我会对它进行两次排序。我知道我可以将
数组
更改为
列表
，然后使用
集合。反向
，但有没有更好的方法不涉及更改结构？我在下面添加了一个简单的示例

  public static String[] getStrings() {
        String[] array = {"d","a","c","e","b"};
        boolean first = false;
        boolean second = false;
        int left = 0;
        for (int right = 0; right < array.length; right++) {
            if (array[right].equals("e")){
                  first = true;
                  array[right] = array[left];
                  array[left] = "e";
                  left++;
            }
        }
        if (first) {Arrays.sort(array, left, array.length);}
        left = 0;
        for (int right = 0; right < array.length; right++) {
            if (array[second].equals("c")){
                  second = true;
                  array[right] = array[left];
                  array[left] = "c";
                  left++;
            }
        }
        if (second) {Arrays.sort(array, left, array.length);}
        if (!first && !second) {Arrays.sort(array);}
      }
    return array;
  }

公共静态字符串[]getStrings（）{
字符串[]数组={“d”、“a”、“c”、“e”、“b”}；
布尔优先=假；
布尔秒=假；
int左=0；
for（int right=0；right

编辑

使用示例
d、a、c、e、b中的
数组
。排序后应为
c、e、a、b、d

这两个异常按字母顺序排列，也按字母顺序排列在数组的其余部分之后。
实现自定义
比较器怎么样

String[] array = {"d","a","c","e","b"};
Arrays.sort(array, new Comparator<String> () {
    int compare(String s1, String s2) {
        if (firstOne.equals(s1) && firstOne.equals(s2)) {
           return 0;
        } else if (firstOne.equals(s1) {
           return -1;
        } else if (firstOne.equals(s2)) {
           return 1;
        }

        if (secondOne.equals(s1) && secondOne.equals(s2)) {
           return 0;
        } else if (secondOne.equals(s1) {
           return -1;
        } else if (secondOne.equals(s2)) {
           return 1;
        }

        return s1.compareTo(s2);
    });

String[]数组={“d”、“a”、“c”、“e”、“b”}；
排序（数组，新的比较器（）{
int比较（字符串s1、字符串s2）{
if（firstOne.equals（s1）和&firstOne.equals（s2））{
返回0；
}else if（第一个等于（s1）{
返回-1；
}else如果（第一个等于（s2））{
返回1；
}
if（secondOne.equals（s1）和&secondOne.equals（s2））{
返回0；
}else if（第二个一等于（s1）{
返回-1；
}else if（第二个一等于（s2））{
返回1；
}
返回s1.compareTo（s2）；
});

指



为什么不先对它进行排序，然后查找这两个值，并将它们前移？
最坏的情况是
n*log（n）+2n
您可以使用Java8流API

final String[] array = {"d","a","c","e","b"};
final Set<String> search = Stream.of("c", "e").collect(toSet());
final String[] result = Stream.concat(
    Stream.of(array).filter(search::contains).sorted(),
    Stream.of(array).filter(s -> !search.contains(s)).sorted()
).toArray(String[]::new);

final String[]数组={“d”、“a”、“c”、“e”、“b”}；
最终集搜索=Stream.of（“c”，“e”）.collect（toSet（））；
最终字符串[]结果=Stream.concat(
Stream.of（array）.filter（search:：contains）.sorted（），
Stream.of（array）.filter（s->！search.contains（s））.sorted（）
).toArray（字符串[]：：新建）；

第一部分选择“c”和“e”字符串并分别对它们进行排序，然后选择任何不是“c”或“e”的字符串单独选择并排序。最后，将两个流连接成一个数组。
获取不需要排序的元素的索引，并将这些元素移动到列表的前面，然后对列表的其余部分进行排序

public static String[] getString(String[] strArray, int... firstElems) {
    // Move the elements that are not sorted to the front
    int g = 0;
    for (int f = 0; f < firstElems.length; f++, g++) {
        String elem = strArray[g];
        strArray[g] = strArray[firstElems[f]];
        strArray[firstElems[f]] = elem;
    }

    // Sort the rest
    Arrays.sort(strArray, g, strArray.length);
    return strArray;
}

publicstaticstring[]getString（String[]strArray，int…firstElems）{
//将未排序的元素移到前面
int g=0；
for（int f=0；f
有一个基于@ikicha和Java 8的简短解决方案：

final String first = "c", second = "e";
Arrays.sort(array, (i, j) -> {
    if (i.equals(first) || (i.equals(second) && !j.equals(first))) {
        return -1;
    } else {
        return i.compareTo(j);
    }
});

您可以发布一些测试或示例，说明您希望排序的行为方式吗？如果您没有确切告诉我们您的排序代码应该产生什么结果，我们无法告诉您如何修复排序代码。忘记添加它。现在已编辑。输入是否都是唯一的？如果不是，请给出一个示例，说明在这种情况下您希望输出的方式，如果异常字符重复不止一次输入都是唯一的，是的。有几个错误需要修复。例如，如果
s1
和
s2
都等于
firstOne
，那么结果应该是0，但与上面的结果相比将是-1。更好！现在请向OP演示如何使用比较器；）@alfasin OP是什么意思？OP（原始海报）代表提出问题的人。数组中是否存在
shift
api？如果它不存在，我认为代码将不优雅。