map/reduce实例（二）

map/reduce经典案例——寻找共同好友

1.输入数据。

A:B,C,D,F,E,O
B:A,C,E,K
C:F,A,D,I
D:A,E,F,L
E:B,C,D,M,L
F:A,B,C,D,E,O,M
G:A,C,D,E,F
H:A,C,D,E,O
I:A,O
J:B,O
K:A,C,D
L:D,E,F
M:E,F,G
O:A,H,I,J

以上数据冒号前面的是用户，后面的是这个用户关注的好友，这个好友关注是单向的。

2.思路分析
这个案例主要是过程略微复杂，但是做法比较简单。
分两步做，第一步求出每个用户都被哪些用户关注着，第二步求出两两用户的共同好友。

3.代码展示

第一步的map

public static class friendsonemapper extends Mapper<LongWritable, Text, Text, Text>{
		Text k = new Text();
		Text frd = new Text();
		
	@Override
	protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, Text>.Context context)
			throws IOException, InterruptedException {
		String[] line = value.toString().split(":");
		String[] friends = line[1].split(",");
		k.set(line[0]);
		for (String friend : friends) {
			frd.set(friend);
			context.write(frd, k);
		}
	}
}

取出一行数据按照冒号切分出两个字符串，第一个是用户，第二个是用户的好友，然后把好友按照逗号进行切分，按照
<好友，用户>的格式输出给reduce Task。

第一步的reduce

public static class friendsonereducer extends Reducer<Text, Text, Text, Text>{
		@Override
		protected void reduce(Text key, Iterable<Text> value, Reducer<Text, Text, Text, Text>.Context context)
				throws IOException, InterruptedException {
			StringBuffer sb = new StringBuffer();
			for (Text text : value) {
				sb.append(text.toString()).append(",");
			}
			context.write(key, new Text(sb.toString()));
		}
	}

把好友作为key，相同好友的不同用户拼接起的字符串作为value，输出为第一步map/reduce的结果。

第一步输出的结果，就是第二步map的输入数据。

A	I,K,C,B,G,F,H,O,D,
B	A,F,J,E,
C	A,E,B,H,F,G,K,
D	G,C,K,A,L,F,E,H,
E	G,M,L,H,A,F,B,D,
F	L,M,D,C,G,A,
G	M,
H	O,
I	O,C,
J	O,
K	B,
L	D,E,
M	E,F,
O	A,H,I,J,F,

第二步的map

public static class friendstwomapper extends Mapper<LongWritable, Text, Text, Text>{
		@Override
		protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, Text>.Context context)
				throws IOException, InterruptedException {
			String line = value.toString();
			String[] fields = line.split("\t");
			String[] friends = fields[1].split(",");
			
		Arrays.sort(friends);
		for (int i = 0 ; i < friends.length - 1 ; i++) {
			for(int j = i + 1 ; j < friends.length ; j++) {
				context.write(new Text(friends[i] + "--" + friends[j]), new Text(fields[0]));
			}
		}
	}
}

通过第一步的输出，第二部的输入每一行第一个字符是好友，后面的一串使用户，这代表着后面的用户的好友列表中都有第一个的好友。所以后面的用户两两之间有共同好友就是第一个字符。通过双重循环，将后面的用户两两之间连接起来，把
<“用户”-“用户”，好友>作为map阶段的输出。

第二部的reduce

public static class friendstworeducer extends Reducer<Text, Text, Text, Text>{
		@Override
		protected void reduce(Text key, Iterable<Text> value, Reducer<Text, Text, Text, Text>.Context context)
				throws IOException, InterruptedException {
			StringBuilder s = new StringBuilder();
			for (Text v : value) {
				s.append(v.toString()).append(",");
			}
			context.write(key, new Text(s.toString()));
			
		}
	}

把相同key的所有value拼接起来就得到了两两用户之间的所有共同好友。

第二步的输出结果。

A--B	E,C,
A--C	D,F,
A--D	E,F,
A--E	D,B,C,
A--F	O,B,C,D,E,
A--G	F,E,C,D,
A--H	E,C,D,O,
A--I	O,
A--J	O,B,
A--K	D,C,
A--L	F,E,D,
A--M	E,F,
B--C	A,
B--D	A,E,
B--E	C,
B--F	E,A,C,
B--G	C,E,A,
B--H	A,E,C,
B--I	A,
B--K	C,A,
B--L	E,
B--M	E,
B--O	A,
C--D	A,F,
C--E	D,
C--F	D,A,
C--G	D,F,A,
C--H	D,A,
C--I	A,
C--K	A,D,
C--L	D,F,
C--M	F,
C--O	I,A,
D--E	L,
D--F	A,E,
D--G	E,A,F,
D--H	A,E,
D--I	A,
D--K	A,
D--L	E,F,
D--M	F,E,
D--O	A,
E--F	D,M,C,B,
E--G	C,D,
E--H	C,D,
E--J	B,
E--K	C,D,
E--L	D,
F--G	D,C,A,E,
F--H	A,D,O,E,C,
F--I	O,A,
F--J	B,O,
F--K	D,C,A,
F--L	E,D,
F--M	E,
F--O	A,
G--H	D,C,E,A,
G--I	A,
G--K	D,A,C,
G--L	D,F,E,
G--M	E,F,
G--O	A,
H--I	O,A,
H--J	O,
H--K	A,C,D,
H--L	D,E,
H--M	E,
H--O	A,
I--J	O,
I--K	A,
I--O	A,
K--L	D,
K--O	A,
L--M	E,F,

这个案例理清思路还是很简单的