Scala基础学习01

Posted 2022-03-08 南宫峻熙

文章目录

• 第一个Scala程序
• • 交互式编程
  • 脚本形式
• 定义函数识别号码类型
• • 数据类型
  • 常量与变量
  • 数组
  • 函数
  • • 匿名函数
    • 高阶函数-函数作为参数
    • 高阶函数-函数作为返回值
    • 函数柯里化
  • 任务实现

第一个Scala程序

交互式编程

hadoop@master:~/桌面/ScalaLearn$ scala
Welcome to Scala 2.11.8 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_162).
Type in expressions for evaluation. Or try :help.

scala> 1+1
res0: Int = 2

scala> println("Hello World!")
Hello World!

scala> 

脚本形式

gedit HelloWorld.scala

object HelloWorld 
	def main(args:Array[String]):Unit=
		println("Hello world!")
	

scalac HelloWorld.scala  // 把源码编译为字节码
scala HelloWorld  // 把字节码放到虚拟机中解释运行

Hello world!

定义函数识别号码类型

在中国，手机号码一般分为三种类型，中国移动，中国联通，中国电信。编写一个函数来识别手机号码类型

数据类型

数据类型	描述
Int	整数
Float	单精度浮点数
Double	双精度浮点数
String	字符序列
Boolean	true或false
Unit	表示无值，和Java中的void等同。Unit只有一个实例值，写成()

常量与变量

Scala中数据分为两种类型，常量（也称值）与变量。可通过val关键字来定义常量，通过var来定义变量。
（1）常量
常量一旦定义就不可更改，即不能对常量重新计算或重新赋值。
定义一个常量的语法格式：val name:type=initialization
由于scala具备类型推断的功能，因此定义常量的时候可以不用显式地说明其数据类型。常量名要求以字母或下划线开头，后面跟着更多的字母、数字或下划线。注意变量名中不能使用美元符号$。

一旦初始化val，就不能再进行修改，强行修改变量的初始值会报错。

scala> val x=1+1
x: Int = 2

scala> val x:Int=1+1
x: Int = 2

scala> x=3
<console>:12: error: reassignment to val
       x=3
        ^

（2）变量
变量是在程序运行中其值可能发生改变的量。变量定义后还可以重新被赋值。（只能把同类型的值重新赋值给变量，否则会报错）

scala> var y=1
y: Int = 1

scala> var y:Int=1
y: Int = 1

scala> y=5
y: Int = 5

scala> y=1.5
<console>:12: error: type mismatch;
 found   : Double(1.5)
 required: Int
       y=1.5
         ^

数组

scala声明一个数组的方式如下：

var z:Array[String]=new Array[String](num)或
var z=Array(元素1,元素2,...)

scala> var z:Array[String]=new Array[String](3)
z: Array[String] = Array(null, null, null)

scala> z(0)="baidu";z(1)="google";z(2)="biying"

scala> z
res1: Array[String] = Array(baidu, google, biying)

scala> var z:Array[String]=Array("baidu","google","biying")
z: Array[String] = Array(baidu, google, biying)

基本操作（操作数组arr）	描述
arr.length	返回数组的长度
arr.head	查看数组第一个元素
arr.tail	查看数组中除了第一个元素外的其他元素
arr.isEmpty	判断数组是否为空
arr.contains(x)	判断数组中是否包含元素x

scala> var z:Array[String]=Array("xing","wei","kun")
z: Array[String] = Array(xing, wei, kun)

scala> z.length
res3: Int = 3

scala> z.head
res4: String = xing

scala> z.tail
res5: Array[String] = Array(wei, kun)

scala> z.isEmpty
res6: Boolean = false

scala> z.contains("xing")
res7: Boolean = true

连接连个数组可以用操作符++，也可以使用concat方法，使用concat方法需要先使用import Array._引入包。

scala> var arr1=Array(1,2,3)
arr1: Array[Int] = Array(1, 2, 3)

scala> var arr2=Array(4,5,6)
arr2: Array[Int] = Array(4, 5, 6)

scala> var arr3=arr1++arr2
arr3: Array[Int] = Array(1, 2, 3, 4, 5, 6)

scala> import Array._
import Array._

