相见恨晚的 scala - 01 [ 基础 ]

简洁到不行，多一个分号都是不应该。

学习笔记：

centOS 下安装 scala 和安装 jdk 一毛一样 .

1 . 不同于 Java 的变量声明 :( 但是和 js 很像 )

/**
  * Created by msym on 2017/7/3.
  */
object VarTest {
  def main(args: Array[String]) {
    //使用val定义的变量值是不可变的, 相当于java里用final修饰的变量
    val i = 1
    //使用var定义的变量是可变的，但是在Scala中鼓励使用val, 如果一定需要可变化的变量才会使用 var
    var s = "hello"
    //Scala编译器会自动推断变量的类型, 必要的时候可以指定类型
    //变量名在前，类型在后
    val str: String = "msym"
  }
}

---

2 . 不同于 Java 的数据类型 : ( 无基本数据类型, 只有引用型数据类型 )

数据类型	解释	备注
Byte	8位有符号补码整数, -128~127	这些都是引用类型, 没有基本类型
Short	16位有符号补码整数, -215~215-1
Int	32位有符号补码整数, -231~231-1
Long	64位有符号补码整数, -263~263-1
Float	32位单精度浮点数
Double	64位单精度浮点数
Char	字符, 和 Java一样都是 Unicode编码
Boolean	true 或 false
String	字符串
Null	null 或者空引用
Unit	与 Java中 void相同, 表示没有返回值. 这个类只有一个实例, 就是一对圆括号 ()
Nothing	最底层的类, 是任何类的子类
Any	超类, 等同于 Java中 Object类
AnyRef	所有引用类的基类

什么时候用到了超类呢 ? 如下 :

因为不能确定 res 的类型, 只有在运行的时候才会确定其类型,

所以 res的类型是超类 Any类型, 最终 res的类型还是 String类型.

---

3 . 不同于 java 的 for 循环：

/**
  * Created by msym on 2017/7/3.
  */
object Test {
  def main(args: Array[String]) {
    //普通for循环
    var a = 0
    for (a <- 1 to 10){
      print(a + ", ")
    }
    println()
    //不包含10
    for(a <- 1 until 10){
      print(a + ", ")
    }
    println()
    //不包含9，步长为2
    for(a<- 1 until(9, 2)){
      print(a + ", ")
    }
    println()
    //取笛卡尔积的for
    var b = 0
    var c = 0
    for(a <- 1 to 10;b <- 1 to 9){
      c = c + 1
      println("a: " + a)
      println("b: " + b)
    }
    //c输出为90，也就是循环了90次
    println("c:" + c)

    //遍历集合
    var mlist = List(10,2,13)
    for (a <- mlist){
      print(a + ", ")
    }
    println()
    //多条件过滤
    for(a<-mlist if a!=2;if a>10){
      print(a + ", ")
    }
    println()
    //使用yield关键字存储for循环的每次的结果
    var d = 0;
    val numList = List(1,2,3,4,5,6,7,8,9,10);

    // for 循环，注意这里使用的是大括号
    var retVal = for{ d <- numList
                      if d != 3; if d < 8
    }yield d

    // 输出返回值
    var e = 0
    for( e <- retVal){
      println( "Value of d: " + e );
    }

  }
}

4 . 不同于 Java的方法 (scala里面方法和函数不一样, 定义方法的关键字和python一样)

    // def是定义方法的关键字, 形参写在类型前面, 使用冒号分割,
    // 返回值写在圆括号后面, 这里的返回值是Unit, 也就是void,
    // 别忘了等号, 大括号是函数体, 如果只有一行, 可以省略大括号
    def show(arr : Array[Int]): Unit ={
      for (i <- arr)
        print(i + ", ")
    }
    //调用方法
    show(Array(1, 2, 3, 4))

需要留意方法的签名和函数的签名 .

5 . scala中的函数 ( 暂时不是特别理解函数式编程, 只觉得用着很爽 )

  //定义一个函数fun1
  //使用val或者var定义函数
  //圆括号内是函数签名, =>后面是函数体
  //返回值和方法一样，写在签名后面，如果没有返回值，可以不写，或者写：Unit
  val fun1 = (x:Int, y:Int) => x + y

