Java에서 숫자가 포함 된 문자열을 정렬하는 방법

Question

nr이있는 문자열을 정렬하려고합니다. 어떻게해야합니까?

내 정수 주에서

Class2 
"3" 
"4" 
"1" 

을 말할 수 있습니다 내가 class2.Sort을();

미리 감사드립니다.

Answer 1

public static void main(String[] args) 
    { 
    String string = "3 42 \n 11 \t 7 dsfss 365   \r 1"; 
    String[] numbers = string.split("\\D+"); 
    Arrays.sort(numbers, new Comparator<String>() 
    { 
     public int compare(String s1, String s2) 
     { 
     return Integer.valueOf(s1).compareTo(Integer.valueOf(s2)); 
     } 
    }); 
    System.out.println(Arrays.toString(numbers)); 
    } 

Answer 2

숫자가 모두 한자리 숫자 인 경우 문자열을 문자 배열로 분할하고 배열을 정렬하십시오. 그렇지 않으면 수를 구분하는 구분 기호가 있어야합니다. 해당 구분 기호를 사용하여 string.split을 호출하고 결과 배열을 정렬하십시오. 메모리 나에게 역할을 잘

의 javadoc가

http://java.sun.com/j2se/1.4.2/docs/api/java/lang/String.html#split%28java.lang.String%29 http://java.sun.com/javase/6/docs/api/java/util/Arrays.html#sort%28double[]%29

Answer 3

귀하의 질문은 오히려 잘못을 형성 참조하는 경우 정렬 기능은 Arrays.sort에()하지만, 여기에 몇 가지 있습니다 그

• 임의의 개체를 정렬하는 데 사용할 수있는 Arrays.sort(Object[])이 있습니다.
• String의 자연 순서는 lexicographic입니다.
• Java 배열은 공변입니다. String[]은 Object[]입니다. 당신이 전적으로 (즉 "1" < "10" < "2"), 단순히 Arrays.sort(sarr); 작품을 정렬 할 경우에 따라서

, String[] sarr을 부여. 문자열에 숫자가 포함되는지 여부는 중요하지 않습니다.

문자열을 숫자 (즉, "1" < "2" < "10")처럼 정렬하려면 문자열을 숫자 값으로 변환해야합니다. 이 숫자의 범위에 따라 Integer.parseInt 일 수 있습니다. 그렇지 않으면 항상 BigInteger을 사용할 수 있습니다.

BigInteger이 필요하다고 가정 해 봅시다.

은 이제 두 가지 옵션이 있습니다

• 변환 String[]BigInteger[]에를, 다음 BigInteger implements Comparable<BigInteger> 때문에, 당신은 그것의 자연적인 순서를 사용하여 Arrays.sort를 사용할 수 있습니다. 그런 다음 BigInteger[]을 String[]으로 다시 변환 할 수 있습니다.

• 사용자 정의 Comparator<String>에 대한 비교를 위해 에서 BigInteger으로의 변환을 "적시"로 변환하십시오. Arrays.sort은 비교 기반 mergesort를 사용하므로 O(N log N) 개의 비교가 가능하므로 많은 전환이 발생할 수 있습니다.

Answer 4

범용 솔루션은 '자연 순서 비교기'를 사용하는 것입니다.

다음은 예입니다 : 문자열 숫자의 실행을 포함 할 수 있습니다 당신이 일을 숫자에 알파벳 문자에 있지만 숫자로 정렬 할 경우

http://pierre-luc.paour.9online.fr/NaturalOrderComparator.java

자연 순서 실제로 경우에 매우 중요하다. 최신 버전의 Windows 탐색기에서는 예를 들어 파일 이름을 주문할 때이를 사용합니다. 또한 버전 문자열 (예 : "1.2.3"과 "1.20.1")을 기반으로 최신 버전의 라이브러리를 선택하는 것이 매우 편리합니다.

문자열에 숫자가 실제로 포함되어 있으면 (예 : 설명에 넣은 것처럼) 문자열을 사용하지 않는 것이 가장 좋습니다. 정수 개체를 만들고 대신 사용할 수 있습니다.

참고 : 위 링크는 깨진 것 같습니다. 두 가지 중 어느 것이 먼저에 따라 있습니다 알고있는 비교기를 만드는 몇 가지 순서에 따라 "일을"정렬

/* 
* <copyright> 
* 
* Copyright 1997-2007 BBNT Solutions, LLC 
* under sponsorship of the Defense Advanced Research Projects 
* Agency (DARPA). 
* 
* You can redistribute this software and/or modify it under the 
* terms of the Cougaar Open Source License as published on the 
* Cougaar Open Source Website (www.cougaar.org). 
* 
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
* 
* </copyright> 
*/ 
/* 
NaturalOrderComparator.java -- Perform 'natural order' comparisons of strings in Java. 
Copyright (C) 2003 by Pierre-Luc Paour <natorder@paour.com> 

Based on the C version by Martin Pool, of which this is more or less a straight conversion. 
Copyright (C) 2000 by Martin Pool <mbp@humbug.org.au> 

This software is provided 'as-is', without any express or implied 
warranty. In no event will the authors be held liable for any damages 
arising from the use of this software. 

Permission is granted to anyone to use this software for any purpose, 
including commercial applications, and to alter it and redistribute it 
freely, subject to the following restrictions: 

1. The origin of this software must not be misrepresented; you must not 
claim that you wrote the original software. If you use this software 
in a product, an acknowledgment in the product documentation would be 
appreciated but is not required. 
2. Altered source versions must be plainly marked as such, and must not be 
misrepresented as being the original software. 
3. This notice may not be removed or altered from any source distribution. 
*/ 
package org.cougaar.util; 

