Scala根底篇

数据类型

下表中列出的数据类型都是方针，能够直接对它们调用办法。

表明Long类型，在数字后边增加L或许l作为后缀；浮点数后边有f或许F后缀时，表明Float类型，不然便是Double

变量

用关键词“var”声明变量，关键词"val"声明常量。

var myName : String = "gyt"
val myAge : Int = 21 

scala中纷歧定要指明数据类型，其数据类型通过变量或常量的初始值揣度出来的，因而，在没有指明数据类型的情况下，有必要要给出初始值。

拜访润饰符

用private关键词润饰，只能被当时类以及当时类的内部类拜访到，外层类拜访不到。

class Outer{
    class Inner{
        private def f(){
            println("f")
        }
        class InnerMost{
            f() // 正确
        }
    }
    (new Inner).f() //过错
}

用protected关键词润饰，只能被当时类的子类拜访。

package p {
    class Super {
        protected def f() {println("f")}
    }
    class Sub extends Super {
        f()
    }
    class Other {
        (new Super).f() //过错
    }
}

没有指定任何润饰符，默许为public，在任何地方都能够被拜访。

条件和循环

以下是IF...ELSE句子实例。

object Test {
   def main(args: Array[String]) {
      var x = 30;

      if( x == 10 ){
         println("X 的值为 10");
      }else if( x == 20 ){
         println("X 的值为 20");
      }else if( x == 30 ){
         println("X 的值为 30");
      }else{
         println("无法判别 X 的值");
      }
   }
}

以下是一个运用了 i to j 语法(包括 j)的实例，箭头 <- 用于为变量 a 赋值。

object Test {
   def main(args: Array[String]) {
      var a = 0;
      // for 循环
      for( a <- 1 to 10){
         println( "Value of a: " + a );
      }
   }
}

在 for 循环 中你能够运用分号;来设置多个区间，它将迭代给定区间一切的或许值。

object Test {
   def main(args: Array[String]) {
      var a = 0;
      var b = 0;
      // for 循环
      for( a <- 1 to 3; b <- 1 to 3){
         println( "Value of a: " + a );
         println( "Value of b: " + b );
      }
   }
}

for 循环调集的语法如下。

object Test {
   def main(args: Array[String]) {
      var a = 0;
      val numList = List(1,2,3,4,5,6);

      // for 循环
      for( a <- numList ){
         println( "Value of a: " + a );
      }
   }
}

你能够将 for 循环的回来值作为一个变量存储。

object Test {
   def main(args: Array[String]) {
      var a = 0;
      val numList = List(1,2,3,4,5,6,7,8,9,10);

      // for 循环
      var retVal = for{ a <- numList 
                        if a != 3; if a < 8
                      }yield a

      // 输出回来值
      for( a <- retVal){
         println( "Value of a: " + a );
      }
   }
}

函数式编程（要点）

函数式编程：关于相同的输入永久会得到相同的输出,而且没有任何能够调查的副作用,也不依赖外部的环境状况。参阅什么是函数式编程？。

Scala中函数是为完结某一功用的程序句子的调集，类中界说的函数称之为办法。下面是办法的一个实例。

object add{
   def addInt( a:Int, b:Int ) : Int = {
      var sum:Int = 0
      sum = a + b

      return sum
   }
}

可变参数：咱们不需要指定函数参数的个数，能够向函数传入可变长度参数列表。通过在参数的类型之后放一个星号来设置可变参数(可重复的参数)。

object Test {
   def main(args: Array[String]) {
        printStrings("Runoob", "Scala", "Python");
   }
   def printStrings( args:String* ) = {
      var i : Int = 0;
      for( arg <- args ){
         println("Arg value[" + i + "] = " + arg );
         i = i + 1;
      }
   }
}

默许参数： scala能够为函数参数指定默许参数值，运用了默许参数，你在调用函数的进程中能够不需要传递参数，这时函数就会调用它的默许参数值，假如传递了参数，则传递值会替代默许值。

object Test {
   def main(args: Array[String]) {
        println( "回来值 : " + addInt() );
   }
   def addInt( a:Int=5, b:Int=7 ) : Int = {
      var sum:Int = 0
      sum = a + b

      return sum
   }
}

匿名函数：箭头左面是参数列表，右边是函数体。

var inc = (x: Int) => {x+1}
var x = inc(7) - 1

