一、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 ")
}
}