方法到函数的转换: 看图

下划线和 add1之间的空格不能丢, 虽然这里调用方法和函数的形式是一样的, 不是说函数和方法一样, 借一句名言, " 在函数式编程中, 函数是 '头等公民', 他可以像任何其他数据类型一样被传递和操作 "

值得关注的是函数的签名, 每个函数的签名最后都有一个<function数字> 的样式, 这个的数字代表的是函数需要的函数个数, 这里其实是函数体, 只是使用 <function数字>代替了 .

另外一种函数的定义:

这种才是常用的函数的定义方式,  其中 f1代表函数名, :(Int, Double)代表的是传入的参数列表, =>后的 Double代表的是返回值类型 [ 可以是任何类型, 包括元组 ] , = 后面的是函数体 .

---

6 . 不同于 Java的数组

scala 中数组可以存储不同数据类型的元素 , 当存储不同数据类型时, 数组中的类型直接提升为 Any类型.

其实就是Java中数组元素为 Object类型。

scala 中数组分为两种 : 定长数组和变长数组 [ 同样, List 集合也是, 分为定长和变长 ]

import scala.collection.mutable.ArrayBuffer

object ArrayTest {

  def main(args: Array[String]) {

    //初始化一个长度为8的定长数组，其所有元素均默认为0
    val arr1 = new Array[Int](8)
    //直接打印定长数组，内容为数组的hashcode值
    println(arr1)

    //将数组转换成数组缓冲，就可以看到原数组中的内容了
    //toBuffer会将数组转换数组缓冲
    println(arr1.toBuffer)

    //注意：如果new，相当于调用了数组的apply方法，直接为数组赋值
    //初始化一个长度为1的定长数组, 只有一个元素, 也就是10
    val arr2 = Array[Int](10)
    println(arr2.toBuffer)

    //定义一个长度为3的定长数组
    val arr3 = Array("hadoop", "storm", "spark")
    //使用()来访问元素
    println(arr3(2))

    //变长数组（数组缓冲）
    //如果想使用数组缓冲，需要导入import scala.collection.mutable.ArrayBuffer包
    val ab = ArrayBuffer[Int]()
    //向数组缓冲的尾部追加一个元素
    //+=尾部追加元素
    ab += 1
    //追加多个元素
    ab += (2, 3, 4, 5)
    //追加一个数组++=
    ab ++= Array(6, 7)
    //追加一个数组缓冲
    ab ++= ArrayBuffer(8,9)
    //打印数组缓冲ab

    //在数组某个位置插入元素用insert, 在0的位置插入 -1和0两个元素
    ab.insert(0, -1, 0)
    //删除数组某个位置的元素用remove, 从第八位开始, 移除两个元素
    ab.remove(8, 2)
    println(ab)

  }
}

7 . scala 中的元组

第一次听到元组这个东西还是在 mysql中，代表着一行记录，在 scala中也可以这样理解，一行记录，可以存储各种不同的数据类型值。

创建元组：使用圆括号

object Test {
   def main(args: Array[String]) {
      val t = ("Scala", "hello", 12)
      println("msym: " + t._3 )
   }
}

获取元组中的值使用的的是 “._”，比如上面获取的是元组的第三个元素。

创建元组可以直接用圆括号，也可以这样用

val t = Tuple3("Scala", "hello", 12)

这里的 Tuple 代表元组，数字 3 代表元组中元素的个数，最大的只能为 22，再大就可以选用集合了。

圆括号内只有两个元素的元组叫做对偶元组, 对偶元组在下面的 Map集合中用到比较多, 可以说, Map 中存储的就是对偶元组 .

对偶元组手动创建, 也可以通过数组的拉链操作生成, 下面是数组的拉链操作生成 :

上面先创建了两个数组, 然后通过 zip拉链操作, 合成了一个新数组, 新数组中的元素时以元组的形式存在的 .

注 :

当进行拉链操作时, 合成数组的长度是以短的那个数组长度为准, 较长的那个数组的多余的元素不会被添加到新数组中 .

8. scala中的集合

scala 中的集合有三大类：

