python spark教程菜鸟教程_从零开始学习Spark（二）Scala基础

Scala基础

Spark的原生语言是Scala，因此入门一下Scala是学习Spark的第一步，下面就快速入门一下，争取不花太多的时间。之后的简书中还会有Scala进阶，交代一些其他特性。这篇Scala基础应该可以暂时应付之后Spark的学习。

Scala运行在JVM上

Scala是纯面向对象的语言

Scala是函数式编程语言

Scala是静态类型语言

1. HelloWorld

object HelloWorld {

def main(args: Array[String]): Unit = {

println("Hello, world!")

}

}

2. 交互式编程与脚本形式

交互式编程进入方式有两种，terminal中输入scala，或者输入sbt再输入console

脚本形式则类似Java的编译形式

$ scalac HelloWorld.scala

$ scala HelloWorld.scala

scalac编译生成.class文件，注意可以跳过这一步，直接使用scala来执行

3. Scala包

定义包

package com.runoob

class HelloWorld

第二种定义包的方法，可以一个文件中定义多个包

package com.runoob {

class HelloWorld

}

源文件的目录和包之间并没有强制的关联关系。你不需要将Employee.scala放在com/horstmann/impatient目录当中

package com {

package horstmann {

package impatient {

class Manager

......

}

}

}

引用包

import com.runoob.HelloWorld

import java.awt._ //引入包内所有成员

注意scala中类和对象一般用大写字母开头

4. Scala变量与数据类型

数据类型

只罗列几个特殊的，注意所有的数据类型都是对象

Byte, Short, Int(默认), Long, Float, Double(默认), Char, String

Unit 表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。

Null null 或空引用

Nothing Nothing类型在Scala的类层级的最低端；它是任何其他类型的子类型。

Any Any是所有其他类的超类

AnyRef AnyRef类是Scala里所有引用类(reference class)的基类

变量和常量

在 Scala 中，使用关键词 "var" 声明变量，使用关键词 "val" 声明常量

var myVar: String = "Foo"

var myVar2: Int //变量声明不一定要初始值

val myVal: String = "Too" //常量不能修改

var myVar = 10; //常量和变量的声明不一定要指明数据类型，编译器会自己推断

val myVal = "Hello, Scala!";

还可以声明一个元组，变量常量都可以

scala> val pa = (40,"Foo")

pa: (Int, String) = (40,Foo)

5. Scala访问修饰符

Scala访问权限

private：仅在包含了成员定义的类或对象内部可见。Java中允许这两种访问，因为它允许外部类访问内部类的私有成员。

class Outer{

class Inner{

private def f(){println("f")}

class InnerMost{

f() // 正确

}

}

(new Inner).f() //错误

}

protected：只允许保护成员在定义了该成员的的类的子类中被访问。而在java中，用protected关键字修饰的成员，除了定义了该成员的类的子类可以访问，同一个包里的其他类也可以进行访问。

package p{

class Super{

protected def f() {println("f")}

}

class Sub extends Super{

f()

}

class Other{

(new Super).f() //错误

}

}

public：Scala中，如果没有指定任何的修饰符，则默认为 public。这样的成员在任何地方都可以被访问。

JAVA的访问权限表

public--都可访问(公有)

protected--包内和子类可访问(保护)

不写(default)--包内可访问 (默认)

private--类内可访问(私有)

作用域保护

private[x] 或 protected[x]

这里的x指代某个所属的包、类或单例对象。如果写成private[x],读作"这个成员除了对[…]中的类或[…]中的包中的类及它们的伴生对像可见外，对其它所有类都是private。

6. 运算符，条件，循环

和JAVA基本相同，举几个for循环使用的例子

for( a

println( "Value of a: " + a );

}

until表示不包含后面的值

for( a

println( "Value of a: " + a );

}

在 for 循环 中你可以使用分号 (;) 来设置多个区间，它将迭代给定区间所有的可能值。

