linuxscala命令

㈠ scala maven sbt 哪个

SBT是Simple Build Tool的简称，如果读者使用过Maven，那么可以简单将SBT看做是Scala世界的Maven，虽然二者各有优劣，但完成的工作基本是类似的。

虽然Maven同样可以管理Scala项目的依赖并进行构建， 但SBT的某些特性却让人如此着迷，比如：

* 使用Scala作为DSL来定义build文件（one language rules them all）;
* 通过触发执行(trigger execution)特性支持持续的编译与测试；
* 增量编译；^[SBT的增量编译支持因为如此优秀，已经剥离为Zinc，可被Eclipse, Maven,Gradle等使用]
* 可以混合构建java和Scala项目；
* 并行的任务执行；
* 可以重用Maven或者ivy的repository进行依赖管理；

等等这些，都是SBT得以在Scala的世界里广受欢迎的印记。

SBT的发展可以分为两个阶段， 即SBT_0.7.x时代以及SBT_0.10.x以后的时代。

目前来讲， SBT_0.7.x已经很少使用， 大部分公司和项目都已经迁移到0.10.x以后的版本上来，最新的是0.12版本。 0.10.x之后的版本build定义采用了新的Settings系统，与最初0.7.x版本采用纯Scala代码来定义build文件大相径庭，虽然笔者在迁移之前很抵触（因为0.7.x中采用Scala定义build文件的做法可以体现很好的统一性），但还是升级并接纳了0.10.x以后的版本，并且也逐渐意识到， 虽然新的版本初看起来很复杂，但一旦了解了其设计和实现的哲学跟思路，就会明白这种设计可以更便捷的定义build文件。而且可选的build文件方式也同样运行采用Scala代码来定义，即并未放弃统一性的思想。

以上是SBT的简单介绍，如果读者已经急于开始我们的SBT之旅，那么让我们先从SBT的安装和配置开始吧！

## SBT安装和配置

SBT的安装和配置可以采用两种方式，一种是所有平台都通用的安装配置方式，另一种是跟平台相关的安装和配置方式，下面我们分别对两种方式进行详细介绍。

### 所有平台通用的安装配置方式
所有平台通用的安装和配置方式只需要两步：

1. 下载sbt boot launcher
- 本书采用最新的sbt0.12，其下载地址为<http://typesafe.artifactoryonline.com/typesafe/ivy-releases/org.scala-sbt/sbt-launch/0.12.0/sbt-launch.jar>；
2. 创建sbt启动脚本（启动脚本是平台相关的）
- 如果是linux/Unit系统，创建名称为sbt的脚本，并赋予其执行权限，并将其加到PATH路径中； sbt脚本内容类似于
``java -Xms512M -Xmx1536M -Xss1M -XX:+CMSClassUnloadingEnabled -XX:MaxPermSize=384M -jar `dirname $0`/sbt-launch.jar "$@"``， 可以根据情况调整合适的java进程启动参数；
- 如果是Windows系统，则创建sbt.bat命令行脚本，同样将其添加到PATH路径中。 脚本内容类似于``set SCRIPT_DIR=%~dp0 \n
java -Xmx512M -jar "%SCRIPT_DIR%sbt-launch.jar" %*``

以上两步即可完成sbt的安装和配置。

### 平台相关的安装配置方式
笔者使用的是Mac系统，安装sbt只需要执行``brew install sbt``即可（因为我已经安装有homebrew这个包管理器），使用macport同样可以很简单的安装sbt - ``sudo port install sbt``;

㈡ 大数据技术是学什么的

大数据需要学什么？

1. Java编程技术

Java编程技术是大数据学习的基础，Java是一种强类型语言，拥有极高的跨平台能力，可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等，是大数据工程师最喜欢的编程工具，因此，想学好大数据，掌握Java基础是必不可少的!

2.Linux命令

对于大数据开发通常是在Linux环境下进行的，相比Linux操作系统，Windows操作系统是封闭的操作系统，开源的大数据软件很受限制，因此，想从事大数据开发相关工作，还需掌握Linux基础操作命令。

3. Hadoop

