模块  java.base
软件包  java.text

Class BreakIterator

  • 实现的所有接口
    Cloneable

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

    您可以使用此类提供的工厂方法来创建各种类型的break迭代器的实例。 尤其是,使用getWordInstancegetLineInstancegetSentenceInstancegetCharacterInstance创造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.)
    从以下版本开始:
    1.1
    另请参见:
    CharacterIterator
    • 字段详细信息

      • DONE

        public static final int DONE
        当达到第一个或最后一个文本边界时,由前一个(),下一个(),下一个(整数),前一个(整数)和后一个(整数)返回DONE。
        另请参见:
        常数字段值
    • 构造方法详细信息

      • BreakIterator

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

      • clone

        public Object clone()
        创建此迭代器的副本
        重写:
        clone在课程 Object
        结果
        这份的副本
        另请参见:
        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)文本边界。 next(4)调用将返回BreakIterator.DONE ,最后一个文本边界将成为新的文本位置。
        参数
        n - 返回哪个边界。 值0不起作用。 负值移动到先前的边界,正值移动到后面的边界。
        结果
        当前位置的第n个边界的字符索引,如果已达到第一个或最后一个文本边界, BreakIterator.DONE
      • next

        public abstract int next()
        返回当前边界之后的边界。 如果当前边界是最后一个文本边界,则返回BreakIterator.DONE并且迭代器的当前位置不变。 否则,迭代器的当前位置将设置为当前边界之后的边界。
        结果
        如果当前边界是最后一个文本边界, 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并且迭代器的当前位置不变。 否则,迭代器的当前位置将设置为返回的边界。 返回的值始终大于偏移量或值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如果“offset”是边界位置, 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的新实例 BreakIterator
        参数
        locale - 所需的语言环境
        结果
        单词中断的中断迭代器
        异常
        NullPointerException - 如果 locale为空
      • getLineInstance

        public static BreakIterator getLineInstance​(Locale locale)
        为给定的语言环境返回 BreakIterator的新实例 BreakIterator
        参数
        locale - 所需的区域设置
        结果
        换行符的断点迭代器
        异常
        NullPointerException - 如果 locale为空
      • getCharacterInstance

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

        public static BreakIterator getSentenceInstance​(Locale locale)
        返回一个新 BreakIterator例如 sentence breaks给定语言环境。
        参数
        locale - 所需的语言环境
        结果
        句子中断的中断迭代器
        异常
        NullPointerException - 如果 locale为空
      • getAvailableLocales

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