BreakIterator Classe

Definição

[Android.Runtime.Register("android/icu/text/BreakIterator", ApiSince=24, DoNotGenerateAcw=true)]
public abstract class BreakIterator : Java.Lang.Object, IDisposable, Java.Interop.IJavaPeerable, 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

Herança

Object

Object

BreakIterator

Atributos

RegisterAttribute

Implementações

IJavaObject IJavaPeerable ICloneable IDisposable

Comentários

<strong>[icu enhancement]</strong> ICU's replacement for java.text.BreakIterator.  Métodos, campos e outras funcionalidades específicas da UTI são rotulados como '<strong>[icu]</strong>'.

Uma classe que localiza limites no texto. Essa classe define um protocolo para objetos que dividem um pedaço de texto em linguagem natural de acordo com um conjunto de critérios. Instâncias ou subclasses de BreakIterator podem ser fornecidas, por exemplo, para dividir um pedaço de texto em palavras, frases ou caracteres lógicos de acordo com as convenções de algum idioma ou grupo de idiomas.

Fornecemos cinco tipos internos de BreakIterator: <ul><li>getTitleInstance() retorna um BreakIterator que localiza limites entre quebras de título. <li>getSentenceInstance() retorna um BreakIterator que localiza limites entre frases. Isso é útil para seleção de clique triplo, por exemplo. <li>getWordInstance() retorna um BreakIterator que localiza limites entre palavras. Isso é útil para pesquisas de seleção de clique duplo ou "localizar palavras inteiras". Esse tipo de BreakIterator garante que haja uma posição de limite no início e no final de cada palavra legal. (Os números também contam como palavras.) O espaço em branco e a pontuação são mantidos separados das palavras reais. <li>getLineInstance() retorna um BreakIterator que localiza posições em que é legal para um editor de texto encapsular linhas. Isso é semelhante à quebra de palavras, mas não é o mesmo: pontuação e espaço em branco geralmente são mantidos com palavras (você não quer que uma linha comece com espaço em branco, por exemplo), e alguns caracteres especiais podem forçar uma posição a ser considerada uma posição de quebra de linha ou impedir que uma posição seja uma posição de quebra de linha. <li>getCharacterInstance() retorna um BreakIterator que localiza limites entre caracteres lógicos. Devido à estrutura da codificação Unicode, um caractere lógico pode ser armazenado internamente como mais de um ponto de código Unicode. (Um com um umlaut pode ser armazenado como um seguido por um caractere umlaut de combinação separado, por exemplo, mas o usuário ainda pensa nele como um caractere.) Esse iterador permite que vários processos (especialmente editores de texto) tratem como caracteres as unidades de texto que um usuário pensaria como caracteres, em vez das unidades de texto que o computador vê como "caracteres".</ul> As posições de limite de texto são encontradas de acordo com as regras descritas no Anexo Padrão Unicode nº 29, Limites de Texto e Anexo Padrão Unicode nº 14, Propriedades de Quebra de Linha. Eles estão disponíveis em http://www.unicode.org/reports/tr14/ e http://www.unicode.org/reports/tr29/.

A interface do BreakIterator segue um modelo "iterador" (daí o nome), o que significa que ele tem um conceito de "posição atual" e métodos como first(), last(), next() e previous() que atualizam a posição atual. Todos os BreakIterators mantêm os seguintes invariáveis: <ul><li>O início e o final do texto são sempre tratados como posições de limite. <li>A posição atual do iterador é sempre uma posição de limite (métodos de acesso aleatório movem o iterador para a posição de limite mais próxima antes ou depois da posição especificada, não para a posição especificada). <li>DONE é usado como um sinalizador para indicar quando a iteração foi interrompida. DONE só é retornado quando a posição atual é o final do texto e o usuário chama next() ou quando a posição atual é o início do texto e o usuário chama anterior(). <as posições li>Break são numeradas pelas posições dos caracteres que as seguem. Portanto, em circunstâncias normais, a posição antes do primeiro caractere é 0, a posição após o primeiro caractere é 1 e a posição após o último caractere é 1 mais o comprimento da cadeia de caracteres. <li>O cliente pode alterar a posição de um iterador ou o texto que ele analisa, à vontade, mas não pode alterar o comportamento. Se o usuário quiser um comportamento diferente, ele deverá criar uma instância de um novo iterador.</ul>

O BreakIterator acessa o texto analisado por meio de um CharacterIterator, o que possibilita usar BreakIterator para analisar o texto em qualquer veículo de armazenamento de texto que forneça uma interface CharacterIterator.

<b>Observação:</b> Alguns tipos de BreakIterator podem levar muito tempo para serem criados e as instâncias do BreakIterator não são armazenadas em cache no momento pelo sistema. Para obter um desempenho ideal, mantenha as instâncias do BreakIterator ao redor, desde que faça sentido. Por exemplo, ao encapsular um documento, não crie e destrua um novo BreakIterator para cada linha. Crie um iterador de quebra para todo o documento (ou qualquer trecho de texto que você esteja encapsulando) e use-o para fazer todo o trabalho de encapsular o texto.

<exemplos< fortes>/fortes>:

Criar e usar o blockquote de limites <de texto>

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 na ordem <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 em blockquote de ordem inversa <>

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 blockquote do primeiro elemento <>

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 blockquote do último elemento <>

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 o elemento em um blockquote de posição <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>

Localizar a próxima palavra <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;
                 }
            }

O iterador retornado é #getWordInstance exclusivo porque as posições de interrupção retornadas não representam o início e o final da coisa que está sendo iterada. Ou seja, um iterador de quebra de sentença retorna quebras que representam cada uma delas o fim de uma frase e o início da próxima. Com o iterador de quebra de palavra, os caracteres entre dois limites podem ser uma palavra ou podem ser a pontuação ou o espaço em branco entre duas palavras. O código acima usa para identificar e ignorar limites associados à pontuação ou a outros caracteres #getRuleStatus que não são de palavras. </blockquote>

Java documentação para android.icu.text.BreakIterator.

Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Project Open Source do Open Source e usadas de acordo com os termos descritos na Creative Commons 2.5.