技术

Scala 笔记

字符串：

  • 可使用 + 连接, 使用*重复

val a = "hello "
val b = "world"
println(a + b)

>> "hello world"

val c = a + b * 2
println(c)

>> "hello worldworld"

  • printf格式化输出

val age = 18
printf("%d岁", age)

>> 18岁

val name = "SB"
printf("%s 你好", name)

>> SB 你好

  • 字符串的占位符

println(s"${age}岁的${name}")

>> 18岁的SB

  • 保留小数位

%.NfN代表保留几位小数

val bar = 3.1415f
println(f"当前进度:${bar}%.2f")

>> 当前进度:3.14

  • raw原始输出 只填充${}

println(raw"当前进度:${bar}%.2f")

>> 当前进度:3.1415%.2f

  • 多行模板

println(
  f"""|hello
     |world
     |${name}""".stripMargin)

标准化输入输出：

  • 标准化输出

println()
print()
printf()

  • 标准化输入

import scala.io.StdIn

val input = StdIn.readLine()

>> |输入..

  • 文件读取

import scala.io.Source

val file = scala.io.Source.fromFile("input/word.txt")

  • 文件写入

import java.io.File
import java.io.PrintWriter

val writer = new PrintWriter(new File("input/word.txt"))
writer.write("hello world")
writer.close()

数据类型：

  • 全部：

    Any

    AnyRef 引用类型

    Array

    List

    ArrayList

    Set

    Null

    AnyVal 数据类型

    Short

    Int

    Long

    Float

    Double

    Unit

    ShringOps

    Char

    Boolean

    Byte

    Nothing

  • 整数类型

  • Byte -128到127

  • Short -32768到32767

  • Int ± 20e

  • Long >±20e

    val b1: Byte = -128
    val b2: Byte = 127

    val s1: Short = 32767
    val s2: Short = -32768

    val i1 = 2000000000
    val i2 = -2000000000

    val l1 = 20000000000L
    val l2 = -20000000000L

  • 浮点类型

  • Float 单精度

  • Double 双精度

  • 字符类型

  • Char

使用单引号

val c1: Char = '0'
val c2: Char = '\n'
print("abc" + c2 + "def")

  • String

  • 布尔类型

  • BooleanTrue False

  • 空类型

  • Unit 空值

和其他语言 void 一样 用作不返回结果的方法类型 写成() 空括号

  • Null 空引用

Null 的 唯一实例 null

  val n: Array[String] = null

  • Nothing 什么都没有

所有类型的子类

def f2(n: Int): Nothing = {
  if (n == 0) {
    throw new NullPointerException
  }
  throw new Error("hello world")
}

f2(1)

def f2(n: Int): Int = {
  if (n == 0) {
    throw new NullPointerException
  } else {
    n
  }
}

  • 类型转换

    低转高 自动转换

val b1: Byte = 1
val i1: Int = b1
// 自动转换

val i2: Int = 1
val b2: Byte = i2.toByte

  • toString 转String

  • toInt 转Int 以此类推

Char 转 Byte 时 IDEA不会报错 但编译器会报错 要使用toByte

运算符：

计算运算符：

  • + 相加或者代表字符串的连接

  • - 相减

  • * 相乘

  • / 相除

  • % 取余

关系运算符：

  • == 等于

  • ≠ 不等于

  • > 大于

  • < 小于

  • ≥ 大于等于

  • ≤ 小于等于

逻辑运算符：

  • && 与

println(true && true)  // True
println(false && true)  // False
println(false && false)  // False

  • || 或

println(true || true)  // True
println(false || true)  // True
println(false || false)  // False

  • ! 非

println(!true)  // False
println(!false)  // True

赋值运算符：

  • = 直接赋值

  • += 相加赋值

  • -= 相减赋值

  • *= 相乘赋值

  • /= 相乘赋值

  • %= 求余赋值

循环（loop）：

while 循环：

while (条件) {
  代码块
}

