BreakIterator Clase

Definición

[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

Herencia

Object

JavaObject

Object

BreakIterator

Atributos

RegisterAttribute

Implementaciones

IJavaObject IJavaPeerable ICloneable IDisposable

Comentarios

<strong>[icu enhancement]</strong> ICU's replacement for java.text.BreakIterator.  Los métodos, los campos y otras funcionalidades específicas de ICU se etiquetan como "<strong>[icu]</strong>".

Clase que busca límites en texto. Esta clase define un protocolo para los objetos que dividen un fragmento de texto de lenguaje natural según un conjunto de criterios. Se pueden proporcionar instancias o subclases de BreakIterator, por ejemplo, para dividir un fragmento de texto en palabras, oraciones o caracteres lógicos según las convenciones de algún idioma o grupo de idiomas.

Proporcionamos cinco tipos integrados de BreakIterator: <ul><li>getTitleInstance() devuelve un BreakIterator que busca límites entre saltos de título. <li>getSentenceInstance() devuelve un BreakIterator que busca límites entre oraciones. Esto es útil para la selección de triple clic, por ejemplo. <li>getWordInstance() devuelve un BreakIterator que busca límites entre palabras. Esto es útil para las búsquedas de selección de doble clic o "buscar palabras completas". Este tipo de BreakIterator garantiza que haya una posición de límite al principio y al final de cada palabra legal. (Los números también cuentan como palabras). Los espacios en blanco y la puntuación se mantienen separados de las palabras reales. <li>getLineInstance() devuelve un BreakIterator que localiza las posiciones donde es legal que un editor de texto ajuste las líneas. Esto es similar a la separación de palabras, pero no lo mismo: la puntuación y el espacio en blanco se conservan generalmente con palabras (no desea que una línea comience con espacios en blanco, por ejemplo), y algunos caracteres especiales pueden forzar que una posición se considere una posición de salto de línea o impedir que una posición de salto de línea sea una posición de salto de línea. <li>getCharacterInstance() devuelve un BreakIterator que busca límites entre caracteres lógicos. Debido a la estructura de la codificación Unicode, un carácter lógico se puede almacenar internamente como más de un punto de código Unicode. (Un con un umlaut se puede almacenar como un seguido de un carácter de combinación independiente, por ejemplo, pero el usuario sigue pensando en él como un carácter). Este iterador permite que varios procesos (especialmente los editores de texto) traten como caracteres las unidades de texto que un usuario consideraría como caracteres, en lugar de las unidades de texto que el equipo ve como "caracteres".</ul> Las posiciones de límite de texto se encuentran según las reglas descritas en el Anexo estándar Unicode n.º 29, Límites de texto y Anexo estándar Unicode n.º 14, Propiedades de salto de línea. Están disponibles en http://www.unicode.org/reports/tr14/ y http://www.unicode.org/reports/tr29/.

La interfaz de BreakIterator sigue un modelo de "iterador" (por lo tanto, el nombre), lo que significa que tiene un concepto de "posición actual" y métodos como first(), last(), next() y previous() que actualizan la posición actual. Todos los breakIterators mantienen las siguientes invariables: <ul><li>El principio y el final del texto siempre se tratan como posiciones de límite. <li>La posición actual del iterador es siempre una posición de límite (los métodos de acceso aleatorio mueven el iterador a la posición de límite más cercana antes o después de la posición especificada, no a la posición especificada). <li>DONE se usa como una marca para indicar cuándo se ha detenido la iteración. DONE solo se devuelve cuando la posición actual es el final del texto y el usuario llama a next(), o cuando la posición actual es el principio del texto y el usuario llama a previous(). <li>Break positions are numbered by the positions of the characters that follow them. Por lo tanto, en circunstancias normales, la posición antes del primer carácter es 0, la posición después del primer carácter es 1 y la posición después del último carácter es 1 más la longitud de la cadena. <li>El cliente puede cambiar la posición de un iterador o el texto que analiza, a voluntad, pero no puede cambiar el comportamiento. Si el usuario quiere un comportamiento diferente, debe crear una instancia de un nuevo iterador.</ul>

BreakIterator accede al texto que analiza a través de un CharacterIterator, lo que permite usar BreakIterator para analizar texto en cualquier vehículo de almacenamiento de texto que proporcione una interfaz CharacterIterator.

<b>Nota:</b> Algunos tipos de BreakIterator pueden tardar mucho tiempo en crearse y el sistema no almacena actualmente en caché instancias de BreakIterator. Para obtener un rendimiento óptimo, mantenga las instancias de BreakIterator alrededor siempre que tenga sentido. Por ejemplo, al ajustar palabras de un documento, no cree ni destruya un nuevo BreakIterator para cada línea. Cree un iterador de saltos para todo el documento (o cualquier extensión del texto que esté ajustando) y úselo para realizar todo el trabajo de encapsular el texto.

<ejemplos> seguros</seguros>:

Creación y uso de límites de <texto 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>

Imprimir cada elemento en orden <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>

Imprimir cada elemento en blockquote de orden <inverso>

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>

Imprimir el primer elemento <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>

Imprimir el último bloque de elementos <>

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

</blockquote>

Imprimir el elemento en un blockquote de posición <especificado>

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>

Buscar la palabra <siguiente 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;
                 }
            }

El iterador devuelto por #getWordInstance es único en que las posiciones de interrupción que devuelve no representan tanto el inicio como el final de la cosa en iteración. Es decir, un iterador de interrupción de oración devuelve saltos que representan el final de una oración y el principio del siguiente. Con el iterador de salto de palabras, los caracteres entre dos límites pueden ser una palabra, o bien pueden ser la puntuación o el espacio en blanco entre dos palabras. El código anterior usa #getRuleStatus para identificar y omitir los límites asociados a la puntuación u otros caracteres que no sean de palabra. </blockquote>

Java documentación para android.icu.text.BreakIterator.

Las partes de esta página son modificaciones basadas en el trabajo creado y compartido por el Android y se usan según los términos descritos en creative Creative Commons 2.5 Attribution License.