Hadoop是大数据开发的重要框架，其核心是HDFS和MapRece，HDFS为海量的数据提供了存储，MapRece为海量的数据提供了计算，因此，需要重点掌握，除此之外，还需要掌握Hadoop集群、Hadoop集群管理、YARN以及Hadoop高级管理等相关技术与操作!

4. Hive

Hive是基于Hadoop的一个数据仓库工具，可以将结构化的数据文件映射为一张数据库表，并提供简单的sql查询功能，可以将sql语句转换为MapRece任务进行运行，十分适合数据仓库的统计分析。对于Hive需掌握其安装、应用及高级操作等。

5. Avro与Protobuf

Avro与Protobuf均是数据序列化系统，可以提供丰富的数据结构类型，十分适合做数据存储，还可进行不同语言之间相互通信的数据交换格式，学习大数据，需掌握其具体用法。

6.ZooKeeper

ZooKeeper是Hadoop和Hbase的重要组件，是一个为分布式应用提供一致性服务的软件，提供的功能包括：配置维护、域名服务、分布式同步、组件服务等，在大数据开发中要掌握ZooKeeper的常用命令及功能的实现方法。

7. HBase

HBase是一个分布式的、面向列的开源数据库，它不同于一般的关系数据库，更适合于非结构化数据存储的数据库，是一个高可靠性、高性能、面向列、可伸缩的分布式存储系统，大数据开发需掌握HBase基础知识、应用、架构以及高级用法等。

8.phoenix

phoenix是用Java编写的基于JDBC API操作HBase的开源SQL引擎，其具有动态列、散列加载、查询服务器、追踪、事务、用户自定义函数、二级索引、命名空间映射、数据收集、行时间戳列、分页查询、跳跃查询、视图以及多租户的特性，大数据开发需掌握其原理和使用方法。

9. Redis

Redis是一个key-value存储系统，其出现很大程度补偿了memcached这类key/value存储的不足，在部分场合可以对关系数据库起到很好的补充作用，它提供了Java，C/C++，C#，PHP，JavaScript，Perl，Object-C，Python，Ruby，Erlang等客户端，使用很方便，大数据开发需掌握Redis的安装、配置及相关使用方法。

10. Flume

Flume是一款高可用、高可靠、分布式的海量日志采集、聚合和传输的系统，Flume支持在日志系统中定制各类数据发送方，用于收集数据;同时，Flume提供对数据进行简单处理，并写到各种数据接受方(可定制)的能力。大数据开发需掌握其安装、配置以及相关使用方法。

11. SSM

SSM框架是由Spring、SpringMVC、MyBatis三个开源框架整合而成，常作为数据源较简单的web项目的框架。大数据开发需分别掌握Spring、SpringMVC、MyBatis三种框架的同时，再使用SSM进行整合操作。

12.Kafka

Kafka是一种高吞吐量的分布式发布订阅消息系统，其在大数据开发应用上的目的是通过Hadoop的并行加载机制来统一线上和离线的消息处理，也是为了通过集群来提供实时的消息。大数据开发需掌握Kafka架构原理及各组件的作用和使用方法及相关功能的实现!

13.Scala

Scala是一门多范式的编程语言，大数据开发重要框架Spark是采用Scala语言设计的，想要学好Spark框架，拥有Scala基础是必不可少的，因此，大数据开发需掌握Scala编程基础知识!

14.Spark

Spark是专为大规模数据处理而设计的快速通用的计算引擎，其提供了一个全面、统一的框架用于管理各种不同性质的数据集和数据源的大数据处理的需求，大数据开发需掌握Spark基础、SparkJob、Spark RDD、spark job部署与资源分配、Spark shuffle、Spark内存管理、Spark广播变量、Spark SQL、Spark Streaming以及Spark ML等相关知识。

15.Azkaban

Azkaban是一个批量工作流任务调度器，可用于在一个工作流内以一个特定的顺序运行一组工作和流程，可以利用Azkaban来完成大数据的任务调度，大数据开发需掌握Azkaban的相关配置及语法规则。

16.Python与数据分析

