BreakIterator

public abstract class BreakIterator
extends Object implements Cloneable

[ICU增强] ICU的替代BreakIterator 。 ICU特有的方法，字段和其他功能标记为“ [icu] ”。

一个在文本中定位边界的类。 这个类定义了一个对象的协议，它根据一组标准分解一段自然语言文本。 例如，可以提供BreakIterator的实例或子类，以根据某种语言或一组语言的约定将一段文本分解为单词，句子或逻辑字符。 我们提供了五种内置类型的BreakIterator：

• getTitleInstance() returns a BreakIterator that locates boundaries between title breaks.
• getSentenceInstance() returns a BreakIterator that locates boundaries between sentences. This is useful for triple-click selection, for example.
• getWordInstance() returns a BreakIterator that locates boundaries between words. This is useful for double-click selection or "find whole words" searches. This type of BreakIterator makes sure there is a boundary position at the beginning and end of each legal word. (Numbers count as words, too.) Whitespace and punctuation are kept separate from real words.
• getLineInstance() returns a BreakIterator that locates positions where it is legal for a text editor to wrap lines. This is similar to word breaking, but not the same: punctuation and whitespace are generally kept with words (you don't want a line to start with whitespace, for example), and some special characters can force a position to be considered a line-break position or prevent a position from being a line-break position.
• getCharacterInstance() returns a BreakIterator that locates boundaries between logical characters. Because of the structure of the Unicode encoding, a logical character may be stored internally as more than one Unicode code point. (A with an umlaut may be stored as an a followed by a separate combining umlaut character, for example, but the user still thinks of it as one character.) This iterator allows various processes (especially text editors) to treat as characters the units of text that a user would think of as characters, rather than the units of text that the computer sees as "characters".

BreakIterator的接口遵循一个“迭代器”模型（因此是名称），这意味着它具有“当前位置”的概念以及用于更新当前位置的方法，如first（），last（），next（）和previous（）。 所有BreakIterators都支持以下不变式：

• The beginning and end of the text are always treated as boundary positions.
• The current position of the iterator is always a boundary position (random- access methods move the iterator to the nearest boundary position before or after the specified position, not _to_ the specified position).
• DONE is used as a flag to indicate when iteration has stopped. DONE is only returned when the current position is the end of the text and the user calls next(), or when the current position is the beginning of the text and the user calls previous().
• Break positions are numbered by the positions of the characters that follow them. Thus, under normal circumstances, the position before the first character is 0, the position after the first character is 1, and the position after the last character is 1 plus the length of the string.
• The client can change the position of an iterator, or the text it analyzes, at will, but cannot change the behavior. If the user wants different behavior, he must instantiate a new iterator.

例子 ：

创建和使用文本边界

 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);
      }
 }
 

 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));
     }
 }
 

 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));
     }
 }
 

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

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

 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));
 }
 

 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.charAt(p)))
                 return last;
         }
         last = current;
         current = wb.next();
     }
     return BreakIterator.DONE;
 }
 

(The iterator returned by BreakIterator.getWordInstance() is unique in that the break positions it returns don't represent both the start and end of the thing being iterated over. That is, a sentence-break iterator returns breaks that each represent the end of one sentence and the beginning of the next. With the word-break iterator, the characters between two boundaries might be a word, or they might be the punctuation or whitespace between two words. The above code uses a simple heuristic to determine which boundary is the beginning of a word: If the characters between this boundary and the next boundary include at least one letter (this can be an alphabetical letter, a CJK ideograph, a Hangul syllable, a Kana character, etc.), then the text between this boundary and the next is a word; otherwise, it's the material between words.)

Summary

Inherited methods

From class java.lang.Object Object clone() 创建并返回此对象的副本。 boolean equals(Object obj) 指示其他某个对象是否“等于”这一个。 void finalize() 当垃圾收集确定没有更多对该对象的引用时，由对象上的垃圾回收器调用。 final Class<?> getClass() 返回此 Object的运行时类。 int hashCode() 返回对象的哈希码值。 final void notify() 唤醒正在等待该对象监视器的单个线程。 final void notifyAll() 唤醒在该对象监视器上等待的所有线程。 String toString() 返回对象的字符串表示形式。 final void wait(long millis, int nanos) 导致当前线程等待，直到另一个线程调用此对象的方法 notify()或 notifyAll() ，或某个其他线程中断当前线程或经过一定的实时时间。 final void wait(long millis) 导致当前线程等待，直到另一个线程调用此对象的 notify()方法或 notifyAll()方法，或经过指定的时间量。 final void wait() 导致当前线程等待，直到另一个线程调用此对象的方法 notify()或方法 notifyAll() 。

Constants

int DONE

int KIND_CHARACTER

int KIND_LINE

int KIND_SENTENCE

int KIND_TITLE

int KIND_WORD

int WORD_IDEO

int WORD_IDEO_LIMIT

int WORD_KANA

int WORD_KANA_LIMIT

int WORD_LETTER

int WORD_LETTER_LIMIT

int WORD_NONE

int WORD_NONE_LIMIT

int WORD_NUMBER

int WORD_NUMBER_LIMIT

Protected constructors

BreakIterator ()

Public methods

Object clone ()

int current ()

int first ()

int following (int offset)

Locale[] getAvailableLocales ()

BreakIterator getCharacterInstance (ULocale where)

BreakIterator getCharacterInstance (Locale where)

BreakIterator getCharacterInstance ()

BreakIterator getLineInstance (Locale where)

BreakIterator getLineInstance (ULocale where)

BreakIterator getLineInstance ()

int getRuleStatus ()

int getRuleStatusVec (int[] fillInArray)

BreakIterator getSentenceInstance (Locale where)

BreakIterator getSentenceInstance (ULocale where)

BreakIterator getSentenceInstance ()

CharacterIterator getText ()

BreakIterator getTitleInstance (Locale where)

BreakIterator getTitleInstance (ULocale where)

BreakIterator getTitleInstance ()

BreakIterator getWordInstance (Locale where)

BreakIterator getWordInstance (ULocale where)

BreakIterator getWordInstance ()

boolean isBoundary (int offset)

int last ()

int next ()

int next (int n)

int preceding (int offset)

int previous ()

void setText (String newText)

void setText (CharacterIterator newText)