for( a

println( "Value of a: " + a );

println( "Value of b: " + b );

}

for 循环会迭代所有集合的元素

val numList = List(1,2,3,4,5,6);

for( a

println( "Value of a: " + a );

}

for循环还可以加入条件过滤

val numList = List(1,2,3,4,5,6,7,8,9,10);

// 下面的代码会输出1,2,4,5,6,7

for( a

if a != 3; if a < 8 ){

println( "Value of a: " + a );

}

利用yield来产生集合，和python不一样的

val numList = List(1,2,3,4,5,6,7,8,9,10);

// 下面的代码会输出1,2,4,5,6,7

var retVal = for( a

if a != 3; if a < 8 )yield a

retVal: List[Int] = List(1, 2, 4, 5, 6, 7)

7. 函数

声明

def functionName ([参数列表]) : [return type]

定义

def functionName ([参数列表]) : [return type] = {

function body

return [expr]

}

如果函数没有返回值，可以返回为 Unit，这个类似于 Java 的 void

例子

object Test {

def main(args: Array[String]) {

println("Hello\tWorld\n\n")

println("3 + 4 = " + add(3, 4))

}

def add(a: Int, b: Int): Int = {

var sum: Int = a + b

return sum

}

}

8. 函数高级特性

传名调用

传名调用(Call-by-name)：参数传入时，不事先计算，而是将表达式子代入其中

传入参数时要用=>

object Test {

def main(args: Array[String]) {

delayed(time());

}

def time() = {

println("获取时间，单位为纳秒")

System.nanoTime

}

def delayed( t: => Long ) = {

println("在 delayed 方法内")

println("参数： " + t)

t

}

}

这个时候，相当于函数中的每个t都编程time()，所以输出会变成

在 delayed 方法内

获取时间，单位为纳秒

参数： 241550840475831

获取时间，单位为纳秒

可变参数

Scala 允许你指明函数的最后一个参数可以是重复的，即我们不需要指定函数参数的个数，可以向函数传入可变长度参数列表。

Scala 通过在参数的类型之后放一个星号来设置可变参数(可重复的参数)。

object Test {

def main(args: Array[String]) {

printStrings("Runoob", "Scala", "Python");

}

def printStrings( args:String* ) = {

var i : Int = 0;

for( arg

println("Arg value[" + i + "] = " + arg );

i = i + 1;

}

}

}

高阶函数

高阶函数(Higher-Order Function)就是操作其他函数的函数。

object Test {

def main(args: Array[String]) {

println( apply( layout, 10) )

}

// 函数 f 和 值 v 作为参数，而函数 f 又调用了参数 v

def apply(f: Int => String, v: Int) = f(v)

def layout[A](x: A) = "[" + x.toString() + "]"

}

偏应用函数

实际上就是固定函数的某些参数生成新的函数，使用下划线(_)替换缺失的参数列表

import java.util.Date

object Test {

def main(args: Array[String]) {

val date = new Date

val logWithDateBound = log(date, _ : String) //logWithDateBound就变成函数了

logWithDateBound("message1" )

Thread.sleep(1000)

logWithDateBound("message2" )

Thread.sleep(1000)

logWithDateBound("message3" )

}

def log(date: Date, message: String) = {

println(date + "----" + message)

}

}

匿名函数

相当于python中的lambda

var inc = (x:Int) => x+1

var mul = (x: Int, y: Int) => x*y

var userDir = () => { System.getProperty("user.dir") }

//调用

var x = inc(7)-1

println(mul(3, 4))

println(userDir())

函数柯里化(Currying)

def add(x:Int)(y:Int) = x + y

// 调用

var a = add(1)(2)

add(1)(2) 实际上是依次调用两个普通函数(非柯里化函数)，第一次调用使用一个参数 x，返回一个函数类型的值，第二次使用参数y调用这个函数类型的值。

参考资料