变量定义
- val
- var
常用类型
循环
- while循环中断
判断
块表达式
操作符重载
方法
类型
- 不可变和可变的
懒值
queue
copy方法和带名参数

变量定义

val

可以不声明类型,scala自动推断类型

val a = "123";

也可以直接声明类型

val b: String = "123";

注意: val声明的变量,声明好了之后,值是不可变的,相当于final修饰了,但是可以用val重新赋值

scala> val k = "123"
k: String = 123
scala> k = "234"
<console>:12: error: reassignment to val
       k = "234"
         ^
scala> val k = "234"
k: String = 234

推荐用val,方便垃圾回收

var

和val相比,var是可以重新赋值的

常用类型

scala和java一样,有7种数值类型Byte, Char, Short, Int, Long, Float和Double(无包装类型)和一个Boolean类型

循环

注意:scala没有++这个操作符

scala> val s = "hello123";
s: String = hello123
scala> for (c <- s) println(c)

for里面的就是把s遍历出来的元素赋值给c

表达式1-10循环

for (i <- 1 to 10)
  println(i)

循环数组

# val arr = Array[String](_"a"_ "b"_ "c")
val arr = Array("a", "b", "c")
for (i <- arr)
  println(i)

高级循环

每个生成器都可以带一个条件,注意: if前面没有分号

scala> for (i <- 1 to 3; j<- 1 to 3 if i != j)
     | println(i + "---" + j)

for推导式
如果for循环的循环体以yield开始,则该循环会构建出一个集合
每次迭代生成集合中的一个值

val v = for (i <- 1 to 10) yield i * 10
println(v)
Vector(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)

util包左不包右

val a = Array("a", "b", "c")
for(i <- 0 util a.length) println(a(i))

while循环中断

import scala.util.control.Breaks
  val loop = new Breaks
  var n = 1
  loop.breakable{
    while(n<=20) {
      n+=1;
      println(n)
      if(n == 18) {
        loop.break()
      }
    }
  }

多重while循环

import scala.util.control.Breaks
  val loop1 = new Breaks
  val loop2 = new Breaks
  var count = 1
  loop1.breakable {
    while (true) {
      count += 1
      println(count)
      if (count == 10) {
        loop1.break()
      }
      loop2.breakable {
        while (true) {
          println(count)
          count += 1
          if (count == 20) {
            loop2.break()
          }
        }
      }
    }
  }

判断

支持混合类型的表达式

scala> val x = 1
x: Int = 1
scala> val z = if(x>1) 1 else "error"
z: Any = error

可以缺失else
如果缺失else,相当于if (x>2) 1 else ()

scala> val m = if (x>2) 1
m: AnyVal = ()

块表达式

scala> val x = 0
x: Int = 0
scala> val result = {
     | if(x>0) {
     | -1
     | } else if(x>=1) {
     | 1
     | } else {
     | "error"
     | }
     | }
result: Any = error

操作符重载

a+b

是如下方法调用的简写

a.+(b)

a方法b可以写成a.方法(b)

方法

scala> def m(x:Int) : Int = x*x
m: (x: Int)Int
scala> m(4)
res0: Int = 16

可以把返回值类型去掉

def m(x:Int) : x*x

可以返回空

scala> def n (y:Int, z:Int) : Unit = println(y+z)
n: (y: Int, z: Int)Unit
scala> val a = n(1,3)
4
a: Unit = ()

还可以这样写

scala> def n(y: Int, z: Int) {
     | println(y+z)
     | }
n: (y: Int, z: Int)Unit

类型

AnyVal表示值类型
AnyRef表示引用类型

scala中,所有的值都是类对象,而所有的类,包括值类型,都最终继承自一个统一的根类型Any.
统一类型,是scala的一个特点,scala还定义了几个底层类(Bottom Class),比如Null和Nothing

Null是所有引用类型的子类型,而Nothing是所有类型的子类型.Null类只有一个实例对象,null,类似于java中的null引用.null可以赋值给任意引用类型,但是不能赋值给值类型
Nothing,可以作为没有正常返回值的方法的返回类型,非常直观的告诉你这个方法不会正常返回,而且由于Nothing是其他任意类型的子类,他还能跟要求返回值的方法兼容
Unit类型用来标识过程,也就是没有明确返回值的函数

不可变和可变的

不可变的

可变的

懒值

def play1(a1: Int) = {
    println("play方法被执行")
    a1
  }
  lazy val res = play1(10)
  println("res变量定义完毕")
  println(res)

输出

res变量定义完毕
play方法被执行
10

queue

new Queue[Int]()

queue ++= List(2,3,4) 向队列中追加list
dequeue按进入队列的顺序删除元素
enqueue塞入数据
queue.head返回队列的第一个元素
queue.last 返回队列的最后一个元素
queue.tail 返回除了第一个元素以外的元素

copy方法和带名参数

copy创建一个与现有对象值相同的新对象,并可以通过带名参数来修改某些属性

val amt = Currency(29.95, "EUR")
val price = amt.copy(value=19.95)

spark

基本语法