Scala基础操作

数据类型

数据类型	描述
Byte	8位有符号补码整数。数值区间为 -128 到 127
Short	16位有符号补码整数。数值区间为 -32768 到 32767
Int	32位有符号补码整数。数值区间为 -2147483648 到 2147483647
Long	64位有符号补码整数。数值区间为 -9223372036854775808 到 9223372036854775807
Float	32 位, IEEE 754 标准的单精度浮点数
Double	64 位 IEEE 754 标准的双精度浮点数
Char	16位无符号Unicode字符, 区间值为 U+0000 到 U+FFFF
String	字符序列
Boolean	true或false
Unit	表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。
Null	null 或空引用
Nothing	Nothing类型在Scala的类层级的最底端；它是任何其他类型的子类型。
Any	Any是所有其他类的超类
AnyRef	AnyRef类是Scala里所有引用类(reference class)的基类

变量声明

在学习如何声明变量与常量之前，我们先来了解一些变量与常量。

• 一、变量： 在程序运行过程中其值可能发生改变的量叫做变量。如：时间，年龄。
• 二、常量 在程序运行过程中其值不会发生变化的量叫做常量。如：数值 3，字符'A'。

在 Scala 中，使用关键词 "var" 声明变量，使用关键词 "val" 声明常量。

声明变量实例如下：

var myVar : String = "Foo" var myVar : String = "Too"

以上定义了变量 myVar，我们可以修改它。

声明常量实例如下：

val myVal : String = "Foo"

以上定义了常量 myVal，它是不能修改的。如果程序尝试修改常量 myVal 的值，程序将会在编译时报错。

变量类型引用

在 Scala 中声明变量和常量不一定要指明数据类型，在没有指明数据类型的情况下，其数据类型是通过变量或常量的初始值推断出来的。

所以，如果在没有指明数据类型的情况下声明变量或常量必须要给出其初始值，否则将会报错。

var myVar = 10 ;

val myVal = "Hello, Scala!" ;

以上实例中，myVar 会被推断为 Int 类型，myVal 会被推断为 String 类型。

---

Scala 多个变量声明

Scala 支持多个变量的声明：

val xmax , ymax = 100 // xmax, ymax都声明为100

如果方法返回值是元组，我们可以使用 val 来声明一个元组：

scala > val pa = ( 40 , "Foo" )

pa : ( Int , String ) = ( 40 , Foo )

object ScalaDemo {

def main(args:Array[String]):Unit={

val name="James"

println(s"Hello,$name")

println(s"1+1=${1+1}")

val height=1.9d

val height1=1.32d

val height2=1.5d

val salary=2000.38

val name1="liSan"

val name2="zhang"

val salary1=400000

val salary2=4000.38

println(f"$name%s is $height%4.2f meters tall，月薪：$salary%9.2f 元")

println(f"$name1%s is $height1%4.2f meters tall，月薪：$salary1%9.2f 元")

println ( f" $ name2 %s is $ height2 %4.2f meters tall，月薪： $ salary2 %9.2f 元" )

运行结果

Hello,James

1+1=2

James is 1.90 meters tall，月薪：  2000.38  元

liSan is 1.32 meters tall，月薪：400000.00 元

zhang is 1.50 meters tall，月薪：  4000.38 元

在控制台输入数字

println("请输入数字：")

val num =StdIn.readInt()

for循环

fo'r(i<-0 until 10)print(i）//从0到9

fo'r(i<-0 to 10)print(i）//从0到10

fo'r(i<-0 until 10 reverse)print(i）//从9到0

元组

val tp=(1,"hello","d")//最长22个

println(tp._1)--->1

println(tp._2)--->hello

println(tp._3)--->d

遍历元组

1.def p:Iterator[Any]={tp.productIterator}//val p: Iterator[Any]=tp.productIterator//val  p =tp.productIterator

for(in<-p){//迭代器

println(in)

}

2.tp.productIterator.foreach(x=>println(x))//增强for

二元组置换（特殊）

val t=new t1[String,Int]("chen",26)// val t= ("chen",26)

println(t._1,t._2)

val swap: (Int, String) = t.swap//置换,二元组特殊方法，其他没有

println(swap._1,swap._2)

println(swap._1)

部分函数

def  alarmMsg(title:String,content:String,height:Double):Unit={

println(title+"\t"+content+":"+height)

}

alarmMsg("警报","空气甲醛浓度",21.42d)---> 警报    空气甲醛浓度为:21.42

val title="警报"

def alarmMsg2=alarmMsg(title,content:String,height:Double)

alarmMsg2("空气甲醛浓度为：",21.43d)--->  警报    空气甲醛浓度为:21.32

def alarmMsg3=alarmMsg(content,height:Double)

alarmMsg3(12.45d) --->  警报    空气甲醛浓度为:21.32

偏函数

def funPartition2:PartialFunction[Int,String]={

case 1=>"优秀"

case 2=>"良好"

case 3=>"合格"

case _=>"不及格"

}

println(funPartition2(3))---->合格

println(funPartition2(4))---->不及格

val arr:Array[Int]=Array(1,3,4,3,2)

val strings:Array[String] = arr.collect(funPartition2)

遍历

println(strings.toList)

或

for(in<-strings){

println(in)

}

函数作为返回值

def funTest():(String,String)=>String={

        def funDemo(str:String,str1:String):String={

            str+"@@"+str1

}

funDemo

}

println(funTest()("hello","world"))

函数作为参数

def funTest1(f:(Int,Int)=>Int)):Int={

val a=100

val b=50

f(a,b)

}

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

val ji=(a:Int,b:Int)=>a*b

println(sum(2,3))---->5

println(funTest(sum)))---->150

