scala学习

Scala是什么
Scala是基于JVM的编程语言。Java是运行在jvm上的编程语言，java源代码通过jvm被编译成class文件，然后在os上运行class文件。Scala是运行在jvm上的编程语言，scala源代码通过jvm被编译成class文件，然后在os上运行class文件。

 

声明值和变量
var a = 12        //定义变量

val b = 23        //定义常量，在spark编程中一般都是定义为常量

注：在scala中，对于变量必须要初始化，不允许只声明而不初始化。

 

在scala的变量声明时，可以不指定类型，由解释器自己判断。
“superman ”*3    //表示字符串“ superman”反复输出3次
“superman ”*3    //实际上是字符串“ superman”调用方法*，传入的参数是3

函数在声明后，无论是否有“=”，都有返回值。当没有“=”的时候，表示返回值是Unit类型，Unit类型的值是()。当有“=”的时候，返回值是函数体中的最后一行的值。如果返回值类型强制指定为Unit类型，那么返回值必定是()。

 

if判断

 

def testif(a:Int) :Int = {
    if(a>1){
        1    
    }else if(a<1){
        0
    }else{
        -1
    }            
}

 

 循环

循环(while、for)
基本循环结构，使用生成式“变量 <- 范围”表示

for(i <- 1 to 10){
    printlin(i) // 1 2 3 4 5 6 7 8 9 10
}

 

如果需要倒叙输出，后面加reverse

for(i <- 1 to 10 reverse){
    println(i) // 10 9 8 7 6 5 4 3 2 1
}

 

如果修改步长，可以使用守卫方法，即在生成式后面加一个boolean判断，符合条件的输出

for(i <- 1 to 10 reverse;if i%3==0){
    println(i) // 9 6 3
}

 

 修改步长更简单的方式如下，to后面使用括号，括号中第二个参数表示步长

for(i <- 1 to (10,3)){
    println(i)     // 1 4 7 10
}

 

 支持类似于java的双重for循环，在scala中只需要一个for即可

for(i <- 1 to 10; j <- 1 to 10){
    println(i+"---"+j)
}

 

使用for推导式，可以把结果保存起来

//for推导式，产生新的集合
var a = for(i <- 1 to 10 reverse; if i%3==0)yield(i+1)
println(a)    //Vector(10, 7, 4)

 

常用数据结构
数组
    数组的两种声明方式，建议声明数组时指定类型。

 1、定长数组：长度不变的数组Array，如：声明一个长度为10的整形数组，val arr = Array[Int](10)；声明并初始化一个字符串数组： val arrStr = Array(“wo”,”cha”,”yo”)。访问数组方式:访问arrStr第一个元素，arrStr(1)即可

2、变长数组（即数组缓冲）：java中有ArrayList和scala中的ArrayBuffer等效；但是ArrayBuffer更加强大，通过下面的事列来熟悉ArrayBuffer：

    import collection.mutable.ArrayBuffer
    val arrbuff1 = ArrayBuffer[Int]()
    val arrBuff2 = ArrayBuffer(1,3,4,-1,-4)
    arrbuff1 += 23    //用+=在尾端添加元素
    arrbuff1 += (2,3,4,32) //同时在尾端添加多个元素
    arrbuff1 ++= arrBuff2 //可以用 ++=操作符追加任何集合
    arrbuff1 ++= Array(2,43,88,66)
    arrbuff1.trimEnd(2) //移除最后的2个元素
    arrbuff1.remove(2)  //移除arr(2+1)个元素
    arrbuff1.remove(2,4) //从第三个元素开始移除4个元素
    val arr = arrbuff1.toArray //将数组缓冲转换为Array
    val arrbuff2 = arr.toBuffer //将Array转换为数组缓冲

  3、遍历数组和数组缓冲：在java中数组和数组列表/向量上语法有些不同。scala则更加统一，通常情况，我们可以用相同的代码处理这两种数据结构，for(…) yield 循环创建一个类型和原集合类型相同的新集合。for循环中还可以带守卫：在for中用if来实现。

 

  　 for(i <- 0 until arrbuff1.length) yield arrbuff1(i) * 2 //将得到ArrayBuffer(2,6,4,-2,-4)
    for(i <- 0 until (arrbuff1.length,2)) yield arrbuff1(i) * 2 //将得到ArrayBuffer(12,-4)
    for(elem <-0 arrbuff1) print(elem) //如果不需要使用下标，用这种方式最简单了
    for(i <- arrbuff1 if arrbuff1 > 0) print i //打印出arrbuff1中为整数的值
    arrbuff1.filter( _ > 0).map{ 2 * _} //生成arrbuff1中的正数的两倍的新集合
    arrbuff1.filter {_ > 0} map {2 * _} //另一种写法
    

 

  4、常用算法：scala有很多便捷内建函数，如

    arrbuff1.sum //对arrbuff1元素求和
    Array("asd","sdf","ss").max //求最大元素
    arrbuff1.sorted(_ < _)  //将arrbuff1元素从小到大排序
    arrbuff1.sorted(_ > _)  //从大到小排序
    util.Sorting.quickSort(Array) //针对数组排序，单不能对数组缓冲排序
    val arr = Array(1,23,4,2,45)
    arr.mkString(",") //指定分割符
    arr.mkString("(",",",")") //指定前缀、分隔符、后缀

 

Scala Map(映射)

Map(映射)是一种可迭代的键值对（key/value）结构。

所有的值都可以通过键来获取。

Map 中的键都是唯一的。

Map 也叫哈希表（Hash tables）。

Map 有两种类型，可变与不可变，区别在于可变对象可以修改它，而不可变对象不可以。

默认情况下 Scala 使用不可变 Map。如果你需要使用可变集合，你需要显式的引入 import scala.collection.mutable.Map 类

在 Scala 中 你可以同时使用可变与不可变 Map，不可变的直接使用 Map，可变的使用 mutable.Map。以下实例演示了不可变 Map 的应用：

// Map 键值对演示
val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")

 

不可变：

 a.声明映射

b.映射中的键值对称作对偶，用( , )表示

c.当映射中不存在key时，取值会报错，解决方案是使用 contains方法，或者getOrElse方法

可变：

默认使用的映射中的value是不可修改的，位于scala.collection.immutable包中。如果要修改，必须使用位于scala.collection.mutable包中的Map类型

如果要迭代每一个对偶，还是使用for循环

 

学习地址：http://www.runoob.com/scala/scala-maps.html