Scala 2.11.4 需要JDK什么版本
Scala官网上说的,Scala 2.11.4需要JDK 1.6以上版本,安装JDK 1.6就够了. (据说Scala 2.12将迎来大变更,只支持JDK 1.8及以上,不过目前还没发正式版)
Scala 二叉树
///用foldLeft就可以了，我重新定义了泛型，应该比较完美了
trait Tree[+T]
/**
* 空树
*/
case object Empty extends Tree[Nothing]
/**
* 节点, 单个节点是一棵树
*/
case class Node[T](val value: T, val left: Tree[T], val right: Tree[T]) extends Tree[T]
////////////////////////
def insert[T](x: T, tree: Tree[T])(implicit order: Ordering[T]): Tree[T] = {
tree match {
case Empty => Node(x, Empty, Empty)
case Node(v, left, right) if order.gt(x, v) => Node(v, left, insert(x, right))
case Node(v, left, right) if order.lt(x, v) => Node(v, insert(x, left), right)
case Node(v, left, right) if order.equiv(x, v) => Node(v, left, right) //其实没有必要重新创建
}
}
def mkBinarySearchTree[T](list: List[T])(implicit order: Ordering[T]) = {
list.foldLeft[Tree[T]](Empty)((tree, value) => insert(value, tree))
}
def main(args: Array[String]) {
mkBinarySearchTree(List(1, 2, 3))
}
如何在Linux 上安装 Scala 2.9.1
在Linux上安装Scala，有下面的2种方法。
1) Default Scala version available on your Linux box by typing below command
sudo apt-get install scala
2) If you want to get the latest version of the scala below are the steps
a) Download latest IzPack Installer for linux as shown below
b) For installing the downloaded package we need to decide the location of installation. I have selected /opt/scala. If you decide to select same location please make sure you have created /opt/scala. You can use below command to create directory.
sudo mkdir /opt/scala
c) Start installation by typing below command
sudo java -jar scala-2.9.1.final-installer.jar
d) You will get some welcome message and you will be asked to enter 1 to continue. You can enter 1 for installation.
e) In next step you will be asked to accept license. You can accept license by entering 1.
f) Next step will be selecting target directory for installation. Enter below path for installation.
/opt/scala
g) Next press 1 to continue
h) You will get below message on the shell.
Console Installation Completed
i) Set Scala installation path as below
PATH=”$PATH:/opt/scala/bin”
Congratulation!!! You have successfully installed Scala on your Linux. To check the scala you can type below command
scala -version
You will get below message
Scala code runner version 2.9.1.final — Copyright 2002-2011, LAMP/EPFL..
如何用idea创建scala程序
1.安装JDK,并设置环境变量
(1)JAVA_HOME = C:\Program Files\Java\jdk1.8.0_11
(2)Path = D:\Program Files\scala\bin;%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin
(3)CLASSPATH = %JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;
2.安装Scala(点击打开链接),并设置环境变量
(1)SCALA_HOME = D:\Program Files\scala
(2)Path = D:\Program Files\scala\bin;
3.安装IDEA(点击打开链接)
(1)安装Scala插件(Configure -> Plugins -> Install JetBrains Plugins : 搜索Scala)
4.使用IDEA创建Scala程序
(1)创建Scala程序
scala tuple1 tuple2 tuple3 有什么不同
没有tuple1 scala> val t2=(＂test＂,1) t2: (String, Int) = (test,1) scala> t2.getClass res0: Class[_ scala> val t3=(＂ok＂,12,100.0) t3: (String, Int, Double) = (ok,12,100.0) scala> t3.getClass res1: Class[_ tuple就是用来把几个数据放在一起的比较方便的方式,上面的例子定义了一个tuple2和一个tuple3,区别就是tuple2放两个数据、tuple3放3个数据.好像最大是tuple21
最新版本的scala for eclipse 是支持的scala版本是2.11.7,但我安装的是scala2.10.4,该eclipse可用吗
这上面http://maven.outofmemory.cn/org.specs2/specs2_2.10/3.3.1/有 specs2所依赖的jar包,上面说的scala2.10.5 就够了…2.11.4应该完全没问题吧
Scala中val和var的区别
Scala有两种变量，val和var。val就不能再赋值了。与之对应的，var可以在它生命周期中被多次赋值。
val的演示：
scala> val msg=”Hello,world!”;
msg: java.lang.String = Hello,world!
scala> msg=”Hello again,world!”;
:5: error: reassignment to val msg=”Hello again,world!”;
^
可以看出如果再次给val的变量赋值就会报错！
var的演示：
scala> var msg2=”Hello,world!”;
msg2: java.lang.String = Hello,world!
scala> msg2=”Hello again,world!”;
msg2: java.lang.String = Hello again,world!
如何让Scala脚本快速运行
#!/bin/sh
exec scala “$0” “$@”
!#
println(“Hello, iteblog!!”)
args foreach println
我们将这段代码保存到test.sh文件里面，然后运行它：
[iteblog@www.iteblog.com iteblog]$ time sh test.sh
Hello, iteblog!!
real 0m1.070s
user 0m0.380s
sys 0m0.031s
我们可以看出，这么简单的程序都花费了1.07s才输出结果。这是因为每次运行的时候都会编译里面的内容，编译完才会运行脚本。值得高兴的是，我们可以将编译的内容保存下来，然后以后运行的速度就会加快。Scala解析器提供了
-savecompiled参数，可以将编译的内容保存。所以修改后的代码如下：
#!/bin/sh
exec scala -savecompiled “$0” “$@”
!#
println(“Hello, iteblog!!”)
args foreach println
运行这个脚本，我们可以发现第一次运行的速度还是很慢，但是当程序运行完，我们可以在同一目录下发现一个名为test.sh.jar的jar文件，这就是编译之后的class文件。第二次运行的时候，Scala会检查该脚本是否修改了，如果没有修改，会直接使用之前编译好的test.sh.jar文件，所以以后运行速度会很快：
[iteblog@www.iteblog.com iteblog]$ time sh test.sh
Hello, iteblog!!
real 0m0.298s
user 0m0.292s
sys 0m0.030s
我们来看看test.sh.jar里面的内容：
[iteblog@www.iteblog.com iteblog]$ jar -tvf test.sh.jar
75 Wed Dec 16 19:17:32 CST 2015 META-INF/MANIFEST.MF
832 Wed Dec 16 19:17:32 CST 2015 Main$$anon$1.class
595 Wed Dec 16 19:17:32 CST 2015 Main.class
1097 Wed Dec 16 19:17:32 CST 2015 Main$$anon$1$$anonfun$1.class
547 Wed Dec 16 19:17:32 CST 2015 Main$.class
我们可以看出这些就是编译后的class文件，我们可以通过scala命令去运行里面的类：
[iteblog@www.iteblog.com iteblog]$ scala -cp test.sh.jar Main
Hello, iteblog!!
scala 元组的个数不知道怎么定义
元组在Scala语言中是一个非常有用的容器对象。与列表一样，元组也是不可变的；但是与列表不同，元组可以包含不同类型的元素。例如列表只能写成List[Int]或者List[String]，但是元组可以同时拥有Int和String。元组适用场景很多，比方说，如果需要在方法里返回多个对象。Java里的做法是创建JavaBean已包含多个返回值，Scala里可以仅返回元组。而且做起来也很简单；只要把元组实例化需要的对象放在括号里，并用逗号分隔即可。元组实例化之后，可以用点号、下划线和基于1的索引访问其中的元素。如：
var scalachina =（2010，”Scala中文 “）
println(scalachina._1)
println(scalachina._2)
运行这段代码的结果：
2010
scala中的部分应用函数和偏函数的区别
部分应用函数和偏函数是无关的。经常把部分应用函数（Partial Applied Function)和偏函数（Partial Function） 搞混。
总结如下：
部分应用函数（Partial Applied Function)是缺少部分参数的函数，是一个逻辑上概念
偏函数是只对函数定义域的一个子集进行定义的函数。 scala中用scala.PartialFunction[-T, +S]类来表示
比如定义了一个函数：def sum(x: Int)(y: Int) = x + y, 当调用sum的时候，如果不提供所有的参数或某些参数还未知时，比如sum _ , sum(3)(_: Int), sum(_: Int)(3), 这样就生成了所谓的部分应用函数。部分应用函数只是逻辑上的一个表达，scala编译器会用Function1， Function2这些类来表示它.
下面这个变量signal引用了一个偏函数
val signal: PartialFunction[Int, Int] = {
case x if x > 1 => 1
case x if x < -1 => -1
}
这个signal所引用的函数除了0值外，对所有整数都定义了相应的操作。 signal(0) 会抛出异常，因此使用前最好先signal.isDefinedAt(0)判断一下。 偏函数主要用于这样一种场景：对某些值现在还无法给出具体的操作（即需求还不明朗），也有可能存在几种处理方式（视乎具体的需求）；我们可以先对需求明确的部分进行定义，比如上述除了0外的所有整数域，然后根据具体情况补充对其他域的定义，比如 :
val composed_signal: PartialFunction[Int,Int] = signal.orElse{
case 0 => 0
}
composed_signal(0) // 返回 0
或者对定义域进行一定的偏移（假如需求做了变更, 1 为无效的点）
val new_signal: Function1[Int, Int] = signal.compose{
case x => x – 1
}
new_signal(1) // throw exception
new_signal(0) // 返回 -1
new_signal(2) // 返回 1
还可以用andThen将两个相关的偏函数串接起来
val another_signal: PartialFunction[Int, Int] = {
case 0 => 0
case x if x > 0 => x – 1
case x if x < 0 => x + 1
}
val then_signal = another_signal andThen signal
这里的then_signal 剔除了-1, 0, 1三个点的定义