import org.apache.mahout.math.map.OpenObjectIntHashMap; //导入依赖的package包/类
@Override
protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {

	String[] items = value.toString().split(itemSeparator);

	OpenObjectIntHashMap<String> itemCounts = new OpenObjectIntHashMap<String>();

	// ignore pos 0 which contains a sequence identifier
	for (int i = 1; i < items.length; i++) {
		// update counts of items
		String item = items[i];
		itemCounts.adjustOrPutValue(item, +1, +1);
	}

	// emit item and frequency
	for (String term : itemCounts.keys()) {
		outKey.set(term);
		outValue.set(itemCounts.get(term));
		context.write(outKey, outValue);
	}
}
 

import org.apache.mahout.math.map.OpenObjectIntHashMap; //导入依赖的package包/类
@Override
protected void cleanup(Context context) throws IOException, InterruptedException {

	// sort terms in descending order of their collection frequency
	List<String> temp = cfs.keys();
	String[] terms = temp.toArray(new String[temp.size()]);

	Arrays.sort(terms, new Comparator<String>() {

		@Override
		public int compare(String t, String u) {
			return cfs.get(u) - cfs.get(t);
		}
	});

	// assign term identifiers
	OpenObjectIntHashMap<String> tids = new OpenObjectIntHashMap<String>();
	for (int i = 0; i < terms.length; i++) {
		tids.put(terms[i], (i + 1));
	}

	// sort terms in lexicographic order and produce output
	Arrays.sort(terms);
	for (String term : terms) {
		outKey.set(term);
		outValue.set(cfs.get(term) + "\t" + dfs.get(term) + "\t" + tids.get(term));
		context.write(outKey, outValue);
	}
}
 

import org.apache.mahout.math.map.OpenObjectIntHashMap; //导入依赖的package包/类
@Override
protected void cleanup(Context context) throws IOException, InterruptedException {

    // sort terms in descending order of their collection frequency
	List<String> temp = cfs.keys();
    String[] terms = (String[]) temp.toArray();
    Arrays.sort(terms, new Comparator<String>() {

        @Override
        public int compare(String t, String u) {
            return cfs.get(u) - cfs.get(t);
        }
    });

    // assign term identifiers
    OpenObjectIntHashMap<String> tids = new OpenObjectIntHashMap<String>();
    for (int i = 0; i < terms.length; i++) {
        tids.put(terms[i], (i + 1));
    }

    // sort terms in lexicographic order and produce output
    Arrays.sort(terms);
    for (String term : terms) {
        outKey.set(term);
        outValue.set(cfs.get(term) + "\t" + dfs.get(term) + "\t" + tids.get(term));
        context.write(outKey, outValue);
    }
}
 

import org.apache.mahout.math.map.OpenObjectIntHashMap; //导入依赖的package包/类
/**
 * The following function aids in calculating the document frequency (df) &
 * the collection frequency (cf) of the items in the input sequences contained
 * with the argument to this function viz. <i> File child </i>.
 * 
 * @return void
 * @param File child 
 * @throws IOException 
 */
public void computeFrequency(File child) throws IOException
{
    FileInputStream fstream = new FileInputStream(child);
    DataInputStream in = new DataInputStream(fstream);
    BufferedReader br = new BufferedReader(new InputStreamReader(in));
    
    String strLine;

    
    while ((strLine = br.readLine()) != null) {
  	  
  	  String[] items = strLine.split("\\s+");
  	  
  	  OpenObjectIntHashMap<String> itemCounts = new OpenObjectIntHashMap<String>();
  	  // ignore pos 0 which contains a sequence identifier
        for (int i = 1; i < items.length; i++) {
          // update counts of items
          String item = items[i];
          itemCounts.adjustOrPutValue(item, +1, +1);
        }
        
        for (String term : itemCounts.keys()) {
      	  addItemToDictionary(term, itemCounts.get(term));
        }
    }
    br.close();
}