1-1）List 与set 的区别？

List特点：元素有放入顺序，元素可重复 ，Set特点：元素无放入顺序，元素不可重复。

1-2）数据库的三大范式？

原子性、一致性、专有性

1-3）对象与引用对象的区别?

对象就是好没有初始化的对象，引用对象即使对这个对象进行了初始化，这个初始化可以使自己的直接new的也可以是直接其他的赋值的，那么背new或者背其他赋值的我们叫做是引用对象，区别于。

1-4）谈谈你对反射机制的理解及其用途？

反射有三种获取的方式，分别是：forName  / getClass / 直接使用class方式 使用反射可以获取类的实例

1-5）列出至少五种设计模式

设计方式有工厂法，懒加载，观察者模式，静态工厂，迭代器模式，外观模式、、、、

1-6）RPC原理？

Rpc分为同步调用和一部调用，异步与同步的区别在于是否等待服务器端的返回值。Rpc的组件有RpcServer,RpcClick,RpcProxy,RpcConnection,RpcChannel,RpcProtocol,RpcInvoker等组件，

1-7）使用 StringBuffer 而不是 String

当需要对字符串进行操作时，使用 StringBuffer 而不是 String，String 是 read-only 的，如果对它进行修改，会产生临时对象，而 StringBuffer 是可修改的，不会产生临时对象。

1-8）ArrayList、Vector、LinkedList 的区别及其优缺点？HashMap、HashTable 的区别及优缺点？

ArrayList 和 Vector 是采用数组方式存储数据的,是根据索引来访问元素的，都可以 根据需要自动扩展内部数据长度，以便增加和插入元素，都允许直接序号索引元素，但 是插入数据要涉及到数组元素移动等内存操作，所以索引数据快插入数据慢，他们的区别就是 synchronized 同步的使用。
LinkedList 使用双向链表实现存储，按序号索引数据需要进行向前或向后遍历，但 是插入数据时只需要记录本项的前后项即可，所以插入数度较快！
如果只是查找特定位置的元素或只在集合的末端增加、移除元素，那么使用 Vector 或 ArrayList 都可以。如果是对其它指定位置的插入、删除操作，选择 LinkedList HashMap、HashTable 的区别及其优缺点：
1.HashTable 中的方法是同步的 HashMap 的方法在缺省情况下是非同步的 因此在多线程环境下需要做额外的同步机制。
2.HashTable 不允许有 null 值 key 和 value 都不允许，而 HashMap 允许有 null 值 key和 value 都允许 因此 HashMap 使用 containKey（）来判断是否存在某个键。
3.HashTable 使用 Enumeration ，而 HashMap 使用 iterator。
4.Hashtable 是 Dictionary 的子类，HashMap 是 Map 接口的一个实现类。

1-9）集合的扩充

ArrayList  list = new ArrayList(90000);  list扩充多少次？？
 public ArrayList() {
        this(10);
}
默认的扩充是10由此计算

1-10）java的拆包与封包的问题

System.out.println("5" + 2);

52

1-11）java 中有两个线程怎样等待一个线程执行完毕

可以使用join关键字

1-12）Java中Class.forName和ClassLoader.loadClass的区别

Class.forName("xx.xx")等同于Class.forName("xx.xx",true,CALLClass.class.getClassLoader())，第二个参数(bool)表示装载类的时候是否初始化该类，即调用类的静态块的语句及初始化静态成员变量。
ClassLoader loader = Thread.currentThread.getContextClassLoader(); //也可以用(ClassLoader.getSystemClassLoader())
Class cls = loader.loadClass("xx.xx"); //这句话没有执行初始化
forName可以控制是否初始化类，而loadClass加载时是没有初始化的。

1-13）怎样实现数组的反转

ArrayList arrayList = new ArrayList();
 arrayList.add("A");  
 arrayList.add("B");
对数组进行反转
Collections.reverse(arrayList);

1-14）请使用JAVA实现二分查找

二分查找就是折半查找，要想折半就要把原来的数据进行排序，才能方便的查找：
实现代码如下：
 public static int binarySearch(int[] srcArray, int des){
        int low = 0;   
        int high = srcArray.length-1;
          while(low <= high) {  
              int middle = (low + high)/2;  
            if(des == srcArray[middle]) {  
                return middle;   
            }else if(des                   high = middle - 1;  
            }else {   
                low = middle + 1;  
            }  
        }  
        return -1;  
   }

2-1）关闭不必要的服务

