笔记|scala与java的一些不同点 java|开发语言|scala

变量与常量

变量：

var i:Int = 10
常量：

val j:Int = 20

说明：
类型可以省略，类型确定后，就不能修改，变量声明时，必须要有初始值
字符串、变量一起使用

val s2 = s"name=$name" var age: Int = 18 //格式化输出 printf("info=%s age=%d\n", s2, age)//如果需要对变量进行运算，那么可以加${} val s1 = s""" |select |name, |age |from user |where name="$name" and age=${age+2} """.stripMargin println(s1)

键盘输入

def main(args: Array[String]): Unit = { // 1 输入姓名 println("input name:") var name = StdIn.readLine()// 2 输入年龄 println("input age:") var age = StdIn.readShort()// 3 输入薪水 println("input sal:") var sal = StdIn.readDouble()// 4 打印 println("name=" + name) println("age=" + age) println("sal=" + sal) }

数据类型

scala中一切数据都是对象，都是Any的子类。
scala中数据类型分为两大类：数值类型（AnyVal)、（AnyReg），不管是值类型还是引用类型都是对象。
scala数据类型仍然遵守，低精度的值类型向高精度值类型，自动转换（隐式转换）
scala中的StringOps是对Java中String的增强。
Unit: 对应Java中void.用于方法返回值的位置，表示方法没有返回值。
Unit是一个数据类型，只有一个对象就是()。Void不是数据类型，只是一个关键字
Null是一个类型，只有一个对象就是null。它是所有引用类型（AnyRef)的子类。
Nothing，是所有数据类型的子类，主要用在一个函数没有明确返回值时使用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Z5htjTfL-1652842108188)(O:%5CbmprProject%5CNew%20Mockup%201.png)]
for循环

范围数据循环（To）

for(i <- 1 to 3){ print(i + " ") } println()

范围数据循环（Until） : i 是从 1 到 3 - 1

for(i <- 1 until 3) { print(i + " ") } println()

循环守卫

for(i <- 1 to 3 if i != 2) { print(i + " ") } println()

循环步长

for (i <- 1 to 10 by 2) { println("i=" + i) }

嵌套循环

for(i <- 1 to 3; j <- 1 to 3) { println(" i =" + i + " j = " + j) }

引入变量
（1）for推导式一行中有多个表达式时，所以要加 ; 来隔断逻辑
（2）for推导式有一个不成文的约定：当for推导式仅包含单一表达式时使用圆括号，当包含多个表达式时，一般每行一个表达式，并用花括号代替圆括号

for { i <- 1 to 3 j = 4 - i } { println("i=" + i + " j=" + j) }

循环返回值

需求：将原数据中所有值乘以2，并把数据返回到一个新的集合中。

var res = for(i <-1 to 10) yield { i * 2 } println(res)//输出结果：Vector(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)

倒序打印

for(i <- 1 to 10 reverse){ println(i) }

循环中断
1）基本说明
Scala内置控制结构特地去掉了break和continue，是为了更好的适应函数式编程，推荐使用函数式的风格解决break和continue的功能，而不是一个关键字。Scala中使用breakable控制结构来实现break和continue功能。
2）案例实操
需求1：采用异常的方式退出循环

def main(args: Array[String]): Unit = { try { for (elem <- 1 to 10) { println(elem) if (elem == 5) throw new RuntimeException } }catch { case e => } println("正常结束循环") }

需求2：采用Scala自带的函数，退出循环

import scala.util.control.Breaksdef main(args: Array[String]): Unit = {Breaks.breakable( for (elem <- 1 to 10) { println(elem) if (elem == 5) Breaks.break() } )println("正常结束循环") }

? 需求3：对break进行省略

import scala.util.control.Breaks._object TestBreak {def main(args: Array[String]): Unit = {breakable { for (elem <- 1 to 10) { println(elem) if (elem == 5) break } }println("正常结束循环") } }

函数至简原则
函数至简原则：能省则省
（1）return可以省略，Scala会使用函数体的最后一行代码作为返回值
（2）如果函数体只有一行代码，可以省略花括号
（3）返回值类型如果能够推断出来，那么可以省略（: 和返回值类型一起省略）
（4）如果有return，则不能省略返回值类型，必须指定
（5）如果函数明确声明unit，那么即使函数体中使用return关键字也不起作用
（6）Scala如果期望是无返回值类型，可以省略等号
（7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加
（8）如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略
（9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略
函数的高阶用法

