Spark学习笔记1-Scala基础语法

1.Scala简介

Scala是一门多范式的编程语言，一种类似java的编程语言 ，设计初衷是实现可伸缩的语言、并集成面向对象编程和函数式编程的各种特性。
java之父JamesGosling也曾说过，在java虚拟机JVM上，他除了用java，其他更多的就是使用scala，可见scala也是十分强大的语言。

2.基本语法

2.1值

2.1.1整型

scala> 1+2

res0: Int = 3

如上可以直接做值的计算。res0位结果的返回值，且为整数。
2.1.2浮点型

scala> 1+2.0

res0: Double = 3.0

如上res0位结果的返回值，且为double型。

2.1.3 scala面向对象特性

scala是纯面向对象的，所以上述还可以写成：

scala> 1.+(2)

res1: Int = 3

从中可以知道＋其实就是一个实现相加的方法，符合了面向对象的代码风格，这也是scala优于java之处。也说明了scala中所有表达式都可以作为方法。

2.2 object中的apply

数组的创建实际上是调用了apply方法。如下代码：

scala> val arr = Array(1,2,-3,4,-5)

arr: Array[Int] = Array(1, 2, -3, 4, -5)

上述代码等同于:

scala> val arr = Array.apply(1,2,-3,4,-5)

arr: Array[Int] = Array(1, 2, -3, 4, -5)

其中val相当于常量，变量定义用var，在scala和spark更常用的是val。

2.3 块

scala> val x:Int = 12

x: Int = 12

scala> if(x<15) {

     |println(x)

     |5

     |}

12



res4: AnyVal = 5

上面是先定义来一个整数x=5,然后判断当x小于15，打印x。计算结果为12，返回值为5.

最后一行写了个数字5，是为了说明在块中，若无return ，最后一行就是块默认的返回值。

2.4 输出，输入

2.4.1 scala有3种常用输出

代码如下：

a>println函数

scala> println("Spark")

Spark

b> print函数

scala> print("\nSpark")



Spark

c> printf函数

scala> printf("%s is the future of Big Data ComputationFramwork.\n","Spark")

Spark is the future of Big Data ComputationFramwork.

2.4.2 scala的输入

scala> readLine

warning: there was one deprecation warning; re-run with-deprecation for details

res10: String = wo shi xian ming

readLine是常用的输入方式。如上例中我的输入时 wo shi xian ming

2.6循环

2.6.1 while循环

scala> var element = 15

element: Int = 15

scala> while(element > 10){

     |println(element)

     |element -= 1

     |}

15

14

13

12 

11

如上例子，用while循环打印了15到11.其中说明scala中没有＋＋或－－操作，上面用的时element －＝ 1

2.6.2 for循环

scala> for(i <- 0 to element) println(i)

0

1

2

3

4

5

6

7

8

9

10

如上：可以用for循环，实现相同功能

2.7 函数

2.7.1 函数定义

scala> def f1(param1:String,param2:Int =30)=param1+param2

f1: (param1: String, param2: Int)String

2.7.2 函数使用

scala> f1("hello ")

res15: String = hello 30

如上例子用def定义函数，参数可以直接复值，也可以不赋值。
2.7.3 函数的变长参数

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,7,8,9,10)

res16: Int = 49

如上参数可以使用＊来表示变长参数。

2.8过程

所谓过程，要区别于函数，其实就是无返回值的函数。
用如下3种方式定义同个函数：
a> def morning(content: String) = "Good"+content
b> def morning(content: String) {println("Good "+content)}
c> defmorning(content: String) ：Unit = "Good "+content
上述3种方式a是普通函数，b和c是过程。

2.9 lazy

lazy就是暂时先不执行后面的程序，在处理耗时的函数或处理数据库中非常实用。如下代码：

scala> lazy val newSum =sum(1,2,3,4,5,6,7,8,9,10)

newSum: Int=<lazy>

用lazy修饰了求和后赋值给newSum操作，结果并未计算。只用再次输入newSum后才运行，如下：

scala> newSum

res17: Int = 55

2.10 异常处理

try｛｝catch｛｝finally｛｝

其中区别于java中的try－catch语言，就是catch可以没有参数

2.11 数组

2.11.1数组的创建

scala> val arr = new Array[Int](5)

