Scala - 服务器托管|北京服务器租用|机房托管租用|IDC托管租用|机房机柜带宽租用-价格及费用咨询

Scala用法总结

一、什么是scala

spark新一代内存级大数据计算框架，是大数据的核心内容。

在对 spark 进行二次开发时，由于 Spark 是基于 Scala 基础之上编写的，故而为更好地学习 Spark,需要Scala 此门语言与掌握 spark框架的源代码。

Scala 是 Scalable Language 的简写，含义为可升级、可攀登，是一门多范式的编程语言（面向对象：命令式编程的一种方式/函数式编程），函数的地位得到提升，其运用十分到位。

总的来说就是在对spark进行二次开发时java学的不太好的朋友可以用scale这门更加方便的语言进行操作。

（个人认为这个语言对学过java的并不太友好，很接近java，但是又与java不一样）

（果然学了python以后觉得其他语言都很不友好）

二、安装

1、软件安装

解压安装包到自定义目录下

添加环境变量

2、插件安装

常做开发的兄弟大多喜欢用idea的产品，那么问题来了scala是否可以使用IJ进行开发呢？其实也不是不行，就是需要安装对应的插件。

打开IJ

File——>Setting——>Plugins 然后搜索scala点击 install 安装，点击OK，apply

2.1 安装maven

在官网下载maven包并解压到自定义目录下

配置环境变量

在path中添加maven_path

修改配置

D:Program Filesapache-maven-3.2.2confsettings.xml

55行左右配置本地仓库路径

localRepository>D:Program FilesmavenWarehouselocalRepository>

158行附近配置中央仓库镜像源（这里配置的是阿里云的镜像）

mirror>
  id>aliyunmavenid>
  mirrorOf>*mirrorOf>
  name>阿里云公共仓库name>
  url>https://maven.aliyun.com/repository/publicurl>
mirror>

2.2 idea配置

笔者使用的时2023版本的IJ，还记得上次使用的时2016版本的，与之前比完全不一样了捣鼓大半天才把环境配置好。本章节属于事后总结，不对的地方欢迎指正补充。

配置maven

File——>Setting 然后搜索maven进行如下配置（记得所有的配置需要先点击apply再点击OK）

配置scala

File——>Project Structures

创建maven项目，然后选中main然后右键 Source，Apply，OK。此时文件夹的颜色发生变化。

回到工作空间下选中创建的maven项目，然后双击shift，搜索 Add Framework Support

点击进入后，勾选添加scala。

至此配置应该就结束了。

三、基本语法

1、helloword

创建scala class 选择 object，编写并执行如下程序

package com.wbb.testscala

object Hello {
  def main(args: Array[String]): Unit = {
    println("hello scala")
    System.out.println("hello scala java")
  }
}

scala在线查看帮助手册：https://www.scala-lang.org/

选择对应的版本进行下载（都是英文的凑合看吧）

2、变量定义

变量类型一旦定义则类型确定不可发生修改，如：一个Int类型的变量不可修改为字符串

// var 定义的变量可以发生修改
var i:Int = 10
// val 定义的变量不可发生修改
// 定义变量时数据类型可省略，scala自动识别变量的数据类型
val j = 20

object Hello {
  def main(args: Array[String]): Unit = {
    var name = "wbb"
    var age = 18
    // 字符串连接
    println(name + age)
    // 字符串格式化输出
    printf("name: $s, age: $d", name, age)
    // 多行字符串
    var s =
      """
        |select *
        |from dual
        |""".stripMargin
    println(s)
    // 变量引用（有点类似于python）
    var s1 =
      s"""
         |person:
         |name: ${name} age:${age+2}
         |""".stripMargin
    println(s1)
  }
}

输入变量（从键盘接收变量值，类似java）

object Hello {
  def main(args: Array[String]): Unit = { 
    // 从键盘接收字符串
    var name = StdIn.readLine()
    // 从键盘接收数字
    var age = StdIn.readInt()
    // 变量引用
    println(s"name: ${name} age: ${age}")
  }
}

3、数据类型

