数字を含む可能性のある文字列で並べ替える
Java Stringsを比較するComparatorクラスを書く必要がありますが、1つのひねりがあります。比較している2つの文字列が文字列の先頭と末尾で同じ場合、異なる中間部分は整数であり、それらの整数の数値に基づいて比較しますたとえば、次の文字列を表示順に並べる必要があります。
- aaa
- bbb 3 ccc
- bbb 12 ccc
- ccc 11
- ddd
- eee 3 ddd jpeg2000 eee
- eee 12 ddd jpeg2000 eee
ご覧のとおり、文字列には他の整数が含まれている可能性があるため、正規表現を使用して整数を分割することはできません。私は、文字列を最初から一致しないビットを見つけるまで歩いてから、最後から一致しないビットを見つけるまで歩いて、中央のビットを正規表現「[0-9] +」。比較する場合は数値比較を行い、それ以外の場合は字句比較を行います。
もっと良い方法はありますか？
更新文字列内の他の数字、一致する可能性のある数字、周囲にスペースがないこと、または異なる数字にスペースがあることを保証できないと思います。
ウェブサイトから
「人々はソフトウェアとは異なる番号で文字列をソートします。ほとんどのソートアルゴリズムは、ASCII値を比較します。これにより、人間の論理と矛盾する順序が生成されます。
編集：ここに、そのサイトからの Javaコンパレータ実装 へのリンクがあります。
興味深い小さな挑戦、私はそれを解決することを楽しんだ。
問題に対する私の見解は次のとおりです。
String[] strs =
{
"eee 5 ddd jpeg2001 eee",
"eee 123 ddd jpeg2000 eee",
"ddd",
"aaa 5 yy 6",
"ccc 555",
"bbb 3 ccc",
"bbb 9 a",
"",
"eee 4 ddd jpeg2001 eee",
"ccc 11",
"bbb 12 ccc",
"aaa 5 yy 22",
"aaa",
"eee 3 ddd jpeg2000 eee",
"ccc 5",
};
Pattern splitter = Pattern.compile("(\\d+|\\D+)");
public class InternalNumberComparator implements Comparator
{
public int compare(Object o1, Object o2)
{
// I deliberately use the Java 1.4 syntax,
// all this can be improved with 1.5's generics
String s1 = (String)o1, s2 = (String)o2;
// We split each string as runs of number/non-number strings
ArrayList sa1 = split(s1);
ArrayList sa2 = split(s2);
// Nothing or different structure
if (sa1.size() == 0 || sa1.size() != sa2.size())
{
// Just compare the original strings
return s1.compareTo(s2);
}
int i = 0;
String si1 = "";
String si2 = "";
// Compare beginning of string
for (; i < sa1.size(); i++)
{
si1 = (String)sa1.get(i);
si2 = (String)sa2.get(i);
if (!si1.equals(si2))
break; // Until we find a difference
}
// No difference found?
if (i == sa1.size())
return 0; // Same strings!
// Try to convert the different run of characters to number
int val1, val2;
try
{
val1 = Integer.parseInt(si1);
val2 = Integer.parseInt(si2);
}
catch (NumberFormatException e)
{
return s1.compareTo(s2); // Strings differ on a non-number
}
// Compare remainder of string
for (i++; i < sa1.size(); i++)
{
si1 = (String)sa1.get(i);
si2 = (String)sa2.get(i);
if (!si1.equals(si2))
{
return s1.compareTo(s2); // Strings differ
}
}
// Here, the strings differ only on a number
return val1 < val2 ? -1 : 1;
}
ArrayList split(String s)
{
ArrayList r = new ArrayList();
Matcher matcher = splitter.matcher(s);
while (matcher.find())
{
String m = matcher.group(1);
r.add(m);
}
return r;
}
}
Arrays.sort(strs, new InternalNumberComparator());
このアルゴリズムはさらに多くのテストを必要としますが、かなりうまく動作するようです。
[編集]より明確にするためにコメントを追加しました。私がこれをコーディングし始めたときよりもはるかに多くの答えがあると思います...しかし、良い出発点やいくつかのアイデアを提供したいと思います。
MicrosoftのIan Griffithsには、彼が呼び出すC＃実装 Natural Sorting があります。 Javaへの移植は、とにかくCからよりもかなり簡単であるはずです！
UPDATE：Javaの例 eekboom これを行う、参照「compareNatural」を使用して、ソートの比較子として使用します。
ここで提案する実装は、シンプルで効率的です。 substring（）、split（）、toCharArray（）などの正規表現またはメソッドを使用して、直接的または間接的に余分なメモリを割り当てることはありません。
この実装は、最初に両方の文字列を調べて、異なる最初の文字を最大速度で検索します。この間に特別な処理は行われません。特定の数値比較は、これらの文字が両方とも数字である場合にのみトリガーされます。この実装の副作用は、デフォルトの辞書式順序に反して、数字が他の文字よりも大きいと見なされることです。
public static final int compareNatural (String s1, String s2)
{
// Skip all identical characters
int len1 = s1.length();
int len2 = s2.length();
int i;
char c1, c2;
for (i = 0, c1 = 0, c2 = 0; (i < len1) && (i < len2) && (c1 = s1.charAt(i)) == (c2 = s2.charAt(i)); i++);
// Check end of string
if (c1 == c2)
return(len1 - len2);
// Check digit in first string
if (Character.isDigit(c1))
{
// Check digit only in first string
if (!Character.isDigit(c2))
return(1);
// Scan all integer digits
int x1, x2;
for (x1 = i + 1; (x1 < len1) && Character.isDigit(s1.charAt(x1)); x1++);
for (x2 = i + 1; (x2 < len2) && Character.isDigit(s2.charAt(x2)); x2++);
// Longer integer wins, first digit otherwise
return(x2 == x1 ? c1 - c2 : x1 - x2);
}
// Check digit only in second string
if (Character.isDigit(c2))
return(-1);
// No digits
return(c1 - c2);
}
Javaを使用していることは承知していますが、StrCmpLogicalWの仕組みをご覧ください。 Windowsでファイル名をソートするためにExplorerが使用するものです。 WINEの実装を見ることができます こちら 。
文字列を文字と数字の連続に分割し、「foo 12 bar」がリスト（「foo」、12、「bar」）になり、リストをソートキーとして使用します。このように、数字はアルファベット順ではなく、数字順に並べられます。
Javaで正規表現を使用した非常に簡単な実装を思い付きました。
public static Comparator<String> naturalOrdering() {
final Pattern compile = Pattern.compile("(\\d+)|(\\D+)");
return (s1, s2) -> {
final Matcher matcher1 = compile.matcher(s1);
final Matcher matcher2 = compile.matcher(s2);
while (true) {
final boolean found1 = matcher1.find();
final boolean found2 = matcher2.find();
if (!found1 || !found2) {
return Boolean.compare(found1, found2);
} else if (!matcher1.group().equals(matcher2.group())) {
if (matcher1.group(1) == null || matcher2.group(1) == null) {
return matcher1.group().compareTo(matcher2.group());
} else {
return Integer.valueOf(matcher1.group(1)).compareTo(Integer.valueOf(matcher2.group(1)));
}
}
}
};
}
仕組みは次のとおりです。
final List<String> strings = Arrays.asList("x15", "xa", "y16", "x2a", "y11", "z", "z5", "x2b", "z");
strings.sort(naturalOrdering());
System.out.println(strings);
[x2a、x2b、x15、xa、y11、y16、z、z、z5]
Alphanum algrothimはいいですが、私が取り組んでいるプロジェクトの要件と一致しませんでした。負の数と小数を正しくソートできる必要があります。ここに私が思いついた実装があります。フィードバックは大歓迎です。
public class StringAsNumberComparator implements Comparator<String> {
public static final Pattern NUMBER_PATTERN = Pattern.compile("(\\-?\\d+\\.\\d+)|(\\-?\\.\\d+)|(\\-?\\d+)");
/**
* Splits strings into parts sorting each instance of a number as a number if there is
* a matching number in the other String.
*
* For example A1B, A2B, A11B, A11B1, A11B2, A11B11 will be sorted in that order instead
* of alphabetically which will sort A1B and A11B together.
*/
public int compare(String str1, String str2) {
if(str1 == str2) return 0;
else if(str1 == null) return 1;
else if(str2 == null) return -1;
List<String> split1 = split(str1);
List<String> split2 = split(str2);
int diff = 0;
for(int i = 0; diff == 0 && i < split1.size() && i < split2.size(); i++) {
String token1 = split1.get(i);
String token2 = split2.get(i);
if((NUMBER_PATTERN.matcher(token1).matches() && NUMBER_PATTERN.matcher(token2).matches()) {
diff = (int) Math.signum(Double.parseDouble(token1) - Double.parseDouble(token2));
} else {
diff = token1.compareToIgnoreCase(token2);
}
}
if(diff != 0) {
return diff;
} else {
return split1.size() - split2.size();
}
}
/**
* Splits a string into strings and number tokens.
*/
private List<String> split(String s) {
List<String> list = new ArrayList<String>();
try (Scanner scanner = new Scanner(s)) {
int index = 0;
String num = null;
while ((num = scanner.findInLine(NUMBER_PATTERN)) != null) {
int indexOfNumber = s.indexOf(num, index);
if (indexOfNumber > index) {
list.add(s.substring(index, indexOfNumber));
}
list.add(num);
index = indexOfNumber + num.length();
}
if (index < s.length()) {
list.add(s.substring(index));
}
}
return list;
}
}
PS。 Java.lang.String.split（）メソッドを使用し、「lookahead/lookbehind」を使用してトークンを保持したかったのですが、使用していた正規表現で動作させることができませんでした。
私の2セント。私にとってはうまくいっています。主にファイル名に使用しています。
private final boolean isDigit(char ch)
{
return ch >= 48 && ch <= 57;
}
private int compareNumericalString(String s1,String s2){
int s1Counter=0;
int s2Counter=0;
while(true){
if(s1Counter>=s1.length()){
break;
}
if(s2Counter>=s2.length()){
break;
}
char currentChar1=s1.charAt(s1Counter++);
char currentChar2=s2.charAt(s2Counter++);
if(isDigit(currentChar1) &&isDigit(currentChar2)){
String digitString1=""+currentChar1;
String digitString2=""+currentChar2;
while(true){
if(s1Counter>=s1.length()){
break;
}
if(s2Counter>=s2.length()){
break;
}
if(isDigit(s1.charAt(s1Counter))){
digitString1+=s1.charAt(s1Counter);
s1Counter++;
}
if(isDigit(s2.charAt(s2Counter))){
digitString2+=s2.charAt(s2Counter);
s2Counter++;
}
if((!isDigit(s1.charAt(s1Counter))) && (!isDigit(s2.charAt(s2Counter)))){
currentChar1=s1.charAt(s1Counter);
currentChar2=s2.charAt(s2Counter);
break;
}
}
if(!digitString1.equals(digitString2)){
return Integer.parseInt(digitString1)-Integer.parseInt(digitString2);
}
}
if(currentChar1!=currentChar2){
return currentChar1-currentChar2;
}
}
return s1.compareTo(s2);
}
興味深い問題、そしてここに私の提案した解決策：
import Java.util.Collections;
import Java.util.Vector;
public class CompareToken implements Comparable<CompareToken>
{
int valN;
String valS;
String repr;
public String toString() {
return repr;
}
public CompareToken(String s) {
int l = 0;
char data[] = new char[s.length()];
repr = s;
valN = 0;
for (char c : s.toCharArray()) {
if(Character.isDigit(c))
valN = valN * 10 + (c - '0');
else
data[l++] = c;
}
valS = new String(data, 0, l);
}
public int compareTo(CompareToken b) {
int r = valS.compareTo(b.valS);
if (r != 0)
return r;
return valN - b.valN;
}
public static void main(String [] args) {
String [] strings = {
"aaa",
"bbb3ccc",
"bbb12ccc",
"ccc 11",
"ddd",
"eee3dddjpeg2000eee",
"eee12dddjpeg2000eee"
};
Vector<CompareToken> data = new Vector<CompareToken>();
for(String s : strings)
data.add(new CompareToken(s));
Collections.shuffle(data);
Collections.sort(data);
for (CompareToken c : data)
System.out.println ("" + c);
}
}
このスレッドを発見する前に、javascriptで同様のソリューションを実装しました。おそらく、構文は異なりますが、私の戦略でうまく検索できます。上記と同様に、比較する2つの文字列を解析し、両方を配列に分割して、文字列を連続した数で分割します。
...
var regex = /(\d+)/g,
str1Components = str1.split(regex),
str2Components = str2.split(regex),
...
つまり、「hello22goodbye 33」=> [「hello」、22、「goodbye」、33];したがって、string1とstring2の間のペアで配列の要素をウォークスルーし、何らかの型強制を行い（この要素は本当に数字なのかなど）、歩きながら比較することができます。
ここでの作業例： http://jsfiddle.net/F46s6/3/
注意してください、私は現在、整数型のみをサポートしていますが、10進値の処理は修正するのにそれほど難しくありません。
質問ではJavaソリューションが必要ですが、scalaソリューションが必要な場合：
object Alphanum {
private[this] val regex = "((?<=[0-9])(?=[^0-9]))|((?<=[^0-9])(?=[0-9]))"
private[this] val alphaNum: Ordering[String] = Ordering.fromLessThan((ss1: String, ss2: String) => (ss1, ss2) match {
case (sss1, sss2) if sss1.matches("[0-9]+") && sss2.matches("[0-9]+") => sss1.toLong < sss2.toLong
case (sss1, sss2) => sss1 < sss2
})
def ordering: Ordering[String] = Ordering.fromLessThan((s1: String, s2: String) => {
import Ordering.Implicits.infixOrderingOps
implicit val ord: Ordering[List[String]] = Ordering.Implicits.seqDerivedOrdering(alphaNum)
s1.split(regex).toList < s2.split(regex).toList
})
}
私の問題は、アルファベットの文字列（C22、C3、C5など）、アルファベットの文字列（A、H、Rなど）と数字だけ（99、45など）の組み合わせで構成されるリストがあることです。順序A、C3、C5、C22、H、R、45、99。削除する必要がある重複もあるため、1つのエントリのみを取得します。
また、文字列だけでなく、オブジェクトを注文し、オブジェクト内の特定のフィールドを使用して正しい順序を取得しています。
私のために働くと思われる解決策は次のとおりです：
SortedSet<Code> codeSet;
codeSet = new TreeSet<Code>(new Comparator<Code>() {
private boolean isThereAnyNumber(String a, String b) {
return isNumber(a) || isNumber(b);
}
private boolean isNumber(String s) {
return s.matches("[-+]?\\d*\\.?\\d+");
}
private String extractChars(String s) {
String chars = s.replaceAll("\\d", "");
return chars;
}
private int extractInt(String s) {
String num = s.replaceAll("\\D", "");
return num.isEmpty() ? 0 : Integer.parseInt(num);
}
private int compareStrings(String o1, String o2) {
if (!extractChars(o1).equals(extractChars(o2))) {
return o1.compareTo(o2);
} else
return extractInt(o1) - extractInt(o2);
}
@Override
public int compare(Code a, Code b) {
return isThereAnyNumber(a.getPrimaryCode(), b.getPrimaryCode())
? isNumber(a.getPrimaryCode()) ? 1 : -1
: compareStrings(a.getPrimaryCode(), b.getPrimaryCode());
}
});
ここでStackoverflowで見つけたいくつかのコードに加えて、必要な方法で動作させるための独自の調整を「借用」します。
オブジェクトを注文しようとし、コンパレータと重複除去が必要なため、採用しなければならなかったネガティブなファッジの1つは、Treesetに書き込む前に、まずTreeMapにオブジェクトを書き込む必要があることでした。パフォーマンスに少し影響を与える可能性がありますが、リストが最大で約80コードになるため、問題になることはありません。
文字列にスペースで区切られたセグメントが含まれている場合も、同様の問題が発生しました。この方法で解決しました：
public class StringWithNumberComparator implements Comparator<MyClass> {
@Override
public int compare(MyClass o1, MyClass o2) {
if (o1.getStringToCompare().equals(o2.getStringToCompare())) {
return 0;
}
String[] first = o1.getStringToCompare().split(" ");
String[] second = o2.getStringToCompare().split(" ");
if (first.length == second.length) {
for (int i = 0; i < first.length; i++) {
int segmentCompare = StringUtils.compare(first[i], second[i]);
if (StringUtils.isNumeric(first[i]) && StringUtils.isNumeric(second[i])) {
segmentCompare = NumberUtils.compare(Integer.valueOf(first[i]), Integer.valueOf(second[i]));
if (0 != segmentCompare) {
// return only if uneven numbers in case there are more segments to be checked
return segmentCompare;
}
}
if (0 != segmentCompare) {
return segmentCompare;
}
}
} else {
return StringUtils.compare(o1.getDenominazione(), o2.getDenominazione());
}
return 0;
}
ご覧のとおり、ApacheのStringUtils.compare（）とNumberUtils.compere（）を標準のヘルプとして使用しました。
簡単な答え：コンテキストに基づいて、これが個人用の単なる汚いコードなのか、Goldman Sachsの最新の内部会計ソフトウェアの重要な部分なのかわからないので、次のように言います：eww 。これはかなりファンキーなソートアルゴリズムです。可能であれば、少し「ねじれた」ものを使用してみてください。
長い答え：
あなたのケースですぐに思い浮かぶ2つの問題は、パフォーマンスと正確さです。非公式には、高速であることを確認し、アルゴリズムが total ordering であることを確認してください。
（もちろん、約100個を超えるアイテムを並べ替えていない場合は、おそらくこの段落を無視できます。）コンパレータの速度が並べ替えの速度の最大の要因になるため、パフォーマンスが重要になります（並べ替えアルゴリズムが典型的なリストに「理想的」）。あなたの場合、コンパレータの速度は主に文字列のサイズに依存します。文字列はかなり短いように見えるので、おそらくリストのサイズほどは支配しません。
別の回答で提案されているように、各文字列をstring-number-string Tupleに変換し、このタプルのリストをソートすると、複数の数字が表示される文字列があるように見えるため、場合によっては失敗します。
他の問題は正確さです。具体的には、説明したアルゴリズムがA> B> ...> Aを許可する場合、ソートは非決定的です。あなたの場合、私はそれを証明することはできませんが、かもしれないと恐れています。次のような解析ケースを検討してください。
aa 0 aa
aa 23aa
aa 2a3aa
aa 113aa
aa 113 aa
a 1-2 a
a 13 a
a 12 a
a 2-3 a
a 21 a
a 2.3 a
文字ごとに比較する必要があると思います。文字を取得し、それが数字の場合、取得し続け、1つの数字文字列に文字に再アセンブルし、intに変換します。他の文字列で繰り返し、その後のみ比較を行います。