优酷hadoop，mapred面试题及答案

支持一下，让更多人看到

进击的巨人 发表于 2016-7-26 21:38
reduce的部分  怎样实现寻找重叠的部分（即共同的好友），  在reduce部分commomdfriend是怎样找到value中重 ...

个人觉得：此算法，就是先从每行的朋友中两两组合，找到他们的共同朋友，即第一行的bc、bd、be....的共同好友就是a 输入：A B C D E F           B A C D E           C A B E           D A B E           E A B C D           F A的map  输出:           key:BC,value:A           Key:BD,value:A           key:BE,value:A           ........... Reduce 输入:           key:BC,value[{A}]           key:BD,value[{A,E}] Reduce 输出:           就是讲各个value进行累加

补充内容 (2016-12-23 10:23):
如果好友关系是单向的，这个方法不成立

好资源谢谢分享~感谢楼主，么么哒~

好资源谢谢分享~感谢楼主，么么哒~

不错 学习了

民谊玉超 发表于 2016-9-22 16:59
补充内容 (2016-12-23 10:23):
如果好友关系是单向的，这个方法不成立

单向好友的计算：

[mw_shl_code=java,true]static class UCFMapper extends Mapper<LongWritable, Text, Text, Text> {
                @Override
                protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, Text>.Context context)
                                throws IOException, InterruptedException {

                        StringTokenizer valueLine = new StringTokenizer(value.toString());

                        // 获取每一行的自己
                        String owner = null;
                        if (valueLine.hasMoreTokens()) {
                                owner = valueLine.nextToken();
                        }

                        // 获取每一行人员的朋友 k-v:B-A,即A将B视为朋友，但B不一定这样认为
                        while (valueLine.hasMoreTokens()) {
                                context.write(new Text(valueLine.nextToken()), new Text(owner));
                        }
                }
        }
       
        static class UCFComBine extends Reducer<Text, Text, Text, Text>{
                protected void reduce(Text key, Iterable<Text> values, Reducer<Text, Text, Text, Text>.Context context)
                                throws IOException, InterruptedException {
                        //翻转，计算任意两个人共同认同的朋友
                        Iterator<Text> ite = values.iterator();
                        Set<Object> set = new TreeSet<Object>();
                        while (ite.hasNext()) {
                                //提取出所有需要计算好友的人员
                                Text person = (Text) ite.next();
                                set.add(person.toString());
                        }
                       
                        /*
                         * 计算两个人的共同好友，key即为两个人员的共同好友
                         */
                        Object[] owners = set.toArray();
                        for (int i = 0; i < owners.length - 1; i++) {
                                for (int j = i + 1; j < owners.length; j++) {
                                        String ownerKey = (String)owners+(String)owners[j];
                                        context.write(new Text(ownerKey), key);
                                }
                        }
                }
        }
       
        static class UCFReducer extends Reducer<Text, Text, Text, Text>{
                @Override
                protected void reduce(Text key, Iterable<Text> values, Reducer<Text, Text, Text, Text>.Context context)
                                throws IOException, InterruptedException {
                        StringBuilder cf = new StringBuilder();
                        for (Text friend : values) {
                                cf.append(friend.toString());
                        }
                        context.write(key, new Text(cf.toString()));
                }
        }[/mw_shl_code]

输入：
[mw_shl_code=applescript,true]A B C D E
B C D
C D E[/mw_shl_code]

输出：
[mw_shl_code=applescript,true]AB        CD
AC        D
BC        D
AC        E[/mw_shl_code]

但还没有闹明白为什么AC的两个共同好友不合并

没有考虑如下的情况
A B
B C
结果：
AC B

spark解决方案
[mw_shl_code=java,true]package com;


import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;

import org.apache.spark.api.java.function.PairFunction;
import scala.Tuple2;

import java.util.*;

public class Friend {
    public static void main(String[] args) {
        SparkConf conf = new SparkConf().setAppName("friend").setMaster("local");

        JavaSparkContext javaSparkContext = new JavaSparkContext(conf);

        JavaRDD<String> javaRDD = javaSparkContext.textFile("E:\\spark\\friend.txt");

        JavaPairRDD<List<String>, String> pairRDD = javaRDD.mapToPair(new PairFunction<String, List<String>, String>() {
            @Override
            public Tuple2<List<String>, String> call(String value) throws Exception {
                List<String> keyList = new ArrayList<>();
                StringTokenizer itr = new StringTokenizer(value);
                Set<String> set = new TreeSet<String>();
                String owner = itr.nextToken();
                while (itr.hasMoreTokens()) {
                    set.add(itr.nextToken());
                }
                String[] friends = new String[set.size()];
                friends = set.toArray(friends);
                for (int i = 0; i < friends.length; i++) {
                    for (int j = i + 1; j < friends.length; j++) {
                        String outputkey = friends + friends[j];
                        keyList.add(outputkey);
                    }
                }
                return new Tuple2<>(keyList, owner);
            }
        });

        for (Tuple2<List<String>, String> tuple2 : pairRDD.collect()) {
            System.out.println(tuple2._1() + " " + tuple2._2());
        }
        Map<String, String> map = new HashMap<>();
        for (Tuple2<List<String>, String> tuple2 : pairRDD.collect()) {
            for (String key : tuple2._1) {
                if (map.containsKey(key)) {
                    map.put(key, map.get(key) + ":" + tuple2._2);
                } else {
                    map.put(key, tuple2._2);
                }
            }

        }
        for (Map.Entry entry : map.entrySet()) {
            System.out.println(entry.getKey() + " " + entry.getValue());
        }
        System.out.println("-------------------------------------");


    }
}
[/mw_shl_code]