大数据系列第一课：scala基础

最新推荐文章于 2024-08-08 08:07:25 发布

lhui798

最新推荐文章于 2024-08-08 08:07:25 发布

阅读量556

点赞数

分类专栏：大数据

本文链接：https://blog.csdn.net/lhui798/article/details/50451775

版权

大数据专栏收录该内容

9 篇文章 0 订阅

订阅专栏

内容：

1 Scala的重大价值

2 Scala基础语法入门实战

3 Scala函数入门实战

4 Scala中Array、Map、Tuple实战

5 综合案例及Spark源码解析

一、scala价值

Scala可伸缩的语言的英语翻译是：Scalable Language。它是一门多范式的编程语言，一种类似java的编程语言，集成面向对象编程和函数式编程的各种特性并完美结合，熟练掌握scala对于学习spark来说至关重要。

二、Scala函数定义：

（scala函数定义时候默认会导入包）

有参数的函数定义

def 函数名（参数列表，...)：返回结果类型={...}

①　有时函数必须制定返回结果类型，如函数时递归，就必须明确制定返回结果类型；

②　如果函数仅一个语句，连花括号都可以不写。如是max函数就成了这样,作用功能仍然没有变化；

③　Scala语言在进行函数调用时可不加（）；

④　Scala语言在编写的时候亦可以不用加“；”

⑤　Scala中，i++或者++i都不能其作用，只能使用i=i+1

⑥　foreach与函数字面量

函数字面量格式：参数列表 => 函数体

(x: Int, y:Int) => x + y

三、字段定义

（1）val:类似java中final类型的变量（常量）

1，基本格式：val 变量名：变量类型 = 值

2，其中有时变量类型可以省略，可以自动识别

3，常量不能赋值，修改

（2）var:等同于java中的非final型变量

四、scala中的Array、Map、Tuple以及代码实战

(1)

//函数返回 Any(任何类型)
  def main(args: Array[String]): Unit = {
    val n =7
    def fun :Any = {
     for(i <- 1 to 10){
       if(i == n) return i
       print(i + " ")
     }
    }
    //调用
    fun
  }

(2)

//a、变长参数；b、最后一行作为返回值；c、遍历输入变长参数方法
  def main(args: Array[String]): Unit = {
    defsum(numbers : Int*) = {
     var result = 0
     for(elem <- numbers) result += elem
     result //最后一行作为返回值
    }
    //函数调用
   println(sum(1,2,3,4,5,6,7,8,9,10))
   println(sum(1 to 100 : _*))//遍历输入变长参数方法
  }

(3)

//a、lazy关键字的使用；b、异常判断；c、远程调用和数据库最后要进行关闭
  import scala.io.Source._
  import scala.io._
  import java.io.FileNotFoundException
  def main(args: Array[String]): Unit = {
    try{
      lazy val context = fromFile("d:/3.txt").mkString //lazy关键字的使用
    }catch{
      case _: FileNotFoundException => println("file not found")//异常判断
    }finally{
      println("Byebye world!!")//远程调用和数据库最后要进行关闭
    }
  }

(4)

//a、对象的地址不能改变，内容可以改变；b、默认调用apply方法
  def main(args: Array[String]): Unit = {
    val arr =new Array[Int](5)
    arr(3) = 8//对象的地址不能改变，内容可以改变
    println(arr(3))
   
    val arr2 =Array(1,3,5,7,9)
    val arr3 =Array.apply(1,3,5,7,9)//arr2默认调用apply方法
  }

(5)

//排序
  def main(args: Array[String]): Unit = {
    val arr =Array(1,13,9,23,5,27,7)
   scala.util.Sorting.quickSort(arr)//排序
   println(arr.mkString)//mkString默认实现
   println(arr.mkString(" "))
  }

(6)

//过滤数据并生成新的数组
  def main(args: Array[String]): Unit = {
    val arr =Array(1,13,9,23,5,27,7)
   
    val arr2 =for(i <- arr if i % 3 == 0) yield i * i
    val arr3 =arr.filter(_ % 3 == 0).map(i => i * i) //spark中使用这个
   
   println(arr2.mkString(" "))
   println(arr3.mkString(" "))
  }

(7)

//数组操作
  def main(args: Array[String]): Unit = {
    val arr =Array(1,4,9,2,5,8,7)
   
    for(elem<- arr) print(elem + " ")//原样输出
   println()
   
    for(i <-1 until(arr.length, 1)) print(arr(i) + "")//从下标为1的元素开始，步长为1进行输出
   println()
   
    for(i <-1 until(arr.length, 2)) print(arr(i) + "")//从下标为2的元素开始，步长为2进行输出
   println()
   
    for(i <-0 until(arr.length, 2)) print(arr(i) + "")//从下标为0的元素开始，步长为2进行输出
   println()
   
    for(i <-(0 until arr.length).reverse) print(arr(i) + " ")//反向输出
  }

(8)