println(funTest(ji)))---->5000

递归函数

def  ji(num:Int):Int{

if(num==1) 1     

else num*ji(num-1)

}

样例类+模式匹配

case class Teachers(name:String,age:Int)

def match3(teacher:Teachers):Unit={

teacher match{

case Teachers("zs",age)=>println("hello"+age)

case Teachers("kb15",4)=>println("kb15学习4个月")

case Teachers(name,32)=>println("名字"+name+"年龄"+32)

}

}

match3(Teachers("kb15",4))

def match4(level:String,name:String):Unit={

level match{

case "A"=>println("优秀")

case "B"=>println("良好")

case "C" if name=="zs"=>println("合格")

case "C"=>println("合格")

case _ if name=="bolo"=>println("特殊学生")

case _=>println("不及格")

}

}

match4("A","zs")

隐式类implicit

1.直接在object +类名{}中写

2.新建一个隐式类，然后在直接import 包名.类名._ 引用

使用类

package cn.kgc

import cn.kgc.Impliciteg._

class ImplicitDemo{}

object ImplicitDemo {

val a:Int="3"

val b:String=3

val c:Double="3.5"

//调用函数有隐式参数的方法时 传值>隐式参数>大于默认值

def sum(a:Int)(implicit b:Int):Int={ //隐式参数必须写在后面,且同类型只能出现一个

val sum1: Int = a + b

println(str+" "+sum1)

sum1

}

println(sum(1))

//sum(1)

val i: Int = sum(10)

//println(i)

//val j: Int =sum(10)(2)//已传入参数为主

// println(j)

val demo=new ImplicitDemo

// private val i1: Int = demo.ji(10, 20)

println(demo.ji(10, 20))

// private val str1: String = demo.madeString("kb15")

println(demo.madeString("kb15"))

def main (args:Array[String]):Unit={}

}

隐式类

object Impliciteg {

implicit val num:Int=10//隐式参数

implicit val str:String="hello"

implicit def stringToInt(value:String):Int={

Integer.parseInt(value)

}

implicit def intToString(value:Int):String={

value.toString

}

implicit def stringToDouble(value:String):Double={

//Integer.parseInt(value).toDouble

java.lang.Double.parseDouble(value)

}

implicit class numOperation(implicitDemo: ImplicitDemo){

def ji(a:Int,b:Int):Int={

println("进入隐式类",a,b)

a*b

}

}

implicit class tringOperation(implicitDemo: ImplicitDemo){

def madeString(str:String):String={

str+" "+str.length

}

}

}

构造参数

package cn.kgc

//伴生类

class Oop1 (name:String,age:Int){//scala默认的主构造函数

private var uname:String=name

private var uage :Int=age

private var uaddress:String=_

def this(){

this(" ",0)

println("无参")

}

def this(name:String){

this(name,0)

}

def this(age:Int){

this("",0)

}

def this(name:String,age:Int,address:String){

this(name,age)

this.uaddress=address

}

def showMsg():Unit={

println("进入到Oop1 class showMsg()方法中")

println(this.uname,this.age,this.uaddress)

Oop1.showObjectMsg

println(Oop1.like)

println("进入到Oop1 class showMsg()方法，最后一行")

}

}

//伴生对象

object Oop1{

private var like:String="篮球"

def sum(a:Int,b:Int):Int={

println(a,b)

a+b

}

def showObjectMsg()={

println("Object Oop1 showOjbectMsg")

}

//加上可以省去new对象

def apply(name: String, age: Int): Oop1 = new Oop1(name, age)

def apply(name: String): Oop1 = new Oop1(name)

def apply(age: Int): Oop1 = new Oop1(age)

def apply(): Oop1 = new Oop1()

def apply(name: String, age: Int, address: String): Oop1 = new Oop1(name, age, address) 

def main(args:Array[String]):Unit={

println("main")

// val oop=new Oop1("chen",26)

val oop2 = new Oop1

// val oop3 = new Oop1("kb11")

// val oop4 = new Oop1(12)

// val oop5 = new Oop1("gree", 21, "安德门")

oop2.showMsg

val opp6=Oop1

val opp7=Oop1("zs")

println("main end")

// println(oop.uname)

}

}