Python是面向对象的编程语言，拥有丰富的库，使用简单，应用广泛，在大数据领域也有所应用，主要可用于数据采集、数据分析以及数据可视化等，因此，大数据开发需学习一定的Python知识。

㈢ 什么是大数据技术大数据的概念

大数据技术是指大数据的应用技术，涵盖各类大数据平台、大数据指数体系等大数据应用技术。

大数据是指无法在一定时间范围内用常规软件工具进行捕捉、管理和处理的数据集合。是需要新处理模式才能具有更强的决策力、洞察发现力和流程优化能力的海量、高增长率和多样化的信息资产。

随着云时代的来临，大数据也吸引了越来越多的关注。分析师团队认为，大数据通常用来形容一个公司创造的大量非结构化数据和半结构化数据，这些数据在下载到关系型数据库用于分析时会花费过多时间和金钱。

大数据分析常和云计算联系到一起，因为实时的大型数据集分析需要像MapRece一样的框架来向数十、数百或甚至数千的电脑分配工作。

(3)linuxscala命令扩展阅读：

大数据的三个层面：

1、理论，理论是认知的必经途径，也是被广泛认同和传播的基线。在这里从大数据的特征定义理解行业对大数据的整体描绘和定性；从对大数据价值的探讨来深入解析大数据的珍贵所在；洞悉大数据的发展趋势；从大数据隐私这个特别而重要的视角审视人和数据之间的长久博弈。

2、技术，技术是大数据价值体现的手段和前进的基石。在这里分别从云计算、分布式处理技术、存储技术和感知技术的发展来说明大数据从采集、处理、存储到形成结果的整个过程。

3、实践，实践是大数据的最终价值体现。在这里分别从互联网的大数据，政府的大数据，企业的大数据和个人的大数据四个方面来描绘大数据已经展现的美好景象及即将实现的蓝图。

参考资料来源：网络-大数据

㈣ 如何学好Scala

Spark也是基于JVM，我们构筑分布式系统，借助JVM，而不一定是Java语言。 Spark和消息中间件KAFKA等都是用Scala编写的，学好Scala是掌握Spark的关键。
Scala基础语法入门实战
首先，参照相关攻略，在Linux下分别下载安装Java、Scala，然后配置Java和Scala环境变量。安装完毕，在终端敲入scala即可进入Scala命令行，如下所示：

root@Master:~# scala
Welcome to Scala version 2.10.4 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_66).
Type in expressions to have them evaluated.
Type :help for more information.

简单测试
scala> 1+2
res0: Int = 3

scala> 1.5*2
res1: Double = 3.0

scala> 3*res1
res2: Double = 9.0

//按Tab键，命令自动补全
scala> res2.to
toByte toChar toDouble toFloat toInt toLong toShort toString

变量
var声明可变变量；val声明不可变变量。
val声明的不可变变量，不希望数据被改变，RDD内部的数据都是不可变，所以在Spark中一般都是使用val。

//下面声明了一个不可变变量result，result的值不可改变。
scala> val result=2+10
result: Int = 12

//假若修改result的值，会提示出错，如下：
scala> result=13
<console>:8: error: reassignment to val
result=13

//var声明可变变量：
scala> var name="Spark"
name: String = Spark

scala> name="Scala" //可以修改变量name的值
name: String = Scala

scala> name //name的值现在为Scala
res4: String = Scala

//val声明不可变变量
//age被声明为Int类型的不可变变量
scala> val age: Int=0
age: Int = 0

//声明为String类型
scala> val name:String=null
name: String = null

一行代码声明多个变量
scala> val age1,age2,age3=0
age1: Int = 0
age2: Int = 0
age3: Int = 0

基本数据类型的自动转换操作
Scala自己可以完成基本数据类型的自动转换操作。

//输入整数10，按Tab键盘，可以看见它本身的很多方法：
scala> 10.to
toByte toChar toDouble toFloat toInt toLong toShort toString

scala> 10.toString
res5: String = 10

scala> 0.to(5)
res6: scala.collection.immutable.Range.Inclusive = Range(0, 1, 2, 3, 4, 5)
给了我们一个不可变的集合，获得的结果是：0~5，所以Scala一切皆对象！

