BreakIterator Klasse

Definition

[Android.Runtime.Register("java/text/BreakIterator", DoNotGenerateAcw=true)]
public abstract class BreakIterator : Java.Lang.Object, IDisposable, Java.Lang.ICloneable

[<Android.Runtime.Register("java/text/BreakIterator", DoNotGenerateAcw=true)>]
type BreakIterator = class
    inherit Object
    interface ICloneable
    interface IJavaObject
    interface IDisposable
    interface IJavaPeerable

Vererbung

Object

JavaObject

Object

BreakIterator

Attribute

RegisterAttribute

Implementiert

IJavaObject IJavaPeerable ICloneable IDisposable

Hinweise

Die BreakIterator Klasse implementiert Methoden zum Suchen der Position von Begrenzungen im Text. Instanzen, in denen BreakIterator eine aktuelle Position beibehalten und textübersucht wird, der den Index der Zeichen zurückgibt, in denen Grenzen auftreten. BreakIterator Intern überprüft Text mithilfe eines CharacterIterator, und kann somit Text scannen, der von jedem Objekt gehalten wird, das dieses Protokoll implementiert. A StringCharacterIterator wird verwendet, um Objekte zu scannen String , die an setText. Das CharacterIterator Objekt darf nicht geändert werden, nachdem es übergeben setTextwurde. Wenn der Text im CharacterIterator Objekt geändert wird, muss der Aufrufer durch Aufrufen BreakIteratorzurückgesetzt setText werden.

Sie verwenden die von dieser Klasse bereitgestellten Factorymethoden, um Instanzen verschiedener Typen von Unterbrechungs iteratoren zu erstellen. Verwenden Sie getWordInstanceinsbesondere , getLineInstance, getSentenceInstanceund getCharacterInstance erstellen Sie BreakIterators, die Wort, Zeile, Satz und Zeichenbegrenzungsanalyse durchführen. Ein einzelner BreakIterator kann nur für eine Einheit (Wort, Zeile, Satz usw.) verwendet werden. Sie müssen für jede Analyse der Einheitenbegrenzung einen anderen Iterator verwenden, den Sie ausführen möchten.

> Die Zeilenbegrenzungsanalyse bestimmt, wo beim Zeilenumbruch eine Textzeichenfolge unterbrochen werden kann. Der Mechanismus behandelt Interpunktions- und Silbentrennungswörter richtig. Tatsächlicher Zeilenumbruch muss auch die verfügbare Linienbreite berücksichtigen und von Software auf höherer Ebene behandelt werden.

"Satzbegrenzungsanalyse"> ermöglicht die Auswahl mit der korrekten Interpretation von Punkten innerhalb von Zahlen und Abkürzungen sowie nachfolgende Satzzeichen wie Anführungszeichen und Klammern.

"word"> Word Grenzanalyse wird von Such- und Ersetzungsfunktionen sowie in Textbearbeitungsanwendungen verwendet, mit denen der Benutzer Wörter mit einem Doppelklick auswählen kann. Word Auswahl bietet eine korrekte Interpretation von Interpunktionszeichen innerhalb und folgenden Wörtern. Zeichen, die nicht Teil eines Worts sind, z. B. Symbole oder Satzzeichen, weisen Wortumbrüche auf beiden Seiten auf.

> Mit der Zeichenbegrenzungsanalyse können Benutzer z. B. beim Bewegen des Cursors durch eine Textzeichenfolge mit Zeichen wie erwartet interagieren. Die Zeichenbegrenzungsanalyse bietet eine korrekte Navigation über Zeichenfolgen, unabhängig davon, wie das Zeichen gespeichert wird. Die zurückgegebenen Grenzen können die von zusätzlichen Zeichen sein, zeichenfolgenkombinationen oder Ligaturcluster. Beispielsweise kann ein Akzentzeichen als Basiszeichen und diakritische Zeichen gespeichert werden. Was Benutzer als Zeichen betrachten, kann sich zwischen Sprachen unterscheiden.

Die BreakIterator instanzen, die von den Factorymethoden dieser Klasse zurückgegeben werden, sind nur für die Verwendung mit natürlichen Sprachen vorgesehen, nicht für Programmiersprachetext. Es ist jedoch möglich, Unterklassen zu definieren, die eine Programmiersprache tokenisieren.

