相见恨晚的 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 中的集合有三大类：
- 列表 List
- 集 Set
- 映射 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