//CHANGES: KD - added case sensitive ordering capability 
// Made comparison so it doesn't treat spaces as special characters 

//CHANGES: 
// set package to "org.cougaar.util" 
// replaced "import java.util.*" with explicit imports, 
// added "main" file reader support 

import java.util.Comparator; 

/** 
* A sorting comparator to sort strings numerically, 
* ie [1, 2, 10], as opposed to [1, 10, 2]. 
*/ 
public final class NaturalOrderComparator<T> implements Comparator<T> { 

    public static final Comparator<String> NUMERICAL_ORDER = new NaturalOrderComparator<String>(false); 
    public static final Comparator<String> CASEINSENSITIVE_NUMERICAL_ORDER = new NaturalOrderComparator<String>(true); 

    private final boolean caseInsensitive; 

    private NaturalOrderComparator(boolean caseInsensitive) { 
     this.caseInsensitive = caseInsensitive; 
    } 

    int compareRight(String a, String b) { 
     int bias = 0; 
     int ia = 0; 
     int ib = 0; 

     // The longest run of digits wins. That aside, the greatest 
     // value wins, but we can't know that it will until we've scanned 
     // both numbers to know that they have the same magnitude, so we 
     // remember it in BIAS. 
     for (;; ia++, ib++) { 
      char ca = charAt(a, ia); 
      char cb = charAt(b, ib); 

      if (!Character.isDigit(ca) && !Character.isDigit(cb)) { 
       return bias; 
      } else if (!Character.isDigit(ca)) { 
       return -1; 
      } else if (!Character.isDigit(cb)) { 
       return +1; 
      } else if (ca < cb) { 
       if (bias == 0) { 
        bias = -1; 
       } 
      } else if (ca > cb) { 
       if (bias == 0) 
        bias = +1; 
      } else if (ca == 0 && cb == 0) { 
       return bias; 
      } 
     } 
    } 

    public int compare(T o1, T o2) { 
     String a = o1.toString(); 
     String b = o2.toString(); 

     int ia = 0, ib = 0; 
     int nza = 0, nzb = 0; 
     char ca, cb; 
     int result; 

     while (true) { 
      // only count the number of zeroes leading the last number compared 
      nza = nzb = 0; 

      ca = charAt(a, ia); 
      cb = charAt(b, ib); 

      // skip over leading zeros 
      while (ca == '0') { 
       if (ca == '0') { 
        nza++; 
       } else { 
        // only count consecutive zeroes 
        nza = 0; 
       } 

       // if the next character isn't a digit, then we've had a run of only zeros 
       // we still need to treat this as a 0 for comparison purposes 
       if (!Character.isDigit(charAt(a, ia+1))) 
        break; 

       ca = charAt(a, ++ia); 
      } 

      while (cb == '0') { 
       if (cb == '0') { 
        nzb++; 
       } else { 
        // only count consecutive zeroes 
        nzb = 0; 
       } 

       // if the next character isn't a digit, then we've had a run of only zeros 
       // we still need to treat this as a 0 for comparison purposes 
       if (!Character.isDigit(charAt(b, ib+1))) 
        break; 

       cb = charAt(b, ++ib); 
      } 

      // process run of digits 
      if (Character.isDigit(ca) && Character.isDigit(cb)) { 
       if ((result = compareRight(a.substring(ia), b 
         .substring(ib))) != 0) { 
        return result; 
       } 
      } 

      if (ca == 0 && cb == 0) { 
       // The strings compare the same. Perhaps the caller 
       // will want to call strcmp to break the tie. 
       return nza - nzb; 
      } 

      if (ca < cb) { 
       return -1; 
      } else if (ca > cb) { 
       return +1; 
      } 

      ++ia; 
      ++ib; 
     } 
    } 

    private char charAt(String s, int i) { 
     if (i >= s.length()) { 
      return 0; 
     } else { 
      return caseInsensitive ? Character.toUpperCase(s.charAt(i)) : s.charAt(i); 
     } 
    } 


} 

Answer 5

방법입니다 : 코드는 내가 여기에 게시거야 너무 유용 명령을 내리거나 "물건"자체가 Comparable 인터페이스를 구현하게하여 비교자를 필요로하지 않게하십시오.

작업이 정수로 정렬 할 경우

는 다음 Integer 클래스가 이미 Comparable를 구현으로 다음 종류의 정수로 및 을 변환하는 것이 좋습니다.

Answer 6

자바 8에서 우리는 좋은 해결책이

public static List<String> sortAsNumbers(Collection<String> collection) { 
    return collection 
      .stream() 
      .map(Integer::valueOf) 
      .sorted() 
      .map(String::valueOf) 
      .collect(Collectors.toList()); 
} 

Answer 7

static final Comparator<Object> COMPARADOR = new Comparator<Object>() { 
    public int compare(Object o1, Object o2) { 
     double numero1; 
     double numero2; 
     try { 
      numero1 = Double.parseDouble(o1.toString()); 
      numero2 = Double.parseDouble(o2.toString()); 
      return Double.compare(numero1, numero2); 
     } catch (Exception e) { 
      return o1.toString().compareTo(o2.toString()); 
     } 
    } 
}; 

... 의 ArrayList listaDeDatos; listaDeDatos.sort (COMPARADOR);