//Map操作
  def main(args: Array[String]): Unit = {
   //构造Map
    //不可变：
    //val map0 =Map("sa" -> 1, "s" -> 2) map0("sa") = 3 // error
    valemptyMap0 = new scala.collection.immutable.HashMap[String,Int]
    //可变：
    val map1 =scala.collection.mutable.Map("sa" -> 2);map1("sa") = 3
    valemptyMap1 = new scala.collection.mutable.HashMap[String, Int]
   
    val persons= Map("Spark" -> 6, "Hadoop" -> 11)
   println(persons("Hadoop"))
    val map =scala.collection.mutable.Map("Spark" -> 6, "Hadoop" ->11)
    map +=("Flink" -> 5)
    map -="Hadoop"
   println(map)
   
    valsparkValue = if(map.contains("Spark")) map("Spark") else 1000
   println(sparkValue)
   
    valsparkValue2 = map.getOrElse("Spark", 1000)
   println(sparkValue2)
   
    valsparkValue3 = map.getOrElse("Hadoop", 1000)
   println(sparkValue3)
   
   for((key,value) <- map) println(key + " : " + value)
   
    for(key<- map.keySet) println(key)
  }

(9)

//元组Tuple操作
  def main(args: Array[String]): Unit = {
   //不同类型值的集合
    val tp = (1,"ss", 2.0)
   
    //拉链操作
    val arrkey =Array(1, 3, 5)
    val arrValue= Array("a", "b", "c")
    val tupleArr= arrkey.zip(arrValue) // tupleArr为Array((1,a), (3,b), (5,c))
    val map =tupleArr.toMap
  }

（10）map

Map就是键值对的集合。在Scala中，Map是对偶（键值对的另一个说法）的集合。->操作符用来创建对偶，即key和values。

  def main(args: Array[String]): Unit = {
    /* 
     * Map:映射，把值和集合中的元素联系起来，使用任意类型的键 
     */  
    val map1 = Map{"hadoop"->1 }  
    map1 + ("spark"->2)  
    map1("spark")=3          //更改已有的值   
    map1.contains("scala")     //检查是否包含  
    map1.keySet                //返回key集合  
    //添加多个对偶，使用“+=”操作符：  
    map1+=("Flink"->3,"Hbase"->5)  
    //移除某个对偶，使用“-=”操作符：   
    map1-="hadoop"  
    import scala.collection.mutable._  
    val map2 = mutable.Map.empty[String,Int]//创建空map  
  }

（11）List

List列表（不可变）

1，类型都是相同的

2，不可变的，（Array虽然长度固定，但是元素之使可变的）

3，(：：：)实现叠加List,(::)cons:将新元素组合到列表的最前端

  def main(args: Array[String]): Unit = {
    /* 
     * List:支持头部的快速删除和添加,不可变，列表的所有元素都具有相同类型，类似于数组Array 
     */  
     val color =  List("yellow","blue")  
     val list2 = (1,2,3)  
     var list3 = 4  
     def list4:Int = 5  
     /* 
    	* listBuffer：可以更加高效的通过添加元素的方式构建列表 
    	* 元素的添加使用+=操作符 
    	* 元素的前缀使用+:操作符      
    	*/  
     import scala.collection.mutable.ListBuffer  
     val li= new ListBuffer[Int]  
     li+= 1  
     li +=2  
     3+:li  
     li.toList  
     println(li(2))
  }

（12）Array数组

  def main(args: Array[String]): Unit = {
    /* 
     * Array:使用基于0的索引高效访问任意位置的元素 
     */  
     val array1 = Array[Int](1,2,3,4,54,5,5)  
     val array3 =  new Array[Int](3) //创建长度已知，内容未知  
     println(array3(2))  
     array1.clone()  
     array1.length  
     var array = array1   
     /* 
      * ArrayBuffer：类似于数组，可以在序列的结束和开始的地方添加元素 
     	* 创建ArrayBuffer的时候必须指定它的类型参数，可以不指定数组的长度 
     	* ArrayBuffer也使用+=添加元素 
     	*/  
       import scala.collection.mutable.ArrayBuffer  
       val ar= new ArrayBuffer[String]()    
       ar += "hadoop"  
       ar += "Spark"  
       ar +: "scala"  
       li.length  
        li(2)  
      Ar.remove(2,1)  
  }

（13）Tuple元组（不可变）

在Scala中，元组是n个对象的一个聚集（Map是n=2个对象的聚集），元组可以包含不同类型的元素。

1，元组也是不可变的，但是元组可以是不同类型的数据

2，实例化：var a = （，）

3,可以通过点号，下划线，-N（N从1开始）的索引访问元素

  def main(args: Array[String]): Unit = {
    /* 
     * Tuple:元组，把固定数量的条木组合在一起整体传送，可以包含不同       *的类型 
     */  
    val tuple = (1,"spark",true)  
    tuple._1  
    tuple._2  
    tuple.->(1) 
  }

五、感受

   a、听课之前需要提前做功课，信息量较大；
   b、课后要强化练习，并消化；
   c、本节课老师即兴发挥，讲了很多实用的知识点；
   d、很喜欢老师一行一行写代码；
   e、讲解很深入，实用，实战性极强
   f、喜欢跟着老师看源码

六、作业

//作业之一：移除一个数组中第一个负数后的所有负数
import scala.collection.mutable.ArrayBuffer
object Task {
 
def main(args: Array[String]): Unit = {
   //第一个负数后的所有负数 
    val arr =ArrayBuffer[Int]()
   arr  += (1,2,3,4,-9,9,-4,8,-6)

    var n =0
   //返回的结果是一个vector集合 
    val result =for (i <- 0 until arr.length if n == 0 || arr(i) >= 0) yield{ 
     if (arr(i) < 0) n = 1; arr(i)
    }
    //输出结果
   print(result)
  }
}