A、使用ntsysv命令查看开启与关闭的服务
B、停止打印服务
[root@hadoop1 /]# /etc/init.d/cups stop
[root@hadoop1 /]# chkconfig cups off

2-2）关闭IP6

[root@hadoop1 /]# vim /etc/modprobe.conf
在下面添加一下配置：
alias net-pf-10 off
alias ipv6 off

2-3）调整文件的的打开数

查看当前的文件的数量：[root@hadoop1 /]#ulimit -a
修改配置：
[root@hadoop1 /]# vi /etc/security/limits.conf 在文件后加上：
* soft nofile 65535
* hard nofile 65535
* soft nproc 65535
* hard nproc 65535

2-4）修改 linux 内核参数

[root@hadoop1 /]# vi /etc/sysctl.conf
在文本的后面追加一下内容：
net.core.somaxconn = 32768
表示物理内存使用到 90%（100-10=90）的时候才使用 swap 交换区

2-5）关闭 noatime

在后面追加一下内容
/dev/sda2 /data ext3 noatime,nodiratime 0 0

2-6)请用shell命令把某一个文件下的所有的文件分发到其他的机器上

Scp  -r  /user/local   hadoop2:/user/local

2-7）echo 1+1 && echo "1+1" 会输出什么

[root@hadoop1 ~]# echo 1+1 && echo "1+1"
1+1
1+1
[root@hadoop1 ~]# echo 1+1 && echo "1+1" && echo "1+" 1
1+1
1+1
1+ 1

2-9）linux用什么命令查看cpu,硬盘，内存的信息？

Top 命令

2-10) 如何查看占用端口8080 的进程

lsof -i:8080

2-11)linux 下常用的DNS服务软件是什么，举出几种常用的DNS记录，如果域名abc.com 配置好了一台邮件服务器,IP 地址为202.106.0.20，我该如何做相关的解析？是否了解 bind 的智能解析，如果了解请简述一下其原理

1)常用的DNS 软件是bind
2)A 记录 地址记录,MX 记录 邮件交换记录,CNAME 记录 别名域记录
3)修改abc.com 域名的配置文件，增加以下记录
IN MX 10 mail.abc.com.
mail IN A 202.106.0.20
4)bind 根据请求解析客户端的IP 地址，做出不同的解析，其原理是在配置文件中，设定了view，在每个view 都有客户端的IP 地址段，bind 服务器根据请求解析客户端的IP 地址，匹配不同的view,再根据该view 的配置，到相应的配置文件进行查询，将结果返回给请求 的客户端。

3-1）简单概述hdfs原理，以及各个模块的职责

1、客户端向 nameNode 发送要上传文件的请求
2、nameNode 返回给用户是否能上传数据的状态
3、加入用户端需要上传一个 1024M 的文件，客户端会通过 Rpc 请求 NameNode，并返回需要上传给那些DataNode(分配机器的距离以及空间的大小等),namonode会选择就近原则分配机器。
4、客户端请求建立 block 传输管道 chnnel 上传数据
5、在上传是 datanode 会与其他的机器建立连接并把数据块传送到其他的机器上
6、dataNode 向 namenode 汇报自己的储存情况以及自己的信息
7、当快上传完后再去执行其他的复制的传送

3-2）mr的工作原理

1、当执行mr程序是，会执行一个Job
2、客户端的jobClick会请求namenode的jobTracker要执行任务
3、jobClick会去HDFS端复制作业的资源文件
4、客户端的jobClick会向namenode提交作业,让namenode做准备
5、Namenode的jobTracker会去初始化创建的对象
6、Namenode会获取hdfs的划分的分区
7、Namenode去检查TaskTracker的心跳信息，查看存活的机器
8、当执行的datenode执行任务时Datenode会去HDFS获取作业的资源的文件
9、TaskTracker会去执行代码，并登陆JVM的执行渠道
10、JVM或执行MapTask或者ReduceTask
11、执行终结 

3-3）怎样判断文件时候存在

这是Linux上的知识，只需要在IF[ -f ] 括号中加上-f参数即可判断文件是否存在

3-4）fsimage和edit的区别？

大家都知道namenode与secondary namenode 的关系，当他们要进行数据同步时叫做checkpoint时就用到了fsimage与edit，fsimage是保存新的元数据的信息，当fsimage数据到一定的大小事会去生成一个新的文件来保存元数据的信息，这个新的文件就是edit，edit会回滚新的数据。

3-5）hdfs中的block默认保存几份？

