Wie Sie abschneiden einer Zeichenkette nach n-Wörter in Java?

Gibt es Bibliothek, eine routine für das abschneiden einer Zeichenfolge nach n Wörter? Ich bin auf der Suche nach etwas, dass können schalten Sie:

truncateAfterWords(3, "hello, this\nis a long sentence");

"hello, this\nis"

Könnte ich schreiben es selbst, aber ich dachte, so etwas könnte existieren bereits in einigen open-source-string-manipulation-Bibliothek.

Hier ist eine vollständige Liste der Testfälle, würde ich erwarten, dass jede Lösung zu übergeben:

import java.util.regex.*;

public class Test {

    private static final TestCase[] TEST_CASES = new TestCase[]{
        new TestCase(5, null, null),
        new TestCase(5, "", ""),
        new TestCase(5, "single", "single"),
        new TestCase(1, "single", "single"),
        new TestCase(0, "single", ""),
        new TestCase(2, "two words", "two words"),
        new TestCase(1, "two words", "two"),
        new TestCase(0, "two words", ""),
        new TestCase(2, "line\nbreak", "line\nbreak"),
        new TestCase(1, "line\nbreak", "line"),
        new TestCase(2, "multiple  spaces", "multiple  spaces"),
        new TestCase(1, "multiple  spaces", "multiple"),
        new TestCase(3, " starts with space", " starts with space"),
        new TestCase(2, " starts with space", " starts with"),
        new TestCase(10, "A full sentence, with puncutation.", "A full sentence, with puncutation."),
        new TestCase(4, "A full sentence, with puncutation.", "A full sentence, with"),
        new TestCase(50, "Testing a very long number of words in the testcase to see if the solution performs well in such a situation.  Some solutions don't do well with lots of input.", "Testing a very long number of words in the testcase to see if the solution performs well in such a situation.  Some solutions don't do well with lots of input."),
    };

    public static void main(String[] args){
        for (TestCase t: TEST_CASES){
            try {
                String r = truncateAfterWords(t.n, t.s);
                if (!t.equals(r)){
                    System.out.println(t.toString(r));
                }
            } catch (Exception x){
                System.out.println(t.toString(x));
            }       
        }   
    }

    public static String truncateAfterWords(int n, String s) {
        //TODO: implementation
        return null;
    }
}


class TestCase {
    public int n;
    public String s;
    public String e;

    public TestCase(int n, String s, String e){
        this.n=n;
        this.s=s;
        this.e=e;
    }

    public String toString(){
        return "truncateAfterWords(" + n + ", " + toJavaString(s) + ")\n  expected: " + toJavaString(e);
    }

    public String toString(String r){
        return this + "\n  actual:   " + toJavaString(r) + "";
    }

    public String toString(Exception x){
        return this + "\n  exception: " + x.getMessage();
    }    

    public boolean equals(String r){
        if (e == null && r == null) return true;
        if (e == null) return false;
        return e.equals(r);
    }   

    public static final String escape(String s){
        if (s == null) return null;
        s = s.replaceAll("\\\\","\\\\\\\\");
        s = s.replaceAll("\n","\\\\n");
        s = s.replaceAll("\r","\\\\r");
        s = s.replaceAll("\"","\\\\\"");
        return s;
    }

    private static String toJavaString(String s){
        if (s == null) return "null";
        return " \"" + escape(s) + "\"";
    }
}

Gibt es Lösungen für diese auf dieser Website in anderen Sprachen:

Ich glaube nicht, dass es eine Funktion wie diese, die Aussehen wie etwas ganz besonderes.
Sie können die Verwendung von split(), split-Worte auf " ", und dann zählen Sie Sie auf und wenn Sie mehr als 3, verwerfen Sie den rest. Aber Nein, ich habe noch nie auf etwas gestossen, wie dies bereits gemacht.
Ich dachte an split, aber es neigt dazu, um Sie wegzuwerfen, das, was Sie auf Spalten. Ich will bewahren das Leerzeichen und neue Zeilen in der Zeichenfolge.
anstelle der Verwendung von String.spilt(), ich würde es vorziehen, zu verwenden Scanner Klasse next(). Als die spilt() . Lesen Sie mehr zu diesem link
Meine Antwort unten funktioniert Prima mit Ihr bearbeitet input-string hello, this\nis a long sentence als gut.
Wenn es funktioniert, dann vergessen Sie nicht, markieren Sie es akzeptiert, wenn du kannst 😛

