Mithilfe der binarysearch-Methode mit Komparator und regex

Sollte dies funktionieren:

        Comparator<String> startsWithComparator = new Comparator<String>() {
            public int compare(String currentItem, String key) {
                if(currentItem.startsWith(key)) {
                    return 0;
                }
                return currentItem.compareTo(key);
            }
        };

int index = Collections.binarySearch(items, "contact.", startsWithComparator);

Jedoch Sortieren und dann Binär suchen, ist weniger effizient als die single-pass-iteration.

Nachtrag:

Obwohl die obigen Antworten helfen Sie, hier ist noch eine Möglichkeit (inspiriert von Scala, Google-Collections) :

List<String> items = Arrays.asList("one", "two", "three", "four", "five", "six");
int index = find(items, startsWithPredicate("th"));
System.out.println(index);


public static Predicate<String> startsWithPredicate(final String key) {
    return new Predicate<String>(){
        @Override
        public boolean apply(String item) {
            return item.startsWith(key); 
        }
    };
}

public static <T> int find(Collection<T> items, Predicate<T> predicate) {
    int index = 0;
    for(T item: items) {
        if(predicate.apply(item)) {
            return index;
        }
        index++;
    }
    return -1;
}

interface Predicate<T> {
    boolean apply(T item);
}

Hier die Sache ist die find () - Methode ist nicht gebunden, die mit Ihrem 'matching' - Logik; Sie findet Sie einfach ein element, das erfüllt das Prädikat. Man könnte also pass auf eine andere Implementierung des Prädikats, für die ex. das überprüfen kann, 'endsWith" zu finden () - Methode und würde es wieder das Gefundene Element, das endet mit einer bestimmten Zeichenfolge. Weiter gibt die find () - Methode funktioniert für jede Art von Sammlung; alle es braucht ist ein Prädikat, das transformiert ein element der collection element-type "boolean". Diese mehrere Zeilen code um eine einfache Logik, die auch zeigen, das Java der fehlenden Unterstützung für first-class-Funktionen.

Ich denke, dass die Art und Weise Sie dies tun, jetzt ist eigentlich der beste Weg vom performance-Standpunkt aus. Die Sortierung selbst ist wohl teurer als einfach, Durchlaufen die unsortierte Liste. Aber um sicher zu sein müsste man einige tests machen (obwohl das nicht so einfach, wie es klingt durch die JIT-Kompilierung).

Ist das Kriterium, die Sie suchen, für immer "beginnt mit"? Weil Ihre Frage, Sie sprechen über eine regex.

Wenn Sie wollen, um dies zu implementieren, sollten Sie mindestens verwenden Sie die gleichen Comparator für die Sortierung als für die Suche. Der Komparator selbst kann sehr einfach sein. Schreiben Sie einfach eine, die bringt das alles passt perfekt zu Ihrem Kriterium vor, alles was nicht. Meine syntax nicht ganz korrekt, da ich nicht getan habe Java in eine Weile.

public class MyComparator<string> implements Comparator<string> {
    private string prefix;
    public MyComparator(string prefix) {
        this.prefix = prefix;
    }
    public int compare(string s0, string s1) {
        if (s0.startsWith(prefix) && s1.startsWith(prefix)) {
            return 0;
        }
        else if (s0.startsWith(prefix)) {
            return -1;
        }
        else if (s1.startsWith(prefix)) {
            return 1;
        }
        return 0;
    }
    public bool equals(object comp) {
        return true;
    }
}

Nur ein weiterer Komparator (mit regex):

Comparator<String> comparator = new Comparator<String>() {

    private final Pattern containsPattern = Pattern.compile(searchTerm,Pattern.CASE_INSENSITIVE);

    public int compare(String o1, String o2) {

        Matcher contains1 = containsPattern.matcher(o1);
        Matcher contains2 = containsPattern.matcher(o2);
        boolean find1 = contains1.find();
        boolean find2 = contains2.find();

        if(find1 && find2){
            int compareContains = contains1.end() - contains2.end();
            if (compareContains == 0) {
                return o1.compareTo(o2);
            } else {
                return compareContains;
            }
        }else if(find1){
            return -1;
        }else if(find2){
            return 1;
        }else{
            return o1.compareTo(o2);
        } 
    } 
};

Input ArrayList (search term: dog):

"yxcv",
"dogb",
"doga",
"abcd",
"ein Hund"

Output(sorted) ArrayList:

"doga",
"dogb",
"ein Hund",
"abcd",
"yxcv"