数据类型	取值范围
Byte[1]	-128 到 127
Short [2]	-32768 到 32767
Int [4]	-2147483648 到 2147483647
Long [8]	-(2 的(64-1)次方) = 2 的(64-1)次方-1
Float [4]	32 位, IEEE 754 标准的单精度浮点数
Double [8]	64 位 IEEE 754 标准的双精度浮点数
Char	字符类型
Boolean	布尔类型
Unit	等同于java的void用作无返回值的方法的数据类型，main方法的返回值就是Unit
Null	空类型，仅有一个实例null。可以赋值给任意引用类型（类的实例），但不可以赋值给数值类型。
Nothing	scala特有，表示所有类的子类。Nothing类型的返回值可以兼容其他类型，方便将该类型的返回值赋值给其他方法或者变量（包括返回异常）

保留小数位数

var a:Double = 1.1111
// 四舍五入保留两位小数
println(a.formatted("%.2f"))

4、分支语句（循环）

在scala中if语法与java基本一致，在此处不做说明，主要说明不同于java的语法

4.1 for循环

// 从1循环到10（左闭右闭区间）
for(i1 to 10){
    println(i)
}

4.2 util循环

// 从1循环到10（左闭右开区间）
for(i1 until 10){
    println(i)
}

4.3 循环守卫

// 循环去1到10中3的倍数，满足条件进入循环，不满足则continue
for(i1 to 10 if i %  3 == 0){
    println(i)
}

4.4 步长

// 从1循环到10的奇数。默认步长为 1
for(i1 to 10 by 2){
    println(i)
}

4.5 嵌套循环

for(i1 to 10 by 2; j1 to 3){
    println("" + i + "和" + j)
}

// for 循环内有多个表达式用大括号换行，或者用小括号中间加分号
// 个人认为第二个格式更美观一些
for{i1 to 10 by 2
    j1 to 3
   }{
    println("" + i + "和" + j)
}

4.5 while循环

while (i10){
    println(i)
    i = i + 1
}

4.7 do——while

do {
    println(i)
    i = i + 1
} while (i10)

4.8 break

Breaks.breakable(
      for (i  1 to 10) {
        println(i)
        if (i == 5) Breaks.break()
      } 
   )

四、函数

1、函数基础

scala的函数不同于java，使用方法很灵活，基本属于scala界的大哥大。建议使用的时候还是参考java进行使用，嵌套过多反而不易解读，导致程序可读性和可维护性变差。

1.1 函数可以作为值进行传递

object Hello {
  def main(args: Array[String]): Unit = {
    //调用函数，把返回值给变量 f（因为函数没有参数，所以调用的括号可以省略）
    //val f = fun1()
    val f = fun1
    println(f)
    // 函数后面加 _，相当于把函数当成一个整体，传递给变量 f1，此时f1也是一个函数，可以被调用
    val f1 = fun1 _
    f1()
    //如果明确变量类型，不使用下划线也可以将函数作为整体传递给 变量
    var f2:()=>Int = fun1
    f2()
  }

  def fun1():Int = {
    println("fun1被调用")
    1
  }
}

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

object Hello {
  def main(args: Array[String]): Unit = {
    def f1(a: Int, b: Int): Int = a + b
    // 定义一个函数，函数参数还是一个函数签名；f 表示函数名称;(Int,Int) 表示输入两个 Int 参数；Int 表示函数返回值
    def f2(f: (Int, Int) => Int): Int = {
      f(2, 4)
    }
    println(f2(f1))
  }
}

1.3 函数可以作为返回值进行传递

object Hello {
  def main(args: Array[String]): Unit = {
    def f2(): Any = {
      def f1(a: Int, b: Int): Int = a + b
      f1 _
    }
    println(f2())
  }
}

2、函数进阶

2.1 模拟实现map映射

按照传入的函数操作Array中的每个值

object Hello {
  def main(args: Array[String]): Unit = { 
    // 定义函数map，第一个参数为数组，第二个参数为函数op，op的参数和返回值都是Int
    // 返回值为Array，yield是将数组的每个值用函数进行处理，每个值改变为函数op的返回值
    def map(arr: Array[Int],  op: Int => Int) = {
      for(a  arr) yield op(a)
    }
    // 调用map，第一个参数是数组(1,2,3,4)，第二个参数为匿名函数，匿名函数返回值为参数的平方
    var arr = map(Array(1, 2, 3, 4),(x:Int) => {x * x})
    // 将Array转换为字符串
    println(arr.mkString(","))
  }
}

