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 提供了一套很好的集合实现,提供了一些集合类型的抽象。这让你的代码可以与 Foo 的集合交互,而无需担心该集合是是一个 List,还是 Set,或是任何你有的类型。

这里提供了一个很好的页面来查看各种集合的默认实现,并链接到他们的 scala 在线文档。

基础知识

表 List

标准的链表。

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

你可以用函数式语言的方式连接它们。

scala> 1 :: 2 :: 3 :: Nil
res1: List[Int] = List(1, 2, 3)

集 Set

集没有重复

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

序列 Seq

序列有一个给定的顺序。

scala> Seq(1, 1, 2)
res3: Seq[Int] = List(1, 1, 2)

(请注意返回的是一个列表。因为 Seq 是一个特质;而列表是序列的很好实现。如你所见,Seq 也是一个工厂单例对象,可以用来创建列表。)

映射 Map

映射是键值容器。

scala> Map('a' -> 1, 'b' -> 2)
res4: scala.collection.immutable.Map[Char,Int] = Map((a,1), (b,2))

层次结构

下面介绍的都是特质,它们在可变的(mutable)和不可变的(immutable)的包中都有特定实现。

Traversable

所有集合都可以被遍历。这个特质定义了标准函数组合子。 这些组合子根据 foreach 来写,所有集合必须实现。

Iterable

iterator() 方法返回一个 Iterator 来迭代元素。

Seq 序列

有顺序的对象序列。

Set 集

没有重复的对象集合。

Map

键值对。

方法

Traversable

下面所有方法在子类中都是可用的。参数和返回值的类型可能会因为子类的覆盖而看起来不同。

def head : A
def tail : Traversable[A]

这里是函数组合子定义的地方。

def map [B] (f: (A) => B) : CC[B]

返回每个元素都被 f 转化的集合

def foreach[U](f: Elem => U): Unit

在集合中的每个元素上执行 f 。

def find (p: (A) => Boolean) : Option[A]

返回匹配谓词函数的第一个元素

def filter (p: (A) => Boolean) : Traversable[A]

返回所有匹配谓词函数的元素集合

划分:

def partition (p: (A) ⇒ Boolean) : (Traversable[A], Traversable[A])

按照谓词函数把一个集合分割成两部分

def groupBy [K] (f: (A) => K) : Map[K, Traversable[A]]

转换:

有趣的是,你可以转换集合类型。

def toArray : Array[A]
def toArray [B >: A] (implicit arg0: ClassManifest[B]) : Array[B]
def toBuffer [B >: A] : Buffer[B]
def toIndexedSeq [B >: A] : IndexedSeq[B]
def toIterable : Iterable[A]
def toIterator : Iterator[A]
def toList : List[A]
def toMap [T, U] (implicit ev: <:<[A, (T, U)]) : Map[T, U]
def toSeq : Seq[A]
def toSet [B >: A] : Set[B]
def toStream : Stream[A]
def toString () : String
def toTraversable : Traversable[A]

把映射转换为一个数组,您会得到一个键值对的数组。

scala> Map(1 -> 2).toArray
res41: Array[(Int, Int)] = Array((1,2))

Iterable

添加一个迭代器的访问。

 def iterator: Iterator[A]

一个迭代器能给你提供什么?

def hasNext(): Boolean
def next(): A

这是非常 Java 式的。你通常不会看到在 Scala 中使用迭代器,通常更容易出现的是函数组合器或 for 循环的使用。

Set

 def contains(key: A): Boolean
  def +(elem: A): Set[A]
  def -(elem: A): Set[A]

Map

通过键查找的键值对的序列。

可以像这样将一个键值对列表传入 apply()

scala> Map("a" -> 1, "b" -> 2)
res0: scala.collection.immutable.Map[java.lang.String,Int] = Map((a,1), (b,2))

或者像这样:

scala> Map(("a", 2), ("b", 2))
res0: scala.collection.immutable.Map[java.lang.String,Int] = Map((a,2), (b,2))

题外话

什么是->?这不是特殊的语法,这是一个返回元组的方法。

scala> "a" -> 2

res0: (java.lang.String, Int) = (a,2)

请记住,这仅仅是下面代码的语法糖

scala> "a".->(2)

res1: (java.lang.String, Int) = (a,2)

