Scala介绍

踩着上帝的小丑

已于 2024-07-28 12:02:58 修改

阅读量410

点赞数 10

分类专栏：大数据文章标签： scala 开发语言后端

于 2024-07-28 12:02:38 首次发布

本文链接：https://blog.csdn.net/weixin_57342469/article/details/140748848

版权

大数据专栏收录该内容

2 篇文章 0 订阅

订阅专栏

Scala介绍

1、变量和数据类型

1.1 注释

注释的方式和java注释一样

（1）单行注释： //
（2）多行注释： /* /
（3）文档注释： /* * */
文档注释要在一个方法或类前边进行注释

/*
* object: 关键字，声明一个单例对象（伴生对象）
* */
object Hello {
  /*
  * main 方法：从外部可以直接调用执行的方法
  * def 方法名称（参数名称：参数类型）:返回值类型={ 方法体 }
  * */
  def main(args: Array[String]): Unit = {
    println("hello,world")
    System.out.println("hello world")
    val a=0    // 定义一个常量为a
    println(a);
  }
}

1.2 常量和变量

常量：在程序执行的过程中，其值不会被改变的变量

回顾java的变量和常量语法

// 变量类型 变量名称 = 初始值
int a=10
// final 常量类型 常量名称 = 初始值
final int a=10

scala的基本语法

// val 常量名 [: 常量类型] = 初始值  
val i: int =10
// var 变量名 [: 变量类型] = 初始值  
var j: int =10

注意事项

能用常量的地方不用变量
声明变量时，类型可以省略，编译器自动推导，即类型推导
scala语言是一门强类型语言，常量和变量类型定义决定了初始类型
变量（常量）的声明需要给予初始化
在声明定义一个变量时，可以使用var或者val进行修饰，var修饰的变量是可变的，val修饰的变量是不可变的

object su {
  def main(args: Array[String]): Unit = {
    // 常量和变量的使用
    var a: Int = 10   // 定义一个变量a
    val b: Int = 20   // 定义一个常量b

    // 注意细节
    //(1)声明变量时，类型可以省略，编译器自动推导，即类型推导
    var a1 = 10   // 定义变量a1，和常量b1
    val b1 = 20

    //(2)类型确定后，就不能修改，即scala是一种强数据类型语言

    b1=111  // 报错：重新赋值给 val
    println(b1)
    a1=1111  // 输出为  1111
    // (3)变量声明时，需要要有初始值
    var b2 = 10
    //(4)在声明定义一个变量时，可以使用var或者val进行修饰，var修饰的变量是可变的，val修饰的变量是不可变的
    val zs = new Student("zhangsan", 20)
    zs.printerInfo();
      // 修改常量zs里面的变量类型 name，需要在原函数中将这个属性定义为变量类型才可以使用
    zs.name="lisi"
    zs.printerInfo()
  }
}

student.scala

class Student( var name: String, age: Int) {
  def printerInfo(): Unit = {
    println(name + " " + age + " " + Student.from)
  }
}
//引入伴生对象
object Student{
  val from:String = "zhongguo"

  def main(args: Array[String]): Unit = {
    val liangzai = new Student("liangzai", 24)
    val daiomao = new Student("daiomao", 25)
    liangzai.printerInfo()
    daiomao.printerInfo()
  }
}

1.3 标识符的命名规范

Scala对各种变量、方法、函数等命名时的字符串序列称为标识符。即：单反自己可以起名字的地方都叫标识符

1）命名规则

scala中的标识符声明，基本和java是一致的，但是细节上会有所改变，有以下三种规则

（1）以字母或者下划线开头，后接字母、数字、下划线

（2）以操作符开头，且只包含操作符（+，-，*，/，！，#等）

（3）用反引号...包括的任意字符串，即使是scala关键字（39个）也可以

在这里插入图片描述

1.4 字符串输出

1）基本语法

（1）字符串，通过+号连接

（2）printf用法：字符串，通过%传值

（3）字符串模板（插值字符串）

object string_format {
def main(args:Array[String]) :Unit={
  //1、通过字符串拼接的方式进行输出
  val name="张三"
  val age=12
  print("姓名为"+name+"今年为"+age+"\n")
  // 使用printf 字符串传值的方式进行输出
  printf("今年为%d的%s在学习",age,name)
  // 使用字符串模板进行输出
  print(s"这个同学叫${name}，他今年${age}岁\n")
  // 也可以使用格式化修改
  val salary=1000.1555
  printf(f"姓名为${name},他的薪水是${salary}%2.1f元(保留一位小数）")
}
}

1.5 键盘输入

在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取。

1）基本语法

Stdin.readLine()、Stdin.readShort()、Stdin.readDouble()

