Module  java.base
软件包  java.text

Class BreakIterator

  • All Implemented Interfaces:
    Cloneable


    public abstract class BreakIterator
    extends Object
    implements Cloneable
    BreakIterator类实现了在文本中查找边界位置的方法。 BreakIterator实例保持当前位置并扫描返回边界发生的字符索引的文本。 在内部, BreakIterator扫描文本使用CharacterIterator ,并且因此能够扫描通过实现协议的任何对象保存文本。 A StringCharacterIterator用于扫描传递给setText String对象。

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

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

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

    Word边界分析由搜索和替换功能以及文本编辑应用程序使用,允许用户双击选择单词。 词选择提供正确解释单词内和之后的标点符号。 不是单词的一部分的字符,如符号或标点符号,双方都有单词。

    字符边界分析允许用户与字符进行交互,例如,当将光标移动到文本字符串时。 字符边界分析提供了通过字符串的正确导航,而不管字符的存储方式如何。 返回的边界可以是补充字符,组合字符序列或连字符集的边界。 例如,重音字符可能存储为基本字符和变音标记。 用户认为是一个字符的用户可能因语言而异。

    由本类工厂方法返回的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.)
    从以下版本开始:
    1.1
    另请参见:
    CharacterIterator
    • 字段详细信息

      • DONE

        public static final int DONE
        当达到第一个或最后一个文本边界时,DONE将返回previous(),next(),next(int),previous(int)和after(int)。
        另请参见:
        Constant Field Values
    • 构造方法详细信息

      • BreakIterator

        protected BreakIterator​()
        构造函数。 BreakIterator是无状态的,没有默认行为。
    • 方法详细信息

      • clone

        public Object clone​()
        创建一个这个迭代器的副本
        重写:
        cloneObject
        结果
        这个的副本
        另请参见:
        Cloneable
      • first

        public abstract int first​()
        返回第一个边界。 迭代器的当前位置被设置为第一个文本边界。
        结果
        第一个文本边界的字符索引。
      • last

        public abstract int last​()
        返回最后一个边界。 迭代器的当前位置设置为最后一个文本边界。
        结果
        最后一个文本边界的字符索引。
      • next

        public abstract int next​(int n)
        从当前边界返回第n个边界。 如果达到了第一个或最后一个文本边界,它将返回BreakIterator.DONE并且根据到达哪一个文本边界将当前位置设置为第一个或最后一个文本边界。 否则,迭代器的当前位置被设置为新的边界。 例如,如果迭代器的当前位置是第m个文本边界,并且从当前边界到最后一个文本边界存在三个边界,则下一个(2)调用将返回m + 2。新的文本位置设置为(m + 2)个文本边界。 下一个(4)调用将返回BreakIterator.DONE ,最后一个文本边界将成为新的文本位置。
        参数
        n - 要返回的边界。 0值不起作用。 负值移动到上一个边界,正值移动到稍后的边界。
        结果
        从当前位置起第n个边界的字符索引,如果达到了第一个或最后一个文本边界, BreakIterator.DONE
      • next

        public abstract int next​()
        返回当前边界之后的边界。 如果当前边界是最后一个文本边界,则返回BreakIterator.DONE ,迭代器的当前位置不变。 否则,迭代器的当前位置被设置为当前边界之后的边界。
        结果
        如果当前边界是最后一个文本边界,则下一个文本边界的字符索引为BreakIterator.DONE 相当于下一(1)。
        另请参见:
        next(int)
      • previous

        public abstract int previous​()
        返回当前边界之前的边界。 如果当前边界是第一个文本边界,则返回BreakIterator.DONE ,迭代器的当前位置不变。 否则,迭代器的当前位置被设置为当前边界之前的边界。
        结果
        前一个文本边界的字符索引,如果当前边界是第一个文本边界, BreakIterator.DONE
      • following

        public abstract int following​(int offset)
        返回指定字符偏移后的第一个边界。 如果指定的偏移量等于最后一个文本边界,则返回BreakIterator.DONE ,迭代器的当前位置不变。 否则,迭代器的当前位置被设置为返回的边界。 返回的值始终大于offset或值BreakIterator.DONE
        参数
        offset - 开始扫描的字符偏移量。
        结果
        指定偏移后的第一个边界,如果最后一个文本边界作为偏移传递, BreakIterator.DONE
        异常
        IllegalArgumentException - 如果指定的偏移小于第一个文本边界或大于最后一个文本边界。
      • preceding

        public int preceding​(int offset)
        返回指定字符偏移量之前的最后一个边界。 如果指定的偏移量等于第一个文本边界,则返回BreakIterator.DONE ,迭代器的当前位置不变。 否则,迭代器的当前位置被设置为返回的边界。 返回的值始终小于偏移值或值BreakIterator.DONE
        参数
        offset - 开始扫描的字符偏移量。
        结果
        指定偏移前的最后一个边界,如果第一个文本边界作为偏移传递, BreakIterator.DONE
        异常
        IllegalArgumentException - 如果指定的偏移量小于第一个文本边界或大于最后一个文本边界。
        从以下版本开始:
        1.2
      • isBoundary

        public boolean isBoundary​(int offset)
        如果指定的字符偏移量是文本边界,则返回true。
        参数
        offset - 要检查的字符偏移量。
        结果
        true如果“偏移”是边界位置,否则为 false
        异常
        IllegalArgumentException - 如果指定的偏移小于第一个文本边界或大于最后一个文本边界。
        从以下版本开始:
        1.2
      • current

        public abstract int current​()
        返回最近由next(),next(int),previous(),first(),last(),following(int)或previous(int)返回的文本边界的字符索引。 如果这些方法中的任何一个返回BreakIterator.DONE因为已经达到了第一个或最后一个文本边界,则返回第一个或最后一个文本边界,具体取决于到达哪一个。
        结果
        从上述方法返回的文本边界,第一个或最后一个文本边界。
        另请参见:
        next()next(int)previous()first()last()following(int)preceding(int)
      • getText

        public abstract CharacterIterator getText​()
        获取正在扫描的文本
        结果
        正在扫描的文字
      • setText

        public void setText​(String newText)
        设置要扫描的新文本字符串。 当前的扫描位置被重置为first()。
        参数
        newText - 要扫描的新文本。
      • setText

        public abstract void setText​(CharacterIterator newText)
        设置一个新文本进行扫描。 当前的扫描位置被重置为first()。
        参数
        newText - 要扫描的新文本。
      • getWordInstance

        public static BreakIterator getWordInstance​(Locale locale)
        为给定的区域设置返回一个新的 BreakIterator实例 word breaks
        参数
        locale - 所需的语言环境
        结果
        一个用于单词的中断迭代器
        异常
        NullPointerException - 如果 locale为空
      • getLineInstance

        public static BreakIterator getLineInstance​(Locale locale)
        返回一个新 BreakIterator例如 line breaks给定语言环境。
        参数
        locale - 所需的语言环境
        结果
        换行符用于换行符
        异常
        NullPointerException - 如果 locale为空
      • getCharacterInstance

        public static BreakIterator getCharacterInstance​(Locale locale)
        为给定的语言环境返回一个新的 BreakIterator实例,用于 character breaks
        参数
        locale - 所需的语言环境
        结果
        用于字符中断的中断迭代器
        异常
        NullPointerException - 如果 locale为空
      • getSentenceInstance

        public static BreakIterator getSentenceInstance​(Locale locale)
        为给定的语言环境返回一个新的 BreakIterator实例,用于 sentence breaks
        参数
        locale - 所需的语言环境
        结果
        休假的休息迭代器
        异常
        NullPointerException - 如果 locale为空
      • getAvailableLocales

        public static Locale[] getAvailableLocales​()
        返回一个所有语言环境的数组, get*Instance方法可以返回本地化实例。 返回的数组表示由Java运行时支持的语言环境和已安装的BreakIteratorProvider实现的联合。 它必须至少包含Locale实例等于Locale.US
        结果
        本地化的数组,可用于本地化的 BreakIterator实例。