scala(一)

1.val var 值与变量

• 注意Int首字母要大写.
• val的值不能改

scala> val salary:int = 15000
<console>:11: error: not found: type int
       val salary:int = 15000
                  ^
scala> val salary:Int = 15000
salary: Int = 15000

scala> salary = 20000
<console>:12: error: reassignment to val
       salary = 20000
              ^

• var的值可以改

scala> var name:String="xiaohong"
name: String = xiaohong

scala> name = "xiaobai"
name: String = xiaobai

• 工作中优先选择val,不能满足再改.

2.数据类型

基本类型

• Scala 与 Java 有着相同的数据类型，在 Scala 中数据类型都是对象，也就是说 scala 没有 java 中的原生类型

1. Float

scala> var salary = 10
salary: Int = 10

//float的两种写法
scala> var salary = 10f
salary: Float = 10.0

scala> var salary:Float = 10
salary: Float = 10.0

2. Double

scala> val salary = 1000d
salary: Double = 1000.0

3. String
4. Int
5. Long

scala> val salary = 1000L
salary: Long = 1000

7. Boolean

• 数据类型转换

scala> val i = 10.asInstanceOf[Double]
i: Double = 10.0

• 判断数据类型

scala> 10.isInstanceOf[Double]
res3: Boolean = false

数据类型框架

• 顶层接口:Any
  AnyVal:值类型
  数值,
  Boolean,
  Unit

  AnyRef:引用类型
  注意：不管是 AnyVal 还 是 AnyRef 都是对象。

Unit 类型、Null 类型和 Nothing 类型

1. Null 类只有一个实例对象， null， 类似于 Java 中的 null 引用。 null 可以赋值给任意引用类型 (AnyRef)，但是不能赋值给值类型(AnyVal: 比如 Int, Float, Char, Boolean, Long, Double, Byte, Short)

2. Unit 类型用来标识过程，也就是没有明确返回值的函数。由此可见，Unit 类似于 Java 里的 void。 Unit 只有一个实例，()，这个实例也没有实质的意义

3. Nothing，可以作为没有正常返回值的方法的返回类型，非常直观的告诉你这个方法不会正常返 回，而且由于 Nothing 是其他任意类型的子类，他还能跟要求返回值的方法兼容。

3.function

def sum(x:Int,y:Int):Int={
	fuction body
}

/*
def: 定义的关键字
sum：function的名字
x:Int,y:Int  : function的入参
Int :  返回值类型
*/

function两种写法:

def sum(x: Int, y: Int): Int = {
    x + y
  }

//在特殊场景下还是需要写返回类型的,递归
def sum02(x: Int, y: Int)=x+y

• 如果没有入参,在调用时可以不写()

def sayHello(): Unit ={
    print("sayhello")
 }
 
 def main(args: Array[String]): Unit = {
  	sayHello			//sayhello的()可以写也可以不写
 }