InformationsquelleAutor Stephen Ostermiller | 2013-04-11

java string

4

Können Sie eine einfache regex-basierte Lösung:
```
private String truncateAfterWords(int n, String str) {
   return str.replaceAll("^((?:\\W*\\w+){" + n + "}).*$", "$1");    
}
```
Live-Demo: http://ideone.com/Nsojc7

Update: Basierend auf Ihre Kommentare, um Leistungsprobleme zu beheben:

Verwenden Sie folgende Methode, um eine bessere Leistung beim Umgang mit großen # der Worte:
```
private final static Pattern WB_PATTERN = Pattern.compile("(?<=\\w)\\b");

private String truncateAfterWords(int n, String s) {
   if (s == null) return null;
   if (n <= 0) return "";
   Matcher m = WB_PATTERN.matcher(s);
   for (int i=0; i<n && m.find(); i++);
   if (m.hitEnd())
      return s;
   else
      return s.substring(0, m.end());
}
```
- Leider ist die performance dieser Lösung ist problematisch. Hier ist ein Testfall, der scheinbar in einer endlos-Schleife: truncateAfterWords(50, "Testing test testing as a test of testing testing more test.")
- Okay, lassen Sie mich sehen, wie Sie verbessert werden kann.
- Check meine jetzt Aktualisieren.
- Das nicht kompilieren -- start nicht definiert ist. Ich dachte, Sie könnte gemeint haben m.sart() statt, aber löst eine exception aus, wenn es sich beendet, weil keine mehr übereinstimmungen gefunden wurden.
- Ich habe eine version ähnlich wie die zweite Lösung arbeitet und veröffentlicht es als Lösung hier: stackoverflow.com/a/16049290/1145388
- Oh sorry, es war sehr spät in der Nacht für mich, eigentlich war es sein soll m.end(). Machte noch ein edit, pls überprüfen Sie es jetzt.
- Ich habe einen vollständigen Satz von test-Fällen in die Frage mit einem test-harness. Diese Lösung kann immer noch nicht mehrere von Ihnen werfen ein "Keine übereinstimmung" - Ausnahme.
- Ich denke, dass diese Praxis der un-akzeptieren einer Antwort auf post bearbeitet ist unfair, da meine ursprüngliche Antwort war für deine ursprüngliche Frage. In Fall, dass Sie wollen, erweitern Sie Ihr problem, Sie können so tun, indem Sie erstellen eine neue Frage, die mit Bezug auf diese Frage.
- Ich war auf der Suche für eine Antwort, ich konnte tatsächlich in einer Anwendung eingesetzt werden. Nicht eine Lösung, arbeitete in einer schmalen Reihe von Fällen. Es stellt sich heraus, dass dies nicht so einfach die Frage, wie es scheint auf der Oberfläche, und fast alle der vorgeschlagenen Lösungen problematisch gewesen, als ich entdeckt habe, wenn ich Daten aus der realen Welt in. Ich Schätze Ihre Bereitschaft, wieder zu kommen und verbessern Ihre Antwort, aber ich kann nicht akzeptieren, eine Antwort, die nicht wirklich in allen Fällen funktionieren.
- Es ist natürlich Ihr Vorrecht zu akzeptieren oder nicht akzeptieren. Ich bin nur der Einspruch gegen die änderung der problem selbst. Wenn das problem Komplex ist, dann beschreiben Sie es gut, im Voraus zu erhalten, die gezielter beantworten. btw ich getestet hatte meine Letzte bearbeitete Antwort mit alle Ihre Testfälle und es schien zu funktionieren auf allen von Ihnen.
InformationsquelleAutor anubhava

