package cn.nwsuaf.spilt;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
/**
 * 基于正逆雙向最大匹配分詞算法實現(xiàn)
 * @author 劉永浪
 *
 */
public class WordSpilt {
  /**
   * 存儲分詞詞典
   */
  private Map<String, Integer> map = new HashMap<String, Integer>();
  /**
   * 最大切詞長度,即為五個漢字
   */
  private int MAX_LENGTH = 5;
  /**
   * 構(gòu)造方法中讀取分詞詞典，并存儲到map中
   *
   * @throws IOException
   */
  public WordSpilt() throws IOException {
    BufferedReader br = new BufferedReader(new FileReader("src/dict.txt"));
    String line = null;
    while ((line = br.readLine()) != null) {
      line = line.trim();
      map.put(line, 0);
    }
    br.close();
  }
  /**
   * 設(shè)置最大切詞長度
   *
   * @param max
   *      最大切詞長度
   */
  public void setMaxLength(int max) {
    this.MAX_LENGTH = max;
  }
  /**
   * 獲取當前最大切詞長度，默認為5（5個漢字）
   *
   * @return 當前最大切詞長度
   */
  public int getMaxLength() {
    return this.MAX_LENGTH;
  }
  /**
   * 最大匹配分詞算法
   *
   * @param spiltStr
   *      待切分的字符串
   * @param leftToRight
   *      切分方向，true為從左向右，false為從右向左
   * @return 切分的字符串
   */
  public List<String> spilt(String spiltStr, boolean leftToRight) {
    // 如果帶切分字符串為空則返回空
    if (spiltStr.isEmpty())
      return null;
    // 儲存正向匹配分割字符串
    List<String> leftWords = new ArrayList<String>();
    // 儲存負向匹配分割字符串
    List<String> rightWords = new ArrayList<String>();
    // 用于取切分的字串
    String word = null;
    // 取詞的長度，初始化設(shè)置為最大值
    int wordLength = MAX_LENGTH;
    // 分詞操作中處于字串當前位置
    int position = 0;
    // 已經(jīng)處理字符串的長度
    int length = 0;
    // 去掉字符串中多余的空格
    spiltStr = spiltStr.trim().replaceAll("\\s+", "");
    // 當待切分字符串沒有被切分完時循環(huán)切分
    while (length < spiltStr.length()) {
      // 如果還沒切分的字符串長度小于最大值，讓取詞詞長等于該詞本身長度
      if (spiltStr.length() - length < MAX_LENGTH)
        wordLength = spiltStr.length() - length;
      // 否則取默認值
      else
        wordLength = MAX_LENGTH;
      // 如果是正向最大匹配，從spiltStr的position處開始切割
      if (leftToRight) {
        position = length;
        word = spiltStr.substring(position, position + wordLength);
      }
      // 如果是逆向最大匹配，從spiltStr末尾開始切割
      else {
        position = spiltStr.length() - length;
        word = spiltStr.substring(position - wordLength, position);
      }
      // 從當前位置開始切割指定長度的字符串
      // word = spiltStr.substring(position, position + wordLength);
      // 如果分詞詞典里面沒有切割出來的字符串，舍去一個字符
      while (!map.containsKey(word)) {
        // 如果是單字，退出循環(huán)
        if (word.length() == 1) {
          // 如果是字母或是數(shù)字要將連續(xù)的字母或者數(shù)字分在一起
          if (word.matches("[a-zA-z0-9]")) {
            // 如果是正向匹配直接循環(huán)將后續(xù)連續(xù)字符加起來
            if (leftToRight) {
              for (int i = spiltStr.indexOf(word, position) + 1; i < spiltStr
                  .length(); i++) {
                if ((spiltStr.charAt(i) >= '0' && spiltStr
                    .charAt(i) <= '9')
                    || (spiltStr.charAt(i) >= 'A' && spiltStr
                        .charAt(i) <= 'Z')
                    || (spiltStr.charAt(i) >= 'a' && spiltStr
                        .charAt(i) <= 'z')) {
                  word += spiltStr.charAt(i);
                } else
                  break;
              }
            } else {
              // 如果是逆向匹配，從當前位置之前的連續(xù)數(shù)字、字母字符加起來并翻轉(zhuǎn)
              for (int i = spiltStr.indexOf(word, position - 1) - 1; i >= 0; i--) {
                if ((spiltStr.charAt(i) >= '0' && spiltStr
                    .charAt(i) <= '9')
                    || (spiltStr.charAt(i) >= 'A' && spiltStr
                        .charAt(i) <= 'Z')
                    || (spiltStr.charAt(i) >= 'a' && spiltStr
                        .charAt(i) <= 'z')) {
                  word += spiltStr.charAt(i);
                  if (i == 0) {
                    StringBuffer sb = new StringBuffer(word);
                    word = sb.reverse().toString();
                  }
                } else {
                  // 翻轉(zhuǎn)操作
                  StringBuffer sb = new StringBuffer(word);
                  word = sb.reverse().toString();
                  break;
                }
              }
            }
          }
          break;
        }
        // 如果是正向最大匹配，舍去最后一個字符
        if (leftToRight)
          word = word.substring(0, word.length() - 1);
        // 否則舍去第一個字符
        else
          word = word.substring(1);
      }
      // 將切分出來的字符串存到指定的表中
      if (leftToRight)
        leftWords.add(word);
      else
        rightWords.add(word);
      // 已處理字符串增加
      length += word.length();
    }
    // 如果是逆向最大匹配，要把表中的字符串調(diào)整為正向
    if (!leftToRight) {
      for (int i = rightWords.size() - 1; i >= 0; i--) {
        leftWords.add(rightWords.get(i));
      }
    }
    // 返回切分結(jié)果
    return leftWords;
  }
  /**
   * 判斷兩個集合是否相等
   *
   * @param list1
   *      集合1
   * @param list2
   *      集合2
   * @return 如果相等則返回true，否則為false
   */
  public boolean isEqual(List<String> list1, List<String> list2) {
    if (list1.isEmpty() && list2.isEmpty())
      return false;
    if (list1.size() != list2.size())
      return false;
    for (int i = 0; i < list1.size(); i++) {
      if (!list1.get(i).equals(list2.get(i)))
        return false;
    }
    return true;
  }
  /**
   * 判別分詞歧義函數(shù)
   *
   * @param inputStr
   *      待切分字符串
   * @return 分詞結(jié)果
   */
  public List<String> resultWord(String inputStr) {
    // 分詞結(jié)果
    List<String> result = new ArrayList<String>();
    // “左貪吃蛇”分詞結(jié)果
    List<String> resultLeft = new ArrayList<String>();
    // “中貪吃蛇”（分歧部分）分詞結(jié)果
    List<String> resultMiddle = new ArrayList<String>();
    // “右貪吃蛇”分詞結(jié)果
    List<String> resultRight = new ArrayList<String>();
    // 正向最大匹配分詞結(jié)果
    List<String> left = new ArrayList<String>();
    // 逆向最大匹配分詞結(jié)果
    List<String> right = new ArrayList<String>();
    left = spilt(inputStr, true);
    /*System.out.println("正向分詞結(jié)果：");
    for (String string : left) {
      System.out.print(string + "/");
    }
    System.out.println("\n逆向分詞結(jié)果：");*/
    right = spilt(inputStr, false);
    /*for (String string : right) {
      System.out.print(string + "/");
    }
    System.out.println("\n雙向分詞結(jié)果：");*/
    // 判斷兩頭的分詞拼接，是否已經(jīng)在輸入字符串的中間交匯，只要沒有交匯，就不停循環(huán)
    while (left.get(0).length() + right.get(right.size() - 1).length() < inputStr
        .length()) {
      // 如果正逆向分詞結(jié)果相等，那么取正向結(jié)果跳出循環(huán)
      if (isEqual(left, right)) {
        resultMiddle = left;
        break;
      }
      // 如果正反向分詞結(jié)果不同，則取分詞數(shù)量較少的那個，不用再循環(huán)
      if (left.size() != right.size()) {
        resultMiddle = left.size() < right.size() ? left : right;
        break;
      }
      // 如果以上條件都不符合，那么實行“貪吃蛇”算法
      // 讓“左貪吃蛇”吃下正向分詞結(jié)果的第一個詞
      resultLeft.add(left.get(0));
      // 讓“右貪吃蛇”吃下逆向分詞結(jié)果的最后一個詞
      resultRight.add(right.get(right.size() - 1));
      // 去掉被“貪吃蛇”吃掉的詞語
      inputStr = inputStr.substring(left.get(0).length());
      inputStr = inputStr.substring(0,
          inputStr.length() - right.get(right.size() - 1).length());
      // 清理之前正逆向分詞結(jié)果，防止造成干擾
      left.clear();
      right.clear();
      // 對沒被吃掉的字符串重新開始分詞
      left = spilt(inputStr, true);
      right = spilt(inputStr, false);
    }
    // 循環(huán)結(jié)束，說明要么分詞沒有歧義了，要么"貪吃蛇"從兩頭吃到中間交匯了
    // 如果是在中間交匯，交匯時的分詞結(jié)果，還要進行以下判斷：
    // 如果中間交匯有重疊了：
    // 正向第一個分詞的長度 + 反向最后一個分詞的長度 > 輸入字符串總長度，就直接取正向的
    if (left.get(0).length() + right.get(right.size() - 1).length() > inputStr
        .length())
      resultMiddle = left;
    // 如果中間交匯，剛好吃完，沒有重疊：
    // 正向第一個分詞 + 反向最后一個分詞的長度 = 輸入字符串總長度，那么正反向一拼即可
    if (left.get(0).length() + right.get(right.size() - 1).length() == inputStr
        .length()) {
      resultMiddle.add(left.get(0));
      resultMiddle.add(right.get(right.size() - 1));
    }
    // 將沒有歧義的分詞結(jié)果添加到最終結(jié)果result中
    for (String string : resultLeft) {
      result.add(string);
    }
    for (String string : resultMiddle) {
      result.add(string);
    }
    // “右貪吃蛇”存儲的分詞要調(diào)整為正向
    for (int i = resultRight.size() - 1; i >= 0; i--) {
      result.add(resultRight.get(i));
    }
    return result;
  }
  /**
   * 將一段話分割成若干句話，分別進行分詞
   *
   * @param inputStr
   *      待分割的一段話
   * @return 這段話的分詞結(jié)果
   */
  public List<String> resultSpilt(String inputStr) {
    // 用于存儲最終分詞結(jié)果
    List<String> result = new ArrayList<String>();
    // 如果遇到標點就分割成若干句話
    String regex = "[，。；??？]";
    String[] st = inputStr.split(regex);
    // 將每一句話的分詞結(jié)果添加到最終分詞結(jié)果中
    for (String stri : st) {
      List<String> list = resultWord(stri);
      result.addAll(list);
    }
    return result;
  }
  public static void main(String[] args) {
    // example:過來看房價貴不貴？乒乓球拍賣完了
    Scanner input = new Scanner(System.in);
    String str = input.nextLine();
    WordSpilt wordSpilt = null;
    try {
      wordSpilt = new WordSpilt();
    } catch (IOException e) {
      e.printStackTrace();
    }
    List<String> list = wordSpilt.resultWord(str);
    for (String string : list) {
      System.out.print(string + "/");
    }
  }
}

歡迎
腳本之家
腳本下載
腳本
教程
素材
下載