pianaipj-真题宝典-1

1.1 学长1
1）技术框架部分：
（1）会根据面试者简历上的技能点进行考察。注意技能点描述用词，不要随便用熟悉，觉得特别熟的可以说熟练使用
（2）常用的大数据框架是肯定会问的，比如Hive、Spark、Kafka等。常见的如Kafka精准消费问题的多种解决办法对比，Spark的Task调度规则
（3）有些面试官会直接让讲了解的框架最底层实现
（4）Java，MySQL，Redis必问，JVM，Hashmap，JUC相关，MySQL的索引及优化，Redis数据结构、集群、缓存淘汰
（5）常见的协议会考，租约协议，quarum原理，Zookeeper选举，acid，acp，base等
2）项目部分：
（1）一般会让你挑你最熟的一个项目讲。考察从项目背景到实现的把控
（2）重点是参与的部分，遇到的难点
（3）常见业务难题的解决和优化，层层递进，头条追求做到极致
（4）没有做过的项目、模块不要乱讲，容易被问懵逼或者被太简单被鄙视
3）算法部分：
（1）数据结构必考，手写代码，每一面都会考。常见数组、链表、二叉树、跳表的题。有些部门会先笔试（电脑实际编码运行）再面试
（2）算法部分常见动态规划、概率题、二进制一类
（3）SQL题目，行列转换。分区函数，统计连续登陆天数这一类问题
（4）多刷Leetcode，题都是有套路的
4）HR部分：
（1）想好跳槽理由，一般注重抗压能力和稳定性
1.2 学长2
1）技术部分
（1）WordCount的实现过程
（2）MR与Spark的区别
（3）Spark在Client与在集群运行的区别
（3）相同的SQL在HiveSql与SparkSQL的实现中，为什么Spark比Hadoop快
（4）自定义UDF
（5）设计HBase表需要注意的点
（6）HBase的hlog
（7）数据同样存在HDFS，为什么HBase支持在线查询
（8）数据从Hive中用SparkSql进行操作有遇到什么问题？类似兼容性的问题。
（9）SparkStream与Strom，Flink与什么区别
（10）有三个map，一个reduce来做top10，哪种方法最优。数据量特别大。
 2）项目的架构
（1）数据仓库的模型设计
（2）数据仓库的数据清洗
（3）业务建模、数据分析方法。
（4）数据仓库是怎么设计的
（5）数仓规范设计哪些方面(字段、维度，存储压缩、数据保留机制)
（6）数仓质量怎么监控(数据质量管理系统，主键唯一、非空、数据波动)
（7）数仓主题分哪些(按照公司业务归类：申请单、客户信息、合同信息、放款、还款、余额、逾期等)
（8）数仓拉链表的原理
（9）有没有遇到数据倾斜的问题（场景、解决方式）
（10）数仓重点调度任务的保障方式（调度系统优先级）
（11）数仓任务报错和监控（调度系统捕捉错误，电话短信告之值班人员）
1.3 学长3
1）技术部分
（1）自我介绍
（2）写map-reduce，两份数据，一份是设备id+用户id，一份是设备id+点击的广告+点击时间，找出每个用户id每天10条最新的广告点击记录
（3）说下多线程和多进程
（4）fork命令
2）算法部分
（1）hashmap和map，hash实现原理（hashmap基于哈希，查找O（1）；map基于树，查找O（logn）；hash实现采用数组，偏移地址使得查找满足O（1），无论是再哈希还是链表法解决冲突，都需要存储key和value）
1.4 学长4
（1）MySQL引擎是什么，常用的是哪个innodb，知道原理吗
（2）MySQL优化，怎么建索引？选择合适的字段属性。对于某些文本字段可以设成ENUM类型（MySQL中被当做数值型数据来处理）。使用连接join代替子查询 。使用索引：innodb支持哈希索引、b+树索引、全文索引。
BTree和B+Tree 
（3）手写sql…
user_id login_date
1 20200325
查询出用户连续三天登录的用户

表A 字段a 值1234
表B 字段b 值11235
Join 输出的结果
Left join 输出的结果

（4）Sqoop导入数据是增量怎么实现
（5）Flume事务实现
（6）Kafka消费者角度考虑是拉取数据还是推送数据
（7）Kafka中的数据是有序的吗
（8）Kafka数据推送失败怎么处理
（9）Kafka保证生产者精准一次
（10）没有接受到ack才会出现声明情况
（11）Kafka数据重复怎么处理
（12）Spark Streaming怎么里面实现精准一次消费
（13）如果offset没有发送成功数据会怎样
（14）Hive的优化，项目中怎么优化的(我说了join的一些优化)
（15）然后就问了用MR怎么实现join,手写代码
（16）数据倾斜怎么处理的，
（17）碰到过oom情况吗，什么原因导致的，怎么处理的
（18）Hbase有那些组件，
（19）什么场景会用到Hbase
（20）Hbase的读写流程，大概说一下
（21）Spark,任务提交的流程，
（22）Spark的两种核心Shuffle，未优化的和优化的
（23）常用的数据结构都有哪些，
怎么实现一个list,
怎么实现一个map
map一般什么场景使用
用过树这种结构吗，什么场景用到的
（24）算法
字符串中第一个出现三次且仅出现三次
反转一个链表
两个链表第一次交叉的节点，
（25）用Cannal监控mysql之后，Scala怎么通过SparkStreaming去消费的
（26）你们这个项目spark计算完之后存HBase怎么设计的
（27）HBase你们在项目中怎么设计rowkey的
1.5 学长5
一面
（1）算法：给2个有序数组，合并成一个有序数组
延伸：给n个有序数组，合并成一个有序数组
（2）sql:
班级 学号 科目 分数
求某个班级总分最高的前五名
其他：
（3）精准一次性消费
（4）数据倾斜
二面
（1）主要问项目中是否丢数据，怎么做的数据治理，监控，问了一个算法，一个SQL
（2）算法是有序数组查找目标值，我的做法是二分查找
（3）sql是给用户的观看视频的时长，统计观看时间在0-1分钟的用户数，1-10分钟的用户数
三面：
（1）选型为什么是spark而不是Flink，有哪些优缺点（我项目上写的spark）
（2）HBASE为什么快（列式存储，内存，lsm树）
（3）消费不到kafka数据怎么办
（4）kafka怎么监控，重分区
（5）g1回收器和cms区别
（6）jvm调整过没有

1.6 学长6
一面
项目类型的没啥说的，都是类似的一套东西，问的东西
手写的东西挺多的

rdd手写key的top10, 比如 user_id, score， 求成绩的top10
spark-sql手写个dateframe的demo

sql题目
department_id, user_id, amount
求出来每个部门，每个人的薪资占部门薪资的比例， 一个简单的开窗函数实现的

手写个udf函数？
表的字段 report_date, map_info(map类型的数据类型， key是时间，value是金额)，计算大于当前report_date的所有金额

我直接使用explode函数处理了

然后，继续延伸，增加个 report_date, map_info，count 增加计算个count数量 又怎么处理？ 其实就是max(count)就行了
然后，说那你能写个UDF函数实现吗？ 我最后就写了个轮廓；

又让写了个算法题： 最长回文子串. 给定一个字符串s，找到s中最长的回文子串