不管是hadoop1.x 还是hadoop2.x 都是默认的保存三份，可以通过参数dfs.replication就行修改，副本的数目要根据机器的个数来确定。

3-6）列举几个配置文件优化？

Core-site.xml 文件的优化 
fs.trash.interval
默认值： 0
说明：这个是开启hdfs文件删除自动转移到垃圾箱的选项，值为垃圾箱文件清除时间。
dfs.namenode.handler.count
默认值：10
说明：Hadoop系统里启动的任务线程数，这里改为40，同样可以尝试该值大小对效率的影响变化进行合适的值的设定。
mapreduce.tasktracker.http.threads
默认值：40
说明：map和reduce是通过http进行数据传输的，这个是设置传输的并行线程数。

3-7) 谈谈数据倾斜，如何发生的，并给出优化方案

数据的倾斜主要是两个的数据相差的数量不在一个级别上，在只想任务时就造成了数据的倾斜，可以通过分区的方法减少reduce数据倾斜性能的方法，例如;抽样和范围的分区、自定义分区、数据大小倾斜的自定义侧咯

3-8）简单概括安装hadoop的步骤

1.创建 hadoop 帐户。
2.setup.改 IP。
3.安装 Java，并修改/etc/profile 文件，配置 java 的环境变量。
4.修改 Host 文件域名。
5.安装 SSH，配置无密钥通信。
6.解压 hadoop。
7.配置 conf 文件下 hadoop-env.sh、core-site.sh、mapre-site.sh、hdfs-site.sh。
8.配置 hadoop 的环境变量。
9.Hadoop namenode -format
10.Start-all.sh

3-9）简单概述hadoop中的角色的分配以及功能

Namenode:负责管理元数据的信息
SecondName:做namenode冷备份，对于namenode的机器当掉后能快速切换到制定的Secondname上
DateNode:主要做储存数据的。
JobTracker:管理任务，并把任务分配到taskTasker
TaskTracker：执行任务的

3-10）怎样快速的杀死一个job

1、执行hadoop  job -list  拿到job-id
2、Hadoop job kill hadoop-id

3-11)新增一个节点时怎样快速的启动

Hadoop-daemon.sh start datanode

3-12)你认为用java , streaming , pipe 方式开发map/reduce,各有什么优点

开发mapReduce只用过java与Hive,不过使用java开发mapreduce显得笨拙，效率也慢，基于java慢的原因于是hive，这样就方便了查询与设计

3-13）简单概述hadoop的join的方法

Hadoop 常用的jion有reduce side join  , map side  join ,  SemiJoin 不过reduce side join 与 map side join 比较常用，不过都是比较耗时的。

3-14）简单概述hadoop的combinet与partition的区别

combine和partition都是函数，中间的步骤应该只有shuffle！ combine分为map端和reduce端，作用是把同一个key的键值对合并在一起，可以自定义的,partition是分割map每个节点的结果，按照key分别映射给不同的reduce，也是可以自定义的。这里其实可以理解归类。

3-15 ) hdfs 的数据压缩算法

Hadoop 的压缩算法有很多，其中比较常用的就是gzip算法与bzip2算法，都可以可通过CompressionCodec来实现

3-16）hadoop的调度

Hadoop 的调度有三种其中fifo的调度hadoop的默认的，这种方式是按照作业的优先级的高低与到达时间的先后执行的，还有公平调度器：名字见起意就是分配用户的公平获取共享集群呗!容量调度器:让程序都能货到执行的能力，在队列中获得资源。

3-17）reduce 后输出的数据量有多大？

输出的数据量还不是取决于map端给他的数据量，没有数据reduce也没法运算啊!!

3-18) datanode 在什么情况下不会备份？

Hadoop保存的三个副本如果不算备份的话，那就是在正常运行的情况下不会备份，也是就是在设置副本为1的时候不会备份，说白了就是单台机器呗！！还有datanode 在强制关闭或者非正常断电不会备份。

3-19）combine 出现在那个过程？

Hadoop的map过程，根据意思就知道结合的意思吗，剩下的你们就懂了。想想wordcound

3-20) hdfs 的体系结构？

HDFS有 namenode、secondraynamenode、datanode 组成。
namenode 负责管理 datanode 和记录元数据
secondraynamenode 负责合并日志
datanode 负责存储数据

3-21) hadoop flush 的过程？

Flush 就是把数据落到磁盘，把数据保存起来呗! 

3-22) 什么是队列

队列的实现是链表，消费的顺序是先进先出。

