BreakIterator Classe

Définition

[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

Héritage

Object

JavaObject

Object

BreakIterator

Attributs

RegisterAttribute

Implémente

IJavaObject IJavaPeerable ICloneable IDisposable

Remarques

La BreakIterator classe implémente des méthodes pour rechercher l’emplacement des limites dans le texte. Instances de maintien d’une position actuelle et d’analyse BreakIterator du texte retournant l’index des caractères où les limites se produisent. En interne, BreakIterator analyse du texte à l’aide d’un CharacterIteratortexte et peut ainsi analyser du texte détenu par n’importe quel objet implémentant ce protocole. A StringCharacterIterator est utilisé pour analyser String les objets passés à setText. L’objet CharacterIterator ne doit pas être modifié après avoir été passé à setText. Si le texte de l’objet CharacterIterator est modifié, l’appelant doit être réinitialisé BreakIterator en appelant setText.

Vous utilisez les méthodes de fabrique fournies par cette classe pour créer des instances de différents types d’itérateurs de rupture. En particulier, utilisez getWordInstance, , getLineInstancegetSentenceInstanceet getCharacterInstance pour créer BreakIteratordes s qui effectuent respectivement des analyses de limites de mots, de lignes, de phrases et de caractères. Un seul BreakIterator peut fonctionner sur une seule unité (mot, ligne, phrase, etc.). Vous devez utiliser un itérateur différent pour chaque analyse de limite d’unité que vous souhaitez effectuer.

L’analyse des limites de ligne « ligne »> détermine où une chaîne de texte peut être rompue lors de l’habillage de ligne. Le mécanisme gère correctement les mots ponctuation et traits d’union. Les sauts de ligne réels doivent également prendre en compte la largeur de ligne disponible et sont gérés par des logiciels de niveau supérieur.

L’analyse de la limite de phrase « phrase »> permet une sélection avec une interprétation correcte des périodes dans les nombres et les abréviations, ainsi que les marques de ponctuation de fin telles que les guillemets et parenthèses.

« word »> Word analyse des limites est utilisée par les fonctions de recherche et de remplacement, ainsi que dans les applications de modification de texte qui permettent à l’utilisateur de sélectionner des mots en double-clic. Word sélection fournit une interprétation correcte des marques de ponctuation dans et les mots suivants. Les caractères qui ne font pas partie d’un mot, tels que des symboles ou des marques de ponctuation, ont des sauts de mots sur les deux côtés.

L’analyse des limites de caractères « caractère »> permet aux utilisateurs d’interagir avec des caractères comme ils s’attendent à ce que, par exemple, lors du déplacement du curseur par le biais d’une chaîne de texte. L’analyse des limites de caractères fournit une navigation correcte via des chaînes de caractères, quel que soit le mode de stockage du caractère. Les limites retournées peuvent être celles des caractères supplémentaires, combinant des séquences de caractères ou des clusters de ligature. Par exemple, un caractère accentué peut être stocké en tant que caractère de base et une marque diacritique. Ce que les utilisateurs considèrent comme un caractère peut différer entre les langues.

Les BreakIterator instances retournées par les méthodes de fabrique de cette classe sont destinées à être utilisées uniquement avec des langages naturels, et non pour le texte du langage de programmation. Il est toutefois possible de définir des sous-classes qui tokenisent un langage de programmation.

<exemples forts/forts>< :>

Création et utilisation de limites de texte : <blocquote>

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>

Imprimer chaque élément dans l’ordre : <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>

Imprimer chaque élément dans l’ordre inverse : <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>

Imprimer le premier élément : <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>

Imprimer le dernier élément : <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>

Imprimer l’élément à une position spécifiée : <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>

Recherchez le mot suivant : <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;
            }
            }

(L’itérateur retourné par BreakIterator.getWordInstance() est unique dans le sens où les positions d’arrêt qu’elle retourne ne représentent pas à la fois le début et la fin de la chose en cours d’itération. Autrement dit, un itérateur de saut de phrase retourne des sauts qui représentent chacun la fin d’une phrase et le début de la suivante. Avec l’itérateur de saut de mot, les caractères entre deux limites peuvent être un mot, ou il peut s’agir de la ponctuation ou de l’espace blanc entre deux mots. Le code ci-dessus utilise une simple heuristique pour déterminer quelle limite est le début d’un mot : si les caractères entre cette limite et la limite suivante incluent au moins une lettre (il peut s’agir d’une lettre alphabétique, d’un idéogramme CJK, d’une syllabe hangûl, d’un caractère Kana, etc.), alors le texte entre cette limite et le suivant est un mot ; sinon, c’est le matériau entre les mots.) </blockquote>

Ajouté dans la version 1.1.

Java documentation pour java.text.BreakIterator.

Les parties de cette page sont des modifications basées sur le travail créé et partagé par Android Open Source et utilisées en fonction des termes décrits dans la Creative Commons 2.5 Attribution License.