<starke>Beispiele</starke>:

Erstellen und Verwenden von Textbegrenzungen: <Blockquote>

public static void main(String args[]) {
                 if (args.length == 1) {
                     String stringToExamine = args[0];
                     //print each word in order
                     BreakIterator boundary = BreakIterator.getWordInstance();
                     boundary.setText(stringToExamine);
                     printEachForward(boundary, stringToExamine);
                     //print each sentence in reverse order
                     boundary = BreakIterator.getSentenceInstance(Locale.US);
                     boundary.setText(stringToExamine);
                     printEachBackward(boundary, stringToExamine);
                     printFirst(boundary, stringToExamine);
                     printLast(boundary, stringToExamine);
                 }
            }

</blockquote>

Drucken sie jedes Element in der Reihenfolge: <Blockquote>

public static void printEachForward(BreakIterator boundary, String source) {
                int start = boundary.first();
                for (int end = boundary.next();
                     end != BreakIterator.DONE;
                     start = end, end = boundary.next()) {
                     System.out.println(source.substring(start,end));
                }
            }

</blockquote>

Jedes Element in umgekehrter Reihenfolge drucken: <Blockquote>

public static void printEachBackward(BreakIterator boundary, String source) {
                int end = boundary.last();
                for (int start = boundary.previous();
                     start != BreakIterator.DONE;
                     end = start, start = boundary.previous()) {
                    System.out.println(source.substring(start,end));
                }
            }

</blockquote>

Erstes Element drucken: <Blockquote>

public static void printFirst(BreakIterator boundary, String source) {
                int start = boundary.first();
                int end = boundary.next();
                System.out.println(source.substring(start,end));
            }

</blockquote>

Letztes Element drucken: <Blockquote>

public static void printLast(BreakIterator boundary, String source) {
                int end = boundary.last();
                int start = boundary.previous();
                System.out.println(source.substring(start,end));
            }

</blockquote>

Drucken des Elements an einer angegebenen Position: <Blockquote>

public static void printAt(BreakIterator boundary, int pos, String source) {
                int end = boundary.following(pos);
                int start = boundary.previous();
                System.out.println(source.substring(start,end));
            }

</blockquote>

Suchen des nächsten Worts: <Blockquote>

{@code
            public static int nextWordStartAfter(int pos, String text) {
                BreakIterator wb = BreakIterator.getWordInstance();
                wb.setText(text);
                int last = wb.following(pos);
                int current = wb.next();
                while (current != BreakIterator.DONE) {
                    for (int p = last; p < current; p++) {
                        if (Character.isLetter(text.codePointAt(p)))
                            return last;
                    }
                    last = current;
                    current = wb.next();
                }
                return BreakIterator.DONE;
            }
            }

(Der von BreakIterator.getWordInstance() zurückgegebene Iterator ist eindeutig, da die zurückgegebenen Unterbrechungspositionen nicht sowohl den Anfang als auch das Ende des Überlaufs darstellen. Das heißt, ein Satzumbruch-Iterator gibt Umbrüche zurück, die jeweils das Ende eines Satzes und den Anfang des nächsten darstellen. Bei der Texttrennungs-Iterator können die Zeichen zwischen zwei Begrenzungen ein Wort sein, oder es kann sich um die Interpunktion oder leerzeichen zwischen zwei Wörtern handeln. Der obige Code verwendet eine einfache Heuristik, um zu bestimmen, welche Grenze der Anfang eines Worts ist: Wenn die Zeichen zwischen dieser Grenze und der nächsten Grenze mindestens einen Buchstaben enthalten (dies kann ein alphabetischer Buchstabe, ein CJK-Ideograph, ein Hangul-Silben, ein Kana-Zeichen usw.) sein, dann ist der Text zwischen dieser Grenze und dem nächsten ein Wort; andernfalls ist es das Material zwischen Wörtern.) </blockquote>

In 1.1 hinzugefügt.

Java Dokumentation für java.text.BreakIterator.

Teile dieser Seite sind Änderungen auf der Grundlage von Arbeiten, die von der Android Open Source Project erstellt und gemeinsam verwendet und gemäß den in der 2.5 Attribution License beschriebenen Begriffen verwendet werden.