一、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表示 到最大值 及 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 ") } }