def get_longest_str(s):
n = len(s)
dp = [[False] * n for _ in range(n)]
res_str = “”
for ele in range(n): # ele代表i和j的间隔
for i in range(n): #通过 j=i+ele 得到子串的结束位置， 对角线斜着一行一行的处理
j = i + ele
if j >= n:
break
if ele == 0:
dp[i][j] = True # 单个元素为true
elif ele == 1:
dp[i][j] = (s[i] == s[j]) # 两个元素 判断两个值是否相等
else:
dp[i][j] = (dp[i + 1][j - 1] and s[i] == s[j]) # 如果当前元素相等, 则比较之前的元素
if dp[i][j] and ele + 1 > len(res_str): # 上次ans就是上次的j-i的长度
res_str = s[i:j + 1]
return res_str
1.7 头条猎头
1.数据仓库的基础理论:建模,分层
2.flink容错机制
3.spark调优，数据倾斜的处理方式
4.sql编程考察
5.算法:聚类kmeans
6.二叉树算法
7.Java 线程问题，包括线程安全，锁，和线程池，问得很细。
8.Hbasse和mysql区别和存储原理
9.kafka的底层原理，kafka如何保证全局消费数据有序
10.redis底层原理，如何预估数据量
11.yarn底层原理，执行流程和，yarn底层使用的算法
12.算法基础建模有哪些，如何进行数据挖掘
13.链表反转排序 leetcode原题
14.sql 连续日期活跃用户
15.hive udf udaf udtf spark
16.任务提交过程
17.回文函数
18.hive 数据倾斜
19.redis 跳表
20.spring ioc
21.spring 需要单例设置的参数
22.线程池几个配置参数含义
23.mysql 事务 a b 客户端提交事务处理
24.storm 实时
25.java 并发包
26.hive 如何转mr
27.线程 可重入理解
28.算法题 一个LRU 一个深度优先搜索
29.flink 的watermark shardGroup的概念
30.kafka如何保证消息的有序行高可用
31.数据倾斜如何处理
32.flink watermark 和barries 和checkpoint
33.flink和spark的区别
34.jvm常见的垃圾回收算法
35.heap怎么分带的
36.kafka调优
二 腾讯面试题
2.1 学长1
1）笔试部分
（1）有一表名t_sh_mtt_netdisk_log，从表名可以看出该表是什么业务的，是什么周期粒度的表。
（2）怎么查看表结构，表创建语句？怎么查看表有哪些分区？怎么查看分区对应hdfs路径？怎么计算某个分区的数据量大小？怎么计算某个分区的文件总数？
（3）有一hive sql，怎么计算这个sql会产生多少个map数？
（4）怎么查看hive有什么自带函数？怎么查看函数的详细信息？
（5）Hive支持哪些基木数据类型？
（6）请指出下面两个语句读取分区ds数据的不同
Select * from t where ds=20150101 and province=‘gd’ or province=‘ex’
Select x fromt where ds 20150101 and（province=‘gd’ or province=‘ex’）
（7）将字符串"keyl=valuel&key2=value2…keyn=valuen"进行分割放到一个字段里面，可以查出任意一个keyx对应的valuex值。请写出查询语句，并计算总共有多少个key值。
（8）用一个字符串比如"alblc"来测试某个函数比如split（用|分隔符将字符串进行分割）的语句
（9）a表和b表内连接，a表为小表，只有2000行记录
select a.from a Join b on a.key=b.key
可以进行怎样的优化
（10）a表left join b表，b表为小衣，可以进行怎样优化？
scleet a.from a left join Join b ona.key=b.key
如果a为小表，可以怎样优化？
（11）请指出下面sql语句的区别
select a. from a left Join b on a.key = b.key and a.ds=xxx and b.ds=xxx
sclect a. from a lef Join b on a.key = b.key and b.ds=xxx
select a.* from a lef Join b on a.key = b.key and b.ds=xxx where a.ds=xxx
Select a.* from a left Join b on a.key = b.key where a.ds=xxx and b.ds=xxx
（12）多表连按的写法：a,.b,c三个表内连接，连接字段都是key，怎样写连接语句？
（13）两大表连接，发生了数据倾斜，有几个reduce无法完成，怎么查找发生数据领斜的原因？应该怎样优化？
语句：select t1.,nvl(t2.x,1) from t1 left join t2 on t1.guid=t2.guid
（14）两大表连接，发生了数据倾斜。有一个reduce无法完成，检直发现t1中guid="的记录有很多，其他guid都不重复，这条语句该怎样优化？
语句：select t1.,nvl(t2.x,1) from t1 left join t2 on t1.guid = t2.guid
（15）如何用hive q！实现sqL中的exist/in 子句
mysql语句如下：
SEL ECT a* FROM a where a.key in（select dstinct key from b where key like ‘filter%’）
（16）sort by、distribute by、cluster by 和 order by 区别
注：可参考数据工厂的“帮助中心》集群hive》hive使用优化》hive使用注意事项”
2.2 学长2
1）笔试题
用HiveSQL实现
（1）全量用户登员日志表t_login_all，字段信息ftime（登录日期）、openid（登录帐号）新增用户登录日志表t_login_new，字段信息ftime（登录日期）、openid（登录帐号）求每天新增用户次日、7天、30天留存率。
（说明：7天留存是指当天有登录且第7天还登录的用户）
（2）消息流水表t_chat all，字段信息：
Ftime（日期）、send_user id（发消息用户id）、receive.user id（接收消息用户id）、chat id（消息id）、send.time（发消息时间）
用户登录流水日志表t_login_all，字段信息：
Ftime（日期）、user_id（用户id）、login_id（登录id）、login_loc（登录区服）、login_time（登录时间）
求：每天有收发消息用户最近登录时间、登录区服，输出ftime，user_id，login_loc，login_time
用Spark core实现，写Scala脚本
1、reduceByKey()、groupByKey()有什么区别？
2、DataFrame和RDD有什么区别？
3、使用累加器，对数组Array(1,2,3,4)每个元素实现累加操作，最后打印输出求和结果。
4、现有文件file.txt，文件格式如下
Order_id，user_id，payment，productid
1、1768，50，155
2、1218，600，211
3、2239，788，242
4、3101，288，599
5、4899，25，230
6、2311，890，981
。。。。。。
求Top10个payment字段的值
2.3 学长3
1）技术部分
（1）我看你上面写了你会Spark，那你用Spark写一下刚刚那道题的代码（第6题），不能用Spark SQL
（2）我看你上面有写到熟悉Hive原理和优化，你说一下怎么优化
（3）优化有说到语句优化，然后又说回到pv和uv那个问题，假如说让你优化你怎么优化（我代码里面有count(distinct id) uv,）
（4）问了一些Kafka的，我只记得一点点，问我数据会不会重复消费，什么情况下会重复消费
（5）在Hive执行语句的时候如果很慢，什么原因造成
我有提到数据倾斜的问题，他又问怎么解决数据倾斜
2）项目部分
（1）让你挑一个比较有亮点的项目详细说
（2）你负责了什么，数仓中统计了哪些指标，
（3）刚刚听你说项目里面有提到分层，如果我要你求每天商品的pv，uv，从ods层到dm层它的具体流向，各层都统计了什么（后来让写求pv，uv的sql语句）
3）场景部分
（1）有一个分区表，表名T，字段qq，age，按天分区，让写出创建表的语句
（2）刚刚的分区表，求20200221这个分区中，年龄第N大的qq号列表
（3）有一个表，两个字段，分别是qqa和qqb，数据如下：
12,34
12,56
12,78
34,56
34,12
找出所有互相关注的qq对
4）手写部分
（1）三个字段，timestamp，user_id，product_id，让求pv最大的商品，写了之后又叫用Scala代码写一遍，然后又问，假如说只让你求pv数大于100的top3呢，代码又怎么写
2.4 学长4
1）技术部分
（1）你们数仓用什么建模方法，说出常见的建模方法？
（2）维度建模有什么好处？ 为什么选择这个？比如最后业务需求要增加一个维度，我们需要做什么工作？
（3）怎么判断一个需求能不能实现，你们的判断标准是什么？需求变更要做什么
（4）增加一个维度后发现查询的速度变得非常慢，是什么原因导致的？
（5）你们ADS层的数据量每天的数据量有多大？ADS层再MySQL中的表是怎么创建的？有什么注意事项？索引怎么创建的？
（6）你知道Spark的宽窄依赖吗？ 有没有把宽依赖转化为窄依赖的例子？
（7）Spark参数调优做了些什么 ？
2）算法部分
（1）一个list [1,5,5,7,9] 去重，并计算时间空间复杂度
（2）单链表的反转
三 阿里面试题
3.1 学长1
1）技术部分
（1）Spark提交job流程
（2）提交脚本中-jar什么意思
（3）Excutor怎么获取Task
（4）详解Hadoop的WordCount
（5）Spark做过哪些优化，（优化说完会问你为什么？原理是什么？）
（6）Spark内存管理
2）算法部分
（1）单向链表反转
（2）实现堆栈push Pop Min 复杂度0（1）
（3）实现一个队列，男女均衡最长的队列 复杂度0（N）
3.2 学长2
阿里三面
第一题，亿级的交易订单量，每笔都有金额，快速找出top1000，要求不是简单的排序然后求出top1000，代码要有健壮性；提示注意是top1000不是top10。Map和Reduce分别做Treemap
第二题：有两个约1000万行记录的4到5G文件，JVM只有32M，在内存不溢出的情况下，找出相似的条数并打印出来。布隆过滤器
第三题，有一个双十一的天猫场景，我要做实时和离线两种分析方向，从数据建模、计算性能、元数据管理、数据质量上讲一讲基本架构设计成什么样子。
阿里四面
第一题，岛上有100个囚犯，他们都是蓝眼睛，但是他们都只能看到别人眼睛的颜色，并不能知道自己的眼睛颜色，而且他们之间不能去谈论眼睛颜色的话题，规定每天晚上都可以有一个人去找守卫说出自己的眼睛颜色，如果错了被杀死，如果对了被释放。但是大家在没有十足的把握前都不敢去找守卫，有一天，一个医生对他们说你们之中至少有一个蓝眼睛，然后N天，这些人都获救了，为什么？这句话对他们有什么影响？
第二题，有100层楼梯，从其中一层摔下鸡蛋的时候鸡蛋会碎，并且次层之上的都会碎，次层之下的都不会碎，如果你有一个鸡蛋、两个鸡蛋、三个鸡蛋，你会怎么去找出这个楼层，最多要试多少次
3.3 学长3（杭州）
1）自我介绍
2）技术部分
（1）对未来的职业规划是怎样的？
（2）数仓的流程？你所做的事情？
（3）能讲一下做DW层的案例吗？如何建模的？
（4）讲一下交易的例子吧？
（5）做交易的话模型怎么设计的？
（6）物流的信息，链路的跟踪在不在你的交易表里边？
（7）退款的数据放在哪个表里？
（8）数仓的模型 是怎么建模的？
（9）记录交易的，整体的链路，到底设计了几张表？
（10）拉链表的原理？
（11）拉链表整合的方式？
（12）你在之前的公司遇到的痛点有哪些？（我讲的数据倾斜）
（13）数据倾斜怎么解决的啊？
（14）Join的等倾斜，Join的key，关联键，如果倾斜的话，能直接打散，如果Map端解决不了呢？Mapjoin解决不了怎么办？两个都是大表怎么解决数据倾斜？
（15）MR原理？
（16）Map端做的最重要的事情是什么？
（17）有没有其他你特别擅长的？
（18）怎么提前你SQL写的特别好呢？
（19）建索引要注意哪些事情？
（20）你有啥要问我的吗？
3）总结感悟
全乘32分钟，在所有面试当中时间最长的一次了，之前的话在20多分钟就结束了，主要还是自己的语速太快了（禁忌），还是得慢慢的说，有思考的过程，思考你说完面试官会问你啥？其实这次面试自己的语速还是快，结果的话面试官评价我说“我觉得你大部分的流程都是比较清楚的，就是细节上还是得再琢磨琢磨，加强一点”，通话结束。
四 百度面试题
4.1 学长1
1）笔试部分
（1）你可以得到网站访问记录，没条记录有user IP，设计一个程序，要随时能计算出过去5分钟内访问次数最多的1000个IP
（2）简述Paxos协议
（3）编程简单实现一个阻塞队列
（4）简单实现一个LRU算法
（5）有一个5000万的用户文件(user_id,name,age),一个2亿记录的用户看电影的记录文件(user_id,url),根据年龄段观看电影的次数进行排序？
2）技术部分
（1）Java的NIO是否了解
（2）Java多线程（什么wait、notify）
（3）MapReduce的shuffle过程（手画，边画边介绍），reduce是怎么到map端获取数据的（RPC通信是否了解）
（4）一句话介绍MapReduce
（5） Spark做缓存时缓存在哪里
（6）百度不用Spark，只用Hadoop和MapReduce（至少这个部门是这样，这个部门的主要业务是做用户画像），把MapReduce工作的各个阶段过程吃透
（7）是否看过Hadoop源码
（8）Linux系统（常用命令啥的）
（9）除了这些平时还接触或者学习哪些技术
3）项目部分
（1）业务架构
（2）根据项目业务介绍技术
（3）MapReduce数据倾斜和内存溢出怎么办
4）算法部分
（1）手写归并排序
（2）用递归实现斐波那契数列第100项的值（第一项和第二项分别为0和1），手写
（3）算法和数据结构了解到什么程度、知道多少
（4）Java中的数据结构，ArrayList和LinkedList的区别，ArrayList为什么查询快（为什么用数组就快）、LinkedList为什么增删快，哪些Map是线程安全的
5）手写代码部分
（1）手写MapReduce的WordCount（导入的包最好能记住）
6）场景部分
（1）遇到垃圾日志怎么办（假如说有人恶意制造日志，怎么处理。我说的黑名单机制，那个面试官貌似还挺满意）
4.2 学长2
1）基本信息介绍
（1）百度：视频面试
（2）面试周期：5天
（3）面试次数：6次
（4）面试总时长：3小时
2）百度一面二面（印象中的一些问题）：
（1）自定义UDF、UDTF
（2）如何确定计算数据的准确性？
（3）建立数仓的目的
（4）自定义拦截器步骤
（5）SpringMVC
（6）设计网站前后端交互问题
（7）Linux常用命令
3）百度三面（部门负责人）：
（1）在没有PM的情况下如何对指标做拆分去分析？
（2）介绍了他们部门的工作内容
4）百度四面hrbp:
（1）介绍工作经历+工作遇到的困难+对所应聘职位的理解+分析指标提出时间和原因+离职原因等问题
5）百度五面业务总裁：
（1）某一天日活下降10%，需要从哪些维度分析，如何分析?不用说技术
6）百度六面Recuriter面：
（1）上家薪资+期望薪资+职级+对数据分析和指标分析的理解+职业规划等问题。
4.3 学长3
1）基本信息介绍
（1）11月17号度小满金融（原百度金融，A轮公司）
（2）面试地点：西北旺百度科技园旁
（3）面试时长：2个半小时
（4）面试次数：3次
2）一面：
（1）一面中规中距，有手写SQL环节，还有SparkStreaming常用算子解决实际问题。大概1个多小时。
（2）手写SQL考的是：
三个字段： area、year、temperature，统计每个地区的温度最高的对应的年份。
写的用rank函数，一个子查询，险过。
3）二面：
因为面的是架构师，所以二面问的是几个组件的版本号和几个大数据组件的安装过程和配置文件细节，还有HA的几个进程的作用，比较难。大概20分钟
4）三面：
问了自定义UDAF，UDTF，和数仓开放性问题，和三面主管说了毕业时间，并说了未签订劳务合同，他说怎么没签合同呢，太后悔了，最后走的时候说hr可能过不去，给我争取一下。大概30分钟。
强烈推荐度小满金融公司，环境Top5，面试官很厉害。
4.4 学长4
1）笔试

（1）写出用户表 tb_cuid_1d的 20200401 的次日、次7日留存的具体HQL ：一条sql统计出以下指标 （4.1号uv，4.1号在4.2号的留存uv，4.1号在4.8号的留存uv）(一条sql写完)
（2）统计当天不同平台、版本下的uv、pv
（3）解析ext中所有的"type"( lateral view explode)
2）二面：
t_a (uid,os,day)，t_b(uid,os,day)，15号在t_a，但是不在t_b的用户
ut格式: 机型_app版本_xxx_xxx_厂商， 如 iphone 6s_10.0.0.1_sdk12.1_baidu_iphone：解析 ；12.1

t_a (uid,os,day)
最近30内，所有用户末次活跃日期
最近30内，所有用户末次活跃日期和倒数第二次的差值
4.5 学长5
一面：
讲项目
kafka精确一次性
数据量
log日志类型，存的什么数据
spark streaming怎么做的实时
hbase rowkey你是怎么设计的
namenode 重启流程
hdfs读流程
flume拦截器怎么写的
flume结构
两道算法：
窗口求中位数， 说流式处理底层求热点问题常用到

一个树形结构，一个节点可以监听它的父节点和子节点，问最小监听数量

五 京东面试题
5.1 学长1
1）笔试部分
（1）列举几种数据倾斜的情况，并解释为什么会倾斜，以及如何解决？
（2）解释一下SQL运行步骤，是否有优化空间，如果有，如何优化：
SELECT a.id, b.name FROM a LEFT OUTER JOIN b ON a.id = b.id WHERE a.dt = ‘2016-01-01’ AND b.dt = ‘2016-01-01’;
（3）已知表a是一张内部表，如何将它转换成外部表？请写出相应的Hive语句
（4）用select做查询是，用哪个函数给值喂null的数据设置默认值？
（5）Hive中，建的表为压缩表，但是输入文件为非压缩格式，会产生怎样的现象或者结果？
（6）订单详情表ord_det(order_id订单号，sku_id商品编号，sale_qtty销售数量，dt日期分区)任务计算2016年1月1日商品销量的Top100，并按销量降级排序
（7）某日志的格式如下：
pin|-|request_tm|-url|-|sku_id|-|amount
分隔符为‘|-|’,
数据样例为:
张三|-|q2013-11-23 11:59:30|-|www.jd.com|-|100023|-|110.15
假设本地数据文件为sample.txt,先将其导入到hive的test库的表t_sample中，并计算每个用户的总消费金额，写出详细过程包括表结构
（8）test.log日志中内容如下左列所示，使用awk输出右列4行数据
10-3-jd-dv
2-4-jd-dv 10-4-jd-dv
5-7-pv-click 5-7-pv-click
36-24-pv-uv
37-24-pv-uv 37-24-pv-uv
24-3-uv-mq 24-3-uv-mq
（9）Storm的分组策略有哪些？
5.2 学长2
1）笔试部分
（1）HiveSQL语句中select from where group by having order by的执行顺序
（2）Hive中MapJoin的原理和实际应用
（3）写出你常用的HDFS命令
（4）使用Linux命令查询file1里面空行的所在行号
（5）有文件chengji.txt内容如下:
张三 40
李四 50
王五 60
请使用Linux命令计算第二列的和并输出
（6）在Linux环境下有文件/home/dim_city.txt如何加载dim_city外部表中，HDFS路径/user/dim/dim_city
（7）请列出正常工作的hadoop集群中hadoop都分别需要启动哪些进程，他们的作用分别是什么，尽可能写的全面些
（8）数据仓库的整体架构是什么，其中最重要的是哪个环节
5.3 学长3
1）笔试部分（京东金融）
（1）数据按照业务含义可以分为时点数和时期数，在一般情况下，下列哪些数据属于时点数？
A.昨天的订单量 B.昨天的库存量
C.昨天的点击量 D.昨天的访问次数
（2）About hadoop map/reduce，The right answer is？
A.reduce的数量必须大于零
B.reduce总是在所有map完成之后再执行
C.combiner过程实际也是reduce 过程
D.Mapper的数量由输入的文件个数决定
（3）Hive中的元数据不包括？
A.表的名字 B.表的外键
C.表的列 D.分区及其属性
（4）Hive中如何限制查询条数？
A、TOP B、limit C、rownum D、only
（5）关于hivesql以下说法正确的是：
A.cluster by不会对字段进行排序
B order by只保证每个reducer的输出有序，不保证全局有序
C sortby是全局有序
D distribute by制定规则字段，将相同组数据分发到同一reducer
（6）下面SQL的运行结果是什么？
Select a.id,b.name from (select id from table_id) a left semi join (select id, name from table_nm) b on a.id=b.id
table_id
id
1
2

