Java 如何对字符串进行排序，使带有额外信息的值首先出现？

我正在尝试对以下字符串进行排序

1.0.0.0-00000000-00000
2.1.0.0
2.2.0.0
2.3.0.0-00000000-00000

我目前在字符串数组中有这些值

 String[] arrays = {"1.0.0.0-00000000-00000", "2.1.0.0", "2.2.0.0", "2.3.0.0-00000000-00000"};

我试图得到一个输出，如果没有“-”，那么这些值将按排序顺序进入数组的末尾。我试图获得如下输出：

1.0.0.0-00000000-00000
2.3.0.0-00000000-00000
2.1.0.0
2.2.0.0

我尝试了

Arrays.sort（Arrays）

，但我不确定如何进行排序

import java.util.Arrays;
import java.util.Comparator;
import java.util.Collections;

public class HelloWorld{

     public static void main(String []args){

       String[] arrays = {"1.0.0.0-00000000-00000", "2.1.0.0", "2.2.0.0", "2.3.0.0-00000000-00000"};
       String[] newArray = new String[arrays.length];

    class CustomComparator implements Comparator<String>
    {
        @Override
        public int compare(String a, String b)
        {
            if(a.contains("-") && !b.contains("-"))
                 return 1;
            else if(!a.contains("-") && b.contains("-"))
                 return -1;
            return a.compareTo(b);
        }
    }

    Arrays.sort(arrays, new CustomComparator());

       for(String array : arrays)
       {
            System.out.println(array);
       }

     }
}


Error:

$javac HelloWorld.java 2>&1

HelloWorld.java:25: error: no suitable method found for sort(String[],CustomComparator)
    Collections.sort(arrays, new CustomComparator());
               ^
    method Collections.<T#1>sort(List<T#1>,Comparator<? super T#1>) is not applicable
      (no instance(s) of type variable(s) T#1 exist so that argument type String[] conforms to formal parameter type List<T#1>)
    method Collections.<T#2>sort(List<T#2>) is not applicable
      (cannot instantiate from arguments because actual and formal argument lists differ in length)
  where T#1,T#2 are type-variables:
    T#1 extends Object declared in method <T#1>sort(List<T#1>,Comparator<? super T#1>)
    T#2 extends Comparable<? super T#2> declared in method <T#2>sort(List<T#2>)
1 error



    The method gave me an output of 
2.1.0.0 
2.2.0.0
1.0.0.0-00000000-00000 
2.3.0.0-00000000-00000 

as opposed to

1.0.0.0-00000000-00000
2.3.0.0-00000000-00000
2.1.0.0 
2.2.0.0 

导入java.util.array；
导入java.util.Comparator；
导入java.util.Collections；
公共类HelloWorld{
公共静态void main（字符串[]args）{
字符串[]数组={“1.0.0.0-00000000-00000”、“2.1.0.0”、“2.2.0.0”、“2.3.0.0-00000000-00000”}；
String[]newArray=新字符串[arrays.length]；
类CustomComparator实现Comparator
{
@凌驾
公共整数比较（字符串a、字符串b）
{
如果（a.contains（“-”&&！b.contains（“-”）
返回1；
如果（！a.contains（“-”）&&b.contains（“-”）则为else
返回-1；
返回a.compareTo（b）；
}
}
sort（数组，新的CustomComparator（））；
for（字符串数组：数组）
{
System.out.println（数组）；
}
}
}
错误：
$javac HelloWorld.java 2>&1
java:25:错误：找不到适合排序的方法（字符串[]，CustomComparator）
排序（数组，新的CustomComparator（））；
^
方法集合。排序（列表，比较器使用比较器

    import java.util.Comparator;
    class CustomComparator implements Comparator<String> {
        @Override
        public int compare(String a, String b) {
            if(a.contains("-") && !b.contains("-"))
                 return 1;
            else if(!a.contains("-") && b.contains("-"))
                 return -1;
            return a.compareTo(b);
        }
    }
    Collections.sort(arrays, new CustomComparator());

import java.util.Comparator；
类CustomComparator实现Comparator{
@凌驾
公共整数比较（字符串a、字符串b）{
如果（a.contains（“-”&&！b.contains（“-”）
返回1；
如果（！a.contains（“-”）&&b.contains（“-”）则为else
返回-1；
返回a.compareTo（b）；
}
}
排序（数组，新的CustomComparator（））；

返回负值表示b在a之前，正值表示a在b之前
较小的值在较大的值之前。更改
比较器，如下所示

class CustomComparator implements Comparator<String>
{
    @Override
    public int compare(String a, String b)
    {
        if(a.contains("-") && !b.contains("-"))
             return -1;
        else if(!a.contains("-") && b.contains("-"))
             return 1;
        return a.compareTo(b);
    }
}

类CustomComparator实现Comparator
{
@凌驾
公共整数比较（字符串a、字符串b）
{
如果（a.contains（“-”&&！b.contains（“-”）
返回-1；
如果（！a.contains（“-”）&&b.contains（“-”）则为else
返回1；
返回a.compareTo（b）；
}
}

它很简单，无论数组大小、字符串大小或额外信息如何，都能正常工作。只需为Arrays.sort导入java.util.Arrays即可。如果简单，则无需执行不必要的操作。
尝试使用
string.contains（“-”）进行操作
您可以编写自定义比较-但这与排序算法无关（排序算法只需要一个相对排序函数）。请参阅（或数组的等效项）您需要自定义
比较器
数组。sort
有一个重载，它将一个作为参数。还请注意
数组的一些重载。sort
是稳定的，因此如果创建一个给出正确顺序的
比较器
似乎很困难，那么使用稳定排序进行两次排序可能会更容易使用Arrays.sort for Arrays我尝试了你所说的，但我得到了一个编译错误：下面是我的代码：public static void main（String[]args）{String[]Arrays={“1.0.0.0-00000000-00000”、“2.1.0.0”、“2.2.0.0”，“2.3.0.0-00000000-00000”}；类CustomComparator实现比较器{@Override public int compare（String a，String b）{if（a.contains（“-”&！b.contains（“-”）返回1；else if（！a.contains（“-”&&b.contains（“-”）return-1；return a.compareTo（b）；}}Collections.sort（数组，new CustomComparator（））；}}只是一个猜测，你导入了Comparator吗？正如我说的，请将你尝试的代码粘贴到原始问题中，它作为注释是不可读的。@user3767481如果你正在排序数组，那么就不要使用
集合。sort
但是
数组。sort
集合
处理集合，如
列表
s，
Set
s。
 int dashed = 0;    
//How many strings with a "-" are there?    
for (String s : arrays)    
    if ( s.contains("-") )    
        ++dashed;    

int undashed = arrays.length - dashed;
dashed = 0;
Arrays.sort(arrays);    

for (String s : arrays)    
     if ( s.contains("-") )    
        newArray[dashed++] = s;    
    else    
        newArray[undashed++] = s;