2.2 模拟实现Filter过滤

按照函数的规则筛选Array

import scala.collection.mutable.ArrayBuffer

object Hello {
  def main(args: Array[String]): Unit = {
    // 定义函数filter，第一个参数为Array类型，第二个参数为函数op，op的参数为Int类型，返回布尔值
    def filter(arr:Array[Int],op:Int =>Boolean) ={
      // 定义变长 Array
      var arr1:ArrayBuffer[Int] = ArrayBuffer[Int]()
      // 便利array，每次元素调用op，返回值为true则将元素添加到变长Array
      for(elem  arr if op(elem)){
        arr1.append(elem)
      }
      //  变长Array转换为Array
      arr1.toArray
    }
    // 调用filter，第一个参数为数组(1,2,3,4)，第二个参数为匿名函数，判断匿名函数的参数是否为奇数
    var arr1 = filter(Array(1, 2, 3, 4), _ % 2 == 1)
    println(arr1.mkString(","))
  }
}

2.3 模拟实现reduce规约累乘

将一个Array的元素逐个相乘

object Hello {
  def main(args: Array[String]): Unit = {
    def reduce(arr: Array[Int], op: (Int, Int) => Int) = {
      var init: Int = arr(0)
      for (elem  1 to arr.length) {
        init = op(init, elem)
      }
      init
    }
    val chen = reduce(Array(1, 2, 3, 4), _ * _)
    println(chen)
  }
}

3、递归

阶乘

object Hello {
  def main(args: Array[String]): Unit = {
    def jiechen(a: Int): Int = {
      if (a == 1) {
        return 1
      }
      a * jiechen(a - 1)
    }
    println(jiechen(3))
  }
}

4、惰性加载

有时为了节约资源开销，或者程序设计，期望函数的返回值被使用的时候再去加载函数，这里专业叫法是惰性加载，关键字为lazy。（lazy只可以加在val变量之前）

object Hello {
  def main(args: Array[String]): Unit = {
    lazy val res = addnum(1, 2)
    println("test print") 
    // 此处用到变量值才开始调用函数
    println(res)

    def addnum(a: Int, b: Int): Int = {
      a + b
    }
  }
}

五、类

1、类的属性

package com.wbb.testscala

import scala.beans.BeanProperty

class Person {
  var name: String = "bobking"
  // 给属性age赋予默认的Int值，这里查看是 0 
  var age: Int = _ 
  // 注解为sex属性添加了get set方法（与java bean类似）
  @BeanProperty var sex: String = "不详"
}
object Person {
  def main(args: Array[String]): Unit = {
    var person = new Person()
    println(person.name)
    person.setSex("女")
    println(person.getSex)
  }
}

2、类的方法

与java类似下一小结中的say方法就是Person类的方法

2.1构造器

辅助构造器：一个类可以有多个辅助构造器，辅助构造器必须调用主构造器，辅助构造器可以有多个。

class Person {
  var name: String = _
  var age: Int = _
  def this(age: Int) {
    this()
    this.age = age
    println("辅助构造器")
  }
  def this(age: Int, name: String) {
    this(age)
    this.name = name
  }
  println("主构造器")
}
object Person {
  def main(args: Array[String]): Unit = {
    val person2 = new Person(22)
  }
}

输出结果如下

主构造器
辅助构造器

3、访问权限

package com.wbb.testscala

class Person {
  // 私有属性，仅类和类的对象可用
  private var name: String = "bobking"
  // 保护权限属性，仅同类和子类可以使用
  protected var age: Int = 18
  // testscala包下的其他类可以使用
  private[testscala] var sex: String = "不详"
  def say(): Unit = {
    println("牛B")
  }
}

class Hiker extends Person {
  def test(): Unit = {
    this.age
    this.sex
  }
}

object Person {
  def main(args: Array[String]): Unit = {
    val person = new Person
    person.say()
    println(person.name)
    println(person.age)
    val wbb = new Hiker
    println(teacher.age)
  }
}

4、类的继承

scala的子类继承父类的属性和方法，先执行父类的构造器再执行子类的构造器。（只能是单继承）

package com.wbb.testscala

class Person() {
  var name: String = _
  var age: Int = _
  def this(age: Int) {
    this()
    this.age = age
    println("辅助构造器")
  }
  println("person的主构造器")
}

