跳到主要内容

生产实习02-Scala基础

提示

Scala是一门多范式（multi-paradigm）的编程语言，式Scalable Language的简写。Scala设计的初衷是要集成面向对象编程和函数式编程的各种特性。Scala运行在Java虚拟机上，并兼容现有的Java程序。Scala源代码被编译成Java字节码，所以它可运行在JVM之上，并可以调用现有的Java类库。

scala变量​

基本语法: var/val 变量名[:变量类型]=变量值 (自动推导) var修饰的变量可改变 val修饰的变量不可改变,val修饰的对象属性在编译后类似与Java中增加的final关键字。 注意：声明变量时，类型可以省略【类型可以自动推断】

object TuppleScala {
  def main(args: Array[String]): Unit = {
    //元祖：将不同类型的数据保存为一个变量
    //1. 创建元祖
    val t1 = ("zhangsan",22,"bigdata")
    //2. 访问元祖
    println(t1._1)
    println(t1._2)
    //3.元祖中的数据最多22个数据，分别对应于Tuple1、Tuple2、....Tuple22
    //4.循环遍历
    for(e <- t1.productIterator){
      println(e)
    }
  }
}

输入输出​

流程控制​

if​

有返回值的分支:

val flag =true
val res1:Any = if(flag){
  "hello"
}
println(res1)

val res2:Any=if(flag){
  "hello"
}else{
  "world"
}
println(res2)

for循环​

Scala为for循环提供了非常多的特性，这些for循环特性被成为for推导式或者for表达式。

符号：<-

for (i <- 1 to 5)
  println(s"i=$i")

for (i <- 1 until 5)
  println(s"i=$i")

循环守卫​

循环守卫就是增加条件判断，如果条件成立，则执行循环体，否则跳过循环体。

for(i <- 1 to 10 if i % 2 ==0){
  println(s"i=$i")
}

带返回值的循环​

val result1 = for(i <- 1 to 10){
  println(s"i=$i")
}
 println(result1)

 val result2 = for(i <- 1 to 5) yield i * 2 //yield都会生成一个将被记住的缓存值，然后赋值给result2。
 println(result2)

while 循环​

Scala也提供while循环语句，不过Scala弱化了while循环语句的作用，在程序中不推荐使用While循环，尽量使用for循环或者递归代替while循环语句。

var i =1
var sum =0
while(i < 10){
  sum - sum + i
  i = i +1
}

练习：采用for,while循环计算 1!+2!+...5!

  var tmp=1;var ans=0
  for (i<-1 to 5) {
    for(j<- 1 to i) {
        tmp *= j
    }
    ans = ans + tmp
    println(ans)
  }
  print(ans)

函数​

在 Scala 当中，函数是一等公民，像变量一样，既可以作为函数的参数使用，也可以将函数赋值给一个变量。函数的创建不用依赖于类或者对象，而在 Java 当中，函数的创建则要依赖于类、抽象类或者接口。

def 函数名 ([参数名: 参数类型], ...)[[:  返回值类型] =] {
语句...
[return] 返回值
}
def gcd(x:Int,y:Int) :Int={
  if (x % y ==0)
    y
  else 
    x
}

val result = gcd(20,10) 
print(result)

Scala具有类型推导功能，可以根据最终的返回值推到出函数的返回值类型，因此在实际应用中也常常会省略函数的返回值。


val sum(x:Int,y:Int) => x+y
val result = sum(10,20)
Println(result)

可变参数函数​


def f1(a:Int*) ={
  var sum = 0
  for(i <- a)
    sum += 1
  sum
}
print(f1(1,2,3,4,5))
print(f1()) //?
println(f1(1,2,3,4,5,6))

集合​

Scala中的集合(collection)分为两种，一种是可变集合，另一种是不可变的集合。可变集合可以被添加、修改、删除；不可变集合执行添加、删除、更新操作后返回的是新集合，原来的集合保持不变。Scala中所有的集合都来自于Scala 默认采用不可变集合，对于几乎所有的集合类，Scala 都同时提供了可变(mutable)和不可变(immutable)的版本。

数组​

//1.创建数组对象
    //定长数组，默认值为0
    val a1 = new Array[Int](10)
    //变成数组，直接进行初始化
    val a2 = Array(1,2,3,4,5,6)
    println(a2(1))
    a2.foreach(a => println(a))
    a2.foreach(print)
    println()
    println(a2.mkString(","))
    a2(3)=10
    println(a2.mkString(","))
    println(a2.length)
    println(a2.size)

    //变长数组
    val a3 = ArrayBuffer(1,2,3,4,5)
    println(a3.mkString(","))
    a3.append(10,20)
    println(a3.mkString(","))
    a3 += (30,40,50)
    println(a3.mkString(","))
    //可变数组与不可变数组之间的转换
    a1.toBuffer
    a3.toArray
0%