Java：根据匹配的字符串/模式对数组进行排序

我需要对一个数组进行排序，在这个数组中匹配的项会出现，而其他项会出现

例如，我有一个数组：[z，asxdf，abasdf，abcasdf，b，bc，bcd，c] 我需要的是，当我传递一个关键字时，假设“b”，那么它应该对给定的数组进行排序，其中所有以b开头的字符串都将排在第一位，其余的则排在第二位。将生成最终输出：[b，bc，bcd，z，c，…（rest）。

是否可以在Java中使用comparator

String keyWord = "b";
String[] s = {"z", "asxdf", "abasdf", "abcasdf", "b", "bc", "bcd", "c"};
Arrays.sort(s, new Comparator<String>() {

    @Override
    public int compare(String o1, String o2) {

            //Code to sort array according to need

    }
});
System.out.println(Arrays.toString(s));

String关键字=“b”；
字符串[]s={“z”、“asxdf”、“abasdf”、“abcasdf”、“b”、“bc”、“bcd”、“c”}；
sort，新的比较器（）{
@凌驾
公共整数比较（字符串o1、字符串o2）{
//根据需要对数组进行排序的代码
}
});
System.out.println（Arrays.toString）；

结果->[b，bc，bcd，z，c，…]

（我可以使用列表而不是数组，或者其他任何有助于解决此问题的方法）

关于：

List result = new ArrayList();
for(int i=0;i<s.length();i++) {
    if(s[i].startsWith(keyWord)) {
        result.add(s[i], 0);  // Adding to the beginning
    } else {
        result.add(s[i]);  // Adding to the end
    }
}

List result=new ArrayList（）；
对于（int i=0；i回答是否可以使用比较器进行比较的问题，答案是肯定的：您只需要创建一个新的比较器类，而不是创建一个匿名比较器，如下所示：

    class MyComparator implements Comparator<String> {

        private final String keyWord;

        MyComparator(String keyWord) {
            this.keyWord = keyWord;
        }

        @Override
        public int compare(String o1, String o2) {

            if(o1.startsWith(keyWord)) {
                return o2.startsWith(keyWord)? o1.compareTo(o2): -1;
            } else {
                return o2.startsWith(keyWord)? 1: o1.compareTo(o2); 
            }
        }
    }

就因为它比较短：

@Override
public int compare(String o1, String o2) {
    boolean firstMatches = o1.startsWith(keyWord);
    boolean secondMatches = o2.startsWith(keyWord);
    if (firstMatches != secondMatches) {
        return firstMatches ? -1 : 1;
    }
    return 0;  // or refine the sort sort here
}

因为关键字匹配后的字符串长度似乎很重要，所以我的版本如下：

Arrays.sort(s, new Comparator<String>() {

    @Override
    public int compare(String o1, String o2) {

        boolean o1Has = o1.startsWith( keyWord );
        boolean o2Has = o2.startsWith( keyWord );

        if( o1Has && !o2Has  ) return -1;
        else if( o2Has && !o1Has ) return 1;
        else if( o1Has && o2Has ) return 0;
        else
            return o1.length() - o2.length();
    }
});

数组。排序，新的比较器（）{
@凌驾
公共整数比较（字符串o1、字符串o2）{
布尔值o1Has=o1.startsWith（关键字）；
布尔值o2Has=o2.startsWith（关键字）；
如果（o1Has&！o2Has）返回-1；
否则如果（o2Has&！o1Has）返回1；
否则如果（o1Has&&o2Has）返回0；
其他的
返回o1.length（）-o2.length（）；
}
});

收益率：

---

[b、bc、bcd、z、c、asxdf、abasdf、abcasdf]

我还想补充一点，您可以在本Oracle教程中阅读有关

比较器
和
可比
。
请检查以下内容

package com.pantech.sam.demos;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class SortArray {

/**
 * @param args
 */
private final static char keyWord = 'b';

public static void main(String[] args) {
    // TODO Auto-generated method stub
    String[] s = {"z", "asxdf", "abasdf", "abcasdf", "b", "bc", "bcd", "c"};

    System.out.println("FIRST WAY " + sortArray(s));

    Arrays.sort(s, new CustomeComparator(keyWord));
    System.out.println("SECOND WAY" + Arrays.toString(s));

}

static List<String> sortArray(String[] sArray){
    Arrays.sort(sArray) ;
    List<String> l1 = Arrays.asList(sArray);
    List<String> l2 = new ArrayList<String>(l1.size());
    int index = 0;
    for (String str : l1) {
        if (str.charAt(0) == keyWord) {
            l2.add(index++,str); // add at start
        }else{
            l2.add(l2.size(), str); // add at end
        }

    }
    return l2;
}

}