class Hiker(p_name: String, p_age: Int) extends
  Person{
  var language: String = _
  def this(p_name: String, p_age: Int, p_language: String){
    this(p_name, p_age)
    this.name = p_name
    this.age = p_age
  }
  println("Hiker的主构造器")
}

object Hello {
  def main(args: Array[String]): Unit = {
    val a = new Hiker("bobking", 30, "scala")
  }
}

输出结果为

person的主构造器
Hiker的主构造器

5、抽象

和java一样，有时需要抽象出一个类，在这个类的基础上那可以拓展出多个子类，每个类有自己独有的实现方式。

package com.wbb.testscala

// 抽象类（关键字abstract）
abstract class Person() {
// 抽象属性（仅有属性的定义，没有赋值）
  var name: String
// 抽象方法（仅有方法的声明，没有实现方式）
  def who(): Unit
}

// 子类继承抽象类，必须实现抽象类所有的方法与属性
// 重写非抽象类的方法和属性不需要overwrite关键字
class Hiker() extends{
  var name: String = "bobking"
  def who(): Unit = {
    println(this.name)
  }
}

object Hello {
  def main(args: Array[String]): Unit = {
    val a = new Hiker()
    a.who()
  }
}

6、伴生对象

其实说白了也就是java的静态类，原理不同但实现的效果是没什么差异的。类的半生对象与类同名，可以通过类的半生对象直接访问类的属性和方法，不需要再单独定义一个类对象，从而实现单实例。

package com.wbb.testscala

class Person {
  var name: String = "bobking"
}

object Person {
  var age:Int = 35
}

object Hello {
  def main(args: Array[String]): Unit = {
    println(Person.name)
  }
}

7、类的特质

java中有接口，scala中同样有，将通用的方法和属性进行封装。（关键字 Trait）

scala的类仅可以单继承，但是特质可以多继承，多个特质之间用with关键字进行连接。

特质的使用很灵活可以不进行定义直接在创建对象的时候混入。继承特质时特质中的抽象类和抽象方法都需要重写，非抽象属性不可以重新赋值。

package com.wbb.testscala

// 定义特质，特质中的属性和方法可以使抽象的也可以是具体的
trait PersonTrait {
  var name: String = _
  var age: Int
  def play(): Unit = {
    println("摸鱼")
  }
  def say(): Unit
}

trait SexTrait {
  var sex: String
}

trait HobbyTrait{
  var hobby: String = "爱吃了睡"
}

//一个类可以实现/继承多个特质
class Hiker extends PersonTrait with SexTrait {
  override def say(): Unit = {
    println("say")
  }
  override var age: Int = _
  override var sex: String = _
}

object Test {
  def main(args: Array[String]): Unit = {
    val hiker = new Hiker
    hiker.say()
    hiker.play()
    // 动态混入
    val t2 = new Hiker with HobbyTrait {
    }
    //调用混入 trait 的属性
    println(t2.hobby)
  }
}

7.1 特质叠加

当一个类继承多个特质，特质中有同名方法是就会涉及到特质叠加。

super.play是执行叠加好的下一个对象的play方法

叠加顺序如下

Hiker——>HobbyTrait——>SexTrait——>PersonTrait

package com.wbb.testscala

trait PersonTrait {
  var name: String = _

  def play(): String = {
    "摸鱼"
  }
}

trait SexTrait extends PersonTrait {
  override def play(): String = {
    "男-" + super.play()
  }
}

trait HobbyTrait extends PersonTrait {
  override def play(): String = {
    "爱吃了睡-" + super.play()
  }
}

class Hiker extends SexTrait with HobbyTrait {
  override def play(): String = {
    "程序员-" + super.play()
  }
}

object Test {
  def main(args: Array[String]): Unit = {
    val hiker = new Hiker
    val p = hiker.play()
    println(p)
  }
}

调用某个继承特质的方法：super[特质名称].fangfam()

hiker对象

输出结果为

程序员-爱吃了睡-男-摸鱼

package com.wbb.testscala

class Person {
  var name: String = _
}

object Test {
  def main(args: Array[String]): Unit = {
    var hiker = new Person() 
    // 判断对象是否是某个类的实例
    println(hiker.isInstanceOf[Person])
    // 将对象转换为某个类的实例
    var h1 = hiker.asInstanceOf[Person]
    println(h1)
    // 获取类信息
    println(classOf[Person])
  }
}