3-23）三个 datanode，当有一个 datanode 出现错误会怎样？

一不会给储存带来影响，因为有其他的副本保存着，不过建议尽快修复，二会影响运算的效率，机器少了，reduce在保存数据时选择就少了，一个数据的块就大了所以就会慢。

3-24）mapReduce 的执行过程

首先map端会Text 接受到来自的数据，text可以把数据进行操作，然后通过context把key与value写入到下一步进行计算，一般的reduce接受的value是个集合可以运算，然后再通过context把数据持久化出来。

3-25）Cloudera 提供哪几种安装 CDH 的方法

· Cloudera manager
· Tarball
· Yum
· Rpm

3-29）文件大小默认为 64M，改为 128M 有啥影响？

这样减少了namenode的处理能力，数据的元数据保存在namenode上，如果在网络不好的情况下会增到datanode的储存速度。可以根据自己的网络来设置大小。

3-30）datanode 首次加入 cluster 的时候，如果 log 报告不兼容文件版本，那需要namenode 执行格式化操作，这样处理的原因是？

这样处理是不合理的，因为那么 namenode 格式化操作，是对文件系统进行格式 化，namenode 格式化时清空 dfs/name 下空两个目录下的所有文件，之后，会在目 录 dfs.name.dir 下创建文件。
     文本不兼容，有可能时 namenode 与 datanode 的 数据里的 namespaceID、 clusterID 不一致，找到两个 ID 位置，修改为一样即可解决。

3-31）什么 hadoop streaming？

提示：指的是用其它语言处理

3-33）hadoop的shuffer的概念

Shuffer是一个过程，实在map端到reduce在调reduce数据之前都叫shuffer,主要是分区与排序，也就是内部的缓存分分区以及分发（是reduce来拉数据的）和传输

3-35)3 个 datanode 中有一个 个datanode 出现错误会怎样？

这个 datanode 的数据会在其他的 datanode 上重新做备份。

3-32）MapReduce 中排序发生在哪几个阶段？这些排序是否可以避免？为什么？

  一个 MapReduce 作业由 Map 阶段和 Reduce 阶段两部分组成，这两阶段会对数 据排序，从这个意义上说，MapReduce 框架本质就是一个 Distributed Sort。在 Map 阶段，在 Map 阶段，Map Task 会在本地磁盘输出一个按照 key 排序（采用的是快速 排序）的文件（中间可能产生多个文件，但会合并成一个），在 Reduce 阶段，每 个 Reduce Task 会对收到的数据排序，这样，数据便按照 Key 分成了若干组，之后以 组为单位交给 reduce（）处理。很多人的误解在 Map 阶段，如果不使用 Combiner 便不会排序，这是错误的，不管你用不用 Combiner，Map Task 均会对产生的数据排 序（如果没有 Reduce Task，则不会排序，实际上 Map 阶段的排序就是为了减轻 Reduce 端排序负载）。由于这些排序是 MapReduce 自动完成的，用户无法控制，因此，在 hadoop 1.x 中无法避免，也不可以关闭，但 hadoop2.x 是可以关闭的。

3-34）hadoop的优化

1、优化的思路可以从配置文件和系统以及代码的设计思路来优化
2、配置文件的优化：调节适当的参数，在调参数时要进行测试
3、代码的优化：combiner的个数尽量与reduce的个数相同，数据的类型保持一致，可以减少拆包与封包的进度
4、系统的优化：可以设置linux系统打开的文件数预计网络的带宽MTU的配置
5、为 job 添加一个 Combiner，可以大大的减少shuffer阶段的maoTask拷贝过来给远程的reduce task的数据量，一般而言combiner与reduce相同。
6、在开发中尽量使用stringBuffer而不是string，string的模式是read-only的，如果对它进行修改，会产生临时的对象，二stringBuffer是可修改的，不会产生临时对象。
7、修改一下配置：
一下是修改 mapred-site.xml 文件 修改槽位数 槽位数是在各个 tasktracker 上的 mapred-site.xml 上设置的，默认都是 2

3-36）怎样决定mapreduce的中的map以及reduce的数量

在mapreduce中map是有块的大小来决定的，reduce的数量可以按照用户的业务来配置。

3-38）怎样决定一个job的map和reduce的数量

map的数量通常是由hadoop集群的DFS块大小确定的，也就是输入文件的总块数，reduce端是复制map端的数据，相对于map端的任务，reduce节点资源是相对于比较缺少的，同时运行的速度会变慢，争取的任务的个数应该是0.95过着1.75。