Scala隐私转换：
当类型本身没有没有这个方法，但是又需要调用这个方法时，内部就会自动触发隐式转换。刚才的示例中，Int本身没有to这样的方法，Scala引擎内部会隐式自动转换成RichInt，就像上面0.to(5)这样的调用，RichInt对象类型才有to这样的函数。

scala> 1+1
res7: Int = 2

//因为Scala一切皆对象，所以以上示例又可以写成：
scala> 1.+(1)
res9: Double = 2.0
这个示例，内部其实就是Int的一个隐式转换，+是类的一个方法。

Scala没有++、---操作运算：
scala> var age=10
age: Int = 10

// Scala没有++、---操作运算
scala> age++
<console>:9: error: value ++ is not a member of Int
age++
^

//但是++运算可以用下面方式实现：
scala> age +=1

scala> age
res12: Int = 11

求最大、最小值
scala> min(20,4)
<console>:8: error: not found: value min
min(20,4)
^
该示例因为没有导入库，所以出错。

scala> import scala.math._ //导入math库
import scala.math._

scala> min(20,4)
res14: Int = 4

apply工厂构造实现方法
在Spark中，大量的实例的构造都是使用了apply方式。

scala> Array(1,2,3,4)
res15: Array[Int] = Array(1, 2, 3, 4)

scala> val array=Array(1,2,3,4)
array: Array[Int] = Array(1, 2, 3, 4)

//array是一个声明整数类型的数组变量， 其实内部是自动调用了Array.apply方法，等同如下：
scala> val array = Array.apply(1,2,3,4)
array: Array[Int] = Array(1, 2, 3, 4)

条件控制、循环
// if表达式示例：
scala> if(age>=18) "成年人" else "小孩"
res16: String = 成年人

scala> val result=if(age>=18) "成年人" else "小孩"
result: String = 成年人

scala> result
res17: String = 成年人

scala> val result = if(age>=18){
| "alt"
| buffered=10
| buffered
| }
以上一个代码块，代码块后面有个返回值buffered，代码块的返回值就是最后一行的值。

打印值
scala> println("Spark") //输出一行字符串并换行
Spark

scala> println("\nSpark") //换行，输出一行字符串再换行。\n是换行转义符。

Spark

scala> print("Spark") //输出一行字符串，不换行
Spark
scala>

填充占位符
scala> printf("%s是大数据框架的未来", "Spark") //%s是占位符
Spark是大数据框架的未来

读取内容
readLine用于读取输入的内容
scala> readLine //此时敲入Scala之后，然后回车
res28: String = Scala

scala> res28
res29: String = Scala

补充说明，readLine是一个方法，如果方法如果没有参数，那么可以不带括号，readLine()跟readLine效果一样。

循环

//声明一个可变变量，初始值为100
scala> var element=100
element: Int = 100

//while循环示例：
scala> while(element>90){
| println(element)
| element -= 1
| }
100
99
98
97
96
95
94
93
92
91

scala> 0 to element
res32: scala.collection.immutable.Range.Inclusive = Range(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90)

//for循环遍历并打印
scala> for(i<-80 to element) println(i)
80
81
82
83
84
85
86
87
88
89
90

//循环并增加条件判断
scala> for(i<-0 to element if i%2==0) print(i+" ")
0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42 44 46 48 50 52 54 56 58 60 62 64 66 68 70 72 74 76 78 80 82 84 86 88 90

//for循环，并break退出
scala> import scala.util.control.Breaks._ //添加break引用
import scala.util.control.Breaks._

scala> for(i<-1 to 10){
| if(i==4) break
| println(i)
| }
1
2
3
scala.util.control.BreakControl

//循环，并return
scala> val n=5
n: Int = 5

scala> def f1:Any = {
| for(i <-1 to 10){
| if(i==n) return i
| println(i)
| }
| }
f1: Any

scala> f1
1
2
3
4
res1: Any = 5
解释以上代码块，def是定义一个函数。f1就是一个函数。

二、 Scala函数入门实战

函数示例
函数的定义使用def关键字，并且函数体最后有返回值。