for 循环：

for (i <- 0 to 10) {
  0 - 10 包含 10
}

for (i <- 0 until 10) {
  0 - 9 不包含 10
}

val array = Array[String]("hello", "world", "nmsl") 
// 循环一个可迭代对象 ①
for (i <- array) {
  println(i)
}
// 等价于 ②
for (i <- 0 until array.length) {
  println(array(i))
}
// 等价于 ③
for (i <- array.indices) {
  println(array(i))
}

for 循环过滤：

for (i <- 1 to 9) {
  for (j <- 1 to 9 if j < i) {
    print(f"${j}*${i}=${i*j} ")
  }
  println()
}

// 打印所有奇数
for (i <- 0 to 100 if i % 2 == 1) {
  println(i)
}

yield 储存循环算法 类似于Python列表生成器

val 奇数 = for {i <- 0 to 10 if i % 2 == 1} yield i

for (i <- 奇数) {
  println(i)
}

方法和函数（function and method）：

  • val定义函数

  • def定义方法

  • 传名调用

    当参被用到再计算其值

  • 传值调用

    当传入时计算其值

  • 函数柯里化

    使用以下方式定义函数

def add(x:Int)(y: Int) = x + y

  • 闭包

val y = 1
def add(x: Int) = x + y

这个add方法就是闭包 因为他用到了外部变量

当定义她时y被封装

数组（Array）

  • 定义

val array1: Array[String] = new Array[String](3)
array1(0) = "hello"
array1(1) = "hello"
array1(2) = "nmsl"

val array2 = Array("hello", "nmsl")

  • 处理

// 求最值
val num_array = Array(1,2,3,465,4,65,4,46,456,423,1,465,45,1,321,564,56,561,651,561,56156,56,165,156,1,561,561,56,156,156,156,1,561)
var max_number = num_array(0)
for (i <- num_array) {
  if (i > max_number) {
    max_number = i
  }
}
println("最大的数" + max_number)

  • 多维数组

// 创建
val Matrix = Array.ofDim[Int](3, 3)

// 多维数组打印
for (i <- 0 to 2) {
  for (j <- 0 to 2) {
    Matrix(i)(j) = j // 赋值
    print(" " + Matrix(i)(j))
  }
  println()
}

  • 生成器

val range1 = Range(1, 10)
println(range1)
println("他的类型：" + range1.getClass)

>>Range 1 until 10
>>他的类型：class scala.collection.immutable.Range

他储存的是算法所以不占真实的内存空间（如果不迭代）

他是一个可迭代类型 scala.collection

Range是一个类 和Python range函数差不多 有三个参数

  • start 开始值

  • stop 结束值 不包括

  • step 步进

  • 常用函数

    • Array.concat 连接

    • Array,copy 拷贝

集合（Coliiection）

List

  • 可重复

  • 有序

  • 可以同时包含多种数据类型

val list1: List[String] = List("hello", "world")  // 字符串列表
val list2: List[Any] = List("hello", 123)  // 可以存在不同的类型
val list3: List[String | Int] // Scala3 的写法 Scala2 报错

val list3: List[Nothing] = List()  // 空列表

val list4: List[List[Int]] = List( // 二维列表
  List(1,2,3),
  List(4,5,6),
  List(7,8,9)
)

// list4.head 获取第一个值
// list4.tail 获取最后一个值
// list4.isEmpty 判断是否为空
// val res = list1 ::: list2 连接list 返回list
val list6 = List.fill(5)("nmsl")  // 柯里函数 填充一个值到列表 5是重复次数
>>List(nmsl, nmsl, nmsl, nmsl, nmsl)

val list7 = List.tabulate(100)(x => x * x)  // 柯里函数 生成一个列表 0 until x (这里是100) 然后执行一个函数 结果保存到 list7

println(list7.reverse) // 翻转一个List

Set

  • 不可重复

  • 无序

  • 不能有不同数据类型

Comment