Fand ich einen Weg, es zu tun mit der java.text.BreakIterator Klasse:

private static String truncateAfterWords(int n, String s) {
    if (s == null) return null;
    BreakIterator wb = BreakIterator.getWordInstance();
    wb.setText(s);
    int pos = 0;
    for (int i = 0; i < n && pos != BreakIterator.DONE && pos < s.length();) {
        if (Character.isLetter(s.codePointAt(pos))) i++;
        pos = wb.next();
    }
    if (pos == BreakIterator.DONE || pos >= s.length()) return s;
    return s.substring(0, pos);
}

InformationsquelleAutor Stephen Ostermiller

Hier ist eine version, die verwendet reguläre Ausdrücke, um die nächste Reihe von Räumen in einer Schleife, bis es genug der Worte. Ähnlich wie die BreakIterator-Lösung, aber mit einem regulären Ausdruck zu Durchlaufen, das Wort bricht.

//Any number of white space or the end of the input
private final static Pattern SPACES_PATTERN = Pattern.compile("\\s+|\\z");

private static String truncateAfterWords(int n, String s) {
    if (s == null) return null;
    Matcher matcher = SPACES_PATTERN.matcher(s);
    int matchStartIndex = 0, matchEndIndex = 0, wordsFound = 0;
    //Keep matching until enough words are found, 
    //reached the end of the string, 
    //or no more matches
    while (wordsFound<n && matchEndIndex<s.length() && matcher.find(matchEndIndex)){
        //Keep track of both the start and end of each match
        matchStartIndex = matcher.start();
        matchEndIndex = matchStartIndex + matcher.group().length();
        //Only increment words found when not at the beginning of the string
        if (matchStartIndex != 0) wordsFound++;
    }
    //From the beginning of the string to the start of the final match
    return s.substring(0, matchStartIndex);
}

InformationsquelleAutor Stephen Ostermiller

-1

Versuchen Sie es mit regulären Ausdrücken in Java. Die regex nur abrufen n Worten: (.*?\s){n}.

Versuchen Sie es mit dem code:
```
String inputStr= "hello, this\nis a long sentence";
Pattern pattern = Pattern.compile("(.*?[\\s]){3}", Pattern.DOTALL); 
Matcher matcher = pattern.matcher(inputStr);
matcher.find(); 
String result = matcher.group(); 
System.out.println(result);
```
Mehr wissen über Pakete:
- http://docs.oracle.com/javase/1.5.0/docs/api/java/util/regex/Matcher.html
- http://docs.oracle.com/javase/1.4.2/docs/api/java/util/regex/Pattern.html#DOTALL
- Gute Idee, aber das regex bei mir nicht funktioniert. Dieses erzeugt keine Ausgabe: Matcher m = Pattern.compile("(.*?\\b){3}").matcher("hello, this is a long sentence");m.find();System.out.println(m.group(0));
- Verwenden Sie diesen code @StephenOstermiller: Es hat funktioniert .... String inputStr= "Hallo, dies ist ein langer Satz"; Pattern pattern = Pattern.compile("(.*?[\\s\\n]){3}", Muster.DOTALL); Matcher matcher = pattern.matcher(inputStr); matcher.find(); String result = matcher.Gruppe(); System.aus.println(Ergebnis);
- Ich schrieb einen vollständigen Satz von Testfällen und fügte zu der Frage. Diese Lösung fehlschlägt mehrere von Ihnen, so gut geht das in einer Endlosschleife auf langen Eingang.
- Sorry für die verspätete Antwort. Verwenden Sie die regex als (.*[\\s\\n]{1,}). Das bisherige Modell ist ein Beispiel dafür, wie die arbeiten an Dingen, aber nicht eine vollwertige regex. Dank
- Es war ein typo Fehler .Verwenden Sie diese regex (.*?[\\s\\n]){1,}
InformationsquelleAutor Srivatsa Jenni

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Update: Basierend auf Ihre Kommentare, um Leistungsprobleme zu beheben: