Scala是一种运行在Java虚拟机(JVM)上的编程语言，它以不可变性为特点，使得编写并发和并行代码变得容易。Scala语言的可扩展性强，适合分布式系统。Scala代码优雅且简洁，因为它是函数式编程语言，使用表达式而非详细语句，允许定义匿名和嵌套函数。
编程语言主要分为两大类：命令式和声明式。命令式语言使用一系列语句来完成任务，因此代码行数通常比函数式语言多。
函数式编程是声明式编程的一个子集，面向对象编程是命令式语言的一个子集。为什么函数式编程处于技术前沿？这是因为它在多处理器环境下具有高效可靠的行为，换句话说，在并行编程中表现最佳。
根据操作系统下载合适的JDK：
设置Java环境变量：
// Windows
SystemProperties -> Environment Variables
Set var JAVA_HOME = C:\{Java Path}\java\jdk{version}
Set system var as Path = C:\{Java Path}\java\jdk{version}\bin
// Linux: Terminal
export JAVA_HOME=/usr/local/java{version}
export PATH=$PATH:$JAVA_HOME/bin/
// 执行
java --version
下载合适的Scala版本：
与其他编程语言相比，安装Scala有些不同。Scala的安装方式较为特殊，因为它通常...
选择IntelliJ或SBT或其他方式安装Scala，例如下载Windows的Scala二进制文件。也可以使用命令行或终端运行：
java -jar scala{version}-installer.jar
测试安装是否成功，运行：
scala --version
在IDE中创建新项目，然后创建新文件。编写代码时需要注意以下几点：
C:\>cd C:\Users\Mahsa\ScalaIntro\src
C:\Users\Mahsa\ScalaIntro\src> scalac ScalaQuickStart.scala
C:\Users\Mahsa\ScalaIntro\src> scala ScalaQuickStart
类 - 对象 - 文件I/O - 异常处理：
// Java
import java.io.*;
import scala.io.Source;
import java.io.FileNotFoundException;
import java.io.IOException;
import Array.*;
object ScalaQuickStart {
def main(args: Array[String]) {
var inc = (x:Int) => x+1
println(inc(2))
val rff = new ReadFromFile()
rff.read()
val wr = new WriteToFile()
wr.write()
var myMatrix = ofDim[Int](2, 2)
val bufferedSource = Source.fromFile("C:\\file\\grades.csv")
for (line <- bufferedSource.getLines) {
println(line)
val nums = line.split(",")
println(nums.head, nums.last)
bufferedSource.close()
}
}
}
class ReadFromFile() {
def read() {
try {
Source.fromFile("C:\\file\\grades.csv").foreach {
print
}
} catch {
case ex: FileNotFoundException => {
println("Missing file exception")
}
case ex: IOException => {
println("IO Exception")
}
} finally {
println("finally runs anyway...")
}
}
}
class WriteToFile() {
def write() {
try {
val writer = new PrintWriter(new File("C:\\file\\grades.txt"))
writer.write("Hello Scala")
writer.close()
} catch {
case ex: FileNotFoundException => {
println("Missing file exception")
}
case ex: IOException => {
println("IO Exception")
}
}
}
}
class ProcessArray() {
def read() {
try {
Source.fromFile("C:\\file\\grades.csv").foreach {
print
}
} catch {
case ex: FileNotFoundException => {
println("Missing file exception")
}
case ex: IOException => {
println("IO Exception")
}
} finally {
println("finally runs anyway...")
}
}
}
函数式编程之所以处于技术前沿，是因为它在多处理器环境下具有高效可靠的行为，换句话说，在并行编程中表现最佳。
在函数式语言中，循环和迭代通过递归和尾调用优化(TCO)来完成。TCO是一种调用函数的方法，不需要单独的栈帧，从而避免栈溢出。例如，下面的代码：
// Java
def factorial(n):
if n == 0:
return 1
return n * factorial(n-1)
// 这是TCO
def factorial(n):
return fact(n, 1)
def fact(n, number):
if n == 0:
return number
return fact(n-1, number*n)
什么是竞态条件？在多线程概念中，当两个或多个线程同时尝试获取共享资源或对象时。
什么是死锁？在多线程概念中，进程1持有锁定资源2并等待资源1，而此时进程2持有并锁定资源1并等待资源2。
什么是线程安全？在多线程概念中，线程安全确保每个线程可以同时执行，而不会出现意外的交互。
什么是不可变对象？不可变对象的状态或值在创建后不能更改。
// Java
a = 1
b = 2
a = a + b
在创建时，a应该被定义为只读和不可变的，以防止更改其值。