3-37）两个文件合并的问题

给定a、b两个文件，各存放50亿个url，每个url各占用64字节，内存限制是4G，如何找出a、b文件共同的url？
主要的思想是把文件分开进行计算，在对每个文件进行对比，得出相同的URL,因为以上说是含有相同的URL所以不用考虑数据倾斜的问题。详细的解题思路为：
可以估计每个文件的大小为5G*64=300G，远大于4G。所以不可能将其完全加载到内存中处理。考虑采取分而治之的方法。 
遍历文件a，对每个url求取hash(url)%1000，然后根据所得值将url分别存储到1000个小文件（设为a0,a1,...a999）当中。这样每个小文件的大小约为300M。遍历文件b，采取和a相同的方法将url分别存储到1000个小文件(b0,b1....b999)中。这样处理后，所有可能相同的url都在对应的小文件(a0 vs b0, a1 vs b1....a999 vs b999)当中，不对应的小文件（比如a0 vs b99）不可能有相同的url。然后我们只要求出1000对小文件中相同的url即可。
比如对于a0 vs b0，我们可以遍历a0，将其中的url存储到hash_map当中。然后遍历b0，如果url在hash_map中，则说明此url在a和b中同时存在，保存到文件中即可。
 如果分成的小文件不均匀，导致有些小文件太大（比如大于2G），可以考虑将这些太大的小文件再按类似的方法分成小小文件即可

3-39）hadoop的sequencefile的格式，并说明下什么是JAVA的序列化，如何实现JAVA的序列化

1、hadoop的序列化(sequencefile)是一二进制的形式来保存的
2、Java的序列化是讲对象的内容进行流化
3、实现序列化需要实现Serializable接口便可以了

3-40）简单概述一下hadoop1与hadoop2的区别

Hadoop2与hadoop1的区别在于HDFS的架构与mapreduce的很大的区别，而且速度上有很大的提升，hadoop2主要的两个变化是：namenode可以集群的部署了，hadoop2中的mapreduce中的jobTracker中的资源调度器与生命周期管理拆分成两个独立的组件，并命名为YARN

3-41）YARN的新特性

YARN是hadoop2.x之后才出的，主要是hadoop的HA(也就是集群)，磁盘的容错，资源调度器

3-42）hadoop join的原理

实现两个表的join首先在map端需要把表标示一下，把其中的一个表打标签，到reduce端再进行笛卡尔积的运算，就是reduce进行的实际的链接操作。

3-43）hadoop的二次排序

Hadoop默认的是HashPartitioner排序，当map端一个文件非常大另外一个文件非常小时就会产生资源的分配不均匀，既可以使用setPartitionerClass来设置分区，即形成了二次分区。

3-44）hadoop的mapreduce的排序发生在几个阶段？

发生在两个阶段即使map与reduce阶段

3-45）请描述mapreduce中shuffer阶段的工作流程，如何优化shuffer阶段的？

Mapreduce的shuffer是出在map task到reduce task的这段过程中，首先会进入到copy过程，会通过http方式请求map task所在的task Tracker获取map task 的输出的文件，因此当map  task结束，这些文件就会落到磁盘中，merge实在map端的动作，只是在map拷贝过来的数值，会放到内存缓冲区中，给shuffer使用，reduce阶段，不断的merge后会把文件放到磁盘中。

3-46）mapreduce的combiner的作用是什么，什么时候不易使用？？

Mapreduce中的Combiner就是为了避免map任务和reduce任务之间的数据传输而设置的，Hadoop允许用户针对map task的输出指定一个合并函数。即为了减少传输到Reduce中的数据量。它主要是为了削减Mapper的输出从而减少网络带宽和Reducer之上的负载。 在数据量较少时不宜使用。

3-47）hadoop的TextInputFormat作用是什么，如何自定义实现？

InputFormat会在map操作之前对数据进行两方面的预处理。

1是getSplits，返回的是InputSplit数组，对数据进行split分片，每片交给map操作一次 。

2是getRecordReader，返回的是RecordReader对象，对每个split分片进行转换为key-value键值对格式传递给map。

常用的InputFormat是TextInputFormat，使用的是LineRecordReader对每个分片进行键值对的转换，以行偏移量作为键，行内容作为值。
自定义类继承InputFormat接口，重写createRecordReader和isSplitable方法 。
在createRecordReader中可以自定义分隔符。

