1.类型：Scala的基本类型与Java中的Primitive type对应起来，不过都是首字母大写的类，例如Byte,Short,Int,Long,Char,Float,Double,String,Boolean

2.字面值(literal):在代码中直接写常数值的一种方式。这个Scala与Java基本相同。但是Scala提供Symbol字面值。

val s='type

3.操作：对于大部分操作符来说，与Java相同，但是“==”不同。在Scala中，"=="首先判断“==”左边是否是null,如果不是null然后条用equals方法。

4.Scala给基本类型提供了Rich Wrapper，可以有更加丰富的方法。

1.类：类是对象的蓝图，根据类，使用new关键字，就可以创建对象了。和Java一样，Scala的对象也包含：属性和方法。这部分和Java基本上相同。

• 属性：默认是public的，使用private可以改变作用域；
• 方法：定义类的方法与定义普通的相同；Scala没有静态方法。

  class ChecksumAccumulator {
    private var sum = 0
    def add(b: Byte) { sum += b }
    def checksum(): Int = ~ (sum & 0xFF) + 1
  }

在Scala的代码中，一个语句如果单独一行的话，可以不加分号，自动进行分号的推断；

• class可以带参数，class Rational(a:Int,b:Int)
• 使用override进行函数重载：

• class Rational(a:Int,b:Int){
      overrride def toString = a + "/" + b
  }

• preconditions:可以使用require()。

class Rational(a:Int, b:Int){
	require(b != 0)
	val  numer:Int = a
	val  demon:Int = b
	override def toString = a + "/" + b
	def add(that: Rational) = new Rational(
		a * that.demon + b * that.numer,
		b * that.demon
		)
}

2.使用object定义singleton 对象。

import scala.collection.mutable.Map

object ChecksumAccumulator {
  private val cache = Map[String, Int]()
  def calculate(s: String): Int =
    if (cache.contains(s))
      cache(s)
    else {
      val acc = new ChecksumAccumulator
      for (c <- s)
        acc.add(c.toByte)
      val cs = acc.checksum()
        cache += (s -> cs)
        cs
}
}

Singleton与class的名字相同，他们得放在同一源文件中，称为companion class 与companion object。不会创建新的类型；与class的名字不同，称为standalone对象，这种对象可以作为一个Scala程序的启动点。

3.Scala程序的启动类似Java，使用含有main方法的Singleton对象。

运行程序的话，首先使用scalac或是fsc进行编译，然后使用scala运行（不含后缀），终于Java的命令行是类似的。

也可是使用Application traits来启动程序，不过这种方法仅仅用在一些简单的，单线程程序中。

已经对Scala的变量，函数了解以后，看一下比较高级的数据结构以及IO。

1.数组：

val language = new Array[String](2)
language(0)="Java"
language(1)="Scala"

在scala中提供一种更加简洁的方式，

val language = Array("java","Scala")

可以看到，与Java明显不同的是：Scala中数组使用()来索引，而不是使用[]。得到数组里面的每个元素，可以使用：

for(i <- 0 to 2)
    println(language(i))

需要注意的是：0 to 2 相当于0.to(2)，这个和1+3是一样的道理，所有的操作符都是函数调用的方式进行的。这也是Scala中索引使用()，而不使用[]的原因。language(1)相当于language.apply(1)。

2.Scala的数组长度不可变，但是数组还是可以变化的，比如：

langage(0) = "C"

如果想让数组中元素也不可变，可以使用List。

val l1 = List(1,2)
val l2 = List(3,4)
val l3 = l1:::l2
val l4 = 2::l2

List是不可变的，符合函数式编程的性质，它有很多操作。

• 构造：List()
• 连接：l1 ::: l2
• 数数：l1.count(e => e>0)
• Map:l1.map(e => e* 2)
• filter: l1.filter(e => e>1)
• foreach: l1.foreach(println)
• 长度：l1.length
• reverse:l1.reverse()
• 排序：l1.sortWith((a,b) => a<b)
• head,last,init,tail

3.Tuple:与List基本一样，但是可以放不同类型的元素；最多可以放22个；索引从1开始，使用._进行索引，比如:t._1

4.set,Map

5.读写文件：

import scala.io.Source

for(line <- Source.fromFile(filename).readlines())
    println(line)

1.Scala解释器：键入scala命令启动，使用和python的差不多；也可以运行脚本文件：

 scala xx.scala

2.变量定义：两种变量类型：val和var，val类型变量一旦初始化，不能再被赋值，相当于java中的final类型的变量。与java不同的是Scala可以进行类型推导，不用显示的写出变量的类型。

var a = "Hello World"
val b = 3.14

如同想要显示的写出变量类型，可以在变量名称后面加上“：type”：

var a:String = "Hello World"
val b:Int = 3.14

3.函数定义：

 scala的函数定义用"def"作为开始的标识符，

def max(a:Int, b:Int):Int = {
    if (a>b)
        a
    else
        b
}

需要注意：函数的返回值在非递归函数时可以省去，但是作为良好的编程习惯，还是加上；在只有一个语句的情况下，大括号可以省略。

def error = println("Error!")

Scala的函数参数传递方式一般是CBV(call by value)，如果参数类型前面有“=>”则使用CBN（call by name）。

4.控制结构：可以用while进行循环，if进行判断，与java一样的。

5.使用foreach和for来进行迭代：

函数时first citizen，可以充当参数，所以foreach的参数可以是function literal。例如如果输出脚本的参数，

args.foreach((arg:String) => println(arg))

也可以使用for,

for(arg <- args)
    println(arg)

打算学习一下Spark，因为spark使用Scala语言写的，所以先得学习一下相关的知识。由于我以前对java比较了解了，如果你对java不熟悉，所以这篇文档的内容可能不是很适合你。

1.下个Scala编译器。

2.选择开发环境IntelliJ+scala插件：当然可以在命令行里面进行语言的学习，但是最好先学习个IDE，这样看源码的时候也方便。对于如何在IntelliJ中使用scala的插件，可以参考：这个简单的scala插件使用的文档。

【注意】：直接使用“run”可能没法运行，配置一下就可以了。