BreakIterator Classe
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
La BreakIterator classe implementa i metodi per trovare la posizione dei limiti nel testo.
[Android.Runtime.Register("java/text/BreakIterator", DoNotGenerateAcw=true)]
public abstract class BreakIterator : Java.Lang.Object, IDisposable, Java.Interop.IJavaPeerable, Java.Lang.ICloneable[<Android.Runtime.Register("java/text/BreakIterator", DoNotGenerateAcw=true)>]
type BreakIterator = class
inherit Object
interface ICloneable
interface IJavaObject
interface IDisposable
interface IJavaPeerable- Ereditarietà
- Attributi
- Implementazioni
Commenti
La BreakIterator classe implementa i metodi per trovare la posizione dei limiti nel testo. Le istanze di BreakIterator mantengono una posizione corrente e analizzano il testo restituendo l'indice dei caratteri in cui si verificano i limiti. Internamente, BreakIterator analizza il testo usando un CharacterIteratoroggetto ed è quindi in grado di analizzare il testo contenuto da qualsiasi oggetto che implementa tale protocollo. Un StringCharacterIterator oggetto viene utilizzato per analizzare String gli oggetti passati a setText. L'oggetto CharacterIterator non deve essere modificato dopo essere stato passato a setText. Se il testo nell'oggetto CharacterIterator viene modificato, il chiamante deve reimpostare BreakIterator chiamando setText.
I metodi factory forniti da questa classe consentono di creare istanze di vari tipi di iteratori di interruzione. In particolare, usare getWordInstance, getLineInstance, getSentenceInstancee getCharacterInstance per creare BreakIterators che eseguono rispettivamente l'analisi di parole, righe, frasi e limiti di caratteri. Un singolo BreakIterator può funzionare solo su un'unità (parola, riga, frase e così via). È necessario usare un iteratore diverso per ogni analisi dei limiti di unità da eseguire.
L'analisi dei limiti di linea "line"> determina dove una stringa di testo può essere interrotta durante il wrapping della riga. Il meccanismo gestisce correttamente la punteggiatura e le parole sillabate. L'interruzione di riga effettiva deve considerare anche la larghezza della linea disponibile ed è gestita da software di livello superiore.
L'analisi dei limiti della frase "frase"> consente la selezione con interpretazione corretta dei punti all'interno di numeri e abbreviazioni e segni di punteggiatura finale, ad esempio virgolette e parentesi.
L'analisi dei limiti "word"> Word viene usata dalle funzioni di ricerca e sostituzione, nonché all'interno di applicazioni di modifica del testo che consentono all'utente di selezionare parole con un doppio clic. Word selezione fornisce un'interpretazione corretta dei segni di punteggiatura all'interno e alle parole seguenti. I caratteri che non fanno parte di una parola, ad esempio simboli o segni di punteggiatura, hanno interruzioni di parola su entrambi i lati.
L'analisi dei limiti dei caratteri "character"> consente agli utenti di interagire con i caratteri come previsto, ad esempio quando si sposta il cursore attraverso una stringa di testo. L'analisi dei limiti dei caratteri fornisce una navigazione corretta tramite stringhe di caratteri, indipendentemente dalla modalità di archiviazione del carattere. I limiti restituiti possono essere quelli di caratteri supplementari, combinazione di sequenze di caratteri o cluster di legatura. Ad esempio, un carattere accentato può essere archiviato come carattere di base e un segno diacritico. Gli utenti che considerano un carattere possono differire tra le lingue.
Le BreakIterator istanze restituite dai metodi factory di questa classe sono destinate all'uso solo con i linguaggi naturali, non per il testo del linguaggio di programmazione. È tuttavia possibile definire sottoclassi che tokenzzano un linguaggio di programmazione.
<esempi< sicuri>/sicuri>:
Creazione e uso dei limiti di testo: <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>
Stampare ogni elemento in ordine: <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>
Stampare ogni elemento in ordine inverso: <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>
Stampare il primo 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>
Stampa ultimo elemento: <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>
Stampare l'elemento in una posizione specificata: <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>
Trovare la parola successiva: <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'iteratore restituito da BreakIterator.getWordInstance() è univoco in quanto le posizioni di interruzione restituite non rappresentano sia l'inizio che la fine dell'elemento su cui viene eseguita l'iterazione. Ovvero, un iteratore di interruzione di frase restituisce interruzioni che ognuno rappresenta la fine di una frase e l'inizio del successivo. Con l'iteratore di interruzione di parola, i caratteri tra due limiti potrebbero essere una parola o potrebbero essere la punteggiatura o gli spazi vuoti tra due parole. Il codice precedente usa un'euristica semplice per determinare quale limite è l'inizio di una parola: se i caratteri tra questo limite e il limite successivo includono almeno una lettera (può essere una lettera alfabetica, un ideografo CJK, una sillaba Hangul, un carattere Kana e così via), il testo tra questo limite e il successivo è una parola; in caso contrario, è il materiale tra le parole. </Blockquote>
Aggiunta nella versione 1.1.
Documentazione java per java.text.BreakIterator.
Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dal Android e usato in base ai termini descritti in 2.5 Attribution License Creative Commons 2.5 Attribution License.
Costruttori
| BreakIterator() |
Costruttore. |
| BreakIterator(IntPtr, JniHandleOwnership) |
Costruttore utilizzato durante la creazione di rappresentazioni gestite di oggetti JNI; chiamato dal runtime. |
Campi
| Done |
DONE viene restituito da previous(), next(), next(int), previous(int) e following(int) quando è stato raggiunto il primo o l'ultimo limite di testo. |
Proprietà
| CharacterInstance |
Restituisce una nuova |
| Class |
Restituisce la classe di runtime di questo |
| Handle |
Handle per l'istanza di Android sottostante. (Ereditato da Object) |
| JniIdentityHashCode |
La |
| JniPeerMembers |
La |
| LineInstance |
Restituisce una nuova |
| PeerReference |
La |
| SentenceInstance |
Restituisce una nuova |
| Text |
Restituisce un oggetto |
| ThresholdClass |
Questa API supporta l'infrastruttura Mono per Android e non deve essere usata direttamente dal codice. |
| ThresholdType |
Questa API supporta l'infrastruttura Mono per Android e non deve essere usata direttamente dal codice. |
| WordInstance |
Restituisce una nuova |
Metodi
| Clone() |
Creare una copia di questo iteratore |
| Current() |
Restituisce l'indice dei caratteri del limite di testo restituito più di recente da next(), next(int), previous(), first(), last(), following(int) o previous(int). |
| Dispose() |
La |
| Dispose(Boolean) |
La |
| Equals(Object) |
Indica se un altro oggetto è "uguale a" questo. (Ereditato da Object) |
| First() |
Restituisce il primo limite. |
| Following(Int32) |
Restituisce il primo limite dopo l'offset di caratteri specificato. |
| GetAvailableLocales() |
Restituisce una matrice di tutte le impostazioni locali per cui i |
| GetCharacterInstance(Locale) |
Restituisce una nuova |
| GetHashCode() |
Restituisce un valore del codice hash per l'oggetto. (Ereditato da Object) |
| GetLineInstance(Locale) |
Restituisce una nuova |
| GetSentenceInstance(Locale) |
Restituisce una nuova |
| GetWordInstance(Locale) |
Restituisce una nuova |
| IsBoundary(Int32) |
Restituisce true se l'offset di caratteri specificato è un limite di testo. |
| JavaFinalize() |
Chiamato dal Garbage Collector su un oggetto quando Garbage Collection determina che non sono presenti altri riferimenti all'oggetto . (Ereditato da Object) |
| Last() |
Restituisce l'ultimo limite. |
| Next() |
Restituisce il limite che segue il limite corrente. |
| Next(Int32) |
Restituisce l'n° limite dal limite corrente. |
| Notify() |
Riattiva un singolo thread in attesa del monitor dell'oggetto. (Ereditato da Object) |
| NotifyAll() |
Riattiva tutti i thread in attesa del monitoraggio di questo oggetto. (Ereditato da Object) |
| Preceding(Int32) |
Restituisce l'ultimo limite che precede l'offset di caratteri specificato. |
| Previous() |
Restituisce il limite che precede il limite corrente. |
| SetHandle(IntPtr, JniHandleOwnership) |
Imposta la proprietà Handle. (Ereditato da Object) |
| SetText(String) |
Impostare una nuova stringa di testo da analizzare. |
| ToArray<T>() |
La |
| ToString() |
Restituisce una rappresentazione in formato stringa dell'oggetto. (Ereditato da Object) |
| UnregisterFromRuntime() |
La |
| Wait() |
Fa sì che il thread corrente attenda finché non viene risvegliato, in genere eseguendo <una>notifica</em> o <em>interrotto</em>. (Ereditato da Object) |
| Wait(Int64) |
Fa sì che il thread corrente attenda finché non viene risvegliato, in genere eseguendo <una notifica</>em> o <em>interrotto</em> o fino a quando non è trascorsa una certa quantità di tempo reale. (Ereditato da Object) |
| Wait(Int64, Int32) |
Fa sì che il thread corrente attenda finché non viene risvegliato, in genere eseguendo <una notifica</>em> o <em>interrotto</em> o fino a quando non è trascorsa una certa quantità di tempo reale. (Ereditato da Object) |
Implementazioni dell'interfaccia esplicita
| IJavaPeerable.Disposed() |
La |
| IJavaPeerable.DisposeUnlessReferenced() |
La |
| IJavaPeerable.Finalized() |
La |
| IJavaPeerable.JniManagedPeerState |
La |
| IJavaPeerable.SetJniIdentityHashCode(Int32) |
La |
| IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates) |
La |
| IJavaPeerable.SetPeerReference(JniObjectReference) |
La |
Metodi di estensione
| JavaCast<TResult>(IJavaObject) |
Esegue una conversione del tipo verificato dal runtime Android. |
| JavaCast<TResult>(IJavaObject) |
La |
| GetJniTypeName(IJavaPeerable) |
La |