• 大部分场景scala可以自身推导出返回值类型,但是递归要指明返回值类型
  

  def mult(x: Int): Int = {
    if (x <= 1) {
      1
    } else {
      x * mult(x - 1)
    }

4.循环

1. to 左闭右闭

scala> 1 to 10
res4: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

• 1.to(10)

scala> 1.to(10)
res6: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

2. Range 左闭右开

scala> Range(1,10)
res8: scala.collection.immutable.Range = Range(1, 2, 3, 4, 5, 6, 7, 8, 9)

scala> Range(1,10,2)
res9: scala.collection.immutable.Range = Range(1, 3, 5, 7, 9)

scala> Range(1,10,0)
java.lang.IllegalArgumentException: step cannot be 0.
  at scala.collection.immutable.Range.<init>(Range.scala:86)
  at scala.collection.immutable.Range$.apply(Range.scala:439)
  ... 32 elided

3. until 左闭右开

scala> 1 until 10
res5: scala.collection.immutable.Range = Range(1, 2, 3, 4, 5, 6, 7, 8, 9)

scala> 1.until(10)
res7: scala.collection.immutable.Range = Range(1, 2, 3, 4, 5, 6, 7, 8, 9)

4. 其他

scala> 1 to 100 by 10
res11: scala.collection.immutable.Range = Range(1, 11, 21, 31, 41, 51, 61, 71, 81, 91)

5.数组

val arr = Array(1,2,3,4,5)

for(ele<-arr){
      println(ele)
 }

• foreach遍历

val arr = Array(1,2,3,4,5)
arr.foreach(ele => println(ele))

arr.foreach(println)

val arr = Array(1,2,3,4,5)
val result = for(ele<-arr) yield ele*10
result.foreach(println)

//结果 10 20 30 40 50

6.默认参数.在定义function时,允许指定参数的默认值

def loadConfiguration(name:String="default-conf"): Unit ={
      println(name)
    }

//main中
loadConfiguration()
loadConfiguration("spark")  //在线上环境,不同的作业,spark配置的值是不同的.不走默认参数

//在main方法中输出的结果是不同的
//传进来什么用什么,不传就用默认的

当function入参为空时可以省略,这个是个特例.

7.变长参数

  def sum03(nums:Int*) ={
    var result= 0
    for(num<- nums){
      result += num
    }
    result		//不要忘记加上
  }
  
//main方法中
 println(sum03(1,2,3,4))	//正确输出

println(sum03(1 to 10))	//1 to 10输出的结果格式不正确

println(sum03(1 to 10 :_*))	//正确输出,格式要记住

sum03函数里被声明为类型为Array[Int]

这个标注告诉编译器把 arr 的每个元素当作参数，而不是当作单一的参数传给 sum03 。

1 to 10 获取到的是一个collection.

8.函数

• 函数定义:
  var/val 函数名称 = (参数列表) => {函数体}

//f1是函数名.也可以叫做变量,值
val f1=(x:Int,y:Int)=>x+y

println(f1(2,3))

example

求和100

	var (sum,index)=(0,100)
    while (index>0){
      sum = sum + index
      index = index -1
    }
    println(sum)


  def printCourses(courses:String*): Unit ={
    courses.foreach(println)
  }

yield

    val arr = Array(1,2,3,4,5)
    val result=for(ele<- arr) yield ele*10
    result.foreach(println)

结果:

10
20
30
40
50

  def main(args: Array[String]): Unit = {
    //说明 val res = for(i <- 1 to 10) yield i 含义
    // 1. 对 1 to 10 进行遍历 //2. yield i 将每次循环得到 i 放入到集合 Vector 中，并返回给 res
    // 3. i 这里是一个代码块，这就意味我们可以对 i 进行处理 
    // 4. 下面的这个方式，就体现出 scala 一个重要的语法特点，就是将一个集合中个各个数据进行处理，并返回给新的集合

    val res = for (i <- 1 to 10) yield {
      if (i % 2 == 0) {
        i
      } else {
        "不是偶数"
      }
    }
    println (res)
  }
//输出结果:Vector(不是偶数, 2, 不是偶数, 4, 不是偶数, 6, 不是偶数, 8, 不是偶数, 10)

---

注意的点

1. scala是静态语言

2. scala不强制使用;作为代码的最后

3. 最后一行当做返回值,不需要写return

4. 在idea中拷贝java代码到scala中,会自动重构,.但是不建议使用.

5. 声明变量时，类型可以省略（编译器自动推导,即类型推导）

6. scala 设计者为什么设计 var 和 val:
   1)在实际编程，我们更多的需求是获取/创建一个对象后，读取该对象的属性， // 或者是修改对象的属性值, 但是我们很少去改变这个对象本身
   2)因为 val 没有线程安全问题，因此效率高，scala 的设计者推荐我们 val
   3)如果对象需要改变，则使用 var

7. Scala 不支持三目运算符 , 在 Scala 中使用 if – else 的方式实现。

8. Scala 访问修饰符基本和Java的一样，分别有：private，protected，public。
   如果没有指定访问修饰符，默认情况下，Scala 对象的访问级别都是 public。
   Scala 中的 private 限定符，比 Java 更严格，在嵌套类情况下，外层类甚至不能访问被嵌套类的私有成员。

9. 函数定义定义: val/var 函数名称=(参数列表)=>{函数体}

val f1=(a:Int,b:Int)=>a+b

也可以称作变量,函数名,通常称之为函数名

方法的本质上是一种特殊的函数
方法用def定义,函数的标识=>

不建议用函数,方法足够用了.