我是Scala新手,学习了一个关于提取器(appy/unapply)的教程,并遇到了这个简单的例子。当变量“num”似乎不在任何地方定义时,有人能向我解释为什么它会编译和运行吗?它似乎只在"match“语句中有效。
object Demo {
def main(args: Array[String]) {
val x = Demo(5)
println(x)
x match {
case Demo(num) => println(x+" is bigger two times than "+num)
例如,这段代码编译并输出false,因为Scala编译器隐式地将Int转换为Doubles,而不是创建List[AnyVal],这对我来说很奇怪,因为这可能导致数据丢失(例如,浮点类型不精确;它可以对其他可能具有危险的隐式转换的类型执行类似的操作)。为什么Scala的设计者选择这样做?(我使用的是2.9版)
object Main {
def main(args: Array[String]) {
val x = List(3, 2)
val y = List(3, 2.0)
println(x.head / 2 == y.head /
我的scala解释器/编译器有一个非常奇怪的行为。
Welcome to Scala version 2.10.3 (Java HotSpot(TM) 64-Bit Server VM, Java 1.7.0_45).
Type in expressions to have them evaluated.
Type :help for more information.
scala> class Foo {
| def bar = {
| println("Foo is bar!")
| }
| }
defined
对于没有任何参数列表的案例类(不是case对象),我注意到了非常奇怪的行为。看起来超级类型在尝试模式匹配时完全被忽略了。我写了一个很小的例子来展示这种行为:
object TestMatch {
trait CommonType
case class A(val x:Int) extends CommonType
case class B extends CommonType
case object C extends CommonType
def main(args: Array[String]): Unit = {
printifmatched(A(1))
在Scala中,当您查询对象的类或类名时,您将在打印输出的尾部得到一个流氓美元符号("$"):
object DollarExample {
def main(args : Array[String]) : Unit = {
printClass()
}
def printClass() {
println(s"The class is ${getClass}")
println(s"The class name is ${getClass.getName}")
}
}
其结果是:
The class i
我在Scala中有以下代码:
trait Component {
def state : String
def name: String
}
case class AComponent( id : String) extends Component {
def state = name + ":" + id
def name = "A"
}
trait ComponentDecoratorA extends Component {
abstract override def name = "ByADecorated:&
我从2010年开始用Scala编程(现在已经是2017年底了),今天发现java.util.Arrays.toString方法并没有对String过载感到震惊。
Java
public class Main {
public static void main(String[] args) {
System.out.println(java.util.Arrays.toString(args));
}
}
Scala
object Main {
def main(args: Array[String]): Unit = {
println(java.util.Arra
我对Scala很陌生,在Scala中,我发现尽管println不是变量或方法,但它可以直接在类中编写,这怎么可能呢?
即使println是一种方法,我们为什么不按照方法的一般要求在类中定义它呢?为什么尽管它是一种方法,但在Java类中是不允许的,但是在Scala中是允许的呢?
例如。
class Hero {
println("running fine...") // Why is this println allowed in scala when its not inside a function?
}
object MainObject{
def
最近我一直在使用复合类型,最近我尝试了以下代码:
import scala.reflect._
object Main {
def main(args: Array[String]) {
val a1 = classTag[Int with String with Double].newArray(3)
println(a1.mkString(" "))
val a2 = classTag[String with Int with Double].newArray(3)
println(a2.mkString(" "))
我从下面的代码中得到了不一致的答案,我觉得这很奇怪。
import scala.math.pow
val p = 2
val a = Array(1,2,3)
println(a.par
.aggregate("0")((x, y) => s"$y pow $p; ", (x, y) => x + y))
for (i <- 1 to 100) {
println(a.par
.aggregate(0.0)((x, y) => pow(y, p), (x, y) => x + y) == 14)
}
a.
我正在学习Scala和spark,我想从字符串中提取数字。为此,我使用正则表达式。并开始了解在Scala中使用规则模式的奇怪签名。 下面是我的代码: val myString: String = "there would be some number here 34."
val pattern = """.* ([\d]+).*""".r
val pattern(numberString) = myString
val num = numberString.toInt
println(answer) 代码运行良好,但似乎有点
我发现,在Scala中通过正则表达式上的模式匹配提取的组与使用findAllIn函数提取的组不同。
1)这里有一个使用模式匹配的抽取示例-
scala> val fullRegex = """(.+?)=(.+?)""".r
fullRegex: scala.util.matching.Regex = (.+?)=(.+?)
scala> val x = """a='b'"""
x: String = a='b'
scala> x match {
为什么我必须以这样的方式声明返回类型:
def main(args: Array[String]): Unit = {
val n = (x: Int) => (1 to x) product: Int
println(n(5))
}
如果删除该类型,则必须在打印之前分配它:
def main(args: Array[String]): Unit = {
val n = (x: Int) => (1 to x) product
val a = n(5)
println(n(5))
}
这个变体给出了一个错误-为什么?
val n = (x: Int) =>