//界说一个函数，以函数作为参数输入
def f(func: String => Unit): Unit = {
    func("gyt")
}
var fun = (name: String) => {println(name)}
f(fun)

传名调用：传递的不是详细的值，而是代码块。和一般的传值调用比较，每次运用传名调用时，解说器都会核算一次表达式的值。

def f1(): Int = {
    println("f1被调用")
    12
}
def f2(a: => Int): Unit = {
    println(a)
    println(a)
}
f2(f1())

至简准则：

（1）函数中的return能够省掉，以最终一行代码作为代码块的回来值。

def f1(name: String): String = {
    name
}

（2）假如函数体只要一行代码，能够省掉花括号。

def f2(name: String): String = name

（3）假如编译器能够揣度出来回来值，那么能够省掉（：和回来值类型一同省掉）。有意思的是，到这一步，scala函数的办法形如数学中的f(x) = y。

def f3(name: String) = name

（4）假如有return，则（3）不适用。

（5）假如回来值是Unit，能够省掉等号和回来值，可是此刻花括号不能省掉。

def f4(name: String) {
    println(name)
}

（6）假如函数没有参数，那么调用它的时分能够直接用函数名。不必加“()”。

闭包：假如一个函数，拜访到它的外部（部分）变量的值，那么这个函数和它所在的环境，称为闭包。

柯里化：将本来承受两个参数的函数变成新的承受一个参数的函数的进程。新的函数回来一个以原有第二个参数为参数的函数。

object Test {
   def main(args: Array[String]) {
      val str1:String = "Hello, "
      val str2:String = "Scala!"
      println( "str1 + str2 = " +  strcat(str1)(str2) )
   }

   def strcat(s1: String)(s2: String) = {
      s1 + s2
   }
}

字符串

在 Scala 中，字符串的类型实际上是 Java String，它自身没有 String 类。

数组

Scala 言语中供给的数组是用来存储固定巨细的同类型元素。下面是声明数组的三种办法。

var z:Array[String] = new Array[String](3)
var zz = new Array[String](3)
var zzz = Array("Runoob", "Baidu", "Google")

形式匹配

一个形式匹配包括了一系列备选项，每个都开端于关键字 case。每个备选项都包括了一个形式及一到多个表达式。箭头符号 => 隔开了形式和表达式。

object Test {
   def main(args: Array[String]) {
      println(matchTest("two"))
      println(matchTest("test"))
      println(matchTest(1))
      println(matchTest(6))

   }
   def matchTest(x: Any): Any = x match {
      case 1 => "one"
      case "two" => 2
      case y: Int => "scala.Int"
      case _ => "many"
   }
}

实例中榜首个 case 对应整型数值 1，第二个 case 对应字符串值 two，第三个 case 对应类型形式，用于判别传入的值是否为整型，比较运用isInstanceOf来判别类型，运用形式匹配更好。第四个 case 表明默许的全匹配备选项，即没有找到其他匹配时的匹配项，相似 switch 中的 default。

object Test {
   def main(args: Array[String]) {
        val alice = new Person("Alice", 25)
        val bob = new Person("Bob", 32)
        val charlie = new Person("Charlie", 32)
   
    for (person <- List(alice, bob, charlie)) {
        person match {
            case Person("Alice", 25) => println("Hi Alice!")
            case Person("Bob", 32) => println("Hi Bob!")
            case Person(name, age) =>
               println("Age: " + age + " year, name: " + name + "?")
         }
      }
   }
   // 样例类
   case class Person(name: String, age: Int)
}

运用了case关键字的类界说便是样例类(case classes)，样例类是种特别的类，通过优化以用于形式匹配。

迭代器

Scala Iterator（迭代器）不是一个调集，它是一种用于拜访调集的办法。迭代器 it 的两个根本操作是 next 和 hasNext。调用 it.next() 会回来迭代器的下一个元素，而且更新迭代器的状况。调用 it.hasNext() 用于检测调集中是否还有元素。让迭代器 it 逐一回来一切元素最简略的办法是运用 while 循环：

object Test {
   def main(args: Array[String]) {
      val it = Iterator("Baidu", "Google", "Runoob", "Taobao")
      
      while (it.hasNext){
         println(it.next())
      }
   }
}

下表列出了Scala Iterator常用的办法：