Scala在线运行

版本:

所属目录
点击了解高性能代码运行API
运行结果
教程手册
代码仓库
极速运行
终端运行
图形+终端

                        
以下是用户最新保存的代码
文本文件翻译 发布于:2024-03-15 14:27 九九乘法表 发布于:2024-03-08 20:22 工资计算函数 发布于:2024-03-08 20:10 薪水扣税计算 发布于:2024-03-08 20:04 乘法口诀表 发布于:2024-03-08 20:02 实际工资计算 发布于:2024-03-08 19:53 九九乘法表 发布于:2024-03-08 19:53 九九乘法表 发布于:2024-03-08 19:50 九九乘法表 发布于:2024-03-08 19:46 工资计算器 发布于:2024-03-08 19:43 工资函数计算 发布于:2024-03-08 19:41 02:工资计算函数的实现 发布于:2024-03-08 19:54 乘法口诀表 发布于:2024-03-08 19:41 工资计算函数的实现 发布于:2024-03-08 19:48 工资计算函数的实现 发布于:2024-03-08 19:51 01:编写代码实现1~9乘法口诀 发布于:2024-03-08 19:54 九九乘法表 发布于:2024-03-08 19:39 九九乘法口诀表 发布于:2024-03-08 19:38 实际工资计算 发布于:2024-03-08 19:45 乘法口诀表 发布于:2024-03-08 19:44 工资函数计算 发布于:2024-03-08 19:47 九九乘法表 发布于:2024-03-08 19:34 打印九九乘法表 发布于:2024-03-08 19:39 打印九九乘法表 发布于:2024-03-08 19:32 工资计算函数 发布于:2024-03-08 19:43 九九乘法表 发布于:2024-03-08 19:51 9*9乘法表scala 发布于:2024-03-08 19:43 demo4数组操作 发布于:2024-03-08 19:13 编程计算并输出下列级数的前n 项之和Sn,直到Sn 刚好大于或等于q为止,其中q 为大于0 的整数,其值通过键盘输入。例如, 若q 的值为50.0 , 则输出应为: Sn=50.416695 。请将源文件保存为exercise2-1.scala,在REPL 模式下测试运行,测试样例:q=1 时,Sn=2;q=30 时,Sn=30.891459;q=50 时,Sn=50.416695。 发布于:2024-03-04 22:55 成绩分析代码 发布于:2024-02-17 19:45 记录成绩代码 发布于:2024-02-17 17:15 # ## Scala学习 发布于:2024-02-17 16:12 Scala 水仙花 发布于:2023-12-25 19:51 我的第一个scala程序 发布于:2023-09-27 10:58 class ScalaTest1 { object ScalaClass { var a=10 val b=20 val c=a+b println(c) } } 发布于:2023-06-15 20:49 啊是公司的 发布于:2023-06-09 08:43 Scala - Determine whether a given integer number is prime in Scala 发布于:2023-04-23 18:49 输入一个整型数字,输出是否为奇数 发布于:2023-04-23 17:39 类对象(31-40) 发布于:2022-11-06 19:39 无论是继承abstract class或者混入trait,对于一个要实现的类来说,必须先用extends,剩下的用with,否则编译的时候就会出错。 发布于:2022-10-16 19:15 3.scala_3(循环) 发布于:2022-05-17 10:38 2.scala_2(条件判断) 发布于:2022-05-17 10:32 按市场是从 发布于:2022-03-22 14:24 person类 发布于:2022-03-04 21:46 第一个测试程序 发布于:2021-09-12 08:51 //The is first Demo My code 发布于:2021-09-10 11:22 scala 获取当前日期,日期的加减等 发布于:2020-12-29 14:38 [更多]
显示目录

集合



学习嵌入式的绝佳套件,esp8266开源小电视成品,比自己去买开发板+屏幕还要便宜,省去了焊接不当搞坏的风险。 蜂鸣版+触控升级仅36元,更强的硬件、价格全网最低。

点击购买 固件广场

集合

基本数据结构

Scala 提供了一些不错的集合。

列表 List

scala> val numbers = List(1, 2, 3, 4)
numbers: List[Int] = List(1, 2, 3, 4)

集 Set

集没有重复

scala> Set(1, 1, 2)
res0: scala.collection.immutable.Set[Int] = Set(1, 2)

元组 Tuple

元组是在不使用类的前提下,将元素组合起来形成简单的逻辑集合。

scala> val hostPort = ("localhost", 80)
hostPort: (String, Int) = (localhost, 80)

与样本类不同,元组不能通过名称获取字段,而是使用位置下标来读取对象;而且这个下标基于 1,而不是基于 0。

