BreakIterator Classe

Définition

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

[<Android.Runtime.Register("android/icu/text/BreakIterator", ApiSince=24, 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

<strong>[icu enhancement]</strong> ICU’s replacement for java.text.BreakIterator.  ; Les méthodes, les champs et d’autres fonctionnalités spécifiques à l’ICU sont étiquetées «< strong>[icu]</strong> ».

Classe qui localise les limites dans le texte. Cette classe définit un protocole pour les objets qui décomposent un élément de texte en langage naturel en fonction d’un ensemble de critères. Les instances ou sous-classes de BreakIterator peuvent être fournies, par exemple, pour décomposer un texte en mots, phrases ou caractères logiques en fonction des conventions de certaines langues ou de certains groupes de langues.

Nous fournissons cinq types intégrés de BreakIterator : <ul><li>getTitleInstance() retourne un BreakIterator qui localise les limites entre les sauts de titre. <li>getSentenceInstance() retourne un BreakIterator qui localise les limites entre les phrases. Cela est utile pour la sélection en triple-clic, par exemple. <li>getWordInstance() retourne un BreakIterator qui localise les limites entre les mots. Cela est utile pour la sélection en double-clic ou pour rechercher des mots entiers. Ce type de BreakIterator s’assure qu’il existe une position de limite au début et à la fin de chaque mot juridique. (Nombres comptent en tant que mots, aussi.) Les espaces blancs et la ponctuation sont séparés des mots réels. <li>getLineInstance() retourne un BreakIterator qui localise les positions où il est légal pour un éditeur de texte d’encapsuler des lignes. Ceci est similaire à la rupture de mot, mais pas identique : la ponctuation et les espaces blancs sont généralement conservés avec des mots (vous ne souhaitez pas qu’une ligne commence par un espace blanc, par exemple), et certains caractères spéciaux peuvent forcer une position à considérer comme une position de saut de ligne ou empêcher une position d’être une position de saut de ligne. <li>getCharacterInstance() retourne un BreakIterator qui localise les limites entre les caractères logiques. En raison de la structure de l’encodage Unicode, un caractère logique peut être stocké en interne sous la forme de plusieurs points de code Unicode. (Un avec un umlaut peut être stocké sous la forme d’un suivi d’un caractère umlaut séparé, par exemple, mais l’utilisateur pense toujours qu’il s’agit d’un caractère.) Cet itérateur permet à divers processus (en particulier les éditeurs de texte) de traiter comme des caractères les unités de texte qu’un utilisateur considérerait comme des caractères, plutôt que les unités de texte que l’ordinateur voit comme « caractères ».</ul> Les positions des limites de texte sont trouvées en fonction des règles décrites dans l’annexe standard Unicode #29, les limites de texte et l’annexe standard Unicode #14, propriétés de rupture de ligne. Ceux-ci sont disponibles à l’adresse http://www.unicode.org/reports/tr14/ et http://www.unicode.org/reports/tr29/.

L’interface de BreakIterator suit un modèle « itérateur » (par conséquent, le nom), ce qui signifie qu’il a un concept de « position actuelle » et de méthodes comme first(), last(), next() et previous() qui mettent à jour la position actuelle. Tous les BreakIterators respectent les invariants suivants : <ul><li>Le début et la fin du texte sont toujours traités comme des positions de limite. <li>La position actuelle de l’itérateur est toujours une position de limite (les méthodes d’accès aléatoire déplacent l’itérateur vers la position de limite la plus proche avant ou après la position spécifiée, et non vers la position spécifiée). <li>DONE est utilisé comme indicateur pour indiquer quand l’itération s’est arrêtée. DONE est retourné uniquement lorsque la position actuelle est la fin du texte et que l’utilisateur appelle suivant(), ou lorsque la position actuelle est le début du texte et que l’utilisateur appelle précédent(). <les positions li>Break sont numérotées par les positions des caractères qui les suivent. Ainsi, dans des circonstances normales, la position avant le premier caractère est 0, la position après le premier caractère est 1 et la position après le dernier caractère est 1 plus la longueur de la chaîne. <li>Le client peut modifier la position d’un itérateur, ou le texte qu’il analyse, à la volonté, mais ne peut pas modifier le comportement. Si l’utilisateur souhaite un comportement différent, il doit instancier un nouvel itérateur.</ul>

BreakIterator accède au texte qu’il analyse par le biais d’un CharacterIterator, ce qui permet d’utiliser BreakIterator pour analyser du texte dans n’importe quel véhicule de stockage de texte qui fournit une interface CharacterIterator.

<b>Remarque :</b> Certains types de BreakIterator peuvent prendre beaucoup de temps pour créer, et les instances de BreakIterator ne sont pas actuellement mises en cache par le système. Pour des performances optimales, conservez les instances de BreakIterator tant que cela est judicieux. Par exemple, lors de l’habillage de mots d’un document, ne créez pas et détruisez un nouvel analyseur breakiterator pour chaque ligne. Créez un itérateur d’arrêt pour l’ensemble du document (ou quel que soit l’étendue du texte que vous encapsulez) et utilisez-le pour effectuer tout le travail d’habillage du texte.

<exemples forts/forts>< :>

Création et utilisation d’un blocquote de limites <de texte>

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 <des blocs>

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 un blocquote d’ordre <inverse>

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 blocquote d’un premier élément <>

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

</blockquote>

Print last element <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 en blocquote>

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>

Rechercher le mot <suivant blockquote>

public static int nextWordStartAfter(int pos, String text) {
                BreakIterator wb = BreakIterator.getWordInstance();
                wb.setText(text);
                int wordStart = wb.following(pos);
                for (;;) {
                    int wordLimit = wb.next();
                    if (wordLimit == BreakIterator.DONE) {
                        return BreakIterator.DONE;
                    }
                    int wordStatus = wb.getRuleStatus();
                    if (wordStatus != BreakIterator.WORD_NONE) {
                        return wordStart;
                    }
                    wordStart = wordLimit;
                 }
            }

L’itérateur retourné par #getWordInstance est unique dans le fait que les positions d’arrêt qu’il 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 #getRuleStatus pour identifier et ignorer les limites associées à la ponctuation ou à d’autres caractères non word. </blockquote>

Java documentation pour android.icu.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.