//声明了一个函数f3，两个参数：param1是String类型，param2为Int类型。param2默认值为30，因为有了默认值，那么在调用上可以不传param2。
scala> def f3(param1:String, param2:Int=30) = param1 + param2
f3: (param1: String, param2: Int)String

//调用函数f3,传入第一个参数param1值为Spark，没有传入第二个参数，默认为30。
scala> f3("Spark")
res4: String = Spark30

//带名参数调用，即在函数调用时，显示指定参数名，并不按顺序传入。
scala> f3(param2=100, param1="Scala")
res5: String = Scala100

//变长参数, 定义了一个sum函数，参数numbers是变成参数，即传入的Int变量个数不定。在函数体中，对传入的全部Int变量进行循环遍历并累计求和，最后把结果返回。
scala> def sum(numbers: Int*)={var result=0; for(element<-numbers) result +=element; result}
sum: (numbers: Int*)Int

scala> sum(1,2,3,4,5,6,7,8,9,10)
res1: Int = 55

//下面示例是一个非常经典的语法
scala> sum(1 to 10: _*) // _* 表示提取里面的每个元素, 然后作为变长参数传递
res3: Int = 55

过程
没有返回值的函数就是过程。

//这是一个函数
scala> def morning(content:String) = "Good" + content
morning: (content: String)String

//这是一个过程
scala> def morning(content:String) { println( "Good" + content)}
morning: (content: String)Unit

//强制声明一个过程
scala> def morning(content:String):Unit = "Good" + content
morning: (content: String)Unit

声明lazy类型
scala> import scala.io.Source._ //导入引用库
import scala.io.Source._

//声明一个lazy类型的变量content，打开一个不存在的文件。
scala> lazy val content = fromFile("/root/txt")
content: scala.io.BufferedSource = <lazy>
以上示例执行不会出错，表明content变量并没有执行。

//如果去掉lazy关键字，那么会出错，提示文件不存在。
scala> val content = fromFile("/root/txt")
java.io.FileNotFoundException: /root/txt (No such file or directory)
at java.io.FileInputStream.open0(Native Method)
at java.io.FileInputStream.open(FileInputStream.java:195)
at java.io.FileInputStream.<init>(FileInputStream.java:138)

耗时的操作，在大型分布式系统中，比较常见。声明lazy类型的变量，在需要的时候才去执行。

异常

//首先导入相关引用包
scala> import java.io._
import java.io._

scala>

//示例打开一个存在的文件，使用try…catch捕获异常
scala> try{
| val content = fromFile("/root/.bashrc").mkString
| }catch{
| //case是一个偏函数
| case _: FileNotFoundException => println("Oh, file not found!")
| }finally{
| println("Ok!")
| }
Ok!

scala>

//示例打开一个不存在的文件，使用try…catch捕获异常
scala> try{
| val content = fromFile("/root/.bashrc111").mkString
| }catch{
| //case是一个偏函数
| case _: FileNotFoundException => println("Oh, file not found!")
| }finally{
| println("Ok!")
| }
Oh, file not found!
Ok!

三、 Scala中Array、Map、Tuple实战

Array

//声明变量arr为Array整数类型的数组，包含5个元素。
scala> val arr= new Array[Int](5)
arr: Array[Int] = Array(0, 0, 0, 0, 0)

//访问第三个元素
scala> arr(2)
res15: Int = 0

//修改第三个元素
scala> arr(2)=8

//再次查看arr数组，发现第三个元素值已经变成8了。
scala> arr
res17: Array[Int] = Array(0, 0, 8, 0, 0)

补充说明，刚才声明arr数组变量时，所以把它声明为val不可变变量，这只是表明arr的地址不可以变，但是数组里面的元素还是可以变化的。

//在Spark中，更常见地创建数组是直接通过类名
scala> val arr1 = Array("Scala", "Spark")
arr1: Array[String] = Array(Scala, Spark)
该示例中，声明arr1为数组变量时，没有使用new关键字，也没有指定String类型，系统默认根据元素值，自动推导出元素的类型为String。
没有使用new关键字，其实它内部调用了apply方法， apply是工厂类构造器。等同于下面的写法：
scala> val arr1 = Array.apply("Scala", "Spark")
arr1: Array[String] = Array(Scala, Spark)