函数可以作为值进行传递

object TestFunction { def main(args: Array[String]): Unit = {//函数里嵌套函数 def foo():Int = { println("foo...") 1 }//1. 调用foo函数，把返回值给变量f val f = foo println(f)//2. 在被调用函数foo后面加上 _，相当于把函数foo当成一个整体，传递给变量f1 val f1 = foo _ foo() f1()//3. 如果明确变量类型，那么不使用下划线也可以将函数作为整体传递给变量 var f2:()=>Int = foo } }

函数可以作为参数进行传递

def main(args: Array[String]): Unit = {// （1）定义一个函数，函数参数还是一个函数签名；f表示函数名称; (Int,Int)表示输入两个Int参数；Int表示函数返回值 def f1(f: (Int, Int) => Int): Int = { f(2, 4)//这个f1函数相当于提供了2个数值 }// （2）定义一个函数，参数和返回值类型和f1的输入参数一致 def add(a: Int, b: Int): Int = a + b// （3）将add函数作为参数传递给f1函数，如果能够推断出来不是调用，_可以省略 println(f1(add)) println(f1(add _))}

函数可以作为函数返回值返回

def main(args: Array[String]): Unit = { def f1() = { def f2() = { 1 } f2 _ }val f = f1() // 因为f1函数的返回值依然为函数，所以可以变量f可以作为函数继续调用 f() // 上面的代码可以简化为 f1()() }

匿名函数
例：(x:Int)=>{函数体} 注意与定义函数时，= 变成了 =>

def main(args: Array[String]): Unit = {// （1）定义一个函数：参数包含数据和逻辑函数 def operation(arr: Array[Int], op: Int => Int) = { for (elem <- arr) yield op(elem) }// （2）定义逻辑函数 def op(ele: Int): Int = { ele + 1 }// （3）标准函数调用 val arr = operation(Array(1, 2, 3, 4), op) println(arr.mkString(","))// （4）采用匿名函数 val arr1 = operation(Array(1, 2, 3, 4), (ele: Int) => { ele + 1 }) println(arr1.mkString(","))// （4.1）参数的类型可以省略，会根据形参进行自动的推导; val arr2 = operation(Array(1, 2, 3, 4), (ele) => { ele + 1 }) println(arr2.mkString(","))// （4.2）类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过1的永远不能省略圆括号。 val arr3 = operation(Array(1, 2, 3, 4), ele => { ele + 1 }) println(arr3.mkString(","))// (4.3) 匿名函数如果只有一行，则大括号也可以省略 val arr4 = operation(Array(1, 2, 3, 4), ele => ele + 1) println(arr4.mkString(","))//（4.4）如果参数只出现一次，则参数省略且后面参数可以用_代替 val arr5 = operation(Array(1, 2, 3, 4), _ + 1) println(arr5.mkString(",")) } }

需求2：定义一个计算器函数，传递的函数有两个参数

object TestFunction {def main(args: Array[String]): Unit = {//定义一个计算器函数，可以对 a,b做加减乘除等运算。运算：传递op函数 def calculator(a: Int, b: Int, op: (Int, Int) => Int): Int = { op(a, b) }// （1）标准版 println(calculator(2, 3, (x: Int, y: Int) =>{x + y}))// （2）如果只有一行，则大括号也可以省略 println(calculator(2, 3, (x: Int, y: Int) =>x + y))// （3）参数的类型可以省略，会根据形参进行自动的推导; println(calculator(2, 3, (x , y) =>x + y))// （4）如果参数只出现一次，则参数省略且后面参数可以用_代替 println(calculator(2, 3,_ + _)) } }

高阶函数案例(高阶用法与匿名函数一起使用)
需求：模拟Map映射、Filter过滤、Reduce聚合

object TestFunction { def main(args: Array[String]): Unit = { // （1）map映射 def map(arr: Array[Int], op: Int => Int) = { for (elem <- arr) yield op(elem) } val arr = map(Array(1, 2, 3, 4), (x: Int) => { x * x }) println(arr.mkString(","))// （2）filter过滤。有参数，且参数再后面只使用一次，则参数省略且后面参数用_表示 def filter(arr:Array[Int],op:Int =>Boolean) ={ var arr1:ArrayBuffer[Int] = ArrayBuffer[Int]() for(elem <- arr if op(elem)){ arr1.append(elem) } arr1.toArray } var arr1 = filter(Array(1, 2, 3, 4), _ % 2 == 1) println(arr1.mkString(","))// （3）reduce聚合。有多个参数，且每个参数再后面只使用一次，则参数省略且后面参数用_表示，第n个_代表第n个参数 def reduce(arr: Array[Int], op: (Int, Int) => Int) = { var init: Int = arr(0) for (elem <- 1 until arr.length) { init = op(init, elem) } init } val arr2 = reduce(Array(1, 2, 3, 4), _ * _) println(arr2) } }

函数柯里化&闭包
闭包：函数式编程的标配
1）说明
闭包：如果一个函数，访问到了它的外部（局部）变量的值，那么这个函数和他所处的环境，称为闭包
函数柯里化：把一个参数列表的多个参数，变成多个参数列表。例： f(1,2,3) -> f(1)(2)(3)

object TestFunction {def main(args: Array[String]): Unit = { def f1()={ var a:Int = 10 def f2(b:Int)={ a + b } f2 _ }// 在调用时，f1函数执行完毕后，局部变量a应该随着栈空间释放掉 val f = f1()// 但是在此处，变量a其实并没有释放，而是包含在了f2函数的内部，形成了闭合的效果 println(f(3)) println(f1()(3))// 函数柯里化，其实就是将复杂的参数逻辑变得简单化,函数柯里化一定存在闭包 def f3()(b:Int)={ a + b }println(f3()(3)) } }

名调用：把代码传递过去

object TestControl { def main(args: Array[String]): Unit = {def f = ()=>{ println("f...") 10 }foo(f()) } //def foo(a: Int):Unit = { //名调用，把代码块传过去 def foo(a: =>Int):Unit = {//注意这里变量a没有小括号了 println(a) println(a) } }

【笔记|scala与java的一些不同点】注意：Java只有值调用；Scala既有值调用，又有名调用。
惰性函数
1）说明
当函数返回值被声明为lazy时，函数的执行将被推迟，直到我们首次对此取值，该函数才会执行。这种函数我们称之为惰性函数。

def main(args: Array[String]): Unit = {lazy val res = sum(10, 30) println("----------------") println("res=" + res) }def sum(n1: Int, n2: Int): Int = { println("sum被执行。。。") return n1 + n2 }

输出结果：

---------------- sum被执行。。。 res=40 注意：lazy不能修饰var类型的变量

集合
1）Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质。
2）对于几乎所有的集合类，Scala都同时提供了可变和不可变的版本，分别位于以下两个包
不可变集合：scala.collection.immutable
可变集合： scala.collection.mutable
3）Scala不可变集合，就是指该集合对象不可修改，每次修改就会返回一个新对象，而不会对原对象进行修改。类似于java中的String对象
4）可变集合，就是这个集合可以直接对原对象进行修改，而不会返新的对象。类似于java中StringBuilder对象
建议：在操作集合的时候，不可变用符号，可变用方法
ef sum(n1: Int, n2: Int): Int = {
println(“sum被执行。。。”)
return n1 + n2
}

输出结果：

sum被执行。。。
res=40
注意：lazy不能修饰var类型的变量

### 集合1）Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自**Iterable**特质。2）对于几乎所有的集合类，Scala都同时提供了**可变**和**不可变**的版本，分别位于以下两个包不可变集合：scala.collection.**immutable**可变集合：scala.collection.**mutable**3）Scala不可变集合，就是指该集合对象不可修改，每次修改就会返回一个新对象，而不会对原对象进行修改。类似于java中的String对象4）可变集合，就是这个集合可以直接对原对象进行修改，而不会返新的对象。类似于java中StringBuilder对象**建议：在操作集合的时候，不可变用符号，可变用方法**