1. 列表 List
2. 集 Set
3. 映射 Map

和 Java中一样, List底层是数组形式, 存取顺序一致, 可重复; Set集合不能存储重复元素, 存取顺序不一致, 底层使用的是 Hash算法, Map是双链集合, key不能重复, 存取顺序也不能保证一致 .

上面三种集合都扩展自 Iterable 特性，在 scala中集合有可变（mutable）和不可变（immutable）两种类型，immutable类型的集合初始化后就不能改变了，（但是和val 又不同，val是引用不能改, 内容可以改; immutable是内容都不能改, 引用是可以改变的）

1 . 列表 List:

不可变列表

object ImmutListTest {

  def main(args: Array[String]) {
    //创建一个不可变的集合
    val lst1 = List(1,2,3)
    //将0插入到lst1的前面生成一个新的List
    val lst2 = 0 :: lst1
    val lst3 = lst1.::(0)
    val lst4 = 0 +: lst1
    val lst5 = lst1.+:(0)

    //将一个元素添加到lst1的后面产生一个新的集合
    val lst6 = lst1 :+ 3

    val lst0 = List(4,5,6)
    //将2个list合并成一个新的List
    val lst7 = lst1 ++ lst0
    //将lst0插入到lst1前面生成一个新的集合
    val lst8 = lst1 ++: lst0

    //将lst0插入到lst1前面生成一个新的集合
    val lst9 = lst1.:::(lst0)

    println(lst9)
  }
}

可变列表:

import scala.collection.mutable.ListBuffer

object MutListTest extends App{
  //构建一个可变列表，初始有3个元素1,2,3
  val lst0 = ListBuffer[Int](1,2,3)
  //创建一个空的可变列表
  val lst1 = new ListBuffer[Int]
  //向lst1中追加元素，注意：没有生成新的集合
  lst1 += 4
  lst1.append(5)

  //将lst1中的元素最近到lst0中， 注意：没有生成新的集合
  lst0 ++= lst1

  //将lst0和lst1合并成一个新的ListBuffer 注意：生成了一个集合
  val lst2= lst0 ++ lst1

  //将元素追加到lst0的后面生成一个新的集合
  val lst3 = lst0 :+ 5
}

2 . Set

      不可变的Set

import scala.collection.immutable.HashSet

object ImmutSetTest extends App{
  val set1 = new HashSet[Int]()
  //将元素和set1合并生成一个新的set，原有set不变
  val set2 = set1 + 4
  //set中元素不能重复
  val set3 = set1 ++ Set(5, 6, 7)
  val set0 = Set(1,3,4) ++ set1
  println(set0.getClass)
}

    可变的 Set

import scala.collection.mutable

object MutSetTest extends App{
  //创建一个可变的HashSet
  val set1 = new mutable.HashSet[Int]()
  //向HashSet中添加元素
  set1 += 2
  //add等价于+=
  set1.add(4)
  set1 ++= Set(1,3,5)
  println(set1)
  //删除一个元素
  set1 -= 5
  set1.remove(2)
  println(set1)
}

3 . Map

import scala.collection.mutable

object MutMapTest extends App{
  val map1 = new mutable.HashMap[String, Int]()
  //向map中添加数据
  map1("spark") = 1
  map1 += (("hadoop", 2))
  map1.put("storm", 3)
  println(map1)

  //从map中移除元素
  map1 -= "spark"
  map1.remove("hadoop")
  println(map1)
}

杂项：

1 . 参数默认值 :

这点和 C#一样了，就是在形参列表上指定默认值，如果调用时不指定参数，那么就使用默认值，其实这点会和 java中的重载会有一点冲突，java之所以不支持参数默认值，是因为有重载，如果两者都存在会导致二义性。

object Test {
   def main(args: Array[String]) {
       //不指定参数，返回12
        println( "Res1: " + add() );
       //指定一个参数，返回8
        println( "Res2: " + add(1) );
       //指定两个参数，返回3
        println( "Res3: " + add(1, 2) );
   }
   def add( a:Int=5, b:Int=7 ) : Int = {
      var sum:Int = 0
      sum = a + b
      return sum
   }
}

1