spark源码之scala基础学习
一、scala
scala是一种基于JVM的面向对象的函数编程，scala编程相对于java而言代码整洁、开发效率更高。
其中scala优点主要有：
1：面向对象，可以定义class，通过new调用实例对象使用。
2：兼容java，在scala中可以直接调用java方法。
2：函数式编程，柯里化函数，匿名函数，高阶函数等。
3：代码行简单。
4：支持并发控制，Actor Model机制
5：目前比较流行的kafka，spark均由scala开发。
二、scala基础语法
object Scalademo {
常用符号 _ 通配符 =>匿名函数 <- for便利符号
var a = 1 //变量
val b = 2 //常量
def t1 = a //定义函数
def t3 = print(a + b) //定义函数
def t4 = a + b //定义函数，当有;时需要使用{}
def t5(a: Int, b: Int) = println(a + b); a + b //带参数的函数
def t6(a: Int)(b: Int) = println(a + b); a + b //柯里化函数
def t7 = t5(_, _)
def t8 = (a: Int) => { a } //匿名函数
def t9(t: (Int) => Int) = { println(t(2)) } //高阶函数
def t10(a: Int): Int = { if (a <= 0) 1 else a * t10(a - 1) } //递归函数
def t11(a: Int, b: Int, c: Int): Int = { //嵌套函数
def t11_1(a: Int, b: Int): Int = {
a + b
}
t11_1(t11_1(a, b), c)
}
高阶函数+匿名函数+嵌套函数
def t12(f: Int => Int): (Int, Int) => Int = {
def sumF(a: Int, b: Int): Int =
/* 1+2+3+0
2+3+0
3+0*/
if (a > b) 0 else f(a) + sumF(a + 1, b)
sumF
}
scala常用集合及其方法
1.list不可变的
2.map是key-value
var list = List[Int](1, 2, 3, 4, 5)
def t12(c: List[Int]): List[Int] = {
//to表示 到最大值 及<=n
for (i <- 0 to list.length - 1) {
println(list(i));
}
//until表示 到最大值 及<n
for (i <- 0 until list.length) {
println(list(i));
}
/**
* map方法返回集合，有返回值
*/
c.map(a => {
if (a == 2) println(a);
a + 1
})
}
def t13(c: List[Int]): ListBuffer[Int] = {
var array = ListBuffer[Int]()
/**
* foreach方法不返回集合，没有返回值
*/
c.foreach(q => {
array += q;
})
array
}
/**
* list指定数+所有元素相加
*/
def t14(c: List[Int], d: Int): Int = {
c.:\(d)((c, b) => {
c + b
})
c.:\(1)((b, x) => {
+x
})
}
/**
*list所有元素相加
*/
def t15(c: List[Int]): Int = {
c.reduce((a, b) => {
a + b;
})
}
/**
* map
*/
def t16 = (a: String) => {
var map = Map[String, String]();
map += ("key" -> a);
map += ("key2" -> (a + "1"));
map.foreach(a => {
println(a._1 + "=" + a._2);
})
map.keys.foreach(a => { println(map(a)) })
}
}
伴生机制+继承
object是伴生对象，class是scala中没有static成员存在,但是允许以某种方式使用static成员。
class是伴生对类，需要实例化，支持构造函数等，private 私有。
trait使用interface实现多重继承，在Scala中可以通过特征（trait）实现多重继承，不过与java不同的是，它可以定义自己的属性和实现方法体，在没有自己的实现方法体时可以认为它时java interface是等价的，在Scala中也是一般只能继承一个父类，可以通过多个with进行多重继承。
这就是伴生机制，所谓伴生就是在语言层面上把static成员和非static成员用object和class区分，如果在同一文件下会编译到一起
class Test private (override val a: Int, override val b: Int) extends Test1(a, b) {
override def toStrings(): Unit = {
print(a + "..111.." + b)
}
}
class Test1(val a: Int, val b: Int) {
val q: Int = a;
val w: Int = b;
def toStrings(): Unit = {
print(a + "...." + b)
}
}
隐式转换-包括普通隐式转换，增强转换， 隐式参数等
通过隐式转换，程序员可以在编写Scala程序时故意漏掉一些信息，让编译器去尝试在编译期间自动推导出这些信息来，这种特性可以极大的减少代码量，忽略那些冗长，过于细节的代码。
使用implicit关键字，运营时会自动扫描
class Student(val name: String)
class Gog(val name: String)
class Cat(val a: String)
class Pig(val a: String) {
def getNone {
print("i am a pig " + a)
}
}
object ScalaOf {
/**
* 隐式转换-传送函数参数时可以直接使用转换类
*/
implicit def obiectTo(obj: Object): Student = {
if (obj.getClass == classOf[Gog]) {
var dog = obj.asInstanceOf[Gog];
new Student(dog.name)
} else if (obj.getClass == classOf[Cat]) {
var cat = obj.asInstanceOf[Cat];
new Student(cat.a)
} else {
Nil
}
}
def t17(a: Student) {
print(a.name);
}
/**
* 增强转换-创建class对象后可以直接调用转换类的方法
*/
implicit def ObjtoObj(man: Cat): Pig = new Pig(man.a);
def main(args: Array[String]): Unit = {
var args = new Cat("我是小狗狗");
args.getNone;
}
}
/**
* 隐式参数-不需要实例class即可调用其中函数
*/
class Yin() {
def pro(a: String) = println(a)
}
object ImplicitContext {
implicit val signPen = new Yin
}
object Implicit04 {
def aing(a: String)(implicit signPen: Yin) = {
signPen.pro(a)
}
def main(args: Array[String]): Unit = {
//使用隐式参数时需要导入object
import ImplicitContext._
aing("i like ")
}
}