//给Array增加元素。下面写法会出错，给arr1数组增加一个元素，比如：
scala> arr1(2)="Hadoop"
java.lang.: 2
at .<init>(<console>:16)
at .<clinit>(<console>)
……
如果需要给Array增加元素，那么此时就应该使用ArrayBuffer类型。

ArrayBuffer
//首先导入库
scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer

//定义一个ArrayBuffer类型的变量arrbuffer
scala> val arrbuffer=ArrayBuffer[Int]()
arrbuffer: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()

//向arrbuffer中增加一个元素，值为10
scala> arrbuffer += 10
res23: arrbuffer.type = ArrayBuffer(10)

//向arrbuffer中增加多个元素
scala> arrbuffer += (11,1,3,5)
res25: arrbuffer.type = ArrayBuffer(10, 11, 1, 3, 5)

//查看arrbuffer的内容
scala> arrbuffer
res26: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(10, 11, 1, 3, 5)

//向arrbuffer中增加一个数组
scala> arrbuffer ++= Array(1,2,3,4)
res27: arrbuffer.type = ArrayBuffer(10, 11, 1, 3, 5, 1, 2, 3, 4)

//截掉arrbuffer后面的3个元素
scala> arrbuffer.trimEnd(3)

//再次查看arrbuffer的内容，发现元素：2, 3, 4被截掉
scala> arrbuffer
res29: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(10, 11, 1, 3, 5, 1)

//在第5个位置，插入元素值100
scala> arrbuffer.insert(5,100)

//查看arrbuffer的内容
scala> arrbuffer
res32: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(10, 11, 1, 3, 5, 100, 1)

//在第2个位置，插入多个元素：200,300,400
scala> arrbuffer.insert(2,200,300,400)

//查看arrbuffer的内容
scala> arrbuffer
res34: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(10, 11, 200, 300, 400, 1, 3, 5, 100, 1)

//从arrbuffer中移除第3个位置上的元素
scala> arrbuffer.remove(3)
res35: Int = 300 //被移除的值是300

//再次查看arrbuffer的内容，发现第3个位置上的元素300不见了。
scala> arrbuffer
res36: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(10, 11, 200, 400, 1, 3, 5, 100, 1)

//从arrbuffer中移除第2个位置开始的，3个元素，即：200, 400, 1
scala> arrbuffer.remove(2,3)

//再次查看arrbuffer的内容，发现三个元素：200, 400, 1 不见了。
scala> arrbuffer
res38: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(10, 11, 3, 5, 100, 1)

//可变数组变成不可变数组,此时arr2是一个不可变数组
scala> val arr2 = arrbuffer.toArray
arr2: Array[Int] = Array(10, 11, 3, 5, 100, 1)

// Array.toBuffer的结果变成一个ArrayBuffer
scala> arr2.toBuffer
res40: scala.collection.mutable.Buffer[Int] = ArrayBuffer(10, 11, 3, 5, 100, 1)

//遍历一个数组：
scala> for(elem <- arr2) println(elem)
10
11
3
5
100
1

//遍历数组时加上条件
scala> arr2
res42: Array[Int] = Array(10, 11, 3, 5, 100, 1)

//遍历时的条件，跳过偶数位上的元素
scala> for(i <- 0 until (arr2.length, 2)) println(arr2(i))
10
3
100
此时打印出来的结果，跳过了元素：11、5、1

//从尾部开始遍历
scala> for(i <- (0 until arr2.length).reverse) println(arr2(i))
1
100
5
3
11
10

//对数组进行排序
//导入排序包
scala> import scala.util.Sorting
import scala.util.Sortin

㈤ 大数据技术包括哪些

想要成为炙手可热的大数据技术人才，这些大数据的核心技术一定要知晓！