4-1）写出你对zookeeper的理解

 随着大数据的快速发展，多机器的协调工作，避免主要机器单点故障的问题，于是就引入管理机器的一个软件，他就是zookeeper来协助机器正常的运行。
Zookeeper有两个角色分别是leader与follower ，其中leader是主节点，其他的是副节点，在安装配置上一定要注意配置奇数个的机器上，便于zookeeper快速切换选举其他的机器。
在其他的软件执行任务时在zookeeper注册时会在zookeeper下生成相对应的目录，以便zookeeper去管理机器。

4-2）zookeeper 的搭建过程

主要是配置文件zoo.cfg 配置dataDir 的路径一句dataLogDir 的路径以及myid的配置以及server的配置，心跳端口与选举端口主要是配置文件zoo.cfg 配置dataDir 的路径一句dataLogDir 的路径以及myid的配置以及server的配置，心跳端口与选举端口

5-1）hive是怎样保存元数据的

保存元数据的方式有：内存数据库rerdy，本地MySQL数据库，远程mysql数据库，但是本地的mysql数据用的比较多，因为本地读写速度都比较快

5-2）外部表与内部表的区别

先来说下Hive中内部表与外部表的区别：
  Hive 创建内部表时，会将数据移动到数据仓库指向的路径；若创建外部表，仅记录数据所在的路径，不对数据的位置做任何改变。在删除表的时候，内部表的元数据和数据会被一起删除，而外部表只删除元数据，不删除数据。这样外部表相对来说更加安全些，数据组织也更加灵活，方便共享源数据。

5-3）对于 hive，你写过哪些 UDF 函数，作用是什么

UDF: user  defined  function  的缩写，编写hive udf的两种方式extends UDF 重写evaluate第二种extends GenericUDF重写initialize、getDisplayString、evaluate方法

5-4)Hive 的 sort by 和 order by 的区别

order by 会对输入做全局排序，因此只有一个reducer（多个reducer无法保证全局有序）只有一个reducer，会导致当输入规模较大时，需要较长的计算时间。
sort by不是全局排序，其在数据进入reducer前完成排序.
因此，如果用sort by进行排序，并且设置mapred.reduce.tasks>1， 则sort by只保证每个reducer的输出有序，不保证全局有序。

5-5）hive保存元数据的方式以及各有什么特点？

1、Hive有内存数据库derby数据库，特点是保存数据小，不稳定
2、mysql数据库，储存方式可以自己设定，持久化好，一般企业开发都用mysql做支撑

5-6）在开发中问什么建议使用外部表？

1、外部表不会加载到hive中只会有一个引用加入到元数据中
2、在删除时不会删除表，只会删除元数据，所以不必担心数据的

四个多月的学习让我收获满满，在光环老师们的帮助下我找到一份不错的工作

6-1）mr 和 spark 区别，怎么理解 spark-rdd

Mr是文件方式的分布式计算框架，是将中间结果和结果记录在文件中，map 和 reduce的数据分发也是在文件中。
 Spark 是内存迭代式的计算框架，计算的中间结果可以缓存内存，也可以缓存硬盘，但是不是每一步计算都需要缓存的。
Spark-rdd 是一个数据的分区记录集合，是利用内存来计算的，spark之所以快是因为有内存的模式

6-2）简单描述spark的wordCount的执行过程

Scala> sc.textFile("/usr/local/words.txt")
res0: org.apache.spark.rdd.RDD[String] = /usr/local/words.txt MapPartitionsRDD[1] at textFile at :22
scala> sc.textFile("/usr/local/words.txt").flatMap(_.split(" "))
res2: org.apache.spark.rdd.RDD[String] = MapPartitionsRDD[4] at flatMap at :22
scala> sc.textFile("/usr/local/words.txt").flatMap(_.split(" ")).map((_,1))
res3: org.apache.spark.rdd.RDD[(String, Int)] = MapPartitionsRDD[8] at map at :22
scala> sc.textFile("/usr/local/words.txt").flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_)
res5: org.apache.spark.rdd.RDD[(String, Int)] = ShuffledRDD[17] at reduceByKey at :22
scala> sc.textFile("/usr/local/words.txt").flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_).collect
res6: Array[(String, Int)] = Array((dageda,1), (xiaoli,1), (hellow,4), (xisdsd,1), (xiaozhang,1))

6-3)hadoop和spark的都是并行计算，那么他们有什么相同和区别