输出结果如下

true
com.wbb.testscala.Person@5e025e70
class com.wbb.testscala.Person

六、集合

Scala 的集合有三大类：序列 Seq、集 Set、映射 Map，所有的集合都扩展自 Iterable

特质。

不可变集合：scala.collection.immutable

可变集合： scala.collection.mutable

1、数组

1.1 不可变数组

package com.wbb.testscala


object Hello {
  def main(args: Array[String]): Unit = {
    // 数组定义
    val a1 = new Array[Int](5)
    println(a1.length)
    val a11 = Array(1, 2, "aaa")
    println(a11.mkString(","))
    // 数组元素赋值，注意这里是圆括号
    a1(2) = 1
    // 修改数组下标为1的元素值为10
    a1.update(1, 10)
    // 数组转字符串（查看）
    println(a1.mkString(","))

    // 数组遍历
    for(ele  a1){
      println(ele)
    }

    a1.foreach((x:Int)=>{println(x)})

    // 数组添加元素，在a1的基础上添加元素 5，组成新的数组
    val a2: Array[Int] = a1 :+ 5
    println(a2.mkString(","))
  }
}

1.2 可变数组

package com.wbb.testscala

import scala.collection.mutable.ArrayBuffer


object Hello {
  def main(args: Array[String]): Unit = {
    // 可变数组定义，并为数组赋初始值
    var a1 = ArrayBuffer[Any](1, 2, 3)
    println(a1.mkString(","))
    // 查看数组的hash值
    println(a1.hashCode())

    a1.+= (3)
    // 追加元素 4,5到数组
    a1.append(4, 5)
    println(a1.mkString(","))
    // 在数组0号位添加元素 5，6
    a1.insert(0, 5, 6)
    println(a1.mkString(","))
  }
}

1.3 转换

// 可变数组转不可变
a2 = a1.toArrry
// 不可变数组转可变
a3 = a2.toBuffer

1.4 多维数组

package com.wbb.testscala

object Hello {
  def main(args: Array[String]): Unit = {
    // 可变数组定义，并为数组赋初始值
    var a1 = Array.ofDim[Any](2, 3)
    a1(1)(1) = "wbb"
    for(x  a1){
      for(j  x){
        println(": " + j)
      }
    }
  }
}

2、列表

2.1 不可变list

package com.wbb.testscala

object Hello {
  def main(args: Array[String]): Unit = {
    val l = List(1, 2, 3)
//    Nil为空
    val l1 = 1::2::Nil
//    在l列表的前面加元素 4
    val l2 = 4::l
//    在头部添加元素 5
    val l3 = l.+:(5)
//    在尾部添加元素 5
    val l31 = l.:+(5)
//    将两个列表连接成为一个
    val l4 = l:::l1
    l4.foreach(println)
  }
}

2.2 可变listBuffer

package com.wbb.testscala

import scala.collection.mutable.ListBuffer

object Hello {
  def main(args: Array[String]): Unit = {
    // 创建一个可变数组
    val b = ListBuffer(1,2,3,4)
    // 向数组中添加数据
    b.+=(5)
    b.append(6)
    // 向数组指定位置添加元素
    b.insert(1,2,3)
    // 修改数据
    b(1) = 6
    b.update(1,7)
    // 删除数据
    b.-=(5)
    b.remove(5)
  }
}

3、集合

集合的元素不可重复，元素无序

3.1 不可变集合

val set = Set(1,2,3)

3.2 可变集合

package com.wbb.testscala

import scala.collection.mutable

object Hello {
  def main(args: Array[String]): Unit = {
    // 创建可变集合
    val s = mutable.Set(1,2,3,4,5,6)
    // 集合添加元素
    s += 8
    // 向集合中添加元素，返回一个新的 Set
    val s1 = s.+(9)
    // 删除数据
    s-=(5)
  }
}

4、Map集合

用于存储键值对

4.1 不可变Map

package com.wbb.testscala

