作者简介：

蓝桥签约作者、大数据&Python领域优质创作者。管理多个大数据技术群，帮助大学生就业和初级程序员解决工作难题。

我的使命与愿景：持续稳定输出，赋能中国技术社区蓬勃发展！

大数据系列文章，从技术能力、业务基础、分析思维三大板块来呈现，你将收获：

??提升自信心，自如应对面试，顺利拿到实习岗位或offer；

??掌握大数据的基础知识，与其他同事沟通无障碍；

??具备一定的项目实战能力，对于大数据工作直接上手；

评论、点赞、收藏是对我最大的支持！！！

大数据工程师系列专栏：?面试真题、开发经验、调优策略

大数据工程师知识体系：

大数据时代已经到来

最近几十年，高速发展的互联网，渗透进了我们生活的方方面面，整个人类社会都已经被互联网连接为一体。身处互联网之中，我们无时无刻不在产生大量数据，如浏览商品的记录、成交订单记录、观看视频的数据、浏览过的网页、搜索过的关键词、点击过的广告、朋友圈的自拍和状态等。这些数据，既是我们行为留下的痕迹，同时也是描述我们自身最佳的证据。

2014年3月，马云曾经在北京的一次演讲中说道：“人类正从IT时代走向DT时代”。7年过去了，正如马云预想的那样，大数据时代已经到来了。

大数据工程师的工作内容是什么？

而大数据时代，有一个关键性的岗位不得不提，那就是大数据工程师。想必大家也会好奇，大数据工程师，日常是做什么的呢？?

大数据工程师必备技能

那么，问题来了，如果想成为一名大数据工程师，胜任上述工作内容，需要具备什么样的条件？拥有什么样的知识呢？

Scala为什么会如此重要，作者觉得主要有以下三点原因：

1、因为spark?

大部分从事大数据的工程师是先了解Spark进而再去选择学习Scala的，因为Spark是用Scala开发的。现在Spark是大数据领域的杀手级应用框架，只要搭建了大数据平台，都会大量使用Spark来处理和分析数据，而要想学好Spark，Scala这一关必须是要过的。顺便说一句，Kafka也是基于Scala开发的。

2、无缝对接大数据生态组件?

众所周知，大数据生态的大部分组件都是java语言开发的。而Scala是一门基于JVM的语言，可以与java无缝混编，因此可以很好地融合到大数据生态圈。

3、适合大数据处理与机器学习?

Scala的语法简洁而富有表达力，更容易掌握。Scala将面向对象与函数式编程相结合，功能强大且简练，非常适合用于处理各种数据。因此，在大数据处理与机器学习中占有重要的地位。

针对大数据分析师必须掌握的scala基础知识，本文的讲解思路如下：

第1部分：scala特性。主要讲解面向对象特性、函数式编程、静态类型、扩展性和并发性。

第2部分：表达式。在scala中一切皆为表达式，理解表达式是理解其语法的前提。

第3部分：方法与函数。主要讲两者之间的区别和转换。

第4部分：模式匹配。讲解常用的几种模式，并举例说明。

第5部分：scala?trait。讲解特质的基本特性和示例。

第6部分：集合操作。主要针对常用集合和集合函数的讲解和介绍。

第7部分：读取数据源。只针对scala如何通过Source类读取数据源进行简单介绍。

第8部分：隐式转换、隐式参数。主要讲解Java和scala之间的类型转换，以及通过一个实例介绍一下隐式参数的概念。

第9部分：正则匹配。主要讲解如何写正则相关的代码。

第10部分：异常处理。介绍scala和java的异常有何区别。

第11部分：类型层级。主要介绍scala的类型层级体系。

第12部分：基本数值类型转换。讲解scala与java基本数值类型转换常遇到的问题。

scala基础知识

一、Scala特性

面向对象特性?

Scala是一种纯面向对象的语言，彻底贯彻万物皆对象理念。对象的类型和行为是由类和特质来描述的。Scala引入特质（trait）来改进Java的对象模型，使得可以通过混入特质的方式，扩展类的功能。

函数式编程?

Scala也是一种函数式语言，函数也能当成值来传递。Scala提供了轻量级的语法用以定义匿名函数，支持高阶函数，允许嵌套多层函数，并支持柯里化。Scala的case class及其内置的模式匹配相当于函数式编程语言中常用的代数类型。

静态类型?

Scala拥有一个强大表达能力的类型系统，通过编译时检查，保证代码的安全性和一致性。Scala具备类型推断的特性，这使得开发者可以不去额外标明重复的类型信息，让代码看起来更加整洁易读。

?扩展性?

Scala的设计秉承一项事实，即在实践中，某个领域特定的应用程序开发往往需要特定于该领域的语言扩展。Scala提供了许多独特的语言机制，可以以库的形式轻易无缝添加新的语言结构。

二、表达式

在scala中，一切皆为表达式。scala非常推崇表达式语法，因为表达式语法，对函数式编程是非常友好的。对开发者而言，表达式语法，使得代码非常简洁易读。