两者都是用mr模型来进行并行计算，hadoop的一个作业称为job，job里面分为map task和reduce task，每个task都是在自己的进程中运行的，当task结束时，进程也会结束
spark用户提交的任务成为application，一个application对应一个sparkcontext，app中存在多个job，每触发一次action操作就会产生一个job
这些job可以并行或串行执行，每个job中有多个stage，stage是shuffle过程中DAGSchaduler通过RDD之间的依赖关系划分job而来的，每个stage里面有多个task，组成taskset有TaskSchaduler分发到各个executor中执行，executor的生命周期是和app一样的，即使没有job运行也是存在的，所以task可以快速启动读取内存进行计算
hadoop的job只有map和reduce操作，表达能力比较欠缺而且在mr过程中会重复的读写hdfs，造成大量的io操作，多个job需要自己管理关系 spark的迭代计算都是在内存中进行的，API中提供了大量的RDD操作如join，groupby等，而且通过DAG图可以实现良好的容错

6-4）spark有哪些组件？

（1）master：管理集群和节点，不参与计算。
（2）worker：计算节点，进程本身不参与计算，和master汇报。
（3）Driver：运行程序的main方法，创建spark context对象。
（4）spark context：控制整个application的生命周期，包括dagsheduler和task scheduler等组件。
（5）client：用户提交程序的入口。

6-5）spark工作机制？

用户在client端提交作业后，会由Driver运行main方法并创建spark context上下文。

执行add算子，形成dag图输入dagscheduler，按照add之间的依赖关系划分stage输入task scheduler。

task scheduler会将stage划分为task set分发到各个节点的executor中执行。

6-6）spark的优化怎么做？

通过spark-env文件、程序中sparkconf和set property设置。
（1）计算量大，形成的lineage过大应该给已经缓存了的rdd添加checkpoint，以减少容错带来的开销。
（2）小分区合并，过小的分区造成过多的切换任务开销，使用repartition。

6-7）简单说一下hadoop和spark的shuffle过程

hadoop：map端保存分片数据，通过网络收集到reduce端
spark：spark的shuffle是在DAGSchedular划分Stage的时候产生的，TaskSchedule要分发Stage到各个worker的executor减少shuffle可以提高性能

7-1）海量日志数据，提取出某日访问百度次数的那个IP1 海量日志数据，提取出某日访问百度次数的那个IP

（1）海量日志，文件太大，IP地址有2^32=4G，无法装入内存，，将这个大文件（hash映射：可以取模00）分成多个小文件（如1000）。
（2）对每个小文件进行hash统计，hash_map(ip,value), 得到每个文件出现频率的ip
（3）将这些频率的ip进行统计，然后排序得出值，这里可以采用堆/快速/归并，但只取一个值的话可以采用堆排序。
搜索引擎会通过日志文件把用户每次检索使用的所有检索串都记录下来，每个查询串的长度为1-255字节。

7-2）假设目前有一千万个记录（这些查询串的重复度比较高，虽然总数是1千万，但如果除去重复后，不超过3百万个。一个查询串的重复度越高，说明查询它的用户越多，也就是越热门。），请你统计热门的10个查询串，要求使用的内存不能超过1G。

（1）首先对这1千万个数据进行hash统计，映射成3百万个，每个对应一个频率, O(n)
（2）使用top k算法，遍历这3百万数据，先取前10个数据构成一个小堆（将小的数据都删除掉），后面的元素依次与堆顶元素进行比较，如果大于堆顶元素，替换堆顶元素，重新调整堆，n-10次，时间复杂度建堆O（n）+O（nlogn）= O（nlogn）
时间复杂度O（nlogn）

7-3）有一个1G大小的一个文件，里面每一行是一个词，词的大小不超过16字节，内存限制大小是1M。返回频数高的100个词。

思路：首先要求得每个词的频率，1G无法放入内存，需要分成多个小文件，对每个小文件的词进行统计

（1）顺序读取文件，对每个词，可以hash(x)P00(只要不小于1024个文件，是为了保证每个小文件可以放入内存)， 这样被映射为5000个小文件，每个文件大概200K，每个文件1250个单词
（2）对于每个小文件，利用hash_map记录每个单词出现的频率，选出频率高的100个单词（可以用100个元素的小堆），再生成对应的5000个文件分别包含这100个单词和频率，这分的文件太多了（关于分多少文件有什么准则吗？， 100*16*5000字节 > 1M, 无法放入内存）
（3）对这5000个小文件进行归并排序，选出大的100个。

以上也可以将从5000个文件得到的100个数，然后放入100个小文件吧，然后使用100路归并。

