scala的基本语法

区分常量和变量

常量

变量

写一行代码，写多行代码，终端代码

数据类型

• byte
• char
• short
• int
• long
• float
• double
• boolean

 数据类型与java相似，但与java不同的事，在scala中，这些类型都是“类”，并且都是包scala的成员。

比如，int的全名是scala.Int。

字面量（literal）

操作符

Scala 是一种多范式编程语言，它支持多种操作符，包括算术操作符、关系操作符、逻辑操作符、位操作符、赋值操作符以及一些特殊的操作符。

以下是一些主要的 Scala 操作符：

1. 算术操作符：
   • +：加法
   • -：减法
   • *：乘法
   • /：除法
   • %：取模（求余数）
2. 关系操作符：
   • ==：等于
   • !=：不等于
   • >：大于
   • <：小于
   • >=：大于或等于
   • <=：小于或等于
3. 逻辑操作符：
   • &&：逻辑与
   • ||：逻辑或
   • !：逻辑非
4. 位操作符：
   • &：按位与
   • |：按位或
   • ^：按位异或
   • ~：按位取反
   • <<：左移
   • >>：带符号右移
   • >>>：无符号右移
5. 赋值操作符：
   • =：赋值
   • +=、-=、*=、/=、%=：复合赋值操作符
6. 其他特殊操作符：
   • ::：方法调用操作符（实际上是一个方法名，但通常用作操作符）
   • :::：创建一个新的集合，并添加元素到其尾部
   • +:：将一个元素添加到集合的尾部
   • ++：连接两个集合
   • --：从集合中移除一个元素
   • in：检查元素是否存在于集合中
   • match：模式匹配操作符
   • =>：在函数定义、映射和偏函数中使用
   • _：通配符，用于忽略某些值或在模式匹配中表示任意值

这些只是 Scala 中操作符的一部分。由于 Scala 的灵活性和多范式特性，还可以自定义操作符，但通常需要遵守一些规则和约定。

 在scala中，操作符等同于方法。

• 例子：

scala> var x = 2+2
x: Int = 4

scala> var x=1+2
x: Int = 3

scala> var y=1.+(2)
y: Int = 3

scala> var z=1.+(2)
z: Int = 3

scala> println(x == y)
true

scala> println(x == z)
true

scala> println(y == z)
true

• 总结：
  
  a 方法 b 等价于 a.方法(b)
  
  前者是后者的简写形式。

递增和递减

与java不同，在scala中没有提供++和--操作符，如果想要表达递增或者递减，那么可以使用+=,-=

实例：

scala> var num = 0
num: Int = 0

scala> println(num)
0

scala> num += 1

scala> println(num)
1

scala> num += 1

scala> println(num)
2

富包装类

对于基本的数据类型，除了除了以上操作符之外，scala还提供了许多常用运算的方法，只是这些方法不是在基本类里面定义，而是被封装到一个对应的富包装中。

每个对应的类型都有一个对应的富包装类，比如int类型对应的富包装类是RichInt，这些类位于包scala.runtime中。

当对一个基本数据类型的对象调用其富包装类提供的方法，scaka会自动通过隐式转换将该对象转换为对应的富包装类，然后在调用相应的方法。

实例：

scala> 3 max 8
res12: Int = 8
scala> 19.0 max 97
res14: Double = 97.0

range

在scala中，range是一个特殊的集合，可以用来表示一个范围。

在执行for循环时，我们经常会用到数值序列（比如，i的值从1循环到5），这时就可以采用range来简化代码。

range可以支持创建不同数据类型的数值序列

实例：

//步长不可以为0，步长为0，那么数据不会变
scala> 1 to 10 by 0
java.lang.IllegalArgumentException: step cannot be 0.
  at scala.collection.immutable.Range.<init>(Range.scala:86)
  at scala.collection.immutable.Range$Inclusive.<init>(Range.scala:430)
  at scala.collection.immutable.Range$Inclusive.copy(Range.scala:433)
  at scala.collection.immutable.Range.by(Range.scala:135)
  ... 30 elided
//步长为1
scala> 1 to 10 by 1
res16: scala.collection.immutable.Range = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
//步长为2
scala> 1 to 10 by 2
res17: scala.collection.immutable.Range = Range(1, 3, 5, 7, 9)
//步长为3
scala> 1 to 10 by 3
res18: scala.collection.immutable.Range = Range(1, 4, 7, 10)

scala>

控制台输入输出语句

为了从控制台读写数据，可以使用以read为前缀的方法，包括：readint，redadouble，readline，readchar，readboolean，readline等。分别对应9中数据类型，其中前8中方式，没有参数，readline可以不提供参数，也可以带一个字符串参数的提示。

所有的函数都属于对象scala.io.StdIn，使用前必须导入，活着直接使用全称进行调用。

实例：

//不导入函数，会报错

scala> var i = readInt()
warning: there was one deprecation warning; re-run with -deprecation for detail
s
java.lang.NumberFormatException: For input string: ";"
  at java.base/java.lang.NumberFormatException.forInputString(NumberFormatExcep
tion.java:67)
  at java.base/java.lang.Integer.parseInt(Integer.java:588)
  at java.base/java.lang.Integer.parseInt(Integer.java:685)
  at scala.collection.immutable.StringLike$class.toInt(StringLike.scala:273)
  at scala.collection.immutable.StringOps.toInt(StringOps.scala:29)
  at scala.io.StdIn$class.readInt(StdIn.scala:110)
  at scala.io.StdIn$.readInt(StdIn.scala:229)
  at scala.DeprecatedPredef$class.readInt(Predef.scala:440)
  at scala.Predef$.readInt(Predef.scala:70)
  ... 30 elided