table_id
id name
1 wzb
A 、(a,ok) B、(2,null) C、(1,ok & & 2,null) D、以上结果均不对
（7）你处理过的最大数据量是多少？处理时是否遇到问题，采取了哪些优化的方案？
（8）列举Hive几种数据倾斜的场景以及解决方案？
5.4 学长4
1）技术部分
（1）你们Spark哪个版本
（2）SparkStreaming如何和Kafka对接
（3）Kafka消费过的消息如何再消费
（4）Redis版本多少
（5）CDH版本多少
（6）集群怎么部署的
（7）数据倾斜怎么处理
（8）MR和Spark的Shuffle的区别
（9）MR环形数组怎么设置最大能设置多大
（10）Redis分布式锁怎么实现
（11）Rdd和dateset的区别
（12）说说Scala伴生对象
（13）解释Scala的模式匹配
（14）谈谈Scala隐士转换
（15）Yarn的组件说说他们的功能
（16）Spark一个Excutor给多大内存
（17）Spark几种部署模式还有他们的区别
（18）你运行程序是client还是cluster 为什么
（19）说出git的几个常用命名
（20）git如何切换分支
（21）对Hive的理解做过哪些优化
4）算法部分
（1）用Idea写快速排序
5）手写代码部分
（1）手写Spark WordCount
6）项目部分
（1）整个业务数据的流向
7）场景部分
（1）现有两张大表所有字段都得保留不能再过滤了join操作就发生OOM怎么解决
（2）Session日志分析如何求出用户访问的Page路径
（3）三表的join求销量，order——id的统计（记得不了）就是三表join求统计吧
5.5 学长5
1）一面
（1）HDFS、MR、Yarn的理解
（2）MR的WordCount简单描述
（3）Kafka快的原因，零拷贝的原理
（4）Redis的数据类型
（5）Kafka的isr队列
（6）Spark的运行模式，WordCount的简单描述
（7）基本上是简历的东西
2）二面
基本上和简历无关，问的算法，我不懂，没办法整理
5.6 学长6
1）京东数科二面
（1）最近一两年内你做过感觉最有趣或者让你记忆深刻的项目，挑一个说一说。我说的是SparkStreaming实时计算（李老师讲的在线教育那个项目，我给稍微改了改成电商项目了）。
（2）有关于Spark、Kafka、MySQL的项目你感觉那个比较熟练一点。我回答我的是对spark比较感兴趣。
（3）做这个项目用的是Spark的哪个版本？
（4）这个版本里用Kafka用的是那种消费方式。
（5）可以简单讲一下direct大概的一个设计套路。
（6）如果说我每隔一百条或者一千条，记录偏移量，如果跑到八百条宕掉了，有可能重复消费，针对receiver优势能不能解决这一点？
（7）如果dsteam方式去拉取Reduce拉取出去，那有多少个线程从Kafka里拖数据？
（8）平时除了用Spark比较多，用Hive也不少，平时会涉及到调参优化方面有哪些？
（9）你能介绍一下Flume的架构或者设计。
（10）用代码实现一个类似于Flink水位线的机制。
（11）有做过依赖调解的工作吗？比如说有没有碰到问题说引用自己一个依赖，但是在别的地方用了一个其他的依赖由于版本不统一，不能兼容该怎么办
（12）最近为什么会想到说换一个工作。（离职原因）
（13）你有什么想问我们的。
六 58面试题
6.1 学长1
1）笔试部分（基础题）
（1）请用图形的方式表示出Java运行时数据区
（2）以上哪些数据区在空间不足的情况下会抛出异常？
（3）Java工程出现内存泄露如何排查？请写出你知道的排查工具以及方法
（4）以下代码的输出结果是什么？
String str1=new StringBuilder(“58”).append(“ganji”).toString();
System.out.println(str1.intern == str1);
String str2=new StringBuilder(“ja”).append(“va”).toString();
System.out.println(str2.intern == str2);
（5）在Scala中有一种函数其参数可以为参数，这样的函数称为高阶函数，请参照scala中常见map函数实现一个名为mymap的高阶函数，mymap接收两个参数值，第一个函数（x:Int）=>3*x，第二个为Int型数据。在mymap函数体内将第一个参数作用于第二个参数。
2）笔试部分（算法）
（1）给定两个只含有0和1字符的字符串，实现二进制加法。如：
String str1 = “101”
String str2 = “11”
实现binarySum(String s1,String s2),使得输入以上字符时返回字符串"1000"。
（2）给定一个整型数组array（没有重复元素），再给出一个目标值target，数组array中有两个元素的加和等于target，要求返回这两个元素的下标。如array = {1,2,4,6,3} target = 8，则返回[1,3]。