7-4）有10个文件，每个文件1G，每个文件的每一行存放的都是用户的query，每个文件的query都可能重复。要求你按照query的频度排序。

（1）hash映射这10个文件到另外的10个文件中（hash（query）），这是为了让相同的query放入一个文件中
（2）对每个文件进行hash统计，统计出每个单词的频率，然后按照频率进行排序，使用快速/堆/归并都可以。将每个文件的结果，包含query和频率输出到10个文件中。
（3）对这10个文件进行归并排序。
令因为重复查询比较多，对于所有的查询可以同时放入内存，这样可以将分成的10个文件一次装入内存，进行排序。

7-5）给定a、b两个文件，各存放50亿个url，每个url各占64字节，内存限制是4G，让你找出a、b文件共同的url？

思路：每个文件的大小5G*64 = 32G，远远大于内存，需要对a，b分别分成小文件
（1）利用一个hash(url)00，分别将a，b文件分别映射成1000个小文件，因为通过相同的映射函数，所以对于a，b，相同的url都在对应的文件中，（a0 vs b0, a1 vs b1等等）
（2）分别比对这1000个对应的小文件，可以通过先将a映射到一个hash表中，然后依次遍历b，判断是否在a中出现，出现过则说明重复

7-6）在2.5亿个整数中找出不重复的整数，注，内存不足以容纳这2.5亿个整数。

思路1：总共大小2.5*10^8*4字节=1G
（1）将这么多整数先hash(val)00分成1000个小文件，相同的数就在相同的文件中
（2）对每个小文件进行hash映射，统计出现次数，然后将对应次数为1的输出。
思路2：采用2-Bitmap(每个数分配2bit, 00表示不存在，01表示出现多次，11无意义)，所有的整数总共需内存2^32次方，2^32 * 2 bit = 1G内存，如果可以存入内存，首先全部置为0， 依次遍历这2.5忆个整数，如果bitmap中是00则变01，01变10， 10保持不变，把01对应的数输出即可。

腾讯面试题：给40亿个不重复的unsigned int的整数，没排过序的，然后再给一个数，如何快速判断这个数是否在那40亿个数当中？

思路1：同样采用位图，40忆个不重复的数，每个数用1bit表示，出现或不出现，40*10^8*1 = 0.5G大小。遍历这40忆个数，如果出现将对应位置为1，对于给定的数直接判断位图中对应的值。
思路2：编程珠玑上的一个思路。将每个整数都看成32位的二进制数，从高位，依次按位来分，按高位0，1分成两个文件，每个文件数字个数小于20亿，与所要判断的数的高为进行比较，从而知道去哪个文件继续比较，然后对于选定的文件再按照次高位比较再分成2个文件，再比较判断数对应的位数，依次循环，直到后一位，就可以找到或判断没有该数了。时间复杂度O（log2n）,因为每次都将数据减少一半，直到后一个。

8-1）为什么要用flume导入hdfs，hdfs的构架是怎样的？

flume可以实时的导入数据到hdfs中，当hdfs上的文件达到一个指定大小的时候会形成一个文件，或者超过指定时间的话也形成一个文件。
文件都是存储在datanode上面的，namenode记录着datanode的元数据信息，而namenode的元数据信息是存在内存中的，所以当文件切片很小或者很多的时候会卡死。

8-2）Spark Streaming和Storm有何区别？

一个实时毫秒一个准实时亚秒，不过storm的吞吐率比较低。

8-3）Flume工作机制是什么？

核心概念是agent，里面包括source、chanel和sink三个组件。
source运行在日志收集节点进行日志采集，之后临时存储在chanel中，sink负责将chanel中的数据发送到目的地。
只有成功发送之后chanel中的数据才会被删除。
首先书写flume配置文件，定义agent、source、chanel和sink然后将其组装，执行flume-ng命令。

8-4）为什么要用flume导入hdfs，hdfs的构架是怎样的

flume可以实时的导入数据到hdfs中，当hdfs上的文件达到一个指定大小的时候会形成一个文件，或者超过指定时间的话也形成一个文件
文件都是存储在datanode上面的，namenode记录着datanode的元数据信息，而namenode的元数据信息是存在内存中的，所以当文件切片很小或者很多的时候会卡死

8-5）kafka工作原理？

producer向broker发送事件，consumer从broker消费事件。
事件由topic区分开，每个consumer都会属于一个group。
相同group中的consumer不能重复消费事件，而同一事件将会发送给每个不同group的consumer。