contentparser.java

采用JAVA开发

package com.gctech.sms.sp.dwzb;

import java.util.*;

/**
 * @author <a href="mailto:[e-mail]">贾洪祥 </a>
 * @version 1.0.0
 * @since 2004-8-24 15:17:46
 */
public class ContentParser {
    /**
     * 缺省构造函数
     */
    public ContentParser() {
        this.directives = new HashMap();
        this.directivePositions = new HashMap();
        this.limit = -1;
    }

    /**
     * 设定要分割的文字
     *
     * @param text
     */
    public void setText(String text) {
        this.text = text;
    }

    /**
     * 设定分割字数限制
     *
     * @param limit
     *            字数限制
     */
    public void setLimit(int limit) {
        if (limit != this.limit && limit > 0) { // 如果字数限制更改才处理文字
            this.limit = limit;
            this.doProcess();
        } else { // 否则不做任何处理
        }
    }

    /**
     * 设置替换指令
     *
     * @param directive
     *            指令
     * @param rep
     *            替代文字
     * @param pos
     *            指令位置
     */
    public void addDirective(String directive, String rep, DirectivePosition pos) {
        this.directives.put(directive, rep);
        this.directivePositions.put(directive, pos);
    }

    /**
     * 返回预处理后的内容
     *
     * @return 预处理后的内容
     */
    public String getPreprocessedText() {
        return this.parsedText;
    }

    /**
     * 返回分割后的内容
     *
     * @return 以List存储的内容分段
     */
    public List getDevidedText() {
        return this.devided;
    }

    /**
     * 预处理文字内容
     *
     * @return
     */
    private void doProcess() {
        if(this.limit == -1) return;

        this.devided = new ArrayList();
        Collection res = this.loopDevide(this.text);
        DirectivePosition posTemp;

        String	dirKey_OverallStart = null, // 在所有文字最前的预处理标记
        		dirKey_OverallEnd = null,	// 在所有文字最末的预处理标记
        		dirKey_SegStart = null,		// 在每段文字开始的预处理标记（不包括所有文字的开始）
        		dirKey_SegEnd = null;		// 在每段文字结束的预处理标记（不包括所有文字的结尾）

        String	dirVal_OverallStart = null,	// 在所有文字最前的预处理标记替代文字
        		dirVal_OverallEnd = null,	// 在所有文字最末的预处理标记替代文字
        		dirVal_SegStart = null,		// 在每段文字开始的预处理标记替代文字
        		dirVal_SegEnd = null;		// 在每段文字结束的预处理标记替代文字

        // 取得处于所有位置的预处理标记和对应的替代文字
        Set keys = this.directivePositions.keySet();
        Iterator keyIter = keys.iterator();
        while (keyIter.hasNext()) {
            String directive = (String) keyIter.next();
            posTemp = (DirectivePosition) this.directivePositions
                    .get(directive);
            if (DirectivePosition.OVERALL_START.equals(posTemp)) { // 在所有文字最前
                dirKey_OverallStart = directive;
                dirVal_OverallStart = (String)this.directives.get(dirKey_OverallStart);
                posTemp = null;
            }
            if (DirectivePosition.OVERALL_END.equals(posTemp)) { // 在所有文字最末
                dirKey_OverallEnd = directive;
                dirVal_OverallEnd = (String)this.directives.get(dirKey_OverallEnd);
                posTemp = null;
            }
            if (DirectivePosition.SEGMENT_START.equals(posTemp)) { // 在每段文字的开始
                dirKey_SegStart = directive;
                dirVal_SegStart = (String)this.directives.get(dirKey_SegStart);
                posTemp = null;
            }
            if (DirectivePosition.SEGMENT_END.equals(posTemp)) { // 在每段文字的结束
                dirKey_SegEnd = directive;
                dirVal_SegEnd = (String) this.directives.get(dirKey_SegEnd);
                posTemp = null;
            }
        }

        Collection c = this.loopDevide(text); // 分割文字后
        StringBuffer sbResult = new StringBuffer(); // 用于存储将要替换预处理标记的文字
        StringBuffer sbPreprocessed = new StringBuffer(); // 用于存储将要添加预处理标记的文字
        ArrayList al = new ArrayList(); // 存储加了预处理标记的文字

        Iterator iter = c.iterator();
        int i = 0, end = c.size();
        while (iter.hasNext()) {
            String cur = (String) iter.next();
            StringBuffer tmp = null;
            if (i < end - 1) { // 不是最后一段文字时
                if (i == 0) { // 第一段文字，要求在分段开始处添加属性为DirectivePosition.OVERALL_START的预处理标记
                    if (sbResult.length() == 0) { // 如果当前分段不包含文字
                        sbResult.append(dirVal_OverallStart); // 添加开始标记的替代文字
                        sbPreprocessed.append(dirKey_OverallStart); // 添加开始标记
                    }
                } else { // 不是第一段文字，则在分段开始处添加属性为DirectivePosition.SEGMENT_START的预处理标记
                    if (sbResult.length() == 0) { // 如果当前分段不包含文字
                        sbResult.append(dirVal_SegStart); // 添加开始标记的替代文字
                        sbPreprocessed.append(dirKey_SegStart); // 添加开始标记
                    }
                }
                // 构造新的StringBuffer，用来测试如果把当前分段所要包含的文字和结束标记加入分段后，是否会超过字数限制
                tmp = new StringBuffer(sbResult.toString());
                tmp.append(cur);
                tmp.append(dirVal_SegEnd);

                if (tmp.length() > limit) { // 如果超过字数限制
                    sbResult.append(dirVal_SegEnd); // 当前分段添加结束文字
                    sbPreprocessed.append(dirKey_SegEnd); // 添加结束标记
                    this.devided.add(sbResult.toString()); // 添加当前分段的文字
                    al.add(sbPreprocessed.toString()); // 添加含有预处理标记的文字
                    sbResult = new StringBuffer(); // 更新
                    sbPreprocessed = new StringBuffer(); // 更新
                } else { // 没有超过字数限制
                    sbResult.append(cur); // 添加当前分段所要包含的文字
                    sbPreprocessed.append(cur);
                }
            } else { // 是最后一段时
                if (sbResult.length() == 0) { // 如果当前分段不包含文字
                    sbResult.append(dirVal_SegStart); // 添加分段开始标记的替代文字
                    sbPreprocessed.append(dirKey_SegStart); // 添加分段开始标记
                }
                // 开始测试如果把文字和结束标记都添加后，是否会超过字数限制
                tmp = new StringBuffer(sbResult.toString());
                tmp.append(cur); // 添加当前分段字符串
                tmp.append(dirVal_OverallEnd); // 添加结束标记
                if (tmp.length() > limit) { // 如果超过字数限制
                    sbResult.append(dirVal_SegEnd); // 当前已有文字添加结束标记
                    sbPreprocessed.append(dirKey_SegEnd);
                    this.devided.add(sbResult.toString());
                    al.add(sbPreprocessed.toString());
                    sbResult = new StringBuffer();
                    sbPreprocessed = new StringBuffer();
                } else { // 没有超过字数限制
                    sbResult.append(cur); // 添加当前分段所要包含的文字
                    sbPreprocessed.append(cur);
                }
            }

            i++;
        }

        // 查看当前分段是否还有剩余文字
        // 有剩余文字的话肯定属于最后一个分段，则需添加结尾标记
        if (sbResult.toString().length() != 0) {
            sbResult.append(dirVal_OverallEnd);
            sbPreprocessed.append(dirKey_OverallEnd);
            this.devided.add(sbResult.toString());
            al.add(sbPreprocessed.toString());
        }

        // 生成包含预处理标记的字符串
        StringBuffer parsed = new StringBuffer();
        Iterator resIter = al.iterator();
        while (resIter.hasNext()) {
            String cur = (String) resIter.next();
            parsed.append(cur);
        }
        this.parsedText = parsed.toString();
    }

