webdancer's Blog

Scala--基本类型和操作

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

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

1	`val` `s='type`

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

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

Scala学习-类，对象

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

属性：默认是public的，使用private可以改变作用域；
方法：定义类的方法与定义普通的相同；Scala没有静态方法。
?
1
2
3
4
5
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进行函数重载：
?
1
2
3
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-数组，列表，元组和文件读写

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

1.数组：

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

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

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

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

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

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

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

1	`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)

Scala学习-语言基础

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

scala xx.scala

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

1 2	`var` `a` `=` `"Hello World"` `val` `b` `=` `3.14`

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

1 2	`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
}

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

1	`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。例如如果输出脚本的参数，

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

也可以使用for,

1 2	`for(arg <- args)` `println(arg)`

scala学习——环境配置

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

1.下个Scala编译器。

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

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