object Hello {
  def main(args: Array[String]): Unit = { 
    // 创建map
    val map = Map("a"->1, "b"->2, "c"->3)
    // 遍历map中的值
    for(m  map.keys){
      println(map(m))
    }
    // 按照key值获取对应的map值，若未找到则赋值为0
    println(map.getOrElse("d", 0))
    // 循环打印map
    map.foreach(m=>{println(m)})
  }
}

4.2 可变map

package com.wbb.testscala

import scala.collection.mutab服务器托管网le

object Hello {
  def main(args: Array[String]): Unit = { 
    // 创建可变map
    val map = mutable.Map("a"->1, "b"->2, "c"->3)
    // map添加元素
    map.+=("d"-> 4, "e"->5)
    // map删除元素
    map.-=("a","b")
    // map修改值
    map.update("c", 100)
    map.foreach(m=>{println(m)})
  }
}

5、元组

元组就是将多个无关的数据封装为一个整体（元组最大可有22个元素）

package com.wbb.testscala

object Hello {
  def main(args: Array[String]): Unit = {
    // 声明元组
    val tuple:(String, Int, String) = ("wbb",20,"男")服务器托管网
    // 元组访问
    println(tuple._1)
    // 通过下标访问元组
    println(tuple.productElement(0))
    // 通过迭代器访问
    for(t  tuple.productIterator){
      println(t)
    }
  }
}

6、集合操作

6.1 定义集合

val l: List[Int] = List(1,2,3,4)
val l1: List[Int] = List(5,6,7,8)

6.2 判断list是否包含 3

println(l.contains(3))

输出结果

true

6.3 获取集合的首个元素

println(l.head)

输出结果

6.4 获取集合的最后一个元素

println(l.last)

输出结果

6.5 获取集合的尾（去除头元素）

println(l.tail)

输出结果

List(2,3,4)

6.6 获取集合的头（去除最后一个元素）

println(l.init)

输出结果

List(1,2,3)

6.7 集合反转

println(l.reverse)

输出结果

List(4,3,2,1)

6.8 集合截取（从左开始2位)

println(l.take(2))

输出结果

List(3, 4)

6.9 集合删除元素（右开始2位）

println(l.dropRight(2))

输出结果

List(1, 2)

6.10 集合拉链

println(l.zip(l1))

输出结果

List((1,5), (2,6), (3,7), (4,8))

6.11 集合滑动

l.sliding(3,2).foreach(println)

输出结果

List(1, 2, 3)
List(3, 4)

6.12 集合排序

package com.wbb.testscala

object Hello {
  def main(args: Array[String]): Unit = {
    val l: List[Int] = List(1,2,3,-4) 
    // 求和
    println(l.sum)
    // 求乘积
    println(l.product)
    println(l.max)
    println(l.min)
    println(l.sorted)
    // 按照绝对值排序
    println(l.sortBy(x=>x.abs))
    // 按照指定规则排序（从小到大）
    println(l.sortWith((x,y)=>(xy)))
  }
}

七、函数进阶

package com.wbb.testscala

object Hello {
  def main(args: Array[String]): Unit = {
    val list: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9)
    val nestedList: List[List[Int]] = List(List(1, 2, 3), List(4, 5, 6), List(7, 8, 9))
    val wordList: List[String] = List("hello world", "hello wbb", "hello hiker")
    // 过滤
    println(list.filter(x => x % 2 == 0))
    // 转化
    println(list.map(x => x + 1))
    //扁平化
    println(nestedList.flatten)
    // 扁平化+映射 注：flatMap 相当于先进行 map 操作，在进行 flatten操作
    println(wordList.flatMap(x => x.split(" ")))
    //分组
    println(list.groupBy(x => x % 2))
  }
}

执行结果如下

List(2, 4, 6, 8)
List(2, 3, 4, 5, 6, 7, 8, 9, 10)
List(1, 2, 3, 4, 5, 6, 7, 8, 9)
List(hello, world, hello, nidaye, hello, scala)
Map(1 -> List(1, 3, 5, 7, 9), 0 -> List(2, 4, 6, 8))

八、队列

先进先出

package com.wbb.testscala

import scala.collection.mutable

object Hello {
  def main(args: Array[String]): Unit = {
    val que = new mutable.Queue[String]()
    que.enqueue("a", "b", "c")
    println(que.dequeue())
    println(que.dequeue())
    println(que.dequeue())
  }
}

九、模式

package com.wbb.testscala