    /**
     * 循环分割，将文字按所有指定的标点分割
     *
     * @param t
     * 			将分割的文字
     * @return
     */
    protected Collection loopDevide(String t) {
        List devided = new ArrayList();
        String[] separators = { ",","，","。", ".", "！", "!", "？", "?", "……", "…", "..." };
        String[] regexSep = { ",{1}","，{1}","。{1}", "(\\.{1})", "！+", "!+", "(？){1}",
                "(\\?{1})", "(…{2})", "(…{1})", "(\\.{3})" };
        devided.add(t);
        for (int i = 0; i < separators.length; i++) {
            String separator = separators[i];
            String regSep = regexSep[i];
            devided = devide(devided, separator, regSep);
        }

        return devided;
    }

    /**
     * 分割文字
     *
     * @param con
     * 			分割后的文字都将添加到这个容器中
     * @param sep
     * 			将分割的文字
     * @param regSep
     * 			对应将要分割的文字的正则表达式
     * @param step
     * @return
     */
    private List devide(Collection con, String sep, String regSep) {
        List ret = new ArrayList();
        Iterator it = con.iterator();
        String[] tmp;

        while (it.hasNext()) {
            String cur = (String) it.next();
            tmp = cur.split(regSep);
            if (tmp.length == 1) {
                if (cur.indexOf(sep) != -1) {
                    tmp[0] = tmp[0] + sep;
                }
                ret.add(tmp[0]);
            } else {
                for (int i = 0; i < tmp.length - 1; i++) {
                    tmp[i] = tmp[i] + sep;
                }
                if (cur.endsWith(sep)) {
                    tmp[tmp.length - 1] = tmp[tmp.length - 1] + sep;
                }
                for (int i = 0; i < tmp.length; i++) {
                    String s = tmp[i];
                    ret.add(s);
                }
            }
        }
        return ret;
    }

    private String text; // 将要处理的文字
    private int limit; // 字数限制
    private String parsedText; // 添加预处理标记后的文字
    private HashMap directives; // 所有预处理标记和对应的替代文字
    private HashMap directivePositions; // 所有预处理标记和其应出现的位置
    private ArrayList devided; // 分割后并把预处理标记替换成对应文字后的文字分段
}