大数据知识:快学Scala(一)Scala的函数、方法和数据结构

简介

        上一章，我们已经学习了Scala语言的特点，它是运行在JVM上的一种多范式编程式语言，具有开发快，灵活等特点。如果对于基础不好的同学可以看一下我的文章大数据知识:快学Scala(一)Scala基础。这一章我们将会介绍Scala语言的函数和方法、以及在Scala语言中常用的数据结构。

方法和函数

        Scala中的+ - * / %等操作符的作用与Java一样，位操作符& | ^ >> <<也一样。只是有

        一点特别的：这些操作符实际上是方法。例如：

            a + b

        是如下方法调用的简写：

            a.+(b)

        a 方法b可以写成a.方法(b)

方法

        方法的返回值类型可以不写，编译器可以自动推断出来，但是对于递归函数，必须指定返回类型

函数

方法和函数的区别

        在函数式编程语言中，函数是“头等公民”，它可以像任何其他数据类型一样被传递和操作

        案例：首先定义一个方法，再定义一个函数，然后将函数传递到方法里面

package cn.edu.hust.scala

object FuctionDemo {
  //定义方法，方法和函数是不一样的，方法可以不指定返回类型，只有递归函数需要指定
  def calculate(x:Int,y:Int): Int=x+y


  def f1(x:Int,y:Int): Int={
        x*y
  }
  //定义函数
  val f=(x:Int) => { x+10 }
  //在方法里面调用函数
  def f2(f:Int=>Int,x:Int):Int={
    f(x)
  }
  //定义一个函数，返回元祖，用(a,b)接受参数，具体实现如下
  val func:(Int,Double)=>(Double,Int)={
      (a,b)=>(b,a)
  }

  //定义一个没有返回值的方法,主要使用unit
  def func2(x:Int,y:Int):Unit={
    println(x+y)
  }

  def main(args: Array[String]): Unit = {
      val x=10
      val y=20
      println(calculate(x,y))
      //定义函数
      val z=(x:Int,y:Int) => { x+y }

      val t=(x:String,y:String) => {x+y}
      //方法里面调用函数
      println(f2(f,10))
      //函数的使用
      println(z(100,200))

      val arr=Array(1,2,3,4,5)

      val arr1=arr.map(f)
      println(arr1.toBuffer)
      //原始对象没有变化
      println(arr.toBuffer)
      // 调用函数
      println(func(2,3.0))

      //将方法转化为函数,原来的方法不变
      val b=func2 _
      b(10,20)
  }
}

Scala语言中的数据结构

Scala中的数组

package cn.edu.hust.scala

import scala.collection.mutable.ArrayBuffer

object ArrayDemo {
  def main(args: Array[String]): Unit = {
      //声明一个array，需要指定类型和长度，默认值是0
      val arr=new Array[Int](8)
      println(arr.toBuffer)
      //也可以使用如下的操作声明
      val arr2=Array(1,2,3,4,5)

    //取出下标为1的元素
      println(arr2(1))

    //可以使用一下方式,这里定义了一个长度为1的array，初始值为10
    val arr3=Array[Int](10)
    println(arr3.toBuffer)


    //定义一个可变长度的数组
    val a=new ArrayBuffer[Int]()
    a+=1
    a++=Array(9,8,7,6)
    println(a)

    //在特定的下标中插入值
    a.insert(0,-1,-2)
    println(a)

    //移除下标2
    a.remove(2,1)
    println(a)

    //使用下标取值
    println(a(2))

  }
}

Scala中的

package cn.edu.hust.scala

import scala.collection.mutable.ListBuffer

object ListDemo {
  def main(args: Array[String]): Unit = {
    //不可变的数组
    val list1=List(1,2,3,4,5)
    val list2=List(7,8,9)
    // 取值
    println(list1(1))

    //添加新的元数,添加到前段
    val list3=list1.+:(0)
    println(list3)

    //添加到后段
    val list4=list1.:+(3)
    println(list4)

    val list5=list1++list2
    //三个一组
    val lst=list5.grouped(3)
    println(lst.toList)
    //将lst压平
    val t=lst.toList
    println(t.flatten)
    println(list5)

    val list6=list1:::list2
    println(list6)

    println("listbuffer")
    val lb=new ListBuffer[Int]
    //添加元素
    lb+=2
    //批量添加元素
    lb+=(3,4,5)
    //使用方法添加元素
    lb.append(-1,0)
    println(lb)

    val lb2=ListBuffer("a","b","c")
    //添加成为新的list
    val lb3=lb2++lb
    println(lb3)
    //添加list到lb3中
    lb3++=lb2
    println(lb3)

  }
}

Scala中的Map

package cn.edu.hust.scala
import scala.collection.mutable.Map
object MapDemo {
  def main(args: Array[String]): Unit = {
    //创建一个map
     val m1=Map("a"->1,"b"->2,"c"->3)
    println(m1)
    //修改map的值
    m1("a")=10
    println(m1)

    //添加一些kv
    m1+="d"->8
    println(m1)

    //添加一些元组
    m1+=(("e",9),("h",10))
    println(m1)

    //查询元素如果不包含的处理,如果没有就默认设置0
    val z=m1.getOrElse("z",0)

    print(z)
  }
}

Scala中的Set

package cn.edu.hust.scala

import scala.collection.mutable

object SetDemo {
  def main(args: Array[String]): Unit = {
    val s=new mutable.HashSet[Int]
    //添加元素
    s+=1;
    //批量添加元素
    s+=(2,3,4,5,6)
    println(s)

    //改变set
    s++=mutable.HashSet(0,-1)
    println(s)

    //移除元素
    s.remove(3)
    println(s)

    //按照元素
    s.remove(2)
    println(s)
  }

}

Scala中的元组

package cn.edu.hust.scala

object TupleDemo {
  def main(args: Array[String]): Unit = {
    //元组的声明与初始化
     val t=(1,"spark",2.0)
    println(t)

    //元祖的取值,元祖的下标是从1开始的
    println(t._1)
    //对偶元组
    val t1=Array(("1",1),("a",2),("c",4))
    //将元组转化成map
    println(t1.toMap)
    val t2=Array("a","2",10)
    val t3=Array(1,"spark",2.0);
    //拉链操作
    println(t2.zip(t3).toBuffer)

    //
    val t4=Array(2,5,"t",10)
    //如果元素个数对称那么将会舍弃多余的
    println(t2.zip(t4).toBuffer)
  }
}

Scala练习

       在学习完Scala的函数和数据结构后，我们可以做这样一个练习，这里我们使用Scala来做一个简单的WordCount例子。

package cn.edu.hust.scala

object Test {
  def main(args: Array[String]): Unit = {
    val list=List("hello word li hao","ming hao wo ai ni ai hello word")
    //将文本拿出后按照空格分离然后压平
    val words=list.map(_.split(" ")).toBuffer.flatten
    println(words)
    // 将每一个单词统计为1映射成为map
    val t=words.map((_,1))
    println(t)
    //按照元组分组
    val x=t.groupBy(_._1)
    // 取出key
    val key=x.map(_._1)
    //取出value
    val value=x.map(_._2.size)
    //拉链操作
    val result=key.zip(value)
    println(result)
    //排序
    var a=result
    println(a)
  }
}