mapreduce寻找相同的关注着 mapreduce共同好友数统计

背景
如今大多数的社交网站都有提供的共同好友的服务，可以帮助与好友之间共享图片，消息，视频

博客的好友列表数据，冒号前是一个用户，冒号后是该用户的所有好友（数据中的好友关系是单向的）

求出哪些人两两之间有共同好友，及他俩的共同好友都有谁？

使用MapReduce对这个问题进行处理的时候可以通过两个MapReduce任务完成这个需求：1、对原始数据进行反转解析，找出都有谁的好友里面有该用户；例如对于原始 A:B,C,D,F,E,O 数据，通过在map task中解析成 < B, A>< C, A>< D,A>< F,A>…的形式，这一系列的键值对表示所有代号为key值的用户，他的好友里面都有value值代表的用户。然后对这些键值对在reduce task中对key值相同的键值对（< A, B>< A, D>< A, F>…）进行拼接，拼接成< A B,D,F, …>的形式作为第一次MapReduce任务的输出。

上图为第一次MapReduce的输出，以其中的第一行数据（A F,D,O,I,H,B,K,G,C,）为例，这一行数据的含义是：F,D,O,I,H,B,K,G,C 这些用户的好友里面都有A。即分隔符后面的所有用户的好友里面都有分隔符前面的用户。2、根据第一次MapReduce的输出结果，我们可以很容易的想到，只要把分隔符后面的用户两两任意组合，就可以得到这两个用户的一个共同好友。以第一行数据为例，拆分之后可以得到：< F-D , A>, < F-O , A>, < F-I , A> … < D-O , A>,< D-I , A> …然后我们再在reduce task中按照相同的key值对键值对进行拼接，就得到了整个数据集中任意两个用户之间的共同好友的列表。

输出格式：

A-B:C，E
 (用户-用户：共同好友…)需求分析
 分为两个job
 第一次输出结果，先求出A、B、C、….等是谁的好友
 Job1：
 Mapper:
 keyin-valuein: （A:B,C,D,F,E,O）
 map(): 将valuein拆分为若干好友，作为keyout写出
 将keyin作为valueout
 keyout-valueout: （友:用户）
 （c:A）,(C:B),(C:E)Reducer:
 keyin-valuein : （友:用户）
 （c:A）,(C:B),(C:E)
 reduce():
 keyout-valueout ：（友：用户，用户，用户，用户）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,第二次输出结果，输出每两个人的共同好友
Job2：
 Mapper:
 keyin-valuein: （友：用户，用户，用户，用户）
 map()： 使用keyin作为valueout
 将valuein切分后，两两拼接，作为keyout
 keyout-valueout: （用户-用户，友）
 (A-B,C),(A-B,E)
 (A-E,C), (A-G,C), (A-F,C), (A-K,C)
 (B-E,C ),(B-G,C)--------------------
	(B-E,C)
	(E-B,G)
	
	B-E: C,G1
 2
 3
 4
 5
 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 FReducer:
 keyin-valuein: (A-B,C),(A-B,E)
 reduce():
 keyout-valueout ： (A-B:C,E)

由于上面的分析分析的是：英文字母; 比较麻烦：

二 . 通过倚天屠龙记人物关系来实现

1.原始数据：

2.代码实现：

package friends;
import org.apache.commons.io.FileUtils;
 import org.apache.hadoop.conf.Configuration;
 import org.apache.hadoop.fs.Path;
 import org.apache.hadoop.io.LongWritable;
 import org.apache.hadoop.io.Text;
 import org.apache.hadoop.mapreduce.Job;
 import org.apache.hadoop.mapreduce.Mapper;
 import org.apache.hadoop.mapreduce.Reducer;
 import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
 import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;import java.io.File;
 import java.io.IOException;public class FriendsPublic {
 //map
 public static class MapTask extends Mapper<LongWritable, Text,Text, Text> {

protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        //张三:李四,王五,赵丽,张无忌,灭绝师太,杨逍  ====>   李四-张三  王五-张三   赵丽-张三  .....
        String[] splits = value.toString().split(":");
        String values = splits[0];
        //再去切分另外一个数据   取到key值
        String[] friends = splits[1].split(",");
        //循环遍历  取到每一好友
        for (String friend : friends) {
            context.write(new Text(friend),new Text(values));
        }
    }
}


//reduce
public static class ReduceTask extends Reducer<Text,Text,Text,Text> {
    @Override                 //B               (张三,李四,王五,赵丽.....)
    protected void reduce(Text key, Iterable<Text> values, Context context) throws IOException, InterruptedException {
        //李四-张三  李四-王五  李四-赵丽 =====> 李四  张三,王五,赵丽,.....
        //boolean
        boolean flag=true;
        //需要一个字符串容器
        StringBuffer sb = new StringBuffer();
        for (Text value : values) {
            if(flag){
                sb.append(value);
                flag=false;
            }else{
                sb.append(",").append(value);
            }
        }
        //跳出for循环
        context.write(key,new Text(sb.toString()));
    }
}

//main
public static void main(String[] args) throws Exception {
    //我们需要一盒hadoop的对象去提交这俩个内部类  Job    本地运行
    Configuration conf = new Configuration();
    Job job = Job.getInstance(conf);

    //提交那俩个内部类
    job.setMapperClass(FriendsPublic.MapTask.class);
    job.setReducerClass(FriendsPublic.ReduceTask.class);
    job.setJarByClass(FriendsPublic.class);

    //设置四个输出参数的类型
    job.setMapOutputKeyClass(Text.class);
    job.setMapOutputValueClass(Text.class);
    job.setOutputKeyClass(Text.class);
    job.setOutputValueClass(Text.class);

    //如果输出文件  存在 就删除
    String output="E:\\BigData\\output\\friends1";
    File file = new File(output);
    if(file.exists()){
        FileUtils.deleteDirectory(file);
    }

    //设置输入  输出路径
    FileInputFormat.addInputPath(job,new Path("e:/friend.txt"));
    FileOutputFormat.setOutputPath(job,new Path(output));

    //温馨提示
    boolean b = job.waitForCompletion(true);
    System.out.println(b?"成功进行计算！！！":"哥们,出BUG了,赶快去调一下！！！");
}

}

3.结果：

注意：有的产生的结果中文乱码：

1.在处理输入文件的时候；修改他的编码格式： utf-8