5.1.0Scala基础

Scala基础教程

最新推荐文章于 2024-01-18 09:27:52 发布

原创最新推荐文章于 2024-01-18 09:27:52 发布 · 306 阅读

1 ·

CC 4.0 BY-SA版权

Scala 专栏收录该内容

3 篇文章

订阅专栏

本文介绍了Scala的基础知识，包括IDEA集成Scala插件、变量声明、常用类型、条件与块表达式、循环、数组操作、集合使用、类与对象、继承及模式匹配等内容。

Scala基础

一、 IntelliJ IDEA集成Scala插件

在plugin中搜索Scala插件

二、下载Scala

三、新建Scala项目（使用SBT）(暂时还没使用到。。。)

注意Scala的版本和spark的版本：

spark1.6.0 对应 scala2.10

spark2.0.0 对应 scala2.11

四、新建Scala项目（普通项目类似eclipse的java项目）

五、声明变量

object VariableDemo {
  def main(args:Array[String]) {
    //使用val定义的变量值是不可变的，相当于java里用final修饰的变量
    val i = 1
    //使用var的变量是可变得，在Scala中鼓励使用val
    var s = "hello"
    print(i)
    print(s)
  }
  }

六、常用类型

Scala和Java一样，有7种数值类型Byte、Char、Short、Int、Long、Float和Double（无包装类型）和一个Boolean类型

七、条件表达式

  object ConditionDemo {
  def main(args: Array[String]) {
    val x = 1
    //判断x的值，将结果赋值给y
    val y = if (x > 0) 1 else -1
    println(y)    //1
    //混合类型表达式
    val z = if (x > 1) 1 else " error "
    println(z)    //error
    //如果缺失else 相当于if(x > 2) 1 else ()
    val m = if (x > 2) 1
    println(m)    //()
    //在scala中每个表达式都有值，scala中有个Unit类，写做(),相当于Java中的void
    val n = if (x > 2) 1 else ()
    println(n)    //()
    //if 和 else if
    val k = if (x < 0) 0
    else if (x >= 1) 1
    else -1
    println(k)    //1
  }
}

八、块表达式

  object BlockExpressionDemo {
  def main(args: Array[String]) {
    val x = 0
    //在scala中{}包含一系列表达式，块中最后一个表达式的值就是块的值
    val result = {
      if (x < 0 ){
        -1
      }else if(x >= 1){
        1
      }else{
        "error"
      }
    }
    //result的值就是块表达式的结果
    println(result) //error
  }
}

九、循环

在scala中有for循环和while循环，用for循环比较多

 for循环语法结构：for (i <- 表达式/数组/集合)

object ForDemo {
  def main(args: Array[String]) {
    //for(i <- 表达式),表达式1 to 10返回一个Range（区间）
    //每次循环将区间中的一个值赋给i
    for (i <- 1 to 10){
      println(i)    //1,2,3,4,5,6,7,8,9,10
    }

    //for(i <- 数组)
    val arr = Array("a","b","c")
    for (i <- arr){
      println(i)  //a,b,c
    }

    //高级for循环
    //每个生成器都可以带一个条件，注意：if前面没有分号
    for (i <- 1 to 3 ; j <- 1 to 3 if i != j)
      print((10 * i + j) + " ")         //12 13 21 23 31 32 
    println()

    //for推导式：如果for循环的循环体以yield开始，则该循环会构建出一个集合
    //每次迭代生成集合中的一个值
    val v = for (i <- 1 to 10 )yield i * 10
    println(v)          //Vector(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)
  }
}

十、定义方法和函数

十一、定义数组

1.      定长数组

2.      变长数组

3.      数组代码：

object ArrayDemo {
  def main(args: Array[String]) {
    //初始化一个长度为8的定长数组，所有元素为0
    val arr1 = new Array[Int](8)
    //直接打印定长数组，内容为数组的hashcode值
    println(arr1)             //[I@3c5a99da

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

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

    //定义一个长度为3的定长数组
    val arr3 = Array("hadoop","storm","spark")
    println(arr3(2))          //spark

    println("-----------------------------")

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

    //在数组的某个位置插入元素 insert
    ab.insert(0,-1,0)         //在0索引的地方插入了-1 和 0
    println(ab)             //ArrayBuffer(-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

    //删除数组某个位置的元素 remove
    ab.remove(8,2)            //从8索引开始删除2个元素
    println(ab)             //ArrayBuffer(-1, 0, 1, 2, 3, 4, 5, 6, 9)
  }
}

4. 遍历数组

1）增强for循环

2） until会生成角标，0 until 10 包含0包含10

2）遍历数组代码：

object ForArrayDemo {
  def main(args: Array[String]) {
    val arr = Array(1,2,3,4,5,6,7,8)
    //增强for
    for(i <- arr)
      println(i)              //1,2,3,4,5,6,7,8
    println("----------------")
    //好用的until会生成一个Range
    //reverse是将前面生成的Range反转
    for(i <- (0 until arr.length).reverse)
      println(arr(i))       //8,7,6,5,4,3,2,1
  }
}

5. 数组转换

yield关键字将原始的数组进行转换会产生一个新的数组，原始的数组不变

object ArrayYieldDemo {
  def main(args: Array[String]) {
    val arr = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)
    //将偶数取出 *10 再生成一个新的数组
    val res = for (e <- arr if e % 2 == 0) yield e * 10
    println(res.toBuffer)         //ArrayBuffer(20, 40, 60, 80)
    println("-------------")
    //更高级的写法,用着更爽
    //filter是过滤，接收一个返回值为boolean的函数
    //map相当于将数组中的每一个元素取出来，应用传进去的函数
    val r = arr.filter(_ % 2 == 0).map(_ * 10)
    println(r.toBuffer)          //ArrayBuffer(20, 40, 60, 80)
  }
}

6. 数组中常用的算法

object ArrayMath {
  def main(args: Array[String]) {
    val arr = Array(2,5,1,4,3)
    //求和
    println(arr.sum)  //15
    //求最大、最小值
    println(arr.max)  //5
    println(arr.min)  //1
    //排序
    println(arr.sorted.toBuffer)//ArrayBuffer(1, 2, 3, 4, 5)
  }
}

十二、映射

Scala中，把哈希表这种数据结构叫做映射

1. 创建映射map

1）第一种构建Map方式用箭头

2）第二种构建Map方式用元祖

2. 获取和修改映射中的值

3. 全部代码：

object MappingDemo {
  def main(args: Array[String]) {
    //第一种构建Map方式 用箭头
  val scores = Map("tom" -> 85,"jerry" -> 99,"kitty" -> 90)
    //遍历打印map
    scores.foreach(println)   //(tom,85) (jerry,99) (kitty,90)
    //获取map中的值
    println(scores("jerry"))  //99

    println("----------------------")
    //第二种创建Map方式，用元祖
  val scores2 = Map(("tom",85),("jerry",99),("kitty",90))
    //getOrElse 如果映射中有值，返回映射中的值，如果没有就返回默认值
    println(scores2.getOrElse("tom",0))   //85
    println(scores2.getOrElse("suke",0))  //0
  }
}

4. 两种map

1）一个是immutable包下的Map，该Map中的内容不可改变。