class CustomeComparator implements Comparator<String> {
private final char keyWord;

CustomeComparator(char keyword2) {
    this.keyWord = keyword2;
}


@Override
public int compare(String o1, String o2) {
    // TODO Auto-generated method stub
      if(o1.charAt(0) == (keyWord)) {
            return o2.charAt(0) == (keyWord)? o1.compareTo(o2): -1;
        } else {
            return o2.charAt(0) == (keyWord)? 1: o1.compareTo(o2); 
        }   }
}

package com.pantech.sam.demos；
导入java.util.ArrayList；
导入java.util.array；
导入java.util.Comparator；
导入java.util.List；
公营索塔雷酒店{
/**
*@param args
*/
私有最终静态字符关键字='b'；
公共静态void main（字符串[]args）{
//TODO自动生成的方法存根
字符串[]s={“z”、“asxdf”、“abasdf”、“abcasdf”、“b”、“bc”、“bcd”、“c”}；
System.out.println（“第一条路”+sortArray（s））；
排序（s，新的CustomeComparator（关键字））；
System.out.println（“第二条路”+数组.toString）；
}
静态列表sortArray（字符串[]sArray）{
数组。排序（sArray）；
列表l1=Arrays.asList（sArray）；
列表l2=新的ArrayList（l1.size（））；
int指数=0；
用于（字符串str:l1）{
if（str.charAt（0）=关键字）{
l2.add（index++，str）；//开始时添加
}否则{
l2.add（l2.size（），str）；//在末尾添加
}
}
返回l2；
}
}
类CustomeComparator实现Comparator{
私有最终字符关键字；
CustomeComparator（字符关键字2）{
this.keyWord=keyword2；
}
@凌驾
公共整数比较（字符串o1、字符串o2）{
//TODO自动生成的方法存根
if（o1.charAt（0）==（关键字））{
返回o2.charAt（0）=（关键字）？o1.compareTo（o2）：-1；
}否则{
返回o2.charAt（0）=（关键字）？1:o1.compareTo（o2）；
}   }
}
那么你想让我们为你做比较算法吗？是的，如果不会对你造成伤害的话。但是如果你再次阅读我的问题，你会看到我问的“是否可以在Java中使用comparator？”。算法是否必须是稳定的，即两个组中每个组的元素顺序是否必须与原始数组中的元素顺序相同？不，但优先顺序将是那些最匹配关键字的人。你说“最佳匹配”是什么意思？要么匹配，要么不匹配。我有一个类似的方法。你比我强！；）谢谢你们的努力，但我需要一个comparator和sort（）方法？[b、bc、bcd、z、c、asxdf、abcasdf、abasdf、abasdf]抱歉，这不起作用。抱歉，修复了打字错误（o1被使用了两次，o2一点也不起作用）谢谢，这很好，但问题是它对关键字='b'、'bc'和'bcd'都起作用……我以为您只想对关键字使用一个字符。我将更新用作关键字的字符串谢谢您的参考，我一定会阅读。@n0741337非常感谢！成功了：）
@Override
public int compare(String o1, String o2) {
    boolean firstMatches = o1.startsWith(keyWord);
    boolean secondMatches = o2.startsWith(keyWord);
    if (firstMatches != secondMatches) {
        return firstMatches ? -1 : 1;
    }
    return 0;  // or refine the sort sort here
}

Arrays.sort(s, new Comparator<String>() {

    @Override
    public int compare(String o1, String o2) {

        boolean o1Has = o1.startsWith( keyWord );
        boolean o2Has = o2.startsWith( keyWord );

        if( o1Has && !o2Has  ) return -1;
        else if( o2Has && !o1Has ) return 1;
        else if( o1Has && o2Has ) return 0;
        else
            return o1.length() - o2.length();
    }
});

package com.pantech.sam.demos;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class SortArray {

/**
 * @param args
 */
private final static char keyWord = 'b';

public static void main(String[] args) {
    // TODO Auto-generated method stub
    String[] s = {"z", "asxdf", "abasdf", "abcasdf", "b", "bc", "bcd", "c"};

    System.out.println("FIRST WAY " + sortArray(s));

    Arrays.sort(s, new CustomeComparator(keyWord));
    System.out.println("SECOND WAY" + Arrays.toString(s));

}

static List<String> sortArray(String[] sArray){
    Arrays.sort(sArray) ;
    List<String> l1 = Arrays.asList(sArray);
    List<String> l2 = new ArrayList<String>(l1.size());
    int index = 0;
    for (String str : l1) {
        if (str.charAt(0) == keyWord) {
            l2.add(index++,str); // add at start
        }else{
            l2.add(l2.size(), str); // add at end
        }

    }
    return l2;
}

}


class CustomeComparator implements Comparator<String> {
private final char keyWord;

CustomeComparator(char keyword2) {
    this.keyWord = keyword2;
}


@Override
public int compare(String o1, String o2) {
    // TODO Auto-generated method stub
      if(o1.charAt(0) == (keyWord)) {
            return o2.charAt(0) == (keyWord)? o1.compareTo(o2): -1;
        } else {
            return o2.charAt(0) == (keyWord)? 1: o1.compareTo(o2); 
        }   }
}