web工程打包成war文件后，在本地测试没问题。部署到服务器上后无法访问，查看tomcat的日志，显示java.lang.IllegalArgumentException: Invalid or unreadable WAR file : error in opening zip file。用ls -al命令查看war文件，果然跟本地的文件大小不一样。使用rz命令上传多次，可是每次上传后的文件大小依旧和本地文件不一致，最后将问题定位到rz命令上。
google上查找半天，发现原因是上传时不应该勾选“以ASCII方式上传文件”。取消勾选后再次上传，最后成功。
1. 新建普通工程：
mvn archetype:create -DgroupId=com.lixiaodong -DartifactId=some_app
2. 新建web工程：
mvn archetype:create -DgroupId=com.lixiaodong -DartifactId=some_app -DarchetypeArtifactId=maven-archetype-webapp
3. 将maven工程转换成eclipse支持的工程：
(1) 使用命令行进入到刚刚创建的工程目录：cd some_app
(2) mvn eclipse:eclipse
给定一个社交关系（A,B），A和B分别代表2个人的id或名字（如果是名字，要求名字不能有重复）。要求只使用一次MapReduce，过滤掉里面的双向关系，只保留单向关系。比如现在这个关系里包含如下内容：
（张三，李四）
（张三，王五）
（张三，赵六）
（李四，张三）
里面的第1条和第4条构成了双向关系，要过滤掉，剩下第2和第3条。
思路1：对每一条关系(A, B)，在map阶段生成(A, B) 和(B, A) 。如果A和B是双向的，会生成4条记录，分别是（A, B), (B, A), (B, A), (A,B)。
在reduce阶段，我们发现key A对应的values里，B有2条。我们知道这是由双向关系产生的，我们不应该有任何输出。我们只输出在values里只有1个的。假如C在values里只有1个。则reduce阶段，我们输出(A,C)。
带来的问题：以上的办法能过滤掉双向关系，但是会输出多余的内容。比如一个单项关系 (A, B)。按照以上方法， reduce阶段最后会输出(A,B)和(B,A)。实际上不应该输出(B, A)。这个(B,A)是我们人为加进去的。
思路2：在思路1的基础上，map 阶段加入标记。对每一条关系(A, B)，在map阶段生成(A, B|1) 和(B, A|0)。1代表真实存在的关系，0代表为了解决问题加入的虚构关系。在reduce阶段，我们按照思路1过滤掉有2个值的，然后看标记是不是1，如果是1则输出；如果是0，不输出。
Hadoop MapReduce代码如下：
import java.io.IOException;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapred.MapReduceBase;
import org.apache.hadoop.mapred.Mapper;
import org.apache.hadoop.mapred.OutputCollector;
import org.apache.hadoop.mapred.Reporter;
public class SingleRelationshipMapper extends MapReduceBase implements
Mapper<LongWritable, Text, Text, Text>{
@Override
public void map(LongWritable key, Text value, OutputCollector<Text, Text> output, Reporter arg3)
throws IOException {
String line = value.toString();
String[] names = line.split(" ");
Text text1 = new Text(names[0]);
Text text2 = new Text(names[1]);
output.collect(new Text(text1), new Text(text2+"|1")); //1代表真实关系
output.collect(new Text(text2), new Text(text1+"|0")); //0代表虚构关系
}
}
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapred.MapReduceBase;
import org.apache.hadoop.mapred.OutputCollector;
import org.apache.hadoop.mapred.Reducer;
import org.apache.hadoop.mapred.Reporter;
public class SingleRelationshipReducer extends MapReduceBase implements
Reducer<Text, Text, Text, Text>{
@Override
public void reduce(Text key, Iterator<Text> values, OutputCollector<Text, Text> output, Reporter arg3) throws IOException {
List<String> list = new ArrayList<String>();
while (values.hasNext()) {
list.add(values.next().toString());
}
for(String item:list){
String[] array = item.split("\\|");
if(onlyOne(array[0], list)){
if(array[1].equals("1")){
output.collect(key, new Text(array[0]));
}
}
}
}
private boolean onlyOne(String str, List<String> list){
int count=0;
for(String item: list){
String array[] = item.split("\\|");
if(array[0].equals(str)){
count++;
}
}
return count==1;
}
}
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapred.FileInputFormat;
import org.apache.hadoop.mapred.FileOutputFormat;
import org.apache.hadoop.mapred.JobClient;
import org.apache.hadoop.mapred.JobConf;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;
public class SingleRelationshipDriver extends Configured implements Tool{
/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
int exitCode = ToolRunner.run(new SingleRelationshipDriver(), args);
System.exit(exitCode);
}
@Override
public int run(String[] arg) throws Exception {
JobConf conf = new JobConf();
conf.setJobName("singleRelation");
conf.setJarByClass(SingleRelationshipDriver.class);
conf.setMapperClass(SingleRelationshipMapper.class);
conf.setReducerClass(SingleRelationshipReducer.class);
conf.setOutputKeyClass(Text.class);
conf.setOutputValueClass(Text.class);
FileInputFormat.addInputPaths(conf, arg[0]);
FileOutputFormat.setOutputPath(conf, new Path(arg[1]));
JobClient.runJob(conf);
return 0;
}
}
输入：
John Tom
John Amily
John George
Amily John
输出：
John Tom
John George
Frequent Itemsets mining 最常见的形式就是给定market-basket形式的数据（每一行相当于一个购物篮，包含多个商品item），然后我们找出关联度大于某个值的所有item集合。A-Priori算法是Frequent Itemsets mining里最基本的算法。
一、A-Priori的基本思路
第一遍（pass 1），扫描文件，统计单项(single item)的出现次数（使用1个map进行统计，key就是item，value就是出现次数）。最后，过滤掉小于最小支持度的，得到频繁单项集。
第二遍（pass 2），扫描文件，对于每一行，对任意两个item组合得到pair item。如果pair item的2个单项都在频繁单项集里，则统计这个pair item的出现次数；否则略过。最后得到所有pair item的出现频率，过滤掉小于最小支持度的，得到频繁2项集。
第N遍，如果发现频繁N-1项集不为空，则说明mining还没有完成，需要进行第n次扫描。从每行中取得任意N个item，如果这N项的所有N-1项子集都在频繁N-1项集里，则统计其出现次数，否则略过。最后，过滤掉小于最小支持度的，得到频繁N项集。
直到频繁项集为空才停止循环。
二、java实现
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
public class Apriori {
private String inputFile;
private double minSupport;
private BufferedWriter bw;
private HashSet<Set<Integer>> frequentItems = new HashSet<Set<Integer>>(); //频繁项集
private Set<Integer> frequentSingleItems = new HashSet<Integer>(); //频繁单项集
private int totalCount; //项目数量
public Apriori(String inputFile, double minSupport) {
this.inputFile = inputFile;
this.minSupport = minSupport;
}
/**
* 找出频繁一项集
* @return
* @throws IOException
*/
public Map<Set<Integer>,Integer> findF1Item() throws IOException {
Map<Set<Integer>,Integer> result = new LinkedHashMap<Set<Integer>, Integer>();
Map<Integer, Integer> map = new HashMap<Integer, Integer>();
BufferedReader reader = new BufferedReader(new FileReader(inputFile));
String line;
int numberOfLine = 0;
while ((line = reader.readLine()) != null) {
numberOfLine++;
String[] items = line.split(" ");
for(String item : items){
int intItem = Integer.valueOf(item);
if (map.containsKey(intItem)) {
map.put(intItem, map.get(intItem) + 1);
} else {
map.put(intItem, 1);
}
}
}
totalCount = numberOfLine;
reader.close();
//使用TreeSet按照item编号从小到大排序
TreeSet<Integer> treeSet = new TreeSet<Integer>(map.keySet());
for (Integer item : treeSet) {
int count = map.get(item);
//过滤掉出现频率小于最小支持度的item
if (count >= minSupport*totalCount) {
Set<Integer> f1Set = new TreeSet<Integer>();
f1Set.add(item);
result.put(f1Set, count);
frequentItems.add(f1Set);
frequentSingleItems.add(item);
}
}
return result;
}
public Map<Set<Integer>,Integer> generateNextPass(int k) throws Exception{
Map<Set<Integer>, Integer> map = new HashMap<Set<Integer>, Integer>();
BufferedReader reader = new BufferedReader(new FileReader(inputFile));
String line;
while ((line = reader.readLine()) != null) {
String[] items = line.split(" ");
List<Set<Integer>> list = generateSubset(items, k);
for(Set<Integer> set :list){
if(map.containsKey(set)){
map.put(set, map.get(set)+1);
}
else{
map.put(set, 1);
}
}
}
reader.close();
frequentItems = new HashSet<Set<Integer>>();
frequentSingleItems = new HashSet<Integer>();
Iterator<Set<Integer>> ite = map.keySet().iterator();
while(ite.hasNext()){
Set<Integer> key = ite.next();
int value = map.get(key);
if(value<totalCount*minSupport){
ite.remove();
}
else{
frequentItems.add(key);
for(int item: key){
frequentSingleItems.add(item);
}
}
}
return map;
}
private List<Set<Integer>> generateSubset(String[] array, int k) throws Exception{
List<Set<Integer>> result = new ArrayList<Set<Integer>>();
int[] intArray = new int[array.length];
for(int i=0; i<array.length;i++){
intArray[i] = Integer.parseInt(array[i]);
}
int[] newArray = filterItems(intArray);
List<Set<Integer>> list = generateSubSets(newArray,k);
for(Set<Integer> set: list){
//将set变成数组
int smallArray[] = new int[set.size()];
int i=0;
Iterator<Integer> ite = set.iterator();
while(ite.hasNext()){
smallArray[i]= ite.next();
i++;
}
//找出set的所有k-1次subItemSet
List<Set<Integer>> smallList = generateSubSets(smallArray, k-1);
//如果有1个subItemSet不是频繁的，则判断set不是频繁的
boolean flag = true;
for(Set<Integer> item: smallList){
if(!frequentItems.contains(item)){
flag = false;
break;
}
}
if(flag){
result.add(set);
}
}
return result;
}
public void printFrequentItems(Map<Set<Integer>,Integer> itemSets, int i) throws FileNotFoundException, IOException {
if(bw == null){
bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("output.txt")));
}
StringBuffer sb = new StringBuffer();
for (Set<Integer> set : itemSets.keySet()) {
sb.append("[");
for (Integer str : set) {
sb.append(str + " ");
}
sb.append("], count:");
sb.append(itemSets.get(set));
sb.append("\n");
}
bw.write(sb.toString());
bw.flush();
}
/**
* 过滤掉不在前一次频繁单项集里的item
* @param array
* @return
*/
private int[] filterItems(int[] array){
List<Integer> list = new ArrayList<Integer>();
for(int i=0;i<array.length;i++){
if(frequentSingleItems.contains(array[i])){
list.add(array[i]);
}
}
int[] newArray = new int[list.size()];
for(int i=0;i<newArray.length;i++){
newArray[i] = list.get(i);
}
return newArray;
}
public void closeOutputWriter() throws IOException{
if(bw == null){
bw.close();
}
}
private List<Set<Integer>> generateSubSets(int[] array, int k){
List<Set<Integer>> list = new ArrayList<Set<Integer>>();
if(array.length<k){
return list;
}
// 初始化移位法需要的数组
byte[] bits = new byte[array.length];
for (int i = 0; i < bits.length; i++) {
bits[i] = i < k ? (byte) 1 : (byte) 0;
}
boolean find = false;
do {
// 找到10，换成01
Set<Integer> set = getCombination(array, bits);
if(set!=null && set.size()!=0){
list.add(set);
}
find = false;
for (int i = 0; i < array.length - 1; i++) {
if (bits[i] == 1 && bits[i+1] == 0) {
find = true;
bits[i] = 0;
bits[i+1] = 1;
if(bits[0] == 0){
for (int p=0, q=0; p < i; p++){
if(bits[p] == 1){
byte temp = bits[p];
bits[p] = bits[q];
bits[q] = temp;
q++;
}
}
}
break;
}
}
} while (find);
return list;
}
private Set<Integer> getCombination(int[] array, byte[] bits) {
Set<Integer> set = new TreeSet<Integer>();
for (int i = 0; i < bits.length; i++) {
if (bits[i] == (byte) 1) {
set.add(array[i]);
}
}
return set;
}
}
import java.util.Map;
import java.util.Set;
public class Main {
public static void main(String[] args) {
System.out.println("program starts…");
long startTime = System.currentTimeMillis();
String inputFile = "src/test.txt";
double minSupport = 0.02;
Apriori apriori = new Apriori(inputFile, minSupport);
try {
System.out.println("pass 1");
Map<Set<Integer>, Integer> f1Set = apriori.findF1Item();
apriori.printFrequentItems(f1Set, 1);
Map<Set<Integer>, Integer> result = f1Set;
int i = 2;
do {
System.out.println("pass " + i);
result = apriori.generateNextPass(i);
apriori.printFrequentItems(result, i);
i++;
} while (result.size() != 0);
apriori.closeOutputWriter();
} catch (Exception e) {
e.printStackTrace();
}
long endTime = System.currentTimeMillis();
System.out.println("execution time:" + (endTime - startTime) + "ms");
}
}
输入文件：test.txt
1 2 5
2 4
2 3
1 2 4
1 3
2 3
1 3
1 2 3 5
1 2 3
输出文件：output.txt
[1 ], count:6
[2 ], count:7
[3 ], count:6
[4 ], count:2
[5 ], count:2
[1 2 ], count:4
[1 3 ], count:4
[1 4 ], count:1
[2 3 ], count:4
[2 4 ], count:2
[1 5 ], count:2
[2 5 ], count:2
[3 5 ], count:1
[1 2 3 ], count:2
[1 2 4 ], count:1
[1 2 5 ], count:2
[1 3 5 ], count:1
[2 3 5 ], count:1
[1 2 3 5 ], count:1