3）笔试部分（大数据相关）
（1）现有一张Hive表，表里面有两个字段uuid和ts，分隔符为\001分别表示用户唯一标识和用户来访的时间戳。
有如下需求
（a）要求计算每个用户的最后一次来访时间，用MapReduce实现（写完整的代码）
（b）你所写的代码有没有优化的空间？如果有，请写出优化方法。
（2）用Spark实现WordCount。
（3）Spark-Streaming+Kafka实现实时计算这种方案中通过什么方式保证数据的准确性？
（4）分别列举Hadoop和Spark中的文件缓存方式。
（5）HDFS的一致性是指什么？有几种语义？
（6）基于Yarn的推测执行是怎么实现的？描述其大致算法。
QUESTION NO:1
publicclass Test1{
public static void changeStr(String str){
str=“welcome”;
}
public static void main(String[] args)(
String str=“1234”;
changeStr(str);
System. out. println(str);
}
}
输出结果：
QUESTION NO:2
public class Test2{
static boolean foo(char c){
System out print©;
return true；
}
public static void main(String[] argv）{
int i=0；
for(foo(‘A’);foo(‘B’) &&(i< 2);foo(‘C’)){
i++；
foo(‘D’)；
输出结果：
6.2 学长2
1、一面（学长面）
1）技术部分
（1）HashMap如何遍历。（这个忘了，百度了一下是用EntrySet）
（2）SparkStreaming窗口操作的3个时段设定分别是什么，问到倍数这块（第二轮也问到了）
2）项目部分
（1）讲了一下推荐项目怎么回事
（2）因为是招数仓这块的，所以三轮数仓都问了（第二轮的数仓问题比较偏，我写到第二轮总结里）
3）算法部分
（1）快排或冒泡排序，我讲的是快排
4）情景部分
（1）设定了一个情景，手写SQL，比较简单吧
2、二面
1）技术部分
（1）flatMap和map的区别
（2）A表joinB表，用MR是如何处理的（这个真没看过，百度了之后才知道的）
（3）Yarn的资源调度
（4）Hbase有put方法，那如何批量put数据进hbase里，用什么方法（这个也没答上，面试的时候想不起来了）
（5）NameNode的HA，一台挂掉之后，另一台会丢失数据吗，挂掉之前有一部分日志为更新（这个我答的是edits会保存下来，和之前的镜像一起加载，所以不会丢）
（6）问了Kafka的消费速度（这个我说的几十兆每秒，群里已经发了，是1G每秒，可自由发挥）
（7）Kafka分区（我说的5个，有点多了，应该说2个或者3个吧）
（8）问了HDFS的块你们设置的是多大（我说的128M，他有疑惑，我说默认是128M，他也表示疑惑）
（9）问了Spark版本，说一直是这个版本吗（我说现在用的是2.0，之前用的1.6）
（10）Sparksql什么时候不能读到Hive的数据（这个也没答上来）
2）项目部分
（1）你们数仓之间的数据是怎么调度的（我说直接写SQL，他就问说你怎么知道你的数据已经存储成功了，当时尬了一会，我说用Crontab调度的，他问我这用Crontab合适吗，我说那设置Oozie可以设置一段程序执行完再执行下一条程序，这块基本就聊炸了吧，我不知道Hive内部数据调度还需要这样调，我以为直接读）
3）情景部分
（1）设置了一个情景，让写SQL，也相对简单吧
3、三面
项目组负责人
（1）要招数仓和算法的，所以主要问了数仓。
（2）数仓的DM为何不由数据组来设计封装（因为我说的是指负责设计下面三层，然后由不同的业务组区数仓里调数据），你觉得是数据组封装有什么不妥吗
（3）HBase里面你们都存了具体哪些业务数据（这个我说了大概的存哪类型的数据，他问的非常深，必须说出存的具体是什么数据，我后来说每个商品的点击次数统计，实时更新，），他说这些数据我觉得存到redis或者mysql中也行呀，为什么要非要用HBase（我说HBase查的块，他说我觉得这样的数据量Redis，MySQL查的也不慢吧），然后问了我你认为多少的数据量适合用HBase（我说的几百万）
（4）结合你这个HBase里存储的数据，说一下你们的rowkey怎么设计的（这块说的不好，因为前面说的不好，感觉这边说就强行设计了）
6.3 学长3
1）技术部分
（1）对Hadoop各组件之间通信RPC协议了解
（2）Hadoop的读数据流程
（3）传输过程中DataNode挂掉怎么办
（4）HBase源码
（5）HBase构建二级索引如何保证索引与数据的一致
（6）JVM架构，堆内存，GC算法，问平时会不会调GC算法
（7）-Xms和-Xmx设置一个和设置两个而且两个设置的都是一样有什么区别吗
（8）查看当前Java内存各个代的内存比例
（9）查看线程堆栈的命令
（10）查看Java进程里边对象的大小，
（11）堆内存泄露怎么看，除了Dump出来用MAT还有什么简单的方法
（12）Java进程用户反馈请求服务很慢，但是代码不是你开发的你怎么排查问题，
多线程，实现线程同步的方法
2）算法部分
（1）问对数据结构和算法了解吗，堆栈和链表什么的
6.4 学长4
一面：
sparkstreaming 用了哪些算子
flatmap与map的区别
dwd 的是啥 dws s是啥， dwt t是什么
你们获取kafka Offset的API是什么
HBase创建表时，rowkey的设计
ODS层干了什么
yarn工作机制说一下
kylin怎么用的
superset怎么用的
说一下JVM重用的参数
你们合并文件用的哪个参数 merge.mapred.files
Hive使用时遇到过什么困难
sparkstream如果进行精确一次性消费
七 新浪面试题
7.1 学长1
7.1.1 一面
1）自我介绍
叫什么名字，来自哪里，本科哪个学校，硕士哪个学校，大数据做了多长时间，对Hadoop生态圈以及Spark生态圈中的哪些技术比较了解（很简单的一句就带过了），说完大概2min
2）技术部分
（1）让我介绍下Sqoop，说他没见过
我说Sqoop我用的不熟，知道怎么用，可以简单地给他介绍一下。然后就说Sqoop是HDFS、关系型数据、HBase它们三者之间传输数据用的，很方便。
（2）让我介绍MapReduce的运行过程
二话不说要笔要纸，手绘MapReduce从InputFormat到OutputFormat的流程，一边画图一边说。
3）项目部分
（1）让我介绍项目我都是给他要笔要纸，手绘架构图。
离线：data->flume->kafka->hdfs->hadoop/spark->mysql->前端展示
实时：data->flume->kafka->Spark Streaming->mysql->前端展示
kafka到hdfs是自定义的consumer
（2）为什么要使用Kafka，可不可以用Flume直接将数据放在HDFS上
我说可以用Flume将数据直接放在HDFS上，但是很少有人这么干，为什么要用Kafka我没有深入研究过（当时没想到咋说）
（3）让我介绍下项目中的指标，都是怎么实现的
我就挨个把我写上的项目指标说了下是什么意思，是怎么实现的（我简历上每个项目就写了几个指标，我感觉比较熟的），最后我说还有其他的很多指标，我做的就这些。
4）手写算法部分
（1）让我写链表的反转
我说链表没咋接触过，老师换个吧
（2）接下来让我手写单例
分分钟写了个双端检测单例
5）是否有问题问面试官
（1）最后说有没有问题要问他
问1：我就问他们大数据是做什么，一天的数据量有多大
答1：他给我说他们是做反垃圾的，一天的数据量上T了
问2：我就又问他们怎么定义的垃圾数据
答2：他就给我说一切影响用户体验的数据都是垃圾数据，比如说在用户的评论下面打广告之类的
然后我就说暂时没有了，他就让我在那等着了
7.1.2 二面
1）自我介绍
还是一面那一套
2）技术部分
（1）介绍MapReduce的运行过程
还是上面的一套。不过在我一边画图一边说的时候有人给他发消息，貌似挺着急，然后我就停下来了，他说不好意思他回个消息，我就说不着急，等您忙完咱再聊。
3）项目部分
（1）项目框架介绍
老一套
（2）问我写的公司做什么的
我说做电商的
（3）他又问具体都卖什么
我说什么都卖，就跟京东和淘宝似的，只不过规模小很多
（4）问我上家公司做大数据的有多少人
我说十多个吧
（5）问我公司在哪
我说在丰台
（6）问我一天的数据量有多大
我说APP端有十多个G，将近20多个G，浏览器端大概有四五十G
（7）又问我一天的访问量有多少
我当时心里就按照费老师说的10w个人1G的量大概算了下，说了个数
4）手写算法部分
（1）手写二分查找
二分是基于一个排好序的数组，我就问他数组排序用不用写，他说不用，然后就分分钟写完，最后我还说用不用手写MapReduce的WordCount以及Spark的WordCount的，一点问题没有。
（2）让我用Shell写一个脚本，对文本中无序的一列数字排序
我说Shell简单的我可以，比如说写个脚本，Crontab周期性调度一下，复杂的我得查下资料，也就没写
5）是否有问题问面试官
（1）最后说他没问题了，我有什么要问他的没
我说要我不，他笑了，然后他说除了这个
（2）我当时也没想到什么问题，就问了嘴他们的集群有多大
他说成千上万台
7.1.3 三面
1）自我介绍
（1）自我介绍
老一套
（2）问我哪一年毕业的，公司有多少人
我实话实说，说还没有毕业就去实习了，我说二三百人
（3）问我为什么要做这个，什么专业的
专业我实话实说的，然后说15年底16年初的时候原油价格暴跌，说以前行情好的时候最高一桶原油120美元，巅峰能达到160，我找工作那年最低的时候25，行情特别差，自己比较喜欢编程，硕士毕业的东西都是用MATLAB实现的，然后就自己学的Java，找的这个工作，进去以后领导让做大数据，就跟着老师傅干了。
2）技术部分
（1）问我Kafka用的那个版本
0.11
（2）问我ZooKeeper的常用命令
我说Status（基本全忘了，就这个记得很清楚），他说还有呢，我说ls，然后我又说忘的差不多了，但是我知道它的命令和Linux命令差不多，都是那一套，那老师也就没再问。
（3）问我myisam和innodb的区别
我就按照阳哥讲的，先说了下myisam不支持主外键，不支持事物，它是表锁，不适合高并发，而innodb则不是，然后他又问我还有没，我说了解就这么多，他也没再问
（4）他又问我一句如果单线程访问，myisam和innodb那个性能好一点
我说myisam吧，因为它不支持事物，要快一些
然后他又问我一个问题，我没答上来，我忘了那个问题是啥了
（5）问我Redis常用的命令
我顿了一两秒甩了一句keys*，他笑着说可以可以
（6）问我为什么要用Redis
我就说Redis是内存型数据库，以前访问量没那么大的时候关系型数据库完全可以胜任，但是在高并发的情况下访问量一大，关系型数据就不行了，所以就有了Redis
（7）问我了解HBase不
我说了解不多，就知道它是一个非关系型数据库，它也就没再问
（8）然后问我机械硬盘和SSD硬盘的差别了解不
我说SSD读写快，然后他说是，他又问我底层了解不，为什么SSD读写快，我没答出来，他又说从硬盘读取数据首先要干什么，我说寻址（然后突然一下子好像明白了，就跟他扯了扯）
（9）然后他又问我机械硬盘每秒读取次数多少知道不
我说我不知道，没研究这么深，但是我说我知道我们大数据读取数据的时候寻址不超过10ms（我当时心里这样想的，这些东西我没接触过，我要往大数据上靠，要引导他去问我大数据的东西），结果他说知道这个能算出来机械硬盘1秒能读多少次，然后我好想明白了，就1s/10ms呗，他说是，也就100来次
3）项目部分
（1）问我一天的数据量有多大
我还是按照原来的那个说的，他说不到100G单机就能搞定吧，我说公司就这么定的，然后尴尬不失礼貌地笑了笑（跟尽际老师学的）
然后就看着简历问了一些问题
（2）问我Azkaban一天调度多少个任务
我说三五百个吧
（3）然后他问我这么一个问题，他说你做这些项目需要埋点日志的对吧，然后说如果后台的人不愿意给你加这个埋点，嫌麻烦，你怎么办
我愣了一会，随口说了句，吃顿饭，那老师当场笑了，然后他说这算是个办法，他又说如果这个人没时间，没工夫跟你吃饭，你怎么办，我当时傻笑了两下，没回答。
4）场景题，手写SQL
场景1：是这样的，一张表三个字段，分别是学生名字、科目名字、科目得分，让我用sql把总分最高的找出来
我说我数据掌握不太好，试着写写。
我用了个子查询，先按学生分组，然后求每个学生的总分数
然后在外部查询中求最大的
我一开始在子查询中直接对用聚合函数求的sum_score排序了，他看了以后说能这么做么，我说我忘了，然后我又说子查询不行的话咱们就在外部查询排序呗，然后反问他可以吧，他说可以的
5）平时学习习惯
CSDN、博客园、Apache官网
6）是否有问题问面试官
（1）最后他说他差不多了，我有什么要问他的没
我问了下他业务方面的一些，也没想到啥，随便问的
（2）最后我又问他，他刚才问我埋点日志后台的人不给加怎么办
他给我说这个需要各个组协调好，不然别干活了，就扯了一会
7.1.4 四面
1）自我介绍
老一套
2）技术部分
（1）介绍MapReduce的运行流程
本来我说给他手画的，他不让，说介绍就行。我就从InputFormat开始到OutputFormat给他说了一遍。
然后他就说按着简历来问
（2）让我说下myisam和innodb的区别
老一套
（3）然后看着简历说你知道HDFS的存储过程，我说需不需要我说一下
然后我就把海哥hadoop存储过程那几个图给他说了一遍
3）项目部分
让我介绍下我写的三个项目都是干啥的，我就没画图，给他介绍了下每个项目具体是做啥的，怎么做的（什么领导层要看指标啊啥的）
4）平时学习习惯
还是CSDN、博客园、Apache官网，说都是晚上和周六周天自己学的
（1）问我喜不喜欢技术
我说很喜欢，我说了以后他说为什么喜欢，我就说我搭建起来一个集群很有成就感，能在我女朋友面前炫耀一番。。。
（2）问我喜欢跟人打交道还是喜欢跟机器打交道
我按照实际情况说了下，说比较宅，比较喜欢跟机器打交道，还说从小就比较喜欢玩小霸王游戏机之类的。。。
7.1.5 五面HR
教训：和HR接触不要激动，不要表现的很倾向来她们公司，因为后面工资可能不好谈，要不到理想的价位。
1）自我介绍
老一套
2）人事高频问题
（1）有没有别的offer，面试几家了
我说这周一开始投的简历，在等百度的offer，上午面试的58到家，但是58到家做Hive比较多，我了解不多
（2）问我什么时候辞职的
我说十一月初
（3）问我为什么现在才找工作
说回家一趟，大半年没回家了，这两天刚回来
（4）上家薪资多少
我就按照我心里的想法和马老师说的大概说了个数
然后说什么他们很严格，如果不行会马上辞退啥的，最后说看我能力可以，问我啥时候可以上班，让我准备下薪资流水和离职证明
7.2 学长2
1）技术部分
（1）Kafka吞吐量怎么优化
（2）Hive底层，SQL、表关联、窗口函数、聚合函数、一堆场景题
（3）Join对应的MR
（4）一张小表Join一张大表 在MR上怎么JOIN
（5）map()阶段聚合
（6）Spark job流程
2）项目部分
（1）上个月用户访问次数最大的IP
（2）TopN
（3）日活实时统计
（4）SparkStreaming的活动窗口大小，数据重复怎么办？
（5）数据仓库ODS -》 DWD 用什么写的脚本？
3）算法部分
（1）二分查找
（2）字符串反转
7.3 学长3
1）技术部分
（1）HDFS的小文件处理。
（2）Hive调优，数据倾斜问题
（3）Spark任务提交流程
（4）MR任务提交Yarn流程
（5）HDFS的读写流程，Shuffle流程，Shuffle过程的归并排序具体怎么做。
（6）是否用了currenthashmap，高并发问题就高枕无忧了
（7）线程池了解吗？
（8）怎么判断一个Kafka消费者挂了
（9）了解Redis，MySQL吗，MySQL的索引了解吗？
（10）select。。。for update是什么锁？
（11）MySQL底层文件存储
（12）读过哪些框架的源码？
（13）JVM底层原理
（14）Spark的distinct()算子底层
（15）布隆过滤器
（16）Zookeeper的作用，Zookeeper单独的事务，Nginx的作用，只做收集数据吗？
（17）说一下Kafka的架构，描述hw leo，Kafka的优化，怎么做幂等，你们做业务幂等性，为什么消费者怎么看到hw。消息的一致性能解决什么问题，kafka事务怎么理解。
（18）Spark的Shuffle过程
（19）HBase怎么预分区
（20）Redis有多少曹，Redis的持久化，你们在项目中怎么用Redis的，如何防止雪崩。
（21）mysql update一条语句，需要走那些流程。
（22）了解ES吗？
（23）Yarn执行一个任务用了多少core
（24）produce给Kafka的一个topic发送消息，topic的一个分区挂掉，他的副本也全部挂掉，这个topic还能用吗
（25）有没有用JavaAPI去读Kafka的数据
（26）Spark读取Kafka数据的方式？
（27）Hive的内表和外表的区别，Hive为什么要做分区，Hive的元数据存在哪？
（28）列式存储和关系型数据库的区别
（29）Java中正则表达式用到哪些类？
（30）unlock和synchronzed的区别？
（31）编写SparkSQL的步骤？
2）项目部分
（1）写实时项目遇到了哪些问题
（2）拉链表的创建，连续三天登陆
（3）你们公司日活，月活，留存多少？你们团队多少人？
（4）为什么加最后一层Flume，不能直接Flume到HDFS吗？
（5）分析指标，对APP有什么影响。提升了百分之多少？
（6）有没有访问Kafka的所有Topic的权限
（7）有没有做Hive表的权限管理。
3）算法部分
（1）归并排序
（2）删除单链表的一个节点
4）情景题：
（1）Spark：如果消费Kafka中的数据时，某个分区内数据因为种种原因丢失了一条(也可理解成因为某些条件被过滤了)，现在需要重新把这条数据纳入计算结果中。怎么解决？
（2）a left join b on a.id = b.id and b.age = 20
a left join b on a.id = b.id where b.age = 20
的结果有什么区别
5）平时学习习惯
（1）你最近在研究什么？
7.4 学长4
1）项目介绍
介绍一下项目，你主要负责哪部分，最精通什么
2）技术部分
（1）HDFS读写机制，DataNode怎么保证数据可靠性，原理是什么（答副本，说不对）
（2）MR的过程详细说一下
（3）使用MR写出Join过程
（4）日常开发哪里用到Java多线程，怎么写
（5）说一下并发和同步，单例必须加同步锁么？为什么
（6）说一下MR的底层源码，你研究了哪部分？
（7）说说Spark的底层源码吧
7.5 学长4

八 搜狐面试题
1）笔试部分
（1）HDFS原理，以及各个模块的职责
（2）MR的工作原理
（3）Shell脚本里如何检查文件是否存在，如果不存在该如何处理？Shell里如何检查一个变量是否是空？
（4）Shell脚本里如何统计一个目录下（包含子目录）有多少个Java文件？如何取得每一个文件的名称（不包含路径）
（5）哪个程序同城与NN在一个节点启动？哪个程序和DN在一个节点？如果一个节点脱离了集群应该怎么处理？
（6）列出几个配置文件优化Hadoop，怎么做数据平衡？列出步骤
（7）有序数组的二分查找
（8）编写快速排序(QuickSort)或者归并排序(MergeSort)
（9）整数数组寻找满足条件的点对
（10）给定整数数组A[N]，求两个下标(i, j)且0<=i （11）该(i, j),使得A[i] + A[i] + … + A[j] 最大
（12）要求：时间复杂度尽量低，空间复杂度O(1)
（13）请：1.写出思路的简要描述 2.用你熟悉的语言，定义函数，完成编码和测试用例
2）项目部分
搜狐面试的小伙伴注意，广告变现的业务，会问到Flume监控的问题，必问，二面理论比较强，居然问缓慢变化维，我问一下数据仓库有拉链表么？
九 360面试题
9.1 学长1
1）技术部分
（1）常用的Linux命令，Shell的awk、sed、sort、cut是用来处理什么问题的？
（2）Hive有自带的解析json函数，为什么还要自定义UDF、UDTF
（3）Json的格式，Json存的具体数据
（4）MapReduce过程
（5）Shuffle源码？其中Reduce的分区是怎么设置的，针对每个key，怎么把它放到对应的分区中？
（6）你了解的Hadoop生态圈的框架，及其大概在怎样的一个位置？
（7）MapReduce、Tez和Spark的区别？
（8）Spark读取文件如果内存不够的话，怎么处理？
2）手写部分
（1）自己写过MapReduce吗？怎么写的？
（2）最近七天连续三天活跃用户怎么实现的？手写一个各区域top10商品统计程序？
（3）平时遇到的数据倾斜的问题，怎么解决的？
（4）大表join大表怎么解决？
（5）每一层大概有多少张表？表的字段也需要记
（6）UDF、UDTF、UDAF区别？
3）算法部分
（1）二叉树的前中后序遍历？
（2）排序算法了解过吗？
（3）快排的时间空间复杂度？快排原理
（4）冒泡的时间空间复杂度？原理
4）情景部分
写一个程序获取ip（123.123.123.123）的地理位置信息，读取配置文件，返回结果ip \t loc_nation \t loc_pro \t loc_city
ip_num_start ip_num_end loc_nation loc_pro loc_city ISP
1910946943 1910946945 中国 辽宁 沈阳 联通
1910946947 1910946949 中国 辽宁 沈阳 联通
1910946950 1910946950 中国 辽宁 鞍山 联通
1910946951 1910946953 中国 辽宁 沈阳 联通
1910946959 1910946965 中国 辽宁 沈阳 联通
1910946966 1910946966 中国 辽宁 盘锦 联通
1910946967 1910946985 中国 辽宁 沈阳 联通
1910946986 1910946986 中国 辽宁 大连 联通
1910946995 1910947033 中国 辽宁 沈阳 联通

sc.read(“input/.txt”)
.mapPartition(data=>{
val splitdata = data.split("\t")
ip_num_start = splitdata(0)
ip_num_end = splitdata(1)
loc_nation = splitdata(2)
loc_pro = splitdata(3)
loc_city = splitdata(4)
ISP = splitdata(5)
(ip_num_start, ip_num_end, loc_nation, loc_pro, loc_city)
})
.map(data=>{
if(ip ){
(data.loc_nation,data.loc_pro,data.loc_city)
}
})
针对上面代码的一些问题：
（1）上面那段代码中，如果文件是一个很大的文件，Spark读取的时候用一个任务处理（单机），怎样可以让它读取的效率更高一点？
（2）MapPartition的原理是什么？
9.2 学长1
（1）常用的Linux命令，Shell的awk、sed、sort、cut是用来处理什么问题的？
（2）Hive有自带的解析json函数，为什么还要自定义UDF、UDTF
（3）json的格式，json存的具体数据
（4）写一段代码：
写一个程序获取ip（123.123.123.123）的地理位置信息，读取配置文件，返回结果ip \t loc_nation \t loc_pro \t loc_city
ip_num_start ip_num_end loc_nation loc_pro loc_city ISP
1910946943 1910946945 中国 辽宁 沈阳 联通
1910946947 1910946949 中国 辽宁 沈阳 联通
1910946950 1910946950 中国 辽宁 鞍山 联通
1910946951 1910946953 中国 辽宁 沈阳 联通
1910946959 1910946965 中国 辽宁 沈阳 联通
1910946966 1910946966 中国 辽宁 盘锦 联通
1910946967 1910946985 中国 辽宁 沈阳 联通
1910946986 1910946986 中国 辽宁 大连 联通
1910946995 1910947033 中国 辽宁 沈阳 联通

sc.read(“input/.txt”)
.mapPartition(data=>{
val splitdata = data.split("\t")
ip_num_start = splitdata(0)
ip_num_end = splitdata(1)
loc_nation = splitdata(2)
loc_pro = splitdata(3)
loc_city = splitdata(4)
ISP = splitdata(5)
(ip_num_start, ip_num_end, loc_nation, loc_pro, loc_city)
})
.map(data=>{
if(ip ){
(data.loc_nation,data.loc_pro,data.loc_city)
}
})
针对上面代码的一些问题：
A、上面那段代码中，如果文件是一个很大的文件，spark读取的时候用一个任务处理（单机），怎样可以让它读取的效率更高一点？
答：提高并行度？

B、MapPartition的原理是什么？
（5）MapReduce过程
（6）自己写过MapReduce吗？怎么写的？
（7）Shuffle源码？其中Reduce的分区是怎么设置的，针对每个key，怎么把它放到对应的分区中？
（8）你了解的Hadoop生态圈的框架，及其大概在怎样的一个位置？
（9）MapReduce、Tez和Spark的区别？
（10）Spark读取文件如果内存不够的话，怎么处理？
（11）最近七天连续三天活跃用户怎么实现的？手写一个各区域top10商品统计程序？
（12）平时遇到的数据倾斜的问题，怎么解决的？
（13）大表join大表怎么解决？
（14）每一层大概有多少张表？表的字段也需要记
（15）UDF、UDTF、UDAF区别？
（16）二叉树的前中后序遍历？
（17）排序算法了解过吗？
（18）快排的时间空间复杂度？快排原理
（19）冒泡的时间空间复杂度？原理
十 小米面试题
10.1 学长1
大家可以投一下小米的推荐算法。
一面：问两个有序大数组合并成一个数组的最佳方法，还有快排，问了所有项目。
二面：是问推荐算法的业务实现，还有如果你自己做一个推荐，你会怎么选择模型、算法。
三面：数据结构的查找，新增，删除的时间复杂度、还有各种数学问题，然后写了二叉树的查找、还有根据算法题写了一个递归，差不多就这样就过了
1）技术部分
（1）Java8的新特性？
（2）Java8的hashMap为什么采用数组+链表+红黑树？
（3）垃圾回收的算法，CMS和G1的比较，用什么监控JVM？
（4）Kafka对接SparkStreaming？
（5）线程池好处是什么，什么场合用？
（6）Zookeeper的选举机制，以及我们还可以用Zookeeper做些什么？
（7）Flume采集数据的优缺点，还有什么可以代替它，也可以通过自己公司的业务情况自己开发。
（8）Spark Streaming和Storm，Flink的比较，以及各自的优势？
（9）怎么从10亿条数据中计算TOPN？
10.2 学长2
1）基本信息
（1）面试地点：小米6期
（2）面试时长：共2个半小时
2）一面（下午3点30分到4点10分）:
（1）自我介绍
（2）Spark Streaming和Flink区别
（3）MR和Spark引擎的区别
（4）引起Shuffle的算子有哪些？
（5）Flink+Kafka保证精确一次消费相关问题
（6）Zookeeper的应用
（7）Java中HashMap和TreeMap区别（记不清是不是这个问题了）
（8）SparkStreaming保证精确一次消费
（9）给出数据倾斜解决方案
（10）被问到任务划分的源码(DAGScheduler划分)
（11）给一个整形数组，找出最大的连续子集
（12）给一个数组，一个值，找出第一次出现的两个数的和等于这个值的下标并存入List中（好像Letcode第一道题，双层for循环）
（13）Spark中划分宽窄依赖的底层原理：只说Shuffle划分Stage没用
3）二面（下午4点25分到5点10分）：
（1）自我介绍
（2）手写SQL:(看着你写，注意)
表t1
页面id 点击 浏览 日期
page_id view visiable date
0 0/1 0/1
1 0/1 0/1
…
表t2
品类id 页面id
border_id page_id
a 0
b 1
a 3
a 4
b 0
…
找出各个border_id的view，visable个数 (join group by where count(if)…)
（3）JVM内存和调优
（4）Redis数据类型，事务(凭印象说的multi,exec,watch)，持久化方式和区别，Redis中zSet底层实现是什么？
（5）Redis问的很细
（6）跑任务用的什么（Azkaban）？定点定时跑还是周期性跑？
（7）手画星座模型
（8）业务过程，维度，事实
（9）手写单例模式
（10）实时统计过的指标
（11）如何从0到1搭建数据平台？
4）三面（下午5点10分到5点30分）：
（1）自我介绍
（2）B+树和B树底层，与二叉树的区别(手画) 不太会
（3）给你两个矩阵(txt文件，以\t分隔)，让你用MapReduce实现两个矩阵相加并输出（每行打行号标记）
… …
5）四面：（下午5点35分到5点50分）
（1）了解上家公司情况
（2）入职相关事情
10.3 学长3
1）笔试：
（1）链表两两反转(搞定)
（2）验证二叉树是否符合以下条件：一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。(我说我对二叉树不咋熟悉)
（3）求一个序列中的最长上升子序列的长度(搞定)
2）面试：
（1）Flink的状态后端
（2）说说rockDB状态后端，rockDB做状态后端有啥好处和缺点
（3）说说HDFS状态后端，它是怎么存储的状态的
（4）说说Flink中的keyState包含哪些数据结构
（5）Redis常用数据类型
（6）SparkStreaming是如何处理数据积压的，说说反压机制的令牌桶算法
（7）简单谈谈JVM辣鸡处理的算法，了解多少，分别是什么
（8）谈谈JVM内存的分布，方法区中都存些什么
10.4 学长4
1）语言基础：
（1）String类可以被继承吗？为什么？
（2）HashMap，HashTable，ConcurrentHashMap的异同？
（3）Java单例模式，Scala语言如何实现？
（4）实现快速排序算法
（5）设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。写出程序。
2）Hive
（1）把每科最高分前三名统计出来 --成绩表Score（student_name,student_no,subject_no,score）
（2）找出单科成绩高于该科平均成绩的同学名单（无论该学生有多少科，只要有一科满足即可） --成绩表Score（student_name,student_no,subject_no,score）
（3）一个表 test(name,price)，构建一个新表，将name相同的，price所有价格合并到一个字段里面
（4）如何将题3中price合并后的prices字段再拆分为多条记录？
3）Spark
（1）用户访问日志文件有两列，分别为日期和用户ID：（date，user_id），使用Spark统计每天的访问的记录数和用户数。
（2）在Spark中，代码的执行位置:
dstream.foreachRDD { rdd =>
val where1 = “执行位置1”
rdd.foreachPartition { partition =>
val where2= “执行位置2”
partition.foreach { record =>
val where2 = “执行位置3”
}
}
}
10.5 学长5
1）基本信息
（1）2019年11月10号：
（2）面试地点：小米6期
（3）面试时长：共2个半小时
2）一面（下午3点30分到4点10分）:
（1）自我介绍
（2）Spark Streaming和Flink区别
（3）MR和Spark引擎的区别
（4）引起Shuffle的算子有哪些？
（5）Flink+Kafka保证精确一次消费相关问题(记不清了)：我说的两阶段提交
（6）Zookeeper的应用
（7）Java中HashMap和TreeMap区别（记不清是不是这个问题了）
（8）SparkStreaming保证精确一次消费
（9）给出数据倾斜解决方案
（10）被问到任务划分的源码(DAGScheduler划分)
（11）给一个整形数组，找出最大的连续子集
（12）给一个数组，一个值，找出第一次出现的两个数的和等于这个值的下标并存入List中（好像Letcode第一道题，双层for循环）
（13）Spark中划分宽窄依赖的底层原理：只说shuffle划分stage没用
3）二面（下午4点25分到5点10分）：
（1）自我介绍
（2）手写SQL:(看着你写，注意)
表t1
页面id 点击 浏览 日期
page_id view visiable date
0 0/1 0/1
1 0/1 0/1
…
表t2
品类id 页面id
border_id page_id
a 0
b 1
a 3
a 4
b 0
…
找出各个border_id的view,visable个数 (join group by where count(if)…)
（3）JVM内存和调优
（4）Redis数据类型，事务(凭印象说的multi,exec,watch)，持久化方式和区别，redis中zset底层实现是什么？
（5）Redis问的很细
（6）跑任务用的什么（Azkaban）？定点定时跑还是周期性跑？
（7）手画星座模型
（8）手写单例模式
（9）实时统计过的指标
（10）如何从0到1搭建数据平台？
4）三面（下午5点10分到5点30分）：
（1）自我介绍
（2）B+树和B树底层，与二叉树的区别(手画) 不太会
（3）给你两个矩阵(txt文件，以\t分隔)，让你用MapReduce实现两个矩阵相加并输出（每行打行号标记）
… …
5）四面：（下午5点35分到5点50分）
（1）了解上家公司情况
（2）入职相关事情
10.6 学长6
1）笔试：
语言基础：
（1）String类可以被继承吗？为什么？ 
（2）HashMap，HashTable，ConcurrentHashMap的异同？
（3）Java单例模式  Scala语言如何实现？
（4）实现快速排序算法
（5）设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。写出程序。
Hive
（1）把每科最高分前三名统计出来 --成绩表Score（student_name,student_no,subject_no,score）
（2）找出单科成绩高于该科平均成绩的同学名单（无论该学生有多少科，只要有一科满足即可） --成绩表Score（student_name,student_no,subject_no,score）
（3）一个表 test(name,price),构建一个新表,将name相同的,price所有价格合并到一个字段里面
（4）如何将题3中price合并后的prices 字段再拆分为多条记录？
Spark
（1）用户访问日志文件有两列，分别为日期和用户ID：（date，user_id）,使用Spark统计每天的访问的记录数和用户数。
（2）在Spark中,代码的执行位置:
dstream.foreachRDD { rdd =>
      val where1 = “执行位置1”
      rdd.foreachPartition { partition =>
        val where2= “执行位置2”
        partition.foreach { record =>
          val where2 = “执行位置3”
        }
    }
}
2）面试：
（1）Scala中以下几个的区别

（2）Spark UDF与 Hive UDF区别
（3）Spark广播出去的信息可以修改吗？比如我广播的是配置信息，怎么改呢。
10.7 学长7
小米金融-平台开发方向

一面问了个算法题，第二面实在没时间推掉了
写算法的时候，最好问下用什么语言实现，比如我现在熟悉python, java反而忘记了好多，我就说用python实现吧

二叉树层级遍历
1
2 3
4 5 6 7
打印：
1
2 3
4 5 6 7

def levelOrder(self, root):
res= []
if not root:
return res
queue = [root]
while queue:
tmp1, tmp2 = [], []
for node in queue:
tmp1.append(node.val)
if node.left:
tmp2.append(node.left)
if node.right:
tmp2.append(node.right)
res.append(tmp1)
queue = tmp2
return res
十一 顺丰面试题
11.1 学长1
第一面是做实时推荐同事，针对项目和知识点来问，特别喜欢问Spark，因为他用Kafka和Spark多，认真准备一下这关好过。
第二面是大数据这块的女总监，光跟你怼Spark，全是细节，细致到你传了那些参数
11.2 学长2
 1）技术部分
（1）Kafka原理，数据怎么平分到消费者
 （2）Flume HDFS Sink小文件处理
 （3）Flink与Spark Streaming的差异，具体效果
 （4）Spark背压机制具体原理实现
（5）Spark执行内存如何分配，执行任务时给多大内存
（6）SparkSQL做了哪些功能
 （7）讲一下Flink
（8）状态编程有哪些应用
（9）端到端exactly-once如何保证
（10）Flink checkpoint机制
（11）Yarn调度策略
2）项目部分
（1）离线指标、数据量、用户量
（2）介绍一下实时项目，哪些指标，怎么算的
（3）SparkStreaming遇到什么问题，如何解决
（4）SparkStreaming实现什么指标，怎么算的
（5）实时当天日活怎么累加
 （6）集群规模
（7）一天的指标会用SparkSQL吗
（8）Spark手动设置偏移量，如果数据处理完后，offset提交失败，造成重复计算怎么办
（9）项目中ES做了哪些工作、ES实现原理、ES倒排索引怎么生成
 （10）任务调度
 （11）讲一下HBase、项目中哪些地方用了HBase、HBase写入流程、不同列族之间文件怎么划分
（12）Kerberos安全认证过程
11.3 学长3
（1）问一下，数仓建模有没有更详细的文档说明？
（2）还有HBase的rowkey在生产环境下怎么设计？HBase三个原则：唯一性、长度原则、散列原则
（3）HBase表做预分区，评估半年到一年的数据量
（4）一年之内不能自动切分 （10g数据）
（5）求出分区数量
（6）最后再设计自己的分区键值 01| 02| 03|
（7）rowkey前缀（分区号） 01_ 02_ 03_
（8）后面拼接常用字段 或者 时间戳
（9）在一个分区内 先查询什么字段，就要把那个字段拼接到前面 分区号_要查询的字段_时间戳（保证唯一性）
十二 OPPO面试题
12.1 学长1
OPPO -实时处理工程师。一面试官陈泉，他拿了多个人的简历，边翻边问。
1）技术部分
（1）SparkStreaming消费方式及区别，Spark读取HDFS的数据流程
（2）Kafka高性能
（3）Hive调优，数据倾斜
（4）Zookeeper怎么避免脑裂，什么是脑裂。
（5）Redis的基本类型，并介绍一下应用场景
（6）最后会问一些Linux常用命令，比如怎么查进程，查IO运行内存等。还真有人问啊
2）项目部分
（1）Hive的分层设计
（2）还有一些Flume和Kafka的问题，为什么要把离线和实时搞在一起，可以做成两套系统。
12.2 学长2
（1）介绍你做的所有项目
（2）在项目中你负责什么
（3）数仓的数据量是多少
（4）MapReduce的Shuffle过程
（5）Spark与Flink的区别
（6）平常会自己去学一些技术吗
（7）你们公司的大数据组的人员配置
（8）你为什么离职
（9）工作中遇到哪些困难
（10）怎么使用Redis实现分布式锁
（11）Zookeeper的HA原理？
（12）两个业务有关联，某个业务的数据量有可能暴增崩溃，怎么保证另外的业务数据不受影响？
（13）MapReduce怎么去实现Hive中的mapjoin?
（14）SparkStreaming中Kafka的offset保存到MySQL中去实现的精准一次性消费，假如业务逻辑处理完，在提交offset时程序崩溃，处理完的数据怎么解决？
12.3 学长3
（1）讲一讲什么是CAP法则？Zookeeper符合了这个法则的哪两个？
（2）你们的Flink怎么提交的？使用的per-job模式吗？为什么使用Yarn-Session的模式？有什么好处？
（3）讲一讲Flink的分界线对齐原理，有什么作用？
（4）了解过Flink的两阶段提交策略吗？讲讲详细过程。如果第一阶段宕机了会怎么办？第二阶段呢？
（5）如果Spark在跑任务的途中，Driver直接挂掉了，但是Executor还在继续跑，你该如何解决这个问题？
（6）如何查看Linux中线程的内存、CPU占用、磁盘的消耗等？具体的参数讲一下
（7）讲讲HFile在HDFS中存储的具体格式
（8）讲一讲Spark和Flink的Checkpoint机制异同
12.4 学长4
中科创达 OPPO外包
通信部门 着重问hive，HQL问题
一直都是我自己说，讲数仓采集和离线数仓搭建
他一直在听，也没什么邪门问题，就是他们组是6个人，
属于通信部门，用google的一个封装好软件，主要就是在SHELL上写HQL，不是核心业务
但是业务逻辑很复杂。表比较多。
12.5 学长5
外包

1. 讲讲flink与spark的区别
2. flink的sql写得多吗
3. 在实时计算中, 如何将实时数据与一张大表join
4. 你是如何通过flink实现uv的
5. flink中的双流join与spark中的双流join
6. 如何做实时TopN
7. 如何通过flink的CEP来实现支付延迟提醒
8. flink端到端精准一次的实现过程
9. flink的checkpoint文件是保存在哪里, 可以选择哪些
10. flink中你最常用的算子有哪些
    数仓
11. 数仓分层
12. 数仓建模
13. hive与mysql的区别
14. hive中发生数据倾斜怎么处理
    十三 VIVO面试题
    13.1 学长1
    面试的数仓岗
    1、一面
    1）项目部分
    （1）大概介绍一下你之前的工作
    （2）做过哪些指标，怎么实现的(说出去的指标一定要会写SQL，会一个个问你怎么实现的）
    （3）有没有做过留存用户，比如一个月，1到30天的留存用户
    （4）Hive优化
    （5）统计一个月内，连续登陆7天用户
     2）情景部分
    现场出了个SQL题
    uid event dt
    1 点击 t1
    2 收藏 t2
    … … …
     统计会话Session ：同一个用户事件时间间隔小于1分钟，算一次会话
    2、二面
     1）项目部分
    （1）从数据源头开始问
    （2）你们的数据源是什么，怎么埋点的，数据的格式是怎么样的
    （3）是一次点击生成一个日志？，事件日志为什么会出现套Json
    （4）启动日志和行为日志是怎么区分的
    （5）多次点击是算一个事件还是多个，比如多次点赞，有没有做过类似点击次数的统计，你通过这个日志做了哪些指标，
    （6）除了用户方面的，事件类的指标做过哪些，这些指标是怎么做的
    （7）工作中有什么指标很难的，怎么实现的
      2）总结
    VIVO，好像会根据你的简历侧重，分配岗位，实时或者数仓，做好准备吧，骚年
    13.2 学长2
    面试Spark开发岗。大家如果有去VIVO的，一定要把简历上写到的知识点都搞懂。面试官是带着你的简历过来的，他事先有分析过你的简历。
     1）项目部分
    （1）先介绍你的项目，我介绍采集平台，刚说到Kafka。问双层Flume，第二层Flume怎么对日志类型分类，分多少个类。如果一层Flume新增了一个Topic，怎么处理。
    （2）Hive表中的每层的血缘关系怎么查询
    （3）每天业务量，问简历上的指标是怎么做的。
    （4）Hive中用什么写SQL，Hue。
    （5）case class和class的区别
    （6）SparkStreaming精准一次性消费，会问到你们用的什么版本的Kafka和SparkStreaming 。然后就是根据版本，这里offset的问题会展开详聊。
    （7）写了Redis缓存，会问你缓存机制。
    （8）写了Hive配置MySQL高可用，会问你怎么配置的。
    13.3 学长3 VIVO外包

13.4 学长4
忘记录音了，能记起来这几个不太常规的，大家分享分享见解，其他的问题还比较常规
（1）想要考察我Java基础，但是说了用的Scala，他就虐我Scala了
（2）Scala创建多线程的方式？
（3）Scala闭包的概念、应用？
（4）Spark并行度由什么决定的，引导我好久，我的回答他都不满意。。。
（5）blackmanager是什么？
（6）Flink实现实时uv统计怎么实现，全流程代码解析包括数据读取算子使用这种
（7）Flink有哪几种窗口（5种），分别是什么
（8）想考察我flinksql但是没用，就考察了几个hiveSQL，比较常规
13.5 学长5
vivo(外包 1面 & 2面)
（1）SparkStreaming稳定性的确保
（2）Spark OOM的本质。
可能是从两方面：map执行时oom，shuffle后oom
参考：https://www.cnblogs.com/jiangxiaoxian/p/7442022.html
（3）你了解ES的分页吗？一般到一千页后，就会很慢，怎么解决？
了解，我们公司没有一千页的数据，没操作过。
13.6 学长6
（1）生产环境中谁提需求，谁验收数据，具体的业务需求流程是什么样的？
（2）曝光量有多少、
（3）实时计算男女比例和年龄比例有什么用，这种指标用离线计算一天统计一次不是更好吗？
（4）实时统计热门商品topN的意义在哪里呢？
（5）类加载器的种类，有什么机制，机制有何用处
（6）垃圾回收g1和cms怎么选择
（7）flink的精准一次消费
（8）flink的五种窗口
13.7 学长7-外包
1）1面：
（1）给了任务指标，不知道表的结构的情况下，如何进行分析，解决
（2）你们数仓怎么怎么建模的，举一个具体指标说明一下？
2）2面：
（1）给了很多指标，很相似，很多任务，如何做一个有效率的管理这些指标
13.8 学长8-AI项目外包
（1）数仓中分了哪些主题?
（2）请谈谈你对数仓的理解，它有什么优势？
（3）如果让你来设计数仓，你有什么思路？为什么这样做？
（4）谈谈你对sparkstreaming的理解，对spark的理解，对hive的理解
13.9法本信息，vivo外包
（1）你说开启mapjoin,怎么确定小表小于32M。
（2）你用UDF函数解析公共字段，要是海量数据怎么处理。
（3）Spark手动提交offset，怎么实现精准一次性。手动维护偏移量 保证数据不丢数，提交偏移量代码跟业务处理代码写到一个事务里面去
（4）spark中，大表join大表怎么优化的。 广播join
（5）怎么确定的维度表，要是后期业务增加了怎么办。

十四 华为面试题
14.1 学长1
1）华为非外包岗位，比较看重学历，要求985，如果学历过了，技术基本不怎么卡。
2）外包总部d1区：
（1）namenode内存满了，如何进行扩容，调什么参数。
（2）linux命令怎么查看mr任务的jobid
（3）kafka消费者消费数据的流程，细节到进程和线程这一层。
（4）生产中遇到过哪些OM的情况，怎么解决
（5）namenode设置多目录，在哪个配置文件里面设置，设置哪个参数？
14.2 学长2
介绍一下最近做了两个项目，你主要做了什么？
回答：回答了实时的组件和离线的组件，自己主要负责hql和sql的指标书写
14.3 华为-西安
（1）数据分析怎样呈现
（2）什么样的报表 具体到指标
（3）hdfs用开源的还是别的公司
（4）平台监控用什么 开源的还是其他的
（5）服务器规模有多大
（6）离线数仓负责什么
（7）实时项目介绍
（8）sparkstreaming和flink有什么差异
（9）有没有接触过EE的项目
（10）hive实现原理
（11）hive元数据管理 hive有两个进程 你了解吗
（12）hbase和hvie有什么区别 使用场景有什么区别
（13）实时项目redis在做什么 哪个进程在访问redis
14.4 华为外包 智慧园区项目
软通动力 华为外包面试题
flink 维表关联怎么做的（应该是开发必做，建议提前准备）
https://blog.csdn.net/u012554509/article/details/100533749
redis 支持的数据类型
flink支持的数据类型
flink 数据倾斜是怎么解决的
checkpoint 大小 多少， 怎么监控的
flink CEP 案例
flink 用 rocksDB 状态后端会有什么bug（）？
14.4 华为，吉贝克 面试题
1.spark内存管理
2.hive分区表中，单值分区和范围分区的区别
3.你们公司执行spark任务时，资源怎么设置的（需要直接说出来）
4.介绍一下kafka水位线（其实就是leo和Hw）
5.说几个指标，分别从什么数据层拿取了数据，需要直接说出来
6.数仓采用了什么模型？为什么？
7.hive分区表，单值分区和范围分区的区别
8.spark任务切分，怎么判断有没有执行shuffle
9.你们公司拉链表都有什么字段，拉链表出错怎么办
10.列举几张表的同步策略
11.flink Sql 了解吗
十五 boss直聘面试题
1）技术部分
（1）hadoop二次排序
（2）小表关联大表怎么实现的|切片，shuffle，reduce阶段，map阶段，Yarn流程
（3）combiner使用场景 | 环形缓冲区为什么是环形的 | ETL细节| reduce阶段是怎么下载到本地
（4）hadoop 实现TopN
（5）kvBuffer
（6）说一下你了解的JVM模型算法。为什么要使用复制算法(优势，劣势) 怎么查看full gc日志出现的问题。什么时候发生full Gc。栈存储索引的大小。如何查看当前进程的GC
（7）full GC和old GC区别
（8）javaEE说一下你擅长的框架
2）算法部分
（1）sort快排手写
（2）io模式 算法
（3）设计模式：单例模式、工厂、代理，代理与装饰模式区别，适用场景以及理解
（4）手写：冒泡、二分法
3）项目部分
（1）你的项目的亮点
十六 搜狗金融面试题
在茶水间面试，有很多求职者，都是一对一，并且不同面试官很可能是不同的大数据方向
1）技术部分
（1）RDD是什么？
（2）MySQL的索引如何理解？常用引擎是什么？有什么区别？比较Redis和MySQL的区别？说一下各自的持久化机制…
2）项目部分
（1）Kafka的offset、Flume的组成，项目中为什么用了两层？如何实时统计pv和uv？
（2）给定一款产品，如何评价它的性能？
（3）对于自己统计出来的结果，如何评价结果的正确性？
（4）介绍主要的业务线，现在有没有offer，职业规划是什么，对加班的看法，是否能接受数仓的工作…
3）手写部分
（1）手写代码1：将两个无序数组合并，并保证合并后的数组有序，不允许用Arrays的方法
（2）手写代码2：手写WordCount，然后比较Flatmap和Map的区别、groupByKey和reduceByKey的区别
（3）手写HQL：给定两个表，查找a中有，但是b中没有的元素
（select * from a left join b on a.id=b.id where b.id is null）
说明上述方式产生了几个job？
4）算法部分
（1）将一个栈变成一个队列，至少用几个栈？
5）感受部分
面试大约2个小时，最后面试官介绍业务时才知道主要是做数仓，并且他问的这些问题，除了项目和后面的产品相关内容，基本上每一个问题都会落到数据结构上（RDD、索引、栈、队列、包括groupByKey和reduceByKey…）
十七 瓜子二手车面试题
 1）技术部分
（1）优化必问 hive/spark
（2）为什么kafka可以实现高吞吐？单节点kafka的吞吐量也比其他消息队列大，为什么？
（3）如果写了JVM调优：堆内存溢出如何查看解决，用的那些命令工具；CMS和G1有什么不同？
（4）Hive自定义那些UDF函数
（5）Spark那些算子是在map端聚合的
（6）Kafka的偏移量offset存放在哪儿，为什么？
（7）Linux命令 查看内存、磁盘、IO、端口、进程
2）算法部分
（1）链表转置/二叉树转置
3）情景部分
（1）一个字符串"jasonbbtomccjackddfftomkk"，如果相邻两个字符相同视为一个切分点，实现WordCount(注意会有多个连续相同的情况如aabbccdd，还有要问清出现三个或者多个怎么算)
十八 猎豹移动面试题
1）技术部分
（1）对Java的理解
（2）Java线程的理解
（3）对池的了解（线程池、数据库连接池），Java线程池是怎么实现的，Java线程池都有哪些组件，具体作用是什么
（4）对Spring框架的理解
（5）WebServer端收集的日志放在哪里
2）项目部分
（1）介绍下项目，项目中用的那些技术点
3）手写部分
（1）手绘Hadoop架构
十九 作业盒子面试题
1）手写部分
（1）写一个SQL将每个月的Top3 取出来 我用了三个子查询做出来不行
2）项目部分
（1）讲一下最近做的项目
（2）还有项目的Session字段
（3）项目中的如何分辨数据（错误日志，正确日志）
（4）Hive中的表的创建（项目中的表如何构建，创建的字段的组成）
（5）Hive的优化，MySQL的优化
（6）Scala算子的实际用法，场景
二十 每日优鲜
数仓岗
1）项目部分
（1）为什么用双层Flume
（2）日志标准化在哪里做最好
（3）Hive海量数据（一个分区）怎么导入MySQL
（4）遇到过那些坑，自己认为做过有价值的地方
（5）MapReduce
（6）怎样可以让运维自己做查询
二十一 美团面试要求
1）技术部分
（1）HDFS架构理解（基础）
（2）HDFS源码/工作原理（高级）
（3）MapReduce架构理解（基础）
（4）MapReduce源码/工作原理/Shuffle原理（高级）
（5）MapReduce二次排序（编程，必选）
（6）YARN架构理解（基础）
（7）YARN源码/工作原理（高级）
（8）HBase架构理解（基础）
（9）HBase源码/工作原理（高级）
（10）HBase性能优化（高级）
（11）Hive原理理解（基础）
（12）Hive性能优化（高级）
（13）Flume架构理解（可选）
（14）Kafka架构理解（可选）
（15）Spark RDD理解（基础）
（16）Spark reduceByKey与groupByKey区别（基础）
（17）Spark Broadcast与Accumulator功能（基础）
（18）Spark工作原理（高级）
（19）Spark Shuffle原理（高级）
（20）Spark源码理解/贡献（高级）
（21）Spark性能优化/数据倾斜（高级）
2）项目部分
2.1）数仓理论
（1）数据仓库分层架构（初级）
（2）事实表与维度表（初级）
（3）星型模型与雪花模型 （初级）
（4）日增量表与日全量表 （初级）
（5）拉链表 (初级)
（6）缓慢变化维 （初级）
（7）两种建模理论（初级）
（8）data-vault理论（高级）
2.2）数仓周边系统
（1）血缘关系
（2）调度系统
（3）展示，olap（kylin）
（4）指标管理
（5）数据质量管理 （高级）
（6）元数据管理，调度系统元数据，任务运行数据，表存储数据，数据字典等
3）手写SQL部分
（1）点：窗口函数，行列转换，聚合函数
加一点复杂的：collect_set，split，case when，聚合函数，union等
（2）函数考察
eg: rank, dense_rank, row_number区别 （基础）
行列转换 （基础）
sort by，distribute by，order by，clustered by区别
（3）3个表关联，写下大概的mr过程 (中级)
（4）去重，2个写法的区别:
select count(distinct id) from t1;
select count(1) from ( select id from t1 group by id) a (高级)
（5）map join 原理 （基础）
（6）bloom filter去重，原理(高级)
（7）hive tunning
4）场景部分
（1）Job，Reduce长时间百分之99；
（2）Reduce的3个阶段，Reduce百分之90+，又降下去，反复几次
（3）Map一直百分之90多，之后报错
21.1 学长1
上海科锐国际外派美团点评
1）面试前HR给的重点
（1）SQL要强；
（2）分层是否有参与；
（3）熟悉哪些框架；
（4）项目的数据量有多少；
（5）调度工具用到哪些；
（6）数据源在哪里；
（7）数据可视化怎么做；
（8）跟Java怎么对接；
（9）面试官还会现场出一些题目，现场做
2）一面：
（1）问Spark，Flink优劣势，
（2）Flink如何处理乱序数据，
（3）Flink内存溢出怎么办，
（4）Flink有没有试过优化，
（5）Flink精准一次消费，
（6）建模理论，用过什么模型，雪花和星型的分别解决什么问题。
（7）用过什么工具进行数据迁移，导入导出。
（8）数仓大体干了什么，自己做了哪些指标，
（9）SQL题：用Hive解析Json字符串 或者 七天连续登陆用户
3）二面：
基本情况：去了是帮美团点评做和银行对接的数据仓库，数据量大，面试是完全和美团点评面试，签合同是和科瑞国际签约。
（听内部消息说尚大好像已经进去了两个，目前HR说还缺两个数据开发岗位）
21.2 学长2
美团金融

第一轮：
输入: 表T(user_id, timestamp), 用户在某一页面的所有曝光历史记录
输出: 2020年1月份1~31日，指标: 首次曝光用户数量，次1-7日留存用户数量

select t1.min_visit_date
,sum(if(t1.min_visit_date == t2.visit_date, 1, 0)) as base_count
,sum(if(datediff(t2.visit_date, t1.min_visit_date) = 1, 1, 0)) as liucun_day01
,sum(if(datediff(t2.visit_date, t1.min_visit_date) = 2, 1, 0)) as liucun_day02
,sum(if(datediff(t2.visit_date, t1.min_visit_date) = 3, 1, 0)) as liucun_day03
,sum(if(datediff(t2.visit_date, t1.min_visit_date) = 4, 1, 0)) as liucun_day04
,sum(if(datediff(t2.visit_date, t1.min_visit_date) = 5, 1, 0)) as liucun_day05
,sum(if(datediff(t2.visit_date, t1.min_visit_date) = 6, 1, 0)) as liucun_day06
,sum(if(datediff(t2.visit_date, t1.min_visit_date) = 7, 1, 0)) as liucun_day07
from (
select user_id
,min(to_date(timestamp)) as min_visit_date
from visit_info
group by user_id
having min_visit_date >= ‘2020-01-01’ and min_visit_date <= ‘2020-01-31’
) t1
left join (
select user_id
,to_date(timestamp) as visit_date
from visit_info
where to_date(timestamp) >= ‘2020-01-01’
group by user_id, to_date(timestamp) – 去重
) t2 on t1.user_id = t2.user_id
group by t1.min_visit_date;

第二轮

求：每个uid上一笔成功订单id，没有的记录为null，
状态值：1-成功 0-失败

id time uid is_suc 结果列[最终展示结果]
1 2020-01-01 1 1 Null
2 2020-01-02 1 0 1
3 2020-01-03 1 0 1
4 2020-01-04 1 1 1
5 2020-01-05 1 0 4
6 2020-01-06 2 0 Null
7 2020-01-07 2 1 Null
8 2020-01-08 2 0 7

我开始理解错题目了。我以为求上一个正确的状态值

实际上计算的是上一个状态是正确的id，还要面试给过了

drop table visit_info;
create table visit_info
as
select 1 as id, ‘2020-01-01’ as visit_date, ‘1’ as user_id, 1 as is_suc
union all
select 2 as id, ‘2020-01-02’ as visit_date, ‘1’ as user_id, 0 as is_suc
union all
select 3 as id, ‘2020-01-03’ as visit_date, ‘1’ as user_id, 0 as is_suc
union all
select 4 as id, ‘2020-01-04’ as visit_date, ‘1’ as user_id, 1 as is_suc
union all
select 5 as id, ‘2020-01-05’ as visit_date, ‘1’ as user_id, 0 as is_suc
union all
select 6 as id, ‘2020-01-06’ as visit_date, ‘2’ as user_id, 0 as is_suc
union all
select 7 as id, ‘2020-01-07’ as visit_date, ‘2’ as user_id, 1 as is_suc
union all
select 8 as id, ‘2020-01-08’ as visit_date, ‘2’ as user_id, 0 as is_suc
;

select t1.id
,t1.visit_date
,t1.user_id
,t1.is_suc
,max(if(datediff(t1.visit_date, t2.visit_date) <= 0, Null, t2.id)) as result_flag
from visit_info t1
left join (
select id
,visit_date
,user_id
from visit_info
where is_suc = 1
) t2 on t1.user_id = t2.user_id
group by t1.id ,t1.visit_date,t1.user_id,t1.is_suc
;

t1.id t1.visit_date t1.user_id t1.is_suc result_flag
1 2020-01-01 1 1 NULL
2 2020-01-02 1 0 1
3 2020-01-03 1 0 1
4 2020-01-04 1 1 1
5 2020-01-05 1 0 4
6 2020-01-06 2 0 NULL
7 2020-01-07 2 1 NULL
8 2020-01-08 2 0 7

第三轮:
确定是 技术面
面试官有点奇怪，开头就问为啥没考研，大四实习了吗？成绩很差吗？
什么专业？为什么学习java? 为什么又做大数据开发？为什么在某个公司要离职？
基本没问什么项目, 我尽量回答，最后问了HR 说沟通下，后续有其他部门的offer，就不管这个部门了, 应该是三面挂了
21.3 学长3
美团bp数据中心
一轮说自己写个top10
写完了说有啥问题吗？
我说挺好的？
row_number 如果order by 多个字段一样有问题吗？
然后就解释了一波 row_number, rank, dense_rank的区别

第2轮没有写sql, 问的都是项目内容
21.4 学长4
美团财务集市的面试题

第一轮
面试官不怎么问sql, 就说咱们随便来一个吧

dptid, user_id, age
求每个部门年龄的top10

第二轮，第三轮
也没写sql，面试官问的原理大部分都是基础的东西，觉得我准备的很充足，表达的欲望就是想要你，虽然方向不偏向数仓

第四轮交叉面
应该是个大佬，据说交叉面是定级的
面试偏向于管理方向，比如给你一个团队，你怎么带？怎么安排，我坦诚没带过，然后就回复 假如让你带，你构思下？
最后面试过了，因为选择了其他部门，这个就没进行HR面
21.5 学长5
美团外卖

第一轮：

create table if not exists tmpA(
wm_order_id bigint comment ‘订单id’,
wm_poi_id bigint comment ‘商家id’,
userid string comment ‘用户id’,
month string comment ‘月份，格式：yyyyMM’,
actual_amt double comment ‘实付金额’,
dt string comment ‘日期，格式：yyyyMMdd’
)
row format delimited fields terminated by “,”;

1.统计每月支付额排名前3的用户清单
2.展示每个用户每月的最大实付金额和截止到该月的总实付金额

– 1.统计每月支付额排名前3的用户清单
select month
,useid
,actual_amt
,rn
from (
select month
,useid
,actual_amt
,row_number()over(partition by month order by actual_amt desc) as rn
from (
select month
,useid
,sum(actual_amt) as actual_amt
from tmpA
group by month, userid
) t
) t
where rn <= 3
;

– 2. 展示每个用户每月的最大实付金额和截止到该月的总实付金额

select useid
,month
,max(month_max_actual_amt) as month_max_actual_amt
,max(total_actual_amt) as total_actual_amt
from (
select month
,useid
,max(actual_amt)over(partition by month, useid) as month_max_actual_amt
,sum(actual_amt)over(partition by useid order by month) as total_actual_amt
from tmpA
) t
group by month, useid
;

第二轮:

有个table 有两个字段 dt(yyyyMMdd), jieqi(内容为汉字 比如 立春, 小寒 记录每年农历的24节气)
表中记录了5年的数据
求: 增加一个season列，比如 春，夏，秋，冬，可以根据 立春 和 立夏 之间划分 春 诸如此类的划分；

展示行效果如下

dt jieqi season
2020xxxx 立春 春

select t1.dt
,t1.jieqi
,t2.season
from info t1
left join (
select dt
,jieqi
,season
,lead(dt, 1, ‘99991231’) over(order by dt) as next_dt
from (
select dt
,jieqi
,case when jieqi = ‘立春’ then ‘春’
when jieqi = ‘立夏’ then ‘夏’
when jieqi = ‘立秋’ then ‘秋’
else ‘冬’ end as season
from info
where jieqi in (‘立春’,‘立夏’,‘立秋’,‘立冬’)
) t
) t2
where t1.dt >= t2.dt and t1.dt < t2.next_dt

二面偏向java,问了一些java的
比如list, set, map的理解
并发容器CopyWriteArrayList的原理，又延伸了下 mysql数据的读写锁是怎么回事？写的时候，如何读的？
sql注入怎么理解的？
能否写个3个线程交替打印的代码？

回答的很不好，还是给过了

第三轮:

tord表: 字段为 ord_id, ord_time, usr_id, dt
增量存储的交易记录表，记录每个月新增用户首单在未来30天的复购交易额；

展示字段: 统计月, 复购交易金额

比如 求 7月份的时候，7月1号新增的，求 2~31号的，2号新增的求 3~8-1号的

insert into table order_amt_info partition (dt)
select substr(t1.min_info.col1,1,7) as report_month
,sum(t2.amt) as amt
,substr(t1.min_info.col1,1,7) as dt
from (
select usr_id
,min(struct(min_ord_time, ord_id)) as min_info
from tord
group by usr_id
having min_ord_time >= ‘2020-07-01’ and min_ord_time <= ‘2020-07-31’
) t1
left join (
select ord_id
,to_date(ord_time) as ord_time
,usr_id
,amt
from tord
where dt >= ‘2020-07-01’
) t2 on t1.usr_id = t2.usr_id and t1.min_info.col2 = t2.ord_id
where datediff(t2.ord_time, t1.min_ord_time) >= 1
and datediff(t2.ord_time, t1.min_ord_time) <= 30
group by substr(t1.min_ord_time,1,7)

第三题的衍生发问

延伸题目
从上述的表中构建一个 增量表 记录
fusr: user_id, f_ord_time, dt - 增量的分区，每个分区存当日首购用户

延伸题目
fusr: user_id, f_ord_time,f_ord_amt, dt - 增量的分区，每个分区存当日首购用户以及首单的金额

初始化全量的 收购用户

insert into table order_amt_info partition (dt)
select user_id
,to_date(min_info.col1) as f_ord_time
,min_info.col2 as f_ord_amt
,to_date(min_info.col1) as dt
from (
select user_id
,min(struct(ord_time, amt)) as min_info
from tord
where dt < ‘2020-07-01’
group by user_id
) t

构建后续的每日增量数据

insert into table order_amt_info partition (dt=’${}^{\prime })selectt1.use{r}_{i}d,t{o}_{d}ate(t1.mi{n}_{i}nfo.col1)as{f}_{o}r{d}_{t}ime,t1.mi{n}_{i}nfo.col2as{f}_{o}r{d}_{a}mtfrom(selectuse{r}_{i}d,min(struct(or{d}_{t}ime,amt))asmi{n}_{i}nfofromtordwheredt{=}^{\prime }${}’
group by user_id
) t1
left join (
select user_id
from order_amt_info
where dt < ‘${}’
) t2 on t1.user_id = t2.user_id
where t2.user_id is null
;

继续延伸
用户im： 用户发起会话数，用户参与会话数，用户发起消息数，用户参与消息数，发起会话用户数，参与会话用户数
log：misid，sentid，reid，mis_time，dt
dim：uid，idtype（poi，usr，dlvr）
模型设计 - 出一张公共表：

按照自己的思路展开就好，不是sql题目

HR面
美团面试感觉特别耽搁时间，某天下午直接面了1-3轮，然后第二天HR面，之后等了3天，说面试过了，简单说了下基本工资和期望薪资
然后提交了流水

之后又增了7天，微信问了HR, 反馈面试通过，晚上谈了具体薪资，然后隔了两天再沟通，反馈offer已经审批通过，然后现在还没发offer, 还在等
二十二 快手面试题
22.1 学长1
快手：视频面试
1）一面:50分钟
（1）介绍项目
（2）Flink为什么用aggregate()不用process()
（3）自定义UDF,UDTF实现步骤，有哪些方法？UDTF中的ObjectInspector了解吗？
（4）Flume丢不丢数据？PUT,TAKE事务
（5）SQL题:

1. id department salary manager_id 找出员工薪水比领导薪水高的人员（单表join）
   2. student course score 找出哪些学生课程比平均课程成绩高？（记不太清了，用到子查询）
      （6）快手的数仓分了3层，OLAP用的是Druid,数据量每天达到PB级，上千个指标，平均每个人跑几百个指标吧。
      2）二面：1小时
      （1）手撕SQL
      ①A-天极增量表： uid,module_name,location,date
      目标-B全量表： uid,module_name,first_entry_date,first_location
      找出两个第一次插入到B表
      ②user:uid,age,date
      order:order_id,order_money,location,date，其中location:{“city”,“xx”}
      双十一场景，找出北京市双十一年龄范围在20-25岁的人中 的人数，人均销售额大于1000的人
      ③URL: http://www.a.com/home?key1=v1&key2=v2 ？后面的数据做切分，存放到一个JSON中返回，要求用UDF函数
      ④找出一个List中的最大值和最小值并返回
      （2）问到了几个场景题
      ①Flink设计题
      ②HBase使用场景
      ③Redis使用场景
      ④Druid的一些东西
      （3）最后问到了职业规划，闲聊
      22.2 学长2
      1）技术
      （1）自我介绍
      （2）问了下离线数仓的架构
      （3）问了Hive四层架构
      （4）问了业务系统8张表的更新方式

2）场景题：
（1）使用SQL或者SparkRdd写出代码

（2）两张表，怎么使用SparkRDD的方式实现Join，代码
Table1
uid，dept_id
Table2
dept_id,dept_name
（3）使用MR或者Spark实现countDistinct（例如求uid数量）
22.3 学长3
现有一个用户活跃表user_active、用户注册表user_regist，
表中分区字段都为p_date（yyyy-MM-dd），用户字段均为user_id；
设计一张1-180天注册活跃留存表；

select regist_date
,date_diff
,user_count/regist_count as rate
from (
select t1.regist_date
,max(t1.regist_count) as regist_count
,datediff(t2.active_date, t1.regist_date) as date_diff
,count() as user_count
from (
select user_id
,regist_date
,count() over(partition by regist_date) as regist_count
from user_regist
where dt >= date_sub(current_date(), 180)
) t1
left join (
select user_id
,to_date(active_date) as active_date
from user_active
where dt >= date_sub(current_date(), 180)
group by user_id, to_date(active_date)
) t2 on t1.user_id = t2.user_id
where datediff(t2.active_date, t1.regist_date) >=1
and datediff(t2.active_date, t1.regist_date) <= 180
group by t1.regist_date, datediff(t2.active_date, t1.regist_date)
) t

二面 下周1

– 统计面试几个人，多长时间 ,
– 日志表
– 点击开始面试 emp_id, user_id, session_id ,click_time
– 点击关闭 emp_id, user_id, session_id ,click_time -一次会话
– 计算： 点击会出现重复数据, 会有多个点击 点击时间会不一样，求最后一个时间
– 关闭的时候，第一个点击时间
– 每个面试官，每天 多长时间面试

select t1.dt as report_date
,t1.emp_id
,sum(unix_timestamp(t2.max_click_time, ‘yyyy-MM-dd HH:mm:ss’) -
unix_timestamp(t1.min_click_time, ‘yyyy-MM-dd HH:mm:ss’)) as inv_time
from (
select dt
,emp_id
,session_id
,max(click_time) as min_click_time
from start_log
group by dt, emp_id, session_id
) t1
left join (
select dt
,emp_id
,session_id
,min(click_time) as max_click_time
from end_log
group by dt, emp_id, session_id
) t2 on t1.dt = t2.dt and t1.emp_id = t2.emp_id and t1.session_id = t2.session_id
group by t1.dt, t1.emp_id

面试官描述，我提醒下，先问清楚我需求，一旦你开始写，就不要问我了？
然后我简单问了个问题？
最后面试官说，有个主意事项的，同一个session_id可能对应多个user_id， 因此需要按照人员进行划分，
我表示，我以为每次个用户只有唯一的session_id会话id

三面 本周3
主要问的都是围绕着从业经历，从java到大数据的原因
目前项目的架构，自己做的什么东西，
数据质量有接触吗？怎么理解的
零零碎碎的面试的都是些 类似宏观上的东西，也没问什么废话
二十三 新美互通面试题
（1）简单的自我介绍一下？
（2）用的什么架构？都用了哪些件？
（3）Flume你了解得多吗？
（4）是你来维护Flume吗？
（5）面试官：我们公司没用过Flume，以后的话可能会用到，有这个计划。
（6）为什么前面Flume不直接到HDFS上，中间要用Kafka呢？
（7）原始文件在HDFS上，那数据应该清洗格式化之后才能放到Hive吧？
（8）中间是写的MR吗？
（9）HBase一般放什么数据？
（10）整个流程都是你一个人维护吗？
（11）你们的数据量是多大？
（12）HDFS的集群的物理机有多大？
（13）面试官：我们不做国内的数据，做国外的数据。
（14）你有没有做过数据计算方面的任务，统计方面的任务，自己去调研自己的数据是否合理类似于这种计算？
（15）计算资源不够的问题？
（16）Spark计算写的多吗？
（17）你代码写的多吗？还是主要写SQL？还是写脚本？
（18）你为什么离职呢？
（19）你对下一份工作有什么要求吗？
二十四 金山云面试题
24.1 学长1
1）基本介绍
金山云2.21号下午4点：电话面试
部门主要是做数据平台，二次开发改源代码
面试时长：1小时
2）技术部分：
（1）HashMap，HashTable，ConcurrentHashMap区别，HashMap扩容；注解的使用和内部原理
（2）Spark 任务划分，Job提交流程；
（3）根据进程名杀死进程；查看端口号占用情况；
（4）Flume如何保证数据不丢；TailDir如何保证数据完整性；记不清了，是读取一个Postion
（5）Flink如何保证exactly-once语义； Flink和Spark的区别；
（6）Kylin和Druid的使用场景和原理；CDH集群监控相关问题；
（7）介绍调节Kafka速率和开启背压机制；广播变量原理；项目性能调优（调参一直被怼）；一些集群部署的事情
（8）JVM的参数调优；GC种类和算法（讲讲标记-清除原理）；
（9）两个数组找出中位数；两个线程交替打印递增自然数；
3）金山云2.25号上午11点：电话面试
（1）介绍一个最擅长得项目，用到哪些大数据组件
（2）用Azkaban和其他调度工具的优劣，如何保证某个job挂掉后断点继续跑任务？
（3）Spark用过的算子
（4）Presto了解吗？
（5）HashMap和HashTable的区别？ConcurrentHashMap了解多少？一面和二面都被问到
（6）对网络编程，NIO,BIO等并发相关的理解。
（7）八个硬币找出最重的(分两组二分查找)
（8）一个N阶楼梯，可以步长为1/2的走，有多少种走法？(斐波那契数列)
二十五 图新瀚合面试题
（1）Linux的操作指令，问的比较多，都是比较难记的
（2）Shell脚本，bash的含义，以及简单的说自己写过的脚本
（3）离线实时部分，偏简历的项目，主要讲述自己做的部分，
（4）Spark参与过的调优，运行模式，与Flink的对比，Flink的WaterMark机制和状态一致性
二十六 神州数码（北京）
（1）Kafka如何进行压测
（2）服务器的选型和配置以及集群的分布，用的什么样的阿里云服务器？ 128g
（3）数仓的分层介绍
（4）介绍集群框架，框架版本
二十七 清华同方面试题
（1）公司的集群架构，每台部署了什么东西
（2）公司的数据量，离线数据仓库每层的数据量有多大
（3）关于Hadoop相关的调优
（4）Kafka Manager
（5）Azkaban任务的调度，每天多少指标等等
（6）数据仓库每层都报村的是什么数据，如何存储，存储到哪
（7）数据治理，我就简单的说了一下格里芬
（8）剩下的就是简历上的业务，偏离线，讲逻辑和实现过程
二十八 柠檬微趣面试题
（1）Scala语言的特质,闭包,模式匹配，变量，抽象
（2）Spark的rdd的特点
（3）精准一次性消费如何实现，如何手动维护
（4）为什么选用direct，以及他的并行度是怎么回事
（5）场景题，如何在大量数据中快速抓取某类数据
（6）算法加数据结构加链表，没整理，听不懂也答不上来
二十九 量化派面试题
29.1 学长1
1）基本信息
1月9号:
面试地点：互联网金融中心-11层量化派，金融公司。
面试时长：约2个半小时
面试次数：5次
2）一面：（30分钟）
（1）Spark Core内容。
（2）RDD的容错性，窄依赖，宽依赖怎么进行容错。
（3）RDD的数据从哪来？RDD的五个特性（说不上来）
（4）Partitioner的几个：hash和ranger？？？
（5）说说Hbase的架构
（6）手写代码：二分查找
（7）Java基础：
List：ArrayList,LinkedList
List调用add方法后发生了什么？满了后怎么扩容？
Map：HashMap和TreeMap区别
红黑树底层（不会）
快排，二分以及复杂度
（8）OLAP 是否用过这个：doris
（9）数据一致性
3）二面：大数据老大（1个小时左右）
（1）OLAP中Presto和Druid，Impala区别等问题
（2）数仓的整个过程，每层的细节
（3）实时的指标一些细节
（4）HBase设计原则
（5）HBase场景题
（6）手写代码的环节：单例模式
（7）中序非递归遍历二叉树（只会写递归），我写了递归
4）三面： 应该是个小主管，聊人生（20分钟）
1月15日量化派复试：
5）四面： 技术负责人（35分钟）
（1）问了一些flink和spark,分析Spark TOPN复杂度问题 答得不好
（2）元数据管理和数据治理
6）五面hr（20分钟）：
质疑工作经历，问的很细，一周内等消息（没等到）
29.2 学长2
1）笔试题
（1）用Java写出单例模式（多种方法加分）
（2）写一种常见的排序算法并分析时间复杂度
（3）输入字符串输出判断输入是否是一个数字
例如：3.5->true
Ooo->false;
（4）文本文件Filef里面存放公司各个部门人员的工资明细 数据格式如下：
DeptId name salary
1001 张三01 2000
1002 李四02 2500
1003 张三05 3000
1002 王五01 2600
用Java程序写出各个部门的平均工资并倒序输出
2）面试
（1）udf的种类
（2）reduceByKey和groupByKey的区别
（3）spark的job的提交，处理过程
（4）sparkStreaming UpdateStateByKey底层是如何实现保存数据原来的状态的
（5）还有一些关于你项目的具体问题
（6）你是如何实现flume数据传输的监控的
（7）给你一个数组里面有奇数、偶数，写一个算法实现奇数全在最左侧偶数，全在最右侧

写一个算法实现一个二叉树的各层节点的个数
三十 天阳科技面试题
（1）HashMap和Hashtable区别
（2）Kafka会不会丢失数据
（3）工作中每天都做些什么
（4）在工作中遇到过什么问题
（5）SparkSQL如何调优
（6）简述Flink watermark概念
三十一 泰康保险面试题
13.1 学长1
（1）先做一下自我介绍
（2）你负责那些项目
（3）说自己的项目经历
（4）你对公司的了解
13.1 学长2
（1）之前用Spark Streaming后来为什么用Flink
（2）解释一下Flink的水位线，多流Join水位线怎么确定
（3）Flink的Cep
（4）Flink的Join类算子有哪些，Flink流处理怎么实现两个流的Join的
（5）Flink的重启策略
（6）Flink1.10有没有关注，哪些点你比较关注
（7）Flink用Scala写？你Java是不是不熟
（8）Spark的Join算子有哪些
（9）kafka producer产生数据的流程， 数据顺序怎么保证，场景：要保证一个人的所有信息有序，怎么做
（10）Kafka的ack
（11）flume的拦截器做了什么
（12）HBase读写流程
（13）awk -F的作用
（14）Linux 的inode干嘛用的
三十二 软通动力面试题
（1）都用过哪些技术？
（2）会用Linux吗？我说会用但太底层的没多大研究，只是一些日常的操作，那问几个常用命令
（3）Hive优化
（4）Sqoop优化
（5）Sqoop在导入数据的时候数据倾斜
（6）每天sqoop跑多大的数据量
（7）数据采集架构
（8）Hive常用文件格式介绍一下Orc和Parquet
（9）都分析过哪些指标
（10）Java的一些操作，我说我们公司java开发不是我负责的，掌握的只是一些基础，没有像java程序员那样研究的那么透彻
三十三 乐元素面试题
1）第一面：
（1）聊了之前公司的架构，因为是基础架构的 主要问了基础架构人数等
（2）问了一下使用的语言Java基础问题 包括线程 集合类原理
（3）问了Kafka的原理和使用
2）第二面：
（1）首先询问了一下之前的公司的业务范围 数据量大小 团队规模
（2）了为什么离职，自己未来有什么规划打算
（3）了一些hive sql问题 是否有了解Scala编程 具体有没有使用过Sparkstreaming Flink等流式计算引擎
（4）大数据相关，包括之前的公司的主要技术架构，技术选型有什么考虑 数据量 延迟多少 对原来公司的技术架构问的比较细
（5）如果给定数据量每天1T的数据，设计数仓 实时和离线的 要求延迟小于5分钟 让你设计一套架构