判断一句话的极性

import java.io.StringReader;
import java.util.Collection;
import java.util.List;

import org.Constant.conPro;
import org.analysis.negExtra;

import edu.stanford.nlp.ling.HasWord;
import edu.stanford.nlp.process.Tokenizer;
import edu.stanford.nlp.trees.GrammaticalStructure;
import edu.stanford.nlp.trees.GrammaticalStructureFactory;
import edu.stanford.nlp.trees.Tree;
import edu.stanford.nlp.trees.TreebankLanguagePack;
import edu.stanford.nlp.trees.TypedDependency;

class negExtra{

    public static void main(String[] args) {
          String sentence = "酒鬼酒 没有 添加 塑化剂。 ";
          String[] keywords = {"塑化剂"};
          String[] negWords = { "没有", "不会", "无" };
          extraWord(sentence, negWords,keywords);

          List<TypedDependency> tdl = negExtra.DPFromString(sentence);
          for (TypedDependency oneTdl : tdl) {
                System.out.println(oneTdl);
     }

    /**
    * 抽取否定词 根据关键词否定关系出现的次数，返回否定词出现次数
    * @param sentence
    * @param negword
    */
    @SuppressWarnings("unchecked")
    public static int extraWord(String sentence, String[] negWords,String[] keywords) {

          conPro.lp.setOptionFlags("-maxLength", "20000000");

          TreebankLanguagePack tlp = conPro.lp.getOp().langpack();
          GrammaticalStructureFactory gsf = tlp.grammaticalStructureFactory();

          Tokenizer<? extends HasWord> toke = tlp.getTokenizerFactory().getTokenizer(new StringReader(sentence));
          List<? extends HasWord> sentList = toke.tokenize();
          Tree parser = conPro.lp.apply(sentList);

          GrammaticalStructure gs = gsf.newGrammaticalStructure(parser);
          Collection tdl = gs.typedDependenciesCollapsedTree();

          int count = 0;  //关键词的否定关系出现次数
          int vp = 0; //极性值vp
          // TODO 获取关键词极性值 （例如：致癌 加入其极性值为-1） 
          vp = -1; // vp = keyword.极性值(-1)

          for (int i = 0; i < tdl.size(); i++) {
                TypedDependency td = (TypedDependency) tdl.toArray()[i];
                String nodgov = td.gov().toString();
                String dep = td.dep().value().toString();
                // String gov = td.gov().value().toString();
                String relation = td.reln().toString();

                if (isKeyword(nodgov, keywords)) {
                      if ((relation.equals("neg")) || (relation.equals("advmod") && isNegword(dep, negWords))) {
                      ++count;
                      // System.out.println("relation:" + relation + "  " + "dep:" + dep + "   " + "gov:" + gov);
                      }
                }
          }

          if (count % 2 == 1) {
              vp = vp * -1;
          }
          return vp;
    }

    /**
    * 判断依存关系中是否存在关键词
    * @param nodGov
    * @param keyword
    * @return isKeyword
    */
    public static boolean isKeyword(String nodgov,String[] keywords){

          boolean isKeyword = false;
          for (String keyword : keywords) {
                if (nodgov.contains(keyword)) {
                      isKeyword = true;
                }
          }
          return isKeyword;
    }

    /**
    * 判断是否为否定词
    * @param dep
    * @param negwords
    * @return isNegword (boolean)
    */
    public static boolean isNegword(String dep, String[] negwords) {
          boolean isNegword = false;
          for (String negword : negwords) {
                if (dep.equals(negword)) {
                      isNegword = true;
                }
          }
          return isNegword;
    }
}