object Hello {
  def main(args: Array[String]): Unit = {
    var a = 1
    var b = 2
    var op = "no"
    var res = op match{
      case "+" => a + b
      case "-" => a - b
      case _ => "未知"
    }
    println(res)
  }
}

模式守卫

package com.wbb.testscala

object Hello {
  def main(args: Array[String]): Unit = {
    def abs(x:Int)=x match{
      case i:Int if i > 0 => x
      case j:Int if j  0 => -x
      case _ => "啥也不是"
    }
    println(abs(-5))
  }
}

latten)
// 扁平化+映射注：flatMap 相当于先进行 map 操作，在进行 flatten操作
println(wordList.flatMap(x => x.split(” “)))
//分组
println(list.groupBy(x => x % 2))
}
}


执行结果如下

```textile
List(2, 4, 6, 8)
List(2, 3, 4, 5, 6, 7, 8, 9, 10)
List(1, 2, 3, 4, 5, 6, 7, 8, 9)
List(hello, world, hello, nidaye, hello, scala)
Map(1 -> List(1, 3, 5, 7, 9), 0 -> List(2, 4, 6, 8))

八、队列

先进先出

package com.wbb.testscala

import scala.collection.mutable

object Hello {
  def main(args: Array[String]): Unit = {
    val que = new mutable.Queue[String]()
    que.enqueue("a", "b", "c")
    println(que.dequeue())
    println(que.dequeue())
    println(que.dequeue())
  }
}

九、模式

package com.wbb.testscala

object Hello {
  def main(args: Array[String]): Unit = {
    var a = 1
    var b = 2
    var op = "no"
    var res = op match{
      case "+" => a + b
      case "-" => a - b
      case _ => "未知"
    }
    println(res)
  }
}

模式守卫

package com.wbb.testscala

object Hello {
  def main(args: Array[String]): Unit = {
    def abs(x:Int)=x match{
      case i:Int if i > 0 => x
      case j:Int if j  0 => -x
      case _ => "啥也不是"
    }
    println(abs(-5))
  }
}

服务器托管，北京服务器托管，服务器租用 http://www.fwqtg.net

相关推荐: Nacos安装，服务注册，负载均衡配置，权重配置以及环境隔离

1. 安装首先从官网下载nacos 安装包，注意是下载 nacos-server Nacos官网 | Nacos 官方社区 | Nacos 下载 | Nacos 下载完毕后，解压找到文件夹bin，文本打开startup.cmd 修改配置如下然后双击 sta…

Scala用法总结

一、什么是scala

二、安装

1、软件安装

2、插件安装

2.1 安装maven

2.2 idea配置

三、基本语法

1、helloword

2、变量定义

3、数据类型

4、分支语句（循环）

4.1 for循环

4.2 util循环

4.3 循环守卫

4.4 步长

4.5 嵌套循环

4.5 while循环

4.7 do——while

4.8 break

四、函数

1、函数基础

1.1 函数可以作为值进行 传递

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

1.3 函数可以作为返回值进行传递

2、函数进阶

2.1 模拟实现map映射

2.2 模拟实现Filter过滤

2.3 模拟实现reduce规约累乘

3、递归

4、惰性加载

五、类

1、类的属性

2、类的方法

2.1构造器

3、访问权限

4、类的继承

5、抽象

6、伴生对象

7、类的特质

六、集合

1、数组

1.1 不可变数组

1.2 可变数组

1.3 转换

1.4 多维数组

2、列表

2.1 不可变list

2.2 可变listBuffer

3、集合

3.1 不可变集合

3.2 可变集合

4、Map集合

4.1 不可变Map

4.2 可变map

5、元组

6、集合操作

6.1 定义集合

6.2 判断list是否包含 3

6.3 获取集合的首个元素

6.4 获取集合的最后一个元素

6.5 获取集合的尾（去除头元素）

6.6 获取集合的头（去除最后一个元素）

6.7 集合反转

6.8 集合截取（从左开始2位)

6.9 集合删除元素（右开始2位）

6.10 集合拉链

6.11 集合滑动

6.12 集合排序

七、函数进阶

八、队列

九、模式

八、队列

九、模式

服务器托管，北京服务器托管，服务器租用，机房机柜带宽租用

1.1 函数可以作为值进行传递