BreakIterator

public abstract class BreakIterator
extends Object implements Cloneable

BreakIterator类实现了用于在文本中查找边界位置的方法。 BreakIterator实例维护当前位置并扫描返回出现边界的字符索引的文本。 在内部， BreakIterator扫描文本使用CharacterIterator ，并且因此能够扫描通过实现协议的任何对象保存文本。 使用StringCharacterIterator扫描String传递给setText对象。

您可以使用此类提供的工厂方法来创建各种类型的中断迭代器的实例。 尤其是，使用getWordInstance ， getLineInstance ， getSentenceInstance ，并getCharacterInstance创造BreakIterator s表示分别执行字，行，句子和字符边界分析。 单个BreakIterator只能在一个单元上工作（单词，行，句子等）。 对于您希望执行的每个单位边界分析，您必须使用不同的迭代器。

行边界分析确定了换行时文本字符串可以被破坏的位置。 该机制正确处理标点符号和带连字符的单词。 实际的换行需要考虑可用的行宽，并由更高级别的软件处理。

句子边界分析允许选择正确解释数字和缩写内的句号，以及尾标点符号（如引号和括号）。

搜索和替换功能以及文本编辑应用程序使用词边界分析，允许用户通过双击选择单词。 单词选择提供了对单词内部和后面的标点符号的正确解释。 不属于单词的字符（例如符号或标点符号）在双方都有分词符。

字符边界分析允许用户按照预期与角色进行交互，例如，在通过文本字符串移动光标时。 字符边界分析通过字符串提供正确的导航，而不管字符如何存储。 返回的边界可以是补充字符的边界，组合字符序列或连字集群。 例如，重音字符可能被存储为基本字符和变音符号。 用户认为是角色的语言可能会因语言而异。

BreakIterator的工厂方法返回的BreakIterator实例仅用于自然语言，不适用于编程语言文本。 然而，可以定义标记一种编程语言的子类。

例子 ：

创建和使用文本边界：

 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.codePointAt(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

Protected constructors

BreakIterator ()

Public methods

Object clone ()

int current ()

int first ()

int following (int offset)

Locale[] getAvailableLocales ()

BreakIterator getCharacterInstance (Locale locale)

BreakIterator getCharacterInstance ()

BreakIterator getLineInstance (Locale locale)

BreakIterator getLineInstance ()

BreakIterator getSentenceInstance (Locale locale)

BreakIterator getSentenceInstance ()

CharacterIterator getText ()

BreakIterator getWordInstance ()

BreakIterator getWordInstance (Locale locale)

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)