scala基本语言结构以及函数算子（持续更新......）

一、什么是scala
scala是一种编程式语言，函数是一个独立的类，可以自由传输；是一种纯面向对象的语言，它具备java的一切特性，并在其基础上进行了扩展。
二、scala的基本数据类型



2、变量和常量的声明
scala中通常用var来声明变量，可以改变；用val来声明常量，不可修改即不可对常量进行再赋值；不用指定数据类型，由Scala自己进行类型推测。
注意点： 在scala中每行后面不需要加分号，直接通过换行如来区分；但是一行中写了多个语句，语句与语句之间必须用分号来分割
例如：`
var age = 18 ; var name = “angelababy”

var heighat,score = 10
val sex = "male"

`
3、scala中的类和对象
class :修饰的称为伴生类；定义在class中的属性都是动态的，用于实例化 的;scala中的class类默认可以传参数，默认的传参数就是默认的构造函数。class 类属性自带getter ，setter方法。使用class时要new （必须new，除非在对象伴生用apply方法【在加载类的时候默认自动调用】已实经例化好）,并且new的时候，class中除了方法不执行，其他都执行。
object: 修饰的称为伴生对象;定义在object中的属性（字段、方法）都是静 态的,main函数写在里面;scala 中的object是单例对象，相当于java中的工具类，可以看成是定义静态的方法的类.object不可以传参数。使用object时，不用new.

创建类

class Person{
  val name = "zhangsan"
  val age = 18
  def sayName() = {
    "my name is "+ name
  }
}

在创建类时，可以在类名后面加入一个括号，括号中写定义的参数类型，括号中的参数就表示类的构造函数由括号内的参数组成。补充： ①当参数用var修饰那么可以通过对象修改其值；当参数用val修饰那么无法通过对象来修改值；当参数没有修饰符，那么在外部无法通过对象来调用。
②若想增加一个类的传入参数，则需要在声明的类中重写构造函数，这样就可以在mian函数中声明有增加的属性的对象，当然原来的对象也可以声明。
重写this函数：

  /*
   *  重写的构造函数，参数不能有修饰符
   */
  def this (id:Int,name:String,facePower:Double ){
    //首先要调用父构造函数
    this(id,name)
    fcp = facePower
    
  }

创建对象

object Lesson_Class {
   def main(args: Array[String]): Unit = {
    val person = new Person()
    println(person.age);
    println(person.sayName())
  }
}

Apply方法
使用此方法时，可以在main函数中不通过new来创建一个对象，即可以不用专门的一次一次地进行实例化，加载创建对象的这个类的时候，会自动调用apply这个方法，类似Java中的static静态块。
Apply方法的使用用例：

object ScalaDemo01 {
  def main(args: Array[String]): Unit = {
    val p = new Person("zs",19)
     val person = Person("wagnwu",10)   //不用使用new来创建一个实例
  }
}

class Person(xname :String , xage :Int){
  val name = "zs"
  val age = xage
  var gender = "m"
  def this(name:String,age:Int,g:String){
    this(name,age)
    gender = g
  }
}

object Person{
  def apply(name:String,age:Int)={
    new Person(name,age)  
  }
}

4、函数
1）普通函数

def fun (a: Int , b: Int ) : Unit = {
   println(a+b)
 }
fun(1,1)
    
def fun1 (a : Int , b : Int)= a+b
    println(fun1(1,2))  

2）递归函数

 /**
     * 递归函数 
     * 5的阶乘
     */
    def fun2(num :Int) :Int= {  //必须写返回值类型
      if(num ==1)
        num
      else 
        num * fun2(num-1)
    }
    print(fun2(5))

3）包含参数默认值的函数

 /**
   * 包含参数默认值的函数
   * 	1.	函数的参数有默认值，在调函数的时候可以传参，也可以不传参，
   * 	2.	若不传参使用的默认值，
   * 	3.	如果传参，默认值会被覆盖
   */
  def fun2(num1:Int = 10,num2:Int = 20) = {
    num1 + num2
  }
  
  def fun3(num1:Int,num2:Int = 20) = {
    num1 + num2
  }
  
  def fun4(num1:Int=10,num2:Int) = {
    num1 + num2
  }
  调用：
   println(fun2())
   println(fun3(100))
   println(fun4(num2=1000))

4）可变参数个数的函数：函数参数可以是一个也可以是多个，随机灵活的

 def fun5(args:Double*) = {
    /**
     * 在scala中
     * 		+=前后的数值类型必须一致
     * 		+前后的数值类型可以不一致
     */
    var sum = 0.0
    for(arg <- args) sum += arg
    sum
  }

5）匿名函数：没有函数名的函数

/**
 * 匿名函数
 * 1.有参数匿名函数
 * 2.无参数匿名函数
 * 3.有返回值的匿名函数
 * 注意：
 * 可以将匿名函数返回给定义的一个变量
 * 匿名函数不能显式声明函数的返回类型

 */
//有参数匿名函数
val value1 = (a : Int) => {
  println(a)
}
value1(1)
//无参数匿名函数
val value2 = ()=>{
  println("我爱Angelababy")
}
value2()
//有返回值的匿名函数
val value3 = (a:Int,b:Int) =>{
  a+b
}
println(value3(4,4)) 

6）偏应用函数(偏函数)：偏应用函数是一种表达式，不需要提供函数需要的所有参数，只需要提供部分，或不提供所需参数。在多个函数调用时，有共同的参数被使用，则可提取出来默认写死，只需要为函数提供部分的参数。

/**
 * 偏应用函数
 */
def log(date :Date, s :String)= {
  println("date is "+ date +",log is "+ s)
}

val date = new Date()
log(date ,"log1")
log(date ,"log2")
log(date ,"log3")

//想要调用log，以上变化的是第二个参数，可以用偏应用函数处理
val logWithDate = log(date,_:String)    //下划线相当于占位符的作用，手动传入即可
logWithDate("log11")
logWithDate("log22")
logWithDate("log33")

5、scala算子

• 排序:sortby、sorted、sortwith
• 拉平：flatten
• 聚合函数：
  -aggregate
  1)map端聚合mapCal生效，不走reduce端reduceCal失效
  2）par产生分区，mapCal->reduceCal

var a = Array(1,2,3,10,13,21);
println(a.aggregate(0)((x:Int,y:Int) => {
	println(s"$x + $y = $(x+y)")
	x + y
},(x:Int,y:Int) => {
	println(s"$x - $y = $(x-y)")
	x - y
}))

6、/：从左向右累加（过期用foldLeft代替）；:\ 从右向左累加（过期用foldRight累加）
7、删除操作：不改变源数组，生成新数组
drop(n)：删除数组左侧的n个元素
dropRight(n)：删除数组右侧的n个元素
dropWhile(p:Type=>Boolean)：删除数组中符合条件的元素
i）若第一个元素就不符合条件，则不删除
ii）从第一个符合条件的开始删除，到第一个不符合条件的结束