scala> hostPort._1
res0: String = localhost

scala> hostPort._2
res1: Int = 80

元组可以很好得与模式匹配相结合。

hostPort match {
  case ("localhost", port) => ...
  case (host, port) => ...
}

在创建两个元素的元组时,可以使用特殊语法:

->
scala> 1 -> 2
res0: (Int, Int) = (1,2)

参考 Effective Scala 对 [解构绑定](http://twitter.github.com/effectivescala/#Functional programming-Destructuring bindings) (“拆解”一个元组)的观点。

映射 Map

它可以持有基本数据类型。

Map(1 -> 2)
Map("foo" -> "bar")

这看起来像是特殊的语法,不过不要忘了上文讨论的->可以用来创建二元组。

Map()方法也使用了从第一节课学到的变参列表:Map(1 -> "one", 2 -> "two")将变为 Map((1, "one"), (2, "two")),其中第一个参数是映射的键,第二个参数是映射的值。

映射的值可以是映射甚或是函数。

Map(1 -> Map("foo" -> "bar"))
Map("timesTwo" -> { timesTwo(_) })

选项 Option

Option 是一个表示有可能包含值的容器。

Option基本的接口是这样的:

trait Option[T] {
  def isDefined: Boolean
  def get: T
  def getOrElse(t: T): T
}

Option 本身是泛型的,并且有两个子类: Some[T] 或 None

我们看一个使用 Option 的例子:

Map.get 使用 Option 作为其返回值,表示这个方法也许不会返回你请求的值。

scala> val numbers = Map("one" -> 1, "two" -> 2)
numbers: scala.collection.immutable.Map[java.lang.String,Int] = Map(one -> 1, two -> 2)

scala> numbers.get("two")
res0: Option[Int] = Some(2)

scala> numbers.get("three")
res1: Option[Int] = None

现在我们的数据似乎陷在 Option 中了,我们怎样获取这个数据呢?

直觉上想到的可能是在 isDefined 方法上使用条件判断来处理。

// We want to multiply the number by two, otherwise return 0.
val result = if (res1.isDefined) {
  res1.get * 2
} else {
  0
}

我们建议使用 getOrElse 或模式匹配处理这个结果。

getOrElse 让你轻松地定义一个默认值。

val result = res1.getOrElse(0) * 2

模式匹配能自然地配合 Option 使用。

val result = res1 match {
  case Some(n) => n * 2
  case None => 0
}

参考 Effective Scala 对使用 [Options](http://twitter.github.com/effectivescala/#Functional programming-Options) 的意见。

函数组合子

List(1, 2, 3) map squared 对列表中的每一个元素都应用了squared 平方函数,并返回一个新的列表 List(1, 4, 9)。我们称这个操作 map 组合子。

map

map 对列表中的每个元素应用一个函数,返回应用后的元素所组成的列表。

scala> numbers.map((i: Int) => i * 2)
res0: List[Int] = List(2, 4, 6, 8)

或传入一个部分应用函数

scala> def timesTwo(i: Int): Int = i * 2
timesTwo: (i: Int)Int

scala> numbers.map(timesTwo _)
res0: List[Int] = List(2, 4, 6, 8)

foreach

foreach 很像 map,但没有返回值。foreach 仅用于有副作用

[side-effects]

的函数。

scala> numbers.foreach((i: Int) => i * 2)

什么也没有返回。

你可以尝试存储返回值,但它会是 Unit 类型(即void)

scala> val doubled = numbers.foreach((i: Int) => i * 2)
doubled: Unit = ()

filter

filter 移除任何对传入函数计算结果为 false 的元素。返回一个布尔值的函数通常被称为谓词函数[或判定函数]。

scala> numbers.filter((i: Int) => i % 2 == 0)
res0: List[Int] = List(2, 4)
scala> def isEven(i: Int): Boolean = i % 2 == 0
isEven: (i: Int)Boolean

scala> numbers.filter(isEven _)
res2: List[Int] = List(2, 4)

zip

zip 将两个列表的内容聚合到一个对偶列表中。

scala> List(1, 2, 3).zip(List("a", "b", "c"))
res0: List[(Int, String)] = List((1,a), (2,b), (3,c))

partition

partition 将使用给定的谓词函数分割列表。

scala> val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
scala> numbers.partition(_ % 2 == 0)
res0: (List[Int], List[Int]) = (List(2, 4, 6, 8, 10),List(1, 3, 5, 7, 9))

find

find 返回集合中第一个匹配谓词函数的元素。

scala> numbers.find((i: Int) => i > 5)
res0: Option[Int] = Some(6)

drop & dropWhile

drop 将删除前 i 个元素

scala> numbers.drop(5)
res0: List[Int] = List(6, 7, 8, 9, 10)

dropWhile 将删除元素直到找到第一个匹配谓词函数的元素。例如,如果我们在 numbers 列表上使用 dropWhile 奇数的函数, 1 将被丢弃(但 3 不会被丢弃,因为他被 2 “保护”了)。

scala> numbers.dropWhile(_ % 2 != 0)
res0: List[Int] = List(2, 3, 4, 5, 6, 7, 8, 9, 10)

foldLeft

scala> numbers.foldLeft(0)((m: Int, n: Int) => m + n)
res0: Int = 55

0 为初始值(记住 numbers 是 List[Int] 类型),m 作为一个累加器。

直接观察运行过程:

scala> numbers.foldLeft(0) 
{ (m: Int, n: Int) => println("m: " + m + " n: " + n); m + n }
m: 0 n: 1
m: 1 n: 2
m: 3 n: 3
m: 6 n: 4
m: 10 n: 5
m: 15 n: 6
m: 21 n: 7
m: 28 n: 8
m: 36 n: 9
m: 45 n: 10
res0: Int = 55

foldRight

和 foldLeft 一样,只是运行过程相反。

scala> numbers.foldRight(0)
{ (m: Int, n: Int) => println("m: " + m + " n: " + n); m + n }
m: 10 n: 0
m: 9 n: 10
m: 8 n: 19
m: 7 n: 27
m: 6 n: 34
m: 5 n: 40
m: 4 n: 45
m: 3 n: 49
m: 2 n: 52
m: 1 n: 54
res0: Int = 55

flatten

flatten 将嵌套结构扁平化为一个层次的集合。

scala> List(List(1, 2), List(3, 4)).flatten
res0: List[Int] = List(1, 2, 3, 4)

flatMap

flatMap 是一种常用的组合子,结合映射 [mapping] 和扁平化 [flattening]。flatMap 需要一个处理嵌套列表的函数,然后将结果串连起来。

scala> val nestedNumbers = List(List(1, 2), List(3, 4))
nestedNumbers: List[List[Int]] = List(List(1, 2), List(3, 4))

scala> nestedNumbers.flatMap(x => x.map(_ * 2))
res0: List[Int] = List(2, 4, 6, 8)

可以把它看做是“先映射后扁平化”的快捷操作:

scala> nestedNumbers.map((x: List[Int]) => x.map(_ * 2)).flatten
res1: List[Int] = List(2, 4, 6, 8)

这个例子先调用 map,然后可以马上调用 flatten,这就是“组合子”的特征,也是这些函数的本质。

参考 Effective Scala 对 [flatMap](http://twitter.github.com/effectivescala/#Functional programming-flatMap) 的意见。

扩展函数组合子

现在我们已经学过集合上的一些函数。

我们将尝试写自己的函数组合子。

有趣的是,上面所展示的每一个函数组合子都可以用 fold 方法实现。让我们看一些例子。

def ourMap(numbers: List[Int], fn: Int => Int): List[Int] = {
  numbers.foldRight(List[Int]()) { (x: Int, xs: List[Int]) =>
    fn(x) :: xs
  }
}

scala> ourMap(numbers, timesTwo(_))
res0: List[Int] = List(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)

为什么是ListInt?Scala 没有聪明到理解你的目的是将结果积聚在一个空的 Int 类型的列表中。

Map?

所有展示的函数组合子都可以在 Map 上使用。Map 可以被看作是一个二元组的列表,所以你写的函数要处理一个键和值的二元组。

scala> val extensions = Map("steve" -> 100, "bob" -> 101, "joe" -> 201)
extensions: scala.collection.immutable.Map[String,Int] =
Map((steve,100), (bob,101), (joe,201))

现在筛选出电话分机号码低于 200 的条目。

scala> extensions.filter((namePhone: (String, Int)) => namePhone._2 < 200)
res0: scala.collection.immutable.Map[String,Int] = Map((steve,100),(bob,101))

因为参数是元组,所以你必须使用位置获取器来读取它们的键和值。

幸运的是,我们其实可以使用模式匹配更优雅地提取键和值。

scala> extensions.filter({case (name, extension) => extension < 200})
res0: scala.collection.immutable.Map[String,Int] = Map((steve,100), (bob,101))
由JSRUN为你提供的Scala在线运行、在线编译工具
        JSRUN提供的Scala 在线运行,Scala 在线运行工具,基于linux操作系统环境提供线上编译和线上运行,具有运行快速,运行结果与常用开发、生产环境保持一致的特点。
yout