java中Tfidf的计算和矩阵存储

我有一个txt文件的语料库，我想计算它们的Tfidf值。 我想我必须首先将文件标记为单词，然后计算权重。 我需要这个程序的输出是一个矩阵，其中行是文件，列是单词，剩余矩阵单元格是Tfidf值

我被困在矩阵部分。 这是我的尝试

 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.FileReader;
 import java.io.IOException;
 import java.util.ArrayList;
import java.util.List;


public class DocumentParser {

//This variable will hold all terms of each document in an array.
private List<String[]> termsDocsArray = new ArrayList<String[]>();
private List<String> allTerms = new ArrayList<String>(); //to hold all terms
private List<double[]> tfidfDocsVector = new ArrayList<double[]>();
private List fileNameList = new ArrayList();
private File[] allfiles;
private StringBuilder sb;
private BufferedReader in = null;

/**
 * Method to read files and store in array.
 * @param filePath : source file path
 * @throws FileNotFoundException
 * @throws IOException
 */

public void parseFiles(String filePath) throws FileNotFoundException, IOException {
    allfiles = new File(filePath).listFiles();
    for (File f : allfiles) {
        if (f.getName().endsWith(".txt")) {
            fileNameList.add(f.getName());
            in = new BufferedReader(new FileReader(f));
            sb = new StringBuilder();
            String s = null;
            while ((s = in.readLine()) != null) {
                sb.append(s);
            }
            String[] tokenizedTerms = sb.toString().replaceAll("[\\W&&[^\\s]]", "").split("\\W+");   //to get individual terms
            for (String term : tokenizedTerms) {
                if (!allTerms.contains(term)) {  //avoid duplicate entry
                    allTerms.add(term);
                }
            }
            termsDocsArray.add(tokenizedTerms);
        }
    }

}

/**
 * Method to create termVector according to its tfidf score.
 * @return 
 */
public double tfIdfCalculator(String file, String word) {
    double tf; //term frequency
    double idf; //inverse document frequency
    double tfidf = 0; //term requency inverse document frequency        
    for (String[] docTermsArray : termsDocsArray) {
        double[] tfidfvectors = new double[allTerms.size()];
        int count = 0;
        for (String terms : allTerms) {
            tf = new TfIdf().tfCalculator(docTermsArray, terms);
            idf = new TfIdf().idfCalculator(termsDocsArray, terms);
            tfidf = tf * idf;
            System.out.println(terms+"\t" + tfidf);
            tfidfvectors[count] = tfidf;
            count++;


        }
        tfidfDocsVector.add(tfidfvectors);  //storing document vectors;            
    }

    return tfidf;
}


public void TfIdfMatrix() throws IOException {

    int r=allTerms.size();
    int c=tfidfDocsVector.size();

    String mat[][]= new String [r][c];

    int rNumber=0;

    for (int i = 0; i < fileNameList.size(); i++) {

        rNumber++;

        mat[rNumber][0]=(String) fileNameList.get(i);

        }

     String s;
     while ((s = in.readLine()) != null) {

         rNumber++;

         mat[0][rNumber]=s;

     }


        //System.out.print(mat);

     for (int row = 1; row <= rNumber; row++){  
         for (int col = 1; col <= rNumber; col++){
             double ifidfValue=tfIdfCalculator(mat[0][col], mat[row][0]); 
             mat[row][col]=Double.toString(ifidfValue);

              System.out.print(mat[row][col]);
         }
         }      
}

导入java.io.BufferedReader；
导入java.io.File；
导入java.io.FileNotFoundException；
导入java.io.FileReader；
导入java.io.IOException；
导入java.util.ArrayList；
导入java.util.List；
公共类文档解析器{
//此变量将保存数组中每个文档的所有术语。
私有列表termsDocsArray=new ArrayList（）；
private List allTerms=new ArrayList（）；//保存所有术语
私有列表tfidfDocsVector=new ArrayList（）；
private List fileNameList=new ArrayList（）；
私有文件[]所有文件；
私家侦探；
private BufferedReader in=null；
/**
*方法读取文件并存储在数组中。
*@param filePath:源文件路径
*@抛出FileNotFoundException
*@抛出异常
*/
public void parseFiles（字符串filePath）抛出FileNotFoundException、IOException{
allfiles=新文件（filePath）.listFiles（）；
对于（文件f:所有文件）{
if（f.getName（）.endsWith（“.txt”））{
add（f.getName（））；
in=新的BufferedReader（新的文件读取器（f））；
sb=新的StringBuilder（）；
字符串s=null；
而（（s=in.readLine（））！=null）{
某人追加；
}
字符串[]tokenizedTerms=sb.toString（）.replaceAll（“[\\W&&[^\\s]]”，“”）。拆分（\\W+”；//以获取单个术语
for（字符串术语：tokenizedTerms）{
如果（！allTerms.contains（term））{//避免重复条目
所有条款。添加（条款）；
}
}
termsDocsArray.add（标记化术语）；
}
}
}
/**
*方法根据其tfidf分数创建termVector。
*@返回
*/
公共双TFIDF计算器（字符串文件、字符串字）{
双tf；//术语频率
双idf；//反向文档频率
double tfidf=0；//术语频率与文档频率相反
for（字符串[]docTermsArray:termsDocsArray）{
double[]tfidfvectors=新的double[allTerms.size（）]；
整数计数=0；
for（字符串术语：allTerms）{
tf=新的TfIdf（）.tfCalculator（docTermsArray，terms）；
idf=新的TfIdf（）.idfCalculator（termsDocsArray，术语）；
tfidf=tf*idf；
System.out.println（术语+“\t”+tfidf）；
tfidfvectors[count]=tfidf；
计数++；
}
添加（tfidfvectors）；//存储文档向量；
}
返回tfidf；
}
public void TfIdfMatrix（）引发IOException{
int r=allTerms.size（）；
int c=tfidfDocsVector.size（）；
字符串mat[][]=新字符串[r][c]；
int rNumber=0；
对于（int i=0；i对于（int row=1；row这是我正在使用的代码示例

public void tfIdfCalculator() {
            double tf; //term frequency
            double idf; //inverse document frequency
            double tfidf; //term requency inverse document frequency  

            for (String[] docTermsArray : termsDocsArray) {
                double[] tfidfvectors = new double[allTerms.size()];
                int count = 0;
                for (String terms : allTerms) {
                    tf = new TfIdf().tfCalculator(docTermsArray, terms);
                    idf = new TfIdf().idfCalculator(termsDocsArray, terms);
                    tfidf = tf * idf;
                    tfidfvectors[count] = tfidf;
                    count++;
                }
                tfidfDocsVector.add(tfidfvectors);  //storing document vectors;            
            }
        }

可能值得更清楚地说明确切的问题。关于矩阵，您需要帮助的是什么。请在给出代码之前添加您自己的描述。