object Hello {
  /*
  * main 方法：从外部可以直接调用执行的方法
  * def 方法名称（参数名称：参数类型）:返回值类型={ 方法体 }
  * */
  def main(args: Array[String]): Unit = {
   // 输入输出操作
    println("请输入你的姓名")
    val name = StdIn.readLine()
    println("请输入你的芳龄")
    val age = StdIn.readLine()
    println("姓名为"+name+"今年为"+age+"岁")
  }
}

1.6 文件的输入和输出

scala有自带的文件输出内容，但是对于文件输入内容，scala没有自身的库函数可以调用，只能使用java的内库进行使用

    // 文件的输出
    Source.fromFile("D://java.txt").foreach(print)
    // 文件的输入
    val writer = new PrintWriter(new File("D:\\Java\\src\\scala\\src\\main\\resources\\a.txt"))
    writer.write(
      """
        |select * from database where
        |""".stripMargin)
    writer.close()
    // 也可以使用java进行文件的输入
    val src="D:\\Java\\src\\scala\\src\\main\\resources\\b.txt"
    val stream = new FileOutputStream(src)
    stream.write("好好学习".getBytes())
    stream.close()

1.6 数据类型

java数据类型

java基本类型：char、byte、short、int、long、float、double、boolean；

java引用类型：对象类型

由于java有基本类型，而且基本类型不是真正意义的对象，即使后面产生了基本类型的包装类，但是仍然存在基本数据类型，所以java语言并不是真正意义上的面向对象。

java基本类型的包装类：Character、Byte、Short、Interger、Long、Float、Double、Boolean

scala数据类型

1）Scala中一切数据都是对象，都是Any的子类

2）Scala中数据类型分为两大类，数值类型（AnyVal）、引用类型（AnyRef），不管是值类型还是引用类型都是对象
在这里插入图片描述

3）Scala数据类型仍然遵守，低精度的值类型向高精度值类型，自动转换（隐式转换）

4）Scala中的StringOps是对Java中的String增强

5）Unit：对应Java中的void，用于方法返回值的位置，表示方法没有返回值。Unit是一个数据类型，只有一个对象就是()。Void不是数据类型，只是一个关键字

6）Null是一个类型。只有一个对象就是null。他是所有引用类型（AnyRef）的子类

7）Nothing，是所有数据类型的子类。主要用在一个函数没有明确返回值时使用，因为这样我们可以把抛出的返回值，返回给任何变量或者函数。

1、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)的基类

    val a=10
    val b=10  // scala默认数据类型为Int数据类型

    val a1:Byte=200// 会报错，Byte的数据范围在-127~127之间
    val a2:Long= 20000000l   // 定义长整型类型后面要加l/L，才可以输出

    val a3:Byte=20
    val b3:Byte=10+20  
// 在IDEA中会显示报错（因为默认类型是int+Byte类型，根据隐式转换，会默认转换为int类型，int类型和编译时定义的Byte类型不同，所以存在报错，
//  但是程序可以正常地转换
    println(a3+b3)
// 为了避免IDEA报错，可以使用转换
	val b3:Byte=(10+20).toByte

2、Unit类型、Null类型和Nothing类型

数据类型	描述
Unit	表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。
Null	null , Null 类型只有一个实例值 null
Nothing	Nothing类型在Scala的类层级的最低端；它是任何其他类型的子类型。当一个函数，我们确定没有正常的返回值，可以用Nothing 来指定返回类型，这样有一个好处，就是我们可以把返回的值（异常）赋给其它的函数或者变量（兼容性）

    // Unit的使用
    def f1():Unit={
      println("f1函数被调用了")
    }
    val a11=f1()
    println(a11)

    // null的使用，就是对引用类型的一个设置
    var zhangsan = new Student("zhangsan", 20)
    zhangsan=null
    println(zhangsan)
    //nothing 经常出现在进行异常处理的时候
    def m1(n:Int):Int={
      if(n==0)
          throw new NullPointerException
      else return n
    }
    println(m1(0))

3、类型转换规则

（1）自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数据类型，然后再进行计算

（2）把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换

（3）（byte、short）和char之间不好相互自动转换

（4）byte、short、char他们三者可以计算，再计算时首先转换为int类型

在Scala语言中，运算符是一个符号，告诉编译器执行特定的数学或逻辑函数。Scala语言提供丰富的内置运算符，并提供以下类型的运算符 -

算术运算符
关系运算符
逻辑运算符
按位运算符
赋值运算符
其它运算符

在本章中，我们将学习每个运算符的工作方式。

2、运算符

1.算术运算符

下表显示了Scala支持的所有算术运算符。假设变量A的值是10，变量B的值是20，那么 -

