【问题标题】:Java- How to sort an array of strings that contain periods / dots without extending comparator?Java-如何在不扩展比较器的情况下对包含句点/点的字符串数组进行排序?
【发布时间】:2017-11-20 21:09:59
【问题描述】:

这里是 Java 菜鸟。我想对包含句点/点的字符串数组从小到大进行排序。

所以一个数组包含:

1.0.3
1.0.12
1.0.2

这样排序不正确:

1.0.12
1.0.2
1.0.3

当排序正确应该是:

1.0.2
1.0.3
1.0.12

这是我到目前为止的代码,但它排序不正确。

public static String[] sort(String[] l) {
        String[] ll=new String[l.length];
        for(int i=0;i<l.length;i++)
        {

        }

        for (int i = 0; i < l.length - 1; ++i) {
            int minIndex = i;
            for (int j = i + 1; j < l.length; ++j) {

                if (l[j].compareTo(l[minIndex]) < 0) {
                    minIndex = j;
                }
            }

            String temp = l[i];
            l[i] = l[minIndex];
            l[minIndex] = temp;


        }
        return l;


    }

【问题讨论】:

  • 您可以在字符串上使用split 方法来获取像String[] values = ll.split("\\.") 这样的字符串数组 - 需要转义点。
  • “我读到比较器方法应该有助于这项工作,但我不确定我是否可以在方法中实现。” Comparator 是一个接口,而不是一个方法——是什么让你认为实现它行不通?
  • 我想我有一个误解,即 Comparator 仅适用于类。我会调查的,谢谢。
  • +1 @JonSkeet 的评论。这里正确的解决方案是实现一个比较器。然后你可以使用标准的 Arrays.sort 方法用你的比较器对其进行排序,这意味着你不需要自己实现排序。
  • 您可能对 Comparable 感到困惑,您需要一个类来实现它。比较器在处理这类问题时要简单得多。

标签: java arrays string sorting


【解决方案1】:

EDIT完整、可运行的版本。

使用类,可能更简单:

public class Version implements Comparable<Version> {

   public final int     major;
   public final Integer minor;
   public final Integer patch;

   public Version( String ver ) {
      final String[] parts = ver.split("\\.");
      this.major = Integer.parseInt( parts[0] );
      if( parts.length > 1 ) {
         this.minor = Integer.parseInt( parts[1] );
         if( parts.length > 2 ) {
            this.patch = Integer.parseInt( parts[2] );
         }
         else {
            this.patch = null;
         }
      }
      else {
         this.minor = null;
         this.patch = null;
      }
   }

   @Override
   public int compareTo( Version right ) {
      int diff = this.major - right.major;
      if( diff != 0 ) {
         return diff;
      }
      if( this.minor == null && right.minor == null ) {
         return 0;
      }
      if( this.minor == null && right.minor != null ) {
         return -1;
      }
      if( this.minor != null && right.minor == null ) {
         return +1;
      }
      diff = this.minor - right.minor;
      if( diff != 0 ) {
         return diff;
      }
      if( this.patch == null && right.patch == null ) {
         return 0;
      }
      if( this.patch == null && right.patch != null ) {
         return -1;
      }
      if( this.patch != null && right.patch == null ) {
         return +1;
      }
      diff = this.patch - right.patch;
      return diff;
   }

   @Override
   public String toString() {
      return String.format( "%d.%d.%d", major, minor, patch );
   }

   public static void main( String[] args ) {
      final List<Version> versions = new ArrayList<>( 20 );
      versions.add( new Version( "5.3" ));
      versions.add( new Version( "5.3.0" ));
      versions.add( new Version( "2.5" ));
      versions.add( new Version( "2.5.100" ));
      final Random r = new Random( System.currentTimeMillis());
      for( int i = 0; i < 20; ++i ) {
         final int maj = r.nextInt(  10 );
         final int min = r.nextInt(  10 );
         final int pat = r.nextInt( 100 );
         final Version v =
            new Version( String.format( "%d.%d.%d", maj, min, pat ));
         versions.add( v );
      }
      Collections.sort( versions );
      versions.forEach( System.err::println );
   }
}

执行跟踪:

0.5.55
0.9.54
1.1.60
1.7.19
1.8.15
2.2.85
2.5.null
2.5.100
2.7.68
2.8.42
3.1.57
3.2.50
4.4.18
5.3.null
5.3.0
6.3.0
7.1.26
7.2.30
7.4.47
7.5.63
7.6.13
8.6.12
8.9.80
9.8.4

【讨论】:

  • 谢谢你的回答,但我需要用一种方法来做:(
  • ...这是一个非常奇怪的要求。良好的实践要求将问题拆分为更小的问题,并为每个问题使用一种方法甚至类。要求包含在单一方法中的解决方案需要糟糕的风格。
  • 嗯当然你从一个方法调用排序!比较不只是自己发生! @Aubin 展示了使用什么作为编写该方法的一个步骤。如此明显地拒绝为这样的事情提供解决方案是一种误解,这将是非常愚蠢的。相反,请考虑它如何适合您的完整解决方案。
【解决方案2】:

您可以使用流来完成手头的任务。您可以在分隔符. 上拆分字符串,然后将每个数字与其他数字进行比较,而不是仅按原样比较字符串;当我们发现两个或多个字符串之间的两个数字相等时,我们会使用.thenComparingInt 来进一步比较。

String[] array = {"1.0.3" ,"1.0.12", "1.0.2"};
String[] result = Arrays.stream(array)
        .sorted(Comparator.comparingInt((String x) -> Integer.parseInt(x.split("\\.")[0]))
        .thenComparingInt((String x) -> Integer.parseInt(x.split("\\.")[1]))
        .thenComparingInt((String x) -> Integer.parseInt(x.split("\\.")[2]))).toArray(String[]::new);

结果数组包含:

[1.0.2, 1.0.3, 1.0.12]

【讨论】:

  • 此答案假定您在每个字符串中始终有 3 个部分,但在描述中并未将其指定为始终正确。不要假设示例数据总是具有代表性。
  • 假设他有一个确定的最大零件数量,是的。但正如我们在描述中看到的那样,部分的数量可以任意多。
【解决方案3】:

也许解析和转换为数字很脏,但它解决了我们的问题。

public void test() {

    List<String> versions = new ArrayList<>(Arrays.asList(
            "1.0",
            "1.0.3",
            "1.1.131",
            "1.0.12",
            "1.0.2"
    ));
    List<String> expectedVersions = Arrays.asList(
            "1.0",
            "1.0.2",
            "1.0.3",
            "1.0.12",
            "1.1.131"
    );
    Comparator<String> versionComparator = new Comparator<String>() {

        @Override
        public int compare(String o1, String o2) {
            return parsedVersion(o1) - parsedVersion(o2);
        }

        private int parsedVersion(String version) {
            String cleared = version.replaceAll("\\.", "");
            return Integer.parseInt(cleared);
        }
    };
    versions.sort(versionComparator);
    System.out.println(versions.equals(expectedVersions));
}

【讨论】:

    猜你喜欢
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 2020-05-30
    • 2022-01-20
    • 2011-02-01
    • 1970-01-01
    • 2012-12-02
    • 1970-01-01
    相关资源
    最近更新 更多