您也可以使用++操作符构建

scala> Map.empty ++ List(("a", 1), ("b", 2), ("c", 3))
res0: scala.collection.immutable.Map[java.lang.String,Int] = Map((a,1), (b,2), (c,3))

常用的子类

HashSet 和 HashMap 的快速查找,这些集合的最常用的形式。 TreeMap 是 SortedMap 的一个子类,它可以让你进行有序访问。 [TreeMap API]()

Vector 快速随机选择和快速更新。

scala> IndexedSeq(1, 2, 3)
res0: IndexedSeq[Int] = Vector(1, 2, 3)

Range 等间隔的 Int 有序序列。你经常会在 for 循环看到。

scala> for (i <- 1 to 3) { println(i) }
1
2
3

Ranges 支持标准的函数组合子。

scala> (1 to 3).map { i => i }
res0: scala.collection.immutable.IndexedSeq[Int] = Vector(1, 2, 3)

默认实现

使用特质的 apply 方法会给你默认实现的实例,例如,Iterable(1, 2)会返回一个列表作为其默认实现。

scala> Iterable(1, 2)

res0: Iterable[Int] = List(1, 2)

序列 Seq 也是一样的,正如我们前面所看到的

scala> Seq(1, 2)
res3: Seq[Int] = List(1, 2)

scala> Iterable(1, 2)
res1: Iterable[Int] = List(1, 2)

scala> Sequence(1, 2)
warning: there were deprecation warnings; re-run with -deprecation for details
res2: Seq[Int] = List(1, 2)

Set

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

一些描述性的特质

IndexedSeq 快速随机访问元素和一个快速的长度操作。 LinearSeq 通过 head 快速访问第一个元素,也有一个快速的 tail 操作。

可变 vs 不可变

不可变

优点:

  • 在多线程中不会改变

缺点:

  • 一点也不能改变

Scala 允许我们是务实的,它鼓励不变性,但不惩罚我们需要的可变性。这和 var vs. val 非常相似。我们总是先从 val 开始并在必要时回退为 var。

我们赞成使用不可改变的版本的集合,但如果性能使然,也可以切换到可变的。使用不可变集合意味着你在多线程不会意外地改变事物。

可变集合

前面讨论的所有类都是不可变的。让我们来讨论常用的可变集合。

HashMap 定义了 getOrElseUpdate, +=HashMap API

scala> val numbers = collection.mutable.Map(1 -> 2)
numbers: scala.collection.mutable.Map[Int,Int] = Map((1,2))

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

scala> numbers.getOrElseUpdate(2, 3)
res54: Int = 3

scala> numbers
res55: scala.collection.mutable.Map[Int,Int] = Map((2,3), (1,2))

scala> numbers += (4 -> 1)
res56: numbers.type = Map((2,3), (4,1), (1,2))

与 Java 生活

您可以通过 JavaConverters package 轻松地在 Java 和 Scala 的集合类型之间转换。它用 asScala 装饰常用的 Java 集合以和用 asJava 方法装饰 Scala 集合。

 import scala.collection.JavaConverters._
   val sl = new scala.collection.mutable.ListBuffer[Int]
   val jl : java.util.List[Int] = sl.asJava
   val sl2 : scala.collection.mutable.Buffer[Int] = jl.asScala
   assert(sl eq sl2)

双向转换:

scala.collection.Iterable <=> java.lang.Iterable
scala.collection.Iterable <=> java.util.Collection
scala.collection.Iterator <=> java.util.{ Iterator, Enumeration }
scala.collection.mutable.Buffer <=> java.util.List
scala.collection.mutable.Set <=> java.util.Set
scala.collection.mutable.Map <=> java.util.{ Map, Dictionary }
scala.collection.mutable.ConcurrentMap <=> java.util.concurrent.ConcurrentMap

此外,也提供了以下单向转换

scala.collection.Seq => java.util.List
scala.collection.mutable.Seq => java.util.List
scala.collection.Set => java.util.Set
scala.collection.Map => java.util.Map
由JSRUN为你提供的Scala在线运行、在线编译工具
        JSRUN提供的Scala 在线运行,Scala 在线运行工具,基于linux操作系统环境提供线上编译和线上运行,具有运行快速,运行结果与常用开发、生产环境保持一致的特点。
yout