运算符	描述	示例
`+`	将两个操作数相加	`A + B = 30`
`-`	从第一个操作数减去第二个操作数	`A − B = -10`
`*`	将两个操作数相乘	`A * B = 200`
`/`	将第一个操作数除以第二个操作数
`%`	模数运算符和整数除法后的余数。	`B % A = 0`
`++`	递增运算符将整数值增加`1`。	`A++ = 11`
`--`	递减运算符将整数值减1。	`A-- = 9`

创建一个源代码文件：Demo.scala，如下代码

object Demo {
   def main(args: Array[String]) {
      var a = 10;
      var b = 20;
      var c = 25;
      var d = 25;

      println("a + b = " + (a + b) );
      println("a - b = " + (a - b) );
      println("a * b = " + (a * b) );
      println("b / a = " + (b / a) );
      println("b % a = " + (b % a) );
      println("c % a = " + (c % a) );
   }
}

执行上面示例代码，得到以下结果 -

a + b = 30
a - b = -10
a * b = 200
b / a = 2
b % a = 0
c % a = 5
Shell

2.关系运算符

下表显示了Scala语言支持的关系运算符。假设变量A=10，变量B=20，则

运算符	描述	示例
`==`	检查两个操作数的值是否相等。如果相等，则条件成立。	`(A == B)`结果为`false`
`!=`	检查两个操作数的值是否相等。如果值不相等，则条件成立。	`(A != B)` 结果为`true`
`>`	检查左操作数的值是否大于右操作数的值。如果是，则条件成立。	`(A > B)` 结果为`false`
`<`	检查左操作数的值是否小于右操作数的值。如果是，则条件成立。	`(A < B)`结果为`true`
`>=`	检查左操作数的值是否大于等于右操作数的值。如果是，则条件成立。	`(A >= B)` 结果为`false`
`<=`	检查左操作数的值是否小于等于右操作数的值。如果是，则条件成立。	`(A <= B)`结果为`true`

创建一个源代码文件：Demo.scala，如下代码

object Demo {
   def main(args: Array[String]) {
      var a = 10;
      var b = 20;

      println("a == b = " + (a == b) );
      println("a != b = " + (a != b) );
      println("a > b = " + (a > b) );
      println("a < b = " + (a < b) );
      println("b >= a = " + (b >= a) );
      println("b <= a = " + (b <= a) );
   }
}

执行上面示例代码，得到以下结果 -

a == b = false
a != b = true
a > b = false
a < b = true
b >= a = true
b <= a = false
Shell

3.逻辑运算符

下表显示了Scala支持的所有逻辑运算符。假设变量A=1，变量B=0，则

运算符	描述	示例
`&&`	逻辑与运算符。如果两个操作数都不为零，则条件成立。	`(A && B)`结果为`false`
	称为逻辑或运算符。如果两个操作数中的任何一个非零，则条件成立。	(A B)结果为`true`
`!`	称为逻辑非运算符，它用于反转其操作数的逻辑状态。如果条件为真，则逻辑`NOT`运算符将使其结果为`false`。

**示例：**创建一个源文件：Demo.scala，代码如下 -

object Demo {
   def main(args: Array[String]) {
      var a = true;
      var b = false;

      println("a && b = " + (a&&b) );

      println("a || b = " + (a||b) );

      println("!(a && b) = " + !(a && b) );
   }
}

执行上面代码，得到以下结果 -

a && b = false
a || b = true
!(a && b) = true

4.按位运算符

按位运算符对位进行操作，并执行逐位运算。 ＆，|和^的真值表如下 -

p	q	p & q	p/q	p ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

假设A = 60，B = 13，二进制格式如下：

A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~A = 1100 0011

下表列出了Scala支持的按位运算符。假设变量A=60，变量B=13，则 -

运算符	描述	示例
`&`	如果二进制AND运算符存在于两个操作数中，则二进制AND运算符将对结果复制一位。	`(A&B)= 12`，即`0000 1100`
	二进制OR运算符如果存在于任一操作数中，则复制一位。	(A B) = 61, 即 `0011 1101`
`^`	二进制XOR操作符复制该位，如果它设置在一个操作数中，而不是两者。	`(A ^ B) = 49`, 即, `0011 0001`
`~`	二进制补码运算符是一元的，具有“翻转”位的作用。	`(~A)= -61`，即 `1100 0011`的补码形式。
`<<`	二进制左移操作符，左操作数值左移由右操作数指定的位数。	`A << 2 = 240` 即, `1111 0000`
`>>`	二进制右移操作符，左操作数值被右操作数指定的位移动。	`A >> 2 = 15` 即,`0000 1111`

示例： 创建一个源代码文件：Demo.scala，代码如下所示 -