arr: Array[Int] = Array(0, 0, 0, 0, 0)

如上代码，创建了长度为5，默认初值为0的数组aar，或者可以更加直接，如下省去new和数据类型：

scala> val arr1 =Array("Spark","Hadoop") 

arr1: Array[String] = Array(Spark, Hadoop)

2.11.2对数组操作要把他转换为arrayBuffer

scala> val arr2 = arr1.toBuffer 

arr2: scala.collection.mutable.Buffer[String] =ArrayBuffer(Spark, Hadoop)

也可以转回array,如下：

scala> val arr3 = arr2.toArray

arr3: Array[String] = Array(Spark, Hadoop)

2.11.3在数组中加入，删除元素

a>在数组后追加一个元素

scala> arr2 += "is"

res19: arr2.type = ArrayBuffer(Spark, Hadoop,is)

b>追加整个数组

scala> arr2 ++= Array("new","world","ha")

res20: arr2.type = ArrayBuffer(Spark, Hadoop, is, new,world,ha)

c>删除末尾一个元素

scala> arr2.trimEnd(1)

scala> arr2

res24: scala.collection.mutable.Buffer[String] =ArrayBuffer(Spark, Hadoop, is,new,word)

d>中间加入元素

scala> arr2.insert(2,"a")

scala> arr2

res38: scala.collection.mutable.Buffer[String] =ArrayBuffer(Spark,Hadoop,a, is,new,word)

如上是表示加入了1个元素“a”，其中insert可以插入多个元素，如arr2.insert（6，”It’s”,”OK”），表示从下标6的数组位置开始，添加2个元素。

e>删除中间元素

scala> arr2.remove(1)

res25: String = Hadoop

scala> arr2

res26: scala.collection.mutable.Buffer[String] =ArrayBuffer(Spark,is,a,new, World)

如上是删除了第二个元素Hadoop，小标为1.其中remove还可以用来删除多个元素，如arr2.remove(2,3),表示从第二个元素开始删除3个。

2.11.4数组的遍历

方法一：

scala> for(element <- arr2) println(element)

Spark

is

a

new

world

方法二：

scala> for(i <- 0 until (arr2.length,1))println(arr2(i))

Spark

is

a

new

world

2.11.5数组的进一步操作

如：计算元素和：arrary.sum

求元素中最大数：arrary.max

数组合并为字符串：arrary.mkString或arrary.mkString(“,”)

代码如下：

scala> val array = Array(1,2,3,4,5)

array: Array[Int] = Array(1, 2, 3, 4, 5)

scala> array.max

res43: Int = 5


scala> array.sum

res44: Int = 15


scala> array.mkString

res45: String = 12345


scala> array.mkString(",")

res46: String = 1,2,3,4,5

3.map

3.1map是用来建立key－value数据

如下代码：

scala> val persons = Map("Spark" -> 6,"Hadoop" ->11) 

persons: scala.collection.immutable.Map[String,Int] =Map(Spark -> 6, Hadoop -> 11)

3.2访问key值

scala> persons("Hadoop")



res48: Int = 11

返回了value值

3.3追加值

scala> persons.+("FLink" -> 5)



res52: scala.collection.immutable.Map[String,Int] =Map(Spark -> 6, Hadoop -> 11, FLink -> 5)

3.4删除值

scala> persons.-("Link") 



res53: scala.collection.immutable.Map[String,Int] =Map(Spark -> 6, Hadoop -> 11)

3.5用contains查看是否包含某元素，并返回其值

scala> val sparkValue = if(persons.contains("Spark"))persons("Spark"); else "no value"

sparkValue: Any = 6

改代码也可以表示为更常用的方式，用getOrElse表示如下：

scala> val sparkValue = persons.getOrElse("Spark","novalue") 

sparkValue: Any = 6

3.6打印key－value值

scala> for((key,value) <- persons) println(key +":" +value)

Spark:6

Hadoop:11

4 tuple

tuple是key－value的加强，如下：

scala> val tuple = ("Spark",6,2015)

tuple: (String, Int, Int) = (Spark,6,2015)

可以创建3个值。其访问方式是tuple._[num]，如下：

scala> tuple._1

res55: String = Spark



scala> tuple._2

res56: Int = 6



scala> tuple._3

res57: Int = 2015

---

XianMing
本文原创，转载请标明链接