Wie werden Strings so sortiert, dass zuerst Werte mit zusätzlichen Informationen angezeigt werden?

Question

Ich versuche, die folgenden Strings

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

Im Moment habe ich diese Werte in einem Array von Strings zu sortieren.

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

Ich versuche, um eine Ausgabe zu haben, wo, wenn es keine „-“ dann diese Werte in einer sortierten Reihenfolge an das Ende meiner Array gehen. Ich versuche, um eine Ausgabe zu haben, wie folgt:

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

Ich habe Arrays.sort(arrays) versucht, aber ich bin mir nicht sicher, wie etwa das Sortieren dies zu realisieren?

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 

Answer 1

einen Komparator

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()); 

Rückkehr ein negativer Wert bedeutet, Verwenden b kommt vor dem und ein positiver Wert bedeutet, A vor B

Answer 2

Kleinere Werte kommt zuerst vor der größeren diejenigen kommt. Ändern Sie Ihre Comparator wie unten

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); 
    } 
} 

Answer 3

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; 

Es ist einfach und wird nicht unabhängig von der Größe des Arrays arbeiten, die Saiten oder zusätzliche Informationen. Importieren Sie einfach java.util.Arrays für Arrays.sort. Kein Grund unnötige Sachen zu machen, wenn Einfachheit möglich ist.