scala> var arr4=concat(arr1,arr2)
arr4: Array[Int] = Array(1, 2, 3, 4, 5, 6)

可以使用range方法创建区间数组，同样需要先引入import Array._
生成1~10步长为2的数组

scala> import Array._
import Array._

scala> var arr=range(1,10,2)
arr: Array[Int] = Array(1, 3, 5, 7, 9)

函数

在java中函数需要使用return关键字指明返回值，scala函数中可以不加return关键字来指明返回值。

scala> def add(a:Int,b:Int):Int=a+b
add: (a: Int, b: Int)Int

scala> def add(a:Int,b:Int):Int=
     | var sum=0;
     | sum=a+b;
     | return sum
     | 
add: (a: Int, b: Int)Int

scala> add(1,2)
res8: Int = 3

scala> :paste
// Entering paste mode (ctrl-D to finish)

object Test 
    def addInt(a:Int,b:Int):Int=
        var sum:Int=0
        sum=a+b
        return sum
    


// Exiting paste mode, now interpreting.

defined object Test

scala> Test.addInt(2,3)
res9: Int = 5

匿名函数

匿名函数即在定义函数时不给出函数名。匿名函数是使用箭头=>定义的

scala> (x:Int,y:Int)=>x+y
res10: (Int, Int) => Int = <function2>

scala> val addInt=(x:Int,y:Int)=>x+y
addInt: (Int, Int) => Int = <function2>

scala> addInt(1,3)
res11: Int = 4

如果函数中的每个参数在函数中最多只出现一次，则可以使用占位符_

scala> val addInt=(_:Int)+(_:Int)
addInt: (Int, Int) => Int = <function2>

scala> addInt(1,2)
res12: Int = 3

高阶函数-函数作为参数

定义整数相加的函数addInt，函数addInt中使用了另一个函数f，值a和值b作为参数，而函数f又调用了a和b作为参数。

scala> def addInt(f:(Int,Int)=>Int,a:Int,b:Int)=f(a,b)
addInt: (f: (Int, Int) => Int, a: Int, b: Int)Int

scala> addInt((a:Int,b:Int)=>a+b,1,2)
res13: Int = 3

高阶函数-函数作为返回值

scala> def rectangle(length:Double)=(height:Double)=>(length+height)*2
rectangle: (length: Double)Double => Double

scala> val func=rectangle(4)
func: Double => Double = <function1>

scala> println(func(5))
18.0

函数柯里化

scala> def addInt(a:Int,b:Int):Int=a+b
addInt: (a: Int, b: Int)Int

scala> addInt(1,2)
res16: Int = 3

scala> def addInt(a:Int)(b:Int):Int=a+b
addInt: (a: Int)(b: Int)Int

scala> addInt(1)(2)
res18: Int = 3

任务实现

（1）用数组分别存储各类型手机号段

scala> var yidong=Array(1340,1341,1342,1343,1344,1345,1346,1347,1348,135,136,137,138,139,150,151,152,157,158,159,182,183,184,187,188,178,147,1705)
yidong: Array[Int] = Array(1340, 1341, 1342, 1343, 1344, 1345, 1346, 1347, 1348, 135, 136, 137, 138, 139, 150, 151, 152, 157, 158, 159, 182, 183, 184, 187, 188, 178, 147, 1705)

scala> val liantong=Array(130,131,132,155,156,185,186,176,145,1709)
liantong: Array[Int] = Array(130, 131, 132, 155, 156, 185, 186, 176, 145, 1709)

scala> val dianxin=Array(133,1349,153,180,181,189,1700,177)
dianxin: Array[Int] = Array(133, 1349, 153, 180, 181, 189, 1700, 177)

（2）定义函数识别手机号段

scala> def identify(x:Int)=
     | if(yidong.contains(x))
     | println("这个号码是属于中国移动类型的")
     | else if(liantong.contains(x))
     | println("这个号码是属于中国联通类型的")
     | else if(dianxin.contains(x))
     | println("这个号码是属于中国电信类型的")
     | else
     | println("这个号码号码不属于中国号码")
     | 
     | 
identify: (x: Int)Unit

scala> identify(133)
这个号码是属于中国电信类型的