object Demo {
   def main(args: Array[String]) {
      var a = 60;           /* 60 = 0011 1100 */  
      var b = 13;           /* 13 = 0000 1101 */
      var c = 0;

      c = a & b;            /* 12 = 0000 1100 */ 
      println("a & b = " + c );

      c = a | b;            /* 61 = 0011 1101 */
      println("a | b = " + c );

      c = a ^ b;            /* 49 = 0011 0001 */
      println("a ^ b = " + c );

      c = ~a;               /* -61 = 1100 0011 */
      println("~a = " + c );

      c = a << 2;           /* 240 = 1111 0000 */
      println("a << 2 = " + c );

      c = a >> 2;           /* 215 = 1111 */
      println("a >> 2  = " + c );

      c = a >>> 2;          /* 215 = 0000 1111 */
      println("a >>> 2 = " + c );
   }
}
Scala

执行上面代码，得到以下结果 -

a & b = 12
a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240
a >> 2 = 15
a >>> 2 = 15

5.赋值运算符

下表列出了Scala语言支持的赋值运算符 -

运算符	描述	示例
`=`	简单赋值运算符，将右侧操作数的值分配给左侧操作数	`C = A + B`，将`A + B`的值分配给`C`
`+=`	相加与赋值运算符。它将右操作数添加到左操作数，并将结果分配给左操作数。	`C + = A`等价于`C = C + A`
`-=`	相减与赋值运算符。它从左操作数中减去右操作数，并将结果分配给左操作数。	`C -= A`等价于 `C = C - A`
`*=`	乘以与赋值运算符。它将右操作数与左操作数相乘，并将结果分配给左操作数。	`C * = A`等价于`C = C * A`
`/=`	除以与赋值运算符。它将左操作数与右操作数分开，并将结果分配给左操作数。	`C /= A`等价于`C = C / A`
`%=`	模数与赋值运算符。它需要使用两个操作数的模数，并将结果分配给左操作数。	`C %= A`等价于`C = C % A`
`<<=`	左移与赋值运算符	`C <<= 2`等价于`C = C << 2`
`>>=`	右移与赋值运算符	`C >> = 2`等价于`C = C >> 2`
`&=`	按位与赋值运算符	`C &= 2`等价于`C = C & 2`
`^=`	按位异或运算符和赋值运算符。	`C ^= 2`等价于`C = C ^ 2`
	按位包含OR和赋值运算符。

示例： 创建一个源文件：Demo.scala ，其代码如下 -

object Demo {
   def main(args: Array[String]) {
      var a = 10;    
      var b = 20;
      var c = 0;

      c = a + b;
      println("c = a + b  = " + c );

      c += a ;
      println("c += a  = " + c );

      c -= a ;
      println("c -= a = " + c );

      c *= a ;
      println("c *= a = " + c );

      a = 10;
      c = 15;
      c /= a ;
      println("c /= a  = " + c );

      a = 10;
      c = 15;
      c %= a ;
      println("c %= a  = " + c );

      c <<= 2 ;
      println("c <<= 2  = " + c );

      c >>= 2 ;
      println("c >>= 2  = " + c );

      c >>= 2 ;
      println("c >>= 2  = " + c );

      c &= a ;
      println("c &= a  = " + c );

      c ^= a ;
      println("c ^= a  = " + c );

      c |= a ;
      println("c |= a  = " + c );
   }
}

执行上面代码，得到以下结果 -

c = a + b  = 30
c += a  = 40
c -= a  = 30
c *= a  = 300
c /= a  = 1
c %= a  = 5
c <<= 2  = 20
c >>= 2  = 5
c >>= 2  = 1
c &= a  = 0
c ^= a  = 10
c |= a  = 10

6.运算符优先级

运算符优先级决定表达式中术语的分组，并决定如何评估计算表达式。某些运算符的优先级高于其他运营商; 例如，乘法运算符的优先级高于加法运算符，则先要执行乘法运算符的运算。

让我们通过下面的例子了解优先级：

int value = 10 + 20 * 10;

value变量计算结果为：210，因为*(乘法运算符)的优先级比+(加法运算符)高，所以在+(加法运算符)之前进行求值。

C语言运算符的优先级和关联性如下：

分类	运算符	关联性
后缀	`() [] -> . ++ - -`	左到右
一元	`+ - ! ~ ++ - - (type)* & sizeof`	右到左
乘法	`* / %`	左到右
加法	`+ -`	左到右
位移	`<< >>`	左到右
关系	`< <= > >=`	左到右
等于	`== !=`	左到右
按位与	`&`	左到右
位异或	`^`	左到右
按位或	`/`	左到右
逻辑与	`&&`	左到右
逻辑或	`//`	左到右
条件	`?:`	右到左
赋值	`= += -= *= /= %=>>= <<= &= ^= /=`	右到左