//导入函数，不会报错
scala> import io.StdIn._    //S和I都是大写下划线不要忘记
import io.StdIn._

scala> var i = readInt()    //回车之后会卡住，等你输入数据之后，回车
i: Int = 5499

scala>

scala还带有c语言风格的格式化字符串的printf()函数

print(),printf(),println()都在对象Predef中定义，该对象默认情况下被所有scala程序引用，因此不需要导入，可以直接使用。

scala> printf("hello")
hello
scala> println("hello")
hello

scala> print("hello")
hello
//
scala> var x=102
x: Int = 102
scala> printf("%d",x)
102
scala> print(x)
102
scala> println(x)
102

读写文件

scala需要使用java.io.PrintWriter类来写文件，使用java.io.BufferedReader类来读文件。

默认生成的文件指定路径，如果不是绝对路径，那么默认是当前目录下(启动scala时，所在的路径)。

数组

scala> var name : Array[String] = Array("zhangsan","lisi","wangwu","zhaoliu","qianqi")
name: Array[String] = Array(zhangsan, lisi, wangwu, zhaoliu, qianqi)

scala> name
res0: Array[String] = Array(zhangsan, lisi, wangwu, zhaoliu, qianqi)

scala> name(0)
res1: String = zhangsan

scala> name(1)
res2: String = lisi

scala> name(2)
res3: String = wangwu

scala> name(3)
res4: String = zhaoliu

scala> name(4)
res5: String = qianqi

scala> name.head
res6: String = zhangsan

scala> name.length
res7: Int = 5

scala> name.tail
res8: Array[String] = Array(lisi, wangwu, zhaoliu, qianqi)

scala> name.contains (lisi)
<console>:24: error: not found: value lisi
       name.contains (lisi)
                      ^
scala> name.contains("lisi")
res12: Boolean = true

scala> name.contains("zhangsan")
res13: Boolean = true

数组整合

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

scala> val arr02=Array(5,6,7)
arr02: Array[Int] = Array(5, 6, 7)

scala> val arr3 = arr++arr02
arr3: Array[Int] = Array(1, 2, 3, 5, 6, 7)

scala>

数组加range

scala> val arr03 = range(1,20,3)
<console>:22: error: not found: value range
       val arr03 = range(1,20,3)
                   ^
//需要导入包
scala> import Array._
import Array._

scala> val arr03 = range(1,20,3)
arr03: Array[Int] = Array(1, 4, 7, 10, 13, 16, 19)

scala>

函数

函数由一个def关键字开始，紧接着是函数名称和可选的参数列表，其次是一个冒号":"

scala> def hum(a:Int,b:Int): Int = (a - b)
hum: (a: Int, b: Int)Int

scala> hum(5,3)
res15: Int = 2

scala> def add(x: Int,y: Int): Int = {
     | var sum = 0;
     | sum = x + y;
     | return sum;
     | }
add: (x: Int, y: Int)Int

scala> add(4,5)
res16: Int = 9

scala>

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

object Test {
   def jianInt (a:Int,b:Int) :Int = {
     var sum:Int = 0
     sum = a - b
     return sum
   }
}

// Exiting paste mode, now interpreting.

defined object Test

scala> Test.jianInt(4,3)
res18: Int = 1

scala>

scala> object Test {
     |   def Scala1(x:Int,y:Int): Int = {
     |      3*x + 2*y
     |   }
     |   def Scala3(x:Int,y:Int): Int = {
     |      4*x - y
     |   }
     |   def Scala4(x:Int,y:Int): Int = {
     |      Scala1(x,y) + Scala3(x,y)
     |   }
     | }
defined object Test

scala> Test.Scala1(1,3)
res0: Int = 9

scala> Test.Scala3(1,3)
res1: Int = 1

scala> Test.Scala4(1,3)
res2: Int = 10

scala>

scala> def rectangle(len:Double)=(hei:Double)=>(len+hei)*2
rectangle: (len: Double)Double => Double

scala> val func=rectangle(4)
func: Double => Double = $Lambda$2069/45962859@577c0be6

scala> println(func(5))
18.0

例子

scala> val yidong = Array(1340,1341,1342)
yidong: Array[Int] = Array(1340, 1341, 1342)

scala> val liantong = Array(130,131,132,155)
liantong: Array[Int] = Array(130, 131, 132, 155)

scala> val dianxin = Array(133,1349,153)
dianxin: Array[Int] = Array(133, 1349, 153)
scala> def id(x:Int) = {
     |   if(yidong.contains(x)) {
     |      print("中国移动")
     |   }else if(liantong.contains(x)) {
     |      print("中国联通")
     |   }else if(dianxin.contains(x)) {
     |      print("中国电信")
     |   }else {
     |     print("不是中国号码")}
     | }
id: (x: Int)Unit

scala> id(133)
中国电信
scala> id(130)
中国联通
scala> id(1340)
中国移动
scala>