一、大数据基础阶段
大数据基础阶段需掌握的技术有：Linux、Docker、KVM、MySQL基础、Oracle基础、MongoDB、redis以及hadoop maprece hdfs yarn等。
1、Linux命令
对于大数据开发通常是在Linux环境下进行的，相比Linux操作系统，Windows操作系统是封闭的操作系统，开源的大数据软件很受限制，因此，想从事大数据开发相关工作，还需掌握Linux基础操作命令
2、 Redis
Redis是一个key-value存储系统，其出现很大程度补偿了memcached这类key/value存储的不足，在部分场合可以对关系数据库起到很好的补充作用，它提供了Java，C/C++，C#，PHP，JavaScript，Perl，Object-C，Python，Ruby，Erlang等客户端，使用很方便，大数据开发需掌握Redis的安装、配置及相关使用方法。
二、大数据存储阶段
大数据存储阶段需掌握的技术有：hbase、hive、sqoop等。
1、HBase
HBase是一个分布式的、面向列的开源数据库，它不同于一般的关系数据库，更适合于非结构化数据存储的数据库，是一个高可靠性、高性能、面向列、可伸缩的分布式存储系统，大数据开发需掌握HBase基础知识、应用、架构以及高级用法等。
2、Hive
Hive是基于Hadoop的一个数据仓库工具，可以将结构化的数据文件映射为一张数据库表，并提供简单的sql查询功能，可以将sql语句转换为MapRece任务进行运行，十分适合数据仓库的统计分析。对于Hive需掌握其安装、应用及高级操作等。
三、大数据架构设计阶段
大数据架构设计阶段需掌握的技术有：Flume分布式、Zookeeper、Kafka等。
1、Kafka
Kafka是一种高吞吐量的分布式发布订阅消息系统，其在大数据开发应用上的目的是通过Hadoop的并行加载机制来统一线上和离线的消息处理，也是为了通过集群来提供实时的消息。大数据开发需掌握Kafka架构原理及各组件的作用和使用方法及相关功能的实现！
2、Flume
Flume是一款高可用、高可靠、分布式的海量日志采集、聚合和传输的系统，Flume支持在日志系统中定制各类数据发送方，用于收集数据;同时，Flume提供对数据进行简单处理，并写到各种数据接受方(可定制)的能力。大数据开发需掌握其安装、配置以及相关使用方法。
3、ZooKeeper
ZooKeeper是Hadoop和Hbase的重要组件，是一个为分布式应用提供一致性服务的软件，提供的功能包括：配置维护、域名服务、分布式同步、组件服务等，在大数据开发中要掌握ZooKeeper的常用命令及功能的实现方法。
四、大数据实时计算阶段
大数据实时计算阶段需掌握的技术有：Mahout、Spark、storm。
1、Spark
Spark是专为大规模数据处理而设计的快速通用的计算引擎，其提供了一个全面、统一的框架用于管理各种不同性质的数据集和数据源的大数据处理的需求，大数据开发需掌握Spark基础、SparkJob、Spark RDD、spark job部署与资源分配、Spark shuffle、Spark内存管理、Spark广播变量、Spark SQL、Spark Streaming以及Spark ML等相关知识。
2、storm
Storm为分布式实时计算提供了一组通用原语，可被用于“流处理”之中，实时处理消息并更新数据库。这是管理队列及工作者集群的另一种方式。Storm可以方便地在一个计算机集群中编写与扩展复杂的实时计算，Storm用于实时处理，就好比 Hadoop 用于批处理。Storm保证每个消息都会得到处理，而且它很快——在一个小集群中，每秒可以处理数以百万计的消息。
五、大数据数据采集阶段
大数据数据采集阶段需掌握的技术有：Python、Scala。
1、Python与数据分析
Python是面向对象的编程语言，拥有丰富的库，使用简单，应用广泛，在大数据领域也有所应用，主要可用于数据采集、数据分析以及数据可视化等，因此，大数据开发需学习一定的Python知识。
2、Scala
Scala是一门多范式的编程语言，大数据开发重要框架Spark是采用Scala语言设计的，想要学好Spark框架，拥有Scala基础是必不可少的，因此，大数据开发需掌握Scala编程基础知识！
以上只是一些简单的大数据核心技术总结，比较零散，想要学习大数据的同学，还是要按照一定到的技术路线图学习！