举个例子，我们在定义方法时，会和声明变量一样，使用等号(=)连接，等号左侧是函数名、参数列表和返回值类型（可以省略），而等号右边便是一个由大括号({})包裹的多行表达式。

表达式，是一定会有返回值的。在java中使用void来声明无返回值的方法，而在scala里，这种情况也会有返回值，会返回一个Unit，这是一个特定的值，表示忽略方法的返回值。

三、方法与函数

初学scala时，往往会觉得方法和函数的概念有些模糊，在使用中可能会搞不清楚到底该使用方法还是函数。那怎么区分呢？关键是看这个函数是否在类中定义，在类中定义就是方法，所以Scala 方法是类的一部分。Scala 中的函数则是一个完整的对象，可以赋给一个变量。不过，在scala中，方法和函数是可以相互转化的。下面我们重点说下，如何把方法转为函数。

方法转函数

上文中提到任何方法都是在声明一个表达式，所以将方法转为函数也就非常简单了，相当于是把方法指向的表达式，又重新赋给了一个函数变量，这就是显式转化。还有另外一种写法，是通过偏应用函数的方式，将方法转化为一个新的函数，称作隐式转化。

1）隐式转化

val f2 = f1 _

val f2: (Int) => Int = f1

object ConstantPattern{　　def main(args:Array[String]) :Unit = {　　　　//模式匹配结果作为函数返回值　　　　def patternShow(x : Any) = x match {          //常量模式　　　　　　case 5 => "五"　　　　　　case true => "真"　　　　　　case "test" => "字符串"　　　　　　case null => "null值"　　　　　　case Nil => "空列表"          //变量模式          case x => "变量"          //通配符模式　　　　　　case _ => "通配符"　　　　}　　}}
变量模式和通配符模式，都可以匹配任意值，他们之间的区别是，变量模式匹配成功后，该变量中会存储匹配成功的值，在后续的代码中还可以引用，而通配符模式匹配成功后，不能再引用匹配到的值。另外要注意的是，由于模式匹配是按顺序匹配的，因此变量模式和通配符模式要写在表达式的最后面。

object TypePattern{　　def main(args:Array[String]) :Unit = {　　//类型匹配模式　　def typePattern(t : Any) = t match {　　　　case t : String => "String"　　　　case t : Int => "Intger"　　　　case t : Double => "Double"　　　　case _ => "Other Type"　　  }　　}}

object CaseClassPattern{　　def main(args:Array[String]) :Unit = {　　//定义一个Person实例　　val p = new Person("nyz",27)   //case class 模式　　def constructorPattern(p : Person) = p match {　　　　 case Person(name,age) => "name =" + name + ",age =" + age　　　　 case _ => "Other"　　　　}　　}}

object ConstantPattern{　　def main(args:Array[String]) :Unit = {　　　　//模式匹配结果作为函数返回值　　　　def patternShow(x : Any) = x match {          //模式守卫          case x if(x == 5) => "守卫"          //通配符模式　　　　　　case _ => "通配符"　　　　}　　}}

class OptionDemo {  val map = Map (("a",18),("b",81))??//get方法返回的类型就是Option[Int]  map.get("b") match {    case some(x) => println(x)    case None => println("不存在")  }}

trait Equal {  def isEqual(x: Any): Boolean  def isNotEqual(x: Any): Boolean = !isEqual(x)}

trait Equal { def isEqual(x: Any): Boolean def isNotEqual(x: Any): Boolean = !isEqual(x)}

class Point(xc: Int, yc: Int) extends Equal {  val x: Int = xc  val y: Int = yc  def isEqual(obj: Any) =    obj.isInstanceOf[Point] &&    obj.asInstanceOf[Point].x == x}
object Test {   def main(args: Array[String]) {      val p1 = new Point(2, 3)      val p2 = new Point(2, 4)      val p3 = new Point(3, 3)
      println(p1.isNotEqual(p2))      println(p1.isNotEqual(p3))      println(p1.isNotEqual(2))   }}

$ scalac Test.scala $ scala -cp . Testfalsetruetrue

// 定义整型 List，其元素以线性方式存储，可以存放重复对象。val x = List(1,2,3,4)
// 定义 Set，其对象不按特定的方式排序，并且没有重复对象。val x = Set(1,3,5,7)
// 定义 Map，把键对象和值对象映射的集合，它的每一个元素都包含一对键对象和值对象。val x = Map("one" -> 1, "two" -> 2, "three" -> 3)
// 创建两个不同类型元素的元组，元组是不同类型的值的集合val x = (10, "Bigdata")
// 定义 Option，表示有可能包含值的容器，也可能不包含值。val x:Option[Int] = Some(5)

val numbers = Seq(11, 2, 5, 1, 6, 3, 9)  numbers.max //11 numbers.min //1

case class Book(title: String, pages: Int)  val books = Seq(  Book("Future of Scala developers", 85),  Book("Parallel algorithms", 240),  Book("Object Oriented Programming", 130),  Book("Mobile Development", 495))  //下面代码返回Book(Mobile Development,495)books.maxBy(book => book.pages)  //下面代码返回Book(Future of Scala developers,85)books.minBy(book?=>?book.pages)

val numbers = Seq(1,2,3,4,5,6,7,8,9,10) numbers.filter(n => n % 2 == 0)//上面返回Seq(2,4,6,8,10)

val books = Seq(  Book("Future of Scala developers", 85),  Book("Parallel algorithms", 240),  Book("Object Oriented Programming", 130),  Book("Mobile Development", 495))
books.filter(book => book.pages >= 300)//上面返回Seq(Book("Mobile?Development",?495))

val abcd = Seq('a', 'b', 'c', 'd')val efgj = Seq('e', 'f', 'g', 'h')val ijkl = Seq('i', 'j', 'k', 'l')val mnop = Seq('m', 'n', 'o', 'p')val qrst = Seq('q', 'r', 's', 't')val uvwx = Seq('u', 'v', 'w', 'x')val yz   = Seq('y', 'z')  val alphabet = Seq(abcd, efgj, ijkl, mnop, qrst, uvwx, yz)
alphabet.flatten

List('a',?'b',?'c',?'d',?'e',?'f',?'g',?'h',?'i',?'j',?'k',?'l',?'m',?'n',?'o',?'p',?'q',?'r',?'s',?'t',?'u',?'v',?'w',?'x',?'y',?'z')

val num1 = Seq(1, 2, 3, 4, 5, 6)val num2 = Seq(4, 5, 6, 7, 8, 9)  //返回List(1, 2, 3)num1.diff(num2)  //返回List(4, 5, 6)num1.intersect(num2)  //返回List(1, 2, 3, 4, 5, 6, 4, 5, 6, 7, 8, 9)num1.union(num2)
//合并后再去重，返回List(1, 2, 3, 4, 5, 6, 7, 8, 9)num1.union(num2).distinct

val numbers = Seq(1,2,3,4,5,6)  //返回List(2, 4, 6, 8, 10, 12)numbers.map(n => n * 2)  val chars = Seq('a', 'b', 'c', 'd')  //返回List(A, B, C, D)chars.map(ch?=>?ch.toUpper)

val abcd = Seq('a', 'b', 'c', 'd')  //List(A, a, B, b, C, c, D, d)abcd.flatMap(ch?=>?List(ch.toUpper,?ch))

val numbers = Seq(3, 7, 2, 9, 6, 5, 1, 4, 2)  //返回turenumbers.forall(n => n < 10)  //返回falsenumbers.forall(n => n > 5)
//返回truenumbers.exists(n?=>?n?>?5)

import scala.io.Source

object ReadFile {  //读取ClasPath下的配置文件  val file = Source.fromInputStream(this.getClass.getClassLoader.getResourceAsStream("app.conf"))    
  //一行一行读取文件,getLines()表示读取文件所有行  def readLine: Unit ={    for(line <- file.getLines()){      println(line)    }  }   //读取网络上的内容  def readNetwork: Unit ={    val file = Source.fromURL("http://www.baidu.com")    for(line <- file.getLines()){      println(line)    }  }
 //读取给定的字符串-多用于调试 val source = Source.fromString("test") }

import scala.collection.JavaConversions.bufferAsJavaListscala.collection.mutable.Buffer?=>?java.util.List

import scala.collection.JavaConversions.asScalaBufferjava.util.List?=>?scala.collection.mutable.Buffer

import scala.collection.JavaConversions._
scala.collection.Iterable <=> java.lang.Iterablescala.collection.Iterable <=> java.util.Collectionscala.collection.Iterator <=> java.util.{ Iterator, Enumeration }scala.collection.mutable.Buffer <=> java.util.Listscala.collection.mutable.Set <=> java.util.Setscala.collection.mutable.Map <=> java.util.{ Map, Dictionary }scala.collection.concurrent.Map <=> java.util.concurrent.ConcurrentMap
scala.collection.Seq         => java.util.Listscala.collection.mutable.Seq => java.util.Listscala.collection.Set         => java.util.Setscala.collection.Map         => java.util.Mapjava.util.Properties???=>?scala.collection.mutable.Map[String,?String]

class SayHello{  def write(content:String) = println(content)}implicit val sayHello=new SayHello
def saySomething(name:String)(implicit sayHello:SayHello){ sayHello.write("Hello," + name)}
saySomething("Scala")
//打印 Hello,Scala

val?TEST_REGEX?=?"home\\*(classification|foundation|my_tv)\\*[0-9-]{0,2}([a-z_]*)".r

//path是用来匹配的字符串TEST_REGEX findFirstMatchIn path match {  case Some(p) => {    //获取TEST_REGEX中的第一个括号里正则片段匹配到的内容    launcher_area_code = p.group(1)    //获取TEST_REGEX中的第二个括号里正则片段匹配到的内容    launcher_location_code = p.group(2)    }}