一、scala集合
max 返回最大值
min 返回最小值
sum 求和
take 取出前n项，返回到新的集合中
takeRight 取出后n项，返回到新的集合中
drop 去掉前n项，并将剩余元素返回到新的集合中
dropRight 去掉后n项，并将剩余元素返回到新的集合中
head 返回集合头元素
last 返回集合尾元素
mkString 将集合中所有元素以指定方式返回或者返回一个字符串
intersect 取交集
union 取并集
diff 取出差集
distinct 去重
filter 根据指定的匿名函数实现过滤
exists 根据指定的匿名函数判断元素是否存在
map 根据匿名函数规则，将集合中的元素从一个形式映射到另一个形式
reduce 归约方法
sortBy 根据指定的匿名函数规则排序
groupBy 分组
reverse 反转，与sortBy结合实现降序效果可以用负号（-）
foreach 遍历
flatMap 扁平化映射

1、数组

scala的Array分为定长和变长

定长：immutable

变长：mutable

通过下标操作Array，下标从0开始

object ScalaDemo01 {

  def main(args: Array[String]): Unit = {
    // 创建一个定长数组，并赋初始值
    val a1 = Array(1,2,3,4)
    // 创建一个定长数组，并指定长度
    val a2 = new Array[Int](3)
    // 创建一个变长数组（可以追加新元素），并赋初始值
    val a3 = scala.collection.mutable.ArrayBuffer(1,2,3,4)

    //apply方法可以省略
    a1.apply(0)
    a1(0)
    // 通过下标赋值
    a1(0)=10
    //对变长数组追加元素
    a3.append(5)
    val a4=Array(2,34,6,32,5,7)
    //最大最小值
    val r1=a4.max
    val r2=a4.min
    //求和
    val r3=a4.sum
    //长度
    val r4=a4.length
    //反转
    val r5=a4.reverse
    //取出前n项，返回到新的集合中
    val r6=a4.take(2)
    //取出后n项，返回到新的集合中
    val r7=a4.takeRight(2)
    //去掉前n项，并将剩余元素返回到新的集合中
    val r8=a4.drop(2)
    //去掉后n项，并将剩余元素返回到新的集合中
    val r9=a4.dropRight(2)
    //返回集合的头元素，有别于take(1)。
    val r10=a4.head
    //返回集合尾元素，有别于takeRight(1)
    val r11=a4.last
    //将集合中所有元素以指定的分隔符返回
    val r12=a4.mkString(",")
    //遍历集合
    for(i<-a4){println(i)}
    a4.foreach{(x:Int)=>{println(x)}}
    a4.foreach(x=>println(x))
    val a5=Array(1,2,3)
    val a6=Array(3,4,5)
    //取交集
    val r13=a5.intersect(a6)
    //取并集
    val r14=a5.union(a6)
    //去重
    val r15=a5.distinct
    //取差集，注意有方向
    //交集和差集经常用在比较文件数据之间数据之间的异同场景
    val r16=a5.diff(a6)
    val r17=a6.diff(a5)
    //将集合中的所有元素返回一个字符串
    val r18=a6.mkString
    //集合中所有元素以指定的分隔符返回
    val r19=a6.mkString(",")
  }
}

2、list

scala的List分为定长和变长。都是通过下标来操作。下标从0开始

object ScalaDemo02 {

  def main(args: Array[String]): Unit = {
    //创建一个定长List，并赋值
    val l1=List(1,2,3,4)
    //创建了一个变长List,并赋值
    val l2=scala.collection.mutable.ListBuffer(1,2,3,4)
    //通过下标操作List
    l1.apply(0)
    l1(0)
    val l3=List(1,2,3,4,5,6,7,8)
    //filter方法根据指定的匿名函数实现过滤
    //将过滤出的元素返回到一个新的集合中
    val r1=l3.filter { num => num>4 }

    //操作l3,过滤出大于2的偶数元素
    val r2=l3.filter { num =>num>2&&num%2==0 }
    //计算出l3中所有的奇数数字之和
    val r3=l3.filter { num => num%2==1 }.sum
    val l4=List("tom M 23","rose F 18","jary M 30","jim F 35")
    //过滤出l4中的男性数据
    val r4=l4.filter { line => line.contains("M") }
    val r5=l4.filter { line => line.split(" ")(1).equals("M") }
    //过滤出年龄大于20岁的数据
    val r6=l4.filter { line => line.split(" ")(2).toInt>20 }

    val l5=List(1,2,3,4,5)
    //exists方法是根据指定的匿名函数规则判断元素是否存在。
    //如果元素存在返回True,不存在返回False
    val r7=l5.exists { num => num>4 }
    //map方法,映射方法。作用是:根据匿名函数规则,将集合中的元素从一个形式映射(转变)到另一个形式
    //并将映射后的元素返回到新的集合中,元素个数不变,形式改变
    val r8=l5.map { num => num*2 }
    val r9=l5.map { num => num.toString }

    val l8=List(1,2,3,4)
    //reduce方法归约方法。底层的处理机制
    //第一次:a=1 b=2  a+b=3
    //第二次:a=3 b=3  a+b=6
    //第三次:a=6 b=4  a+b=10
    val r15=l8.reduce{(a,b)=>a+b}

    val l9=List(3,1,5,2,4)
    //sortBy方法是根据指定的匿名函数规则排序,实现升序或降序
    //将排序后的结果返回到新的集合中
    //通过reverse 到达降序的效果。也可以通过负号来实现降序，注意:负号前有空格
    val r18=l9.sortBy { num => num }.reverse
    val r19=l9.sortBy { num => -num }

    val l10=List("b 3","a 4","c 2","d 1")
    //操作l10,按数字做升序
    val r20=l10.sortBy { line => -line.split(" ")(1).toInt }
    //按字母做降序排序。注意:负号只能用于数值类型的排序条件。
    val r21=l10.sortBy { line => line.split(" ")(0) }.reverse

  }
}

3、Set

scala的Set作用和概念同java；scala的Set分为定长和变长

object ScalaDemo03 {
  def main(args: Array[String]): Unit = {
    //声明一个定长Set
    val s1 = Set(1,1,2,3,4,5)
    //创建一个变长Set
    val s2 = scala.collection.mutable.Set(1,2,3,4)
    //创建一个定长Map
    val m1 = Map("yang"->24,"zhi"->23,"chao"->19)
    //创建一个变长Map
    val m2 = scala.collection.mutable.Map("yang"->24,"zhi"->20)
    //对变长Map追加kv键值对
    m2+=("chao"->24)

    //通过Key操作map
    m1.apply("yang")
    m1("zhi")
    //如果想避免报错抛异常,可以通过get(key)来取值
    //返回值类型是Option。如果key存在，则返回Some(value)
    //如果key不存在,则返回None
    m1.get("zhi")
    m2.get("zhi").getOrElse(0)
    //获取Map的所有key
    m1.keys.toList
    //获取Map的所有value
    m1.values.toList

    val m3=Map("yang"->23,"zhi"->18,"chao"->25)
    //过滤年龄大于20的kv对
    val r1 = m3.filter{case(k,v)=>v>20}
  }
}

4、元组

object ScalaDemo04 {
  def main(args: Array[String]): Unit = {
    // 创建一个元组
    val t1 =(1,2,"tuple",3.5)
    //通过元组位置下标操作，元组的下标从1开始
    println(t1._3)

    val t2=(1,2,(3,4))
    println(t2._3._2)

    val t3=(1,(2,3),(4,Array(5,6)))
    println(t3._3._2(0))

    val m1=Map("yang"->23,"handsome"->18)
    println(m1.filter{case (k,v)=>v>20})
    println(m1.filter(x=>x._2>20))
    println(m1.map{x=>(x._1,x._2+10)})
  }

}

二、综合练习

一个简单的数据统计分析的案例：

object ScalaDemo05 {
  def main(args: Array[String]): Unit = {
    val l1=List(("bj",12000),("sh",8000),("bj",9200),("sh",13000))

    //过滤出l1中北京地区的数据
    val r1=l1.filter(x=>x._1.equals("bj"))
    println(r1) //List((bj,12000), (bj,9200))
    //计算出上海地区的平均薪资
    val r2=l1.filter{x=>x._1.equals("sh")}.map{x=>x._2}.sum/2
    println(r2) //10500
    //根据地区分组
    val r3 =l1.groupBy(x=>x._1)
    println(r3) //Map(bj -> List((bj,12000), (bj,9200)), sh -> List((sh,8000), (sh,13000)))

    val l2=List("hello world","hello world","hello spark")
    val r4=l2.map { line=>line.split(" ")}
    //扁平化映射。一般用于读取文件后,处理每行数据,获取每行中的数据
    val r5=l2.flatMap { line => line.split(" ") }
    println(r5) //List(hello, world, hello, world, hello, spark)
    //统计出l2中的单词频次
    val r6=l2.flatMap{line=>line.split(" ")}
      .groupBy{word=>word}
      .map{case (k,v)=>(k,v.length)}
    println(r6) //Map(spark -> 1, world -> 2, hello -> 3)
    val r7=l2.flatMap(line=>line.split(" "))
      .groupBy(word=>word)
      .mapValues(v=>v.length)
    println(r7) //Map(spark -> 1, world -> 2, hello -> 3)

  }

}

object ScalaDemo06 {
    
  val s1="hello"                                  //> s1  : String = hello
  val s2="world"                                  //> s2  : String = world
  val r1=s1 zip s2                                //> r1  : scala.collection.immutable.IndexedSeq[(Char, Char)] = Vector((h,w), (e
                                                  //| ,o), (l,r), (l,l), (o,d))
  val a1=Array("X","Y","Z")                       //> a1  : Array[String] = Array(X, Y, Z)
  val a2=Array(1,2,3)                             //> a2  : Array[Int] = Array(1, 2, 3)
  
  val r2=a1 zip a2                                //> r2  : Array[(String, Int)] = Array((X,1), (Y,2), (Z,3))
  
  def largest(fun:(Int)=>Int,inputs:Seq[Int])={
  		 val result=for(i<-inputs)yield{fun(i)}
  		 result.max
  }                                               //> largest: (fun: Int => Int, inputs: Seq[Int])Int

  largest(x=>10*x-x*x,1 to 10)                    //> res0: Int = 25
  
  val a3=Array(4, -2, 0, -3, 0, 1, 5)             //> a3  : Array[Int] = Array(4, -2, 0, -3, 0, 1, 5)
  def f1(arr:Array[Int])={
  			val arr1=for(i<-arr;if i>0)yield{i}
  			val arr2=for(i<-arr;if i==0)yield{i}
  			val arr3=for(i<-arr;if i<0)yield{i}
  			arr1.union(arr2).union(arr3)
  }                                               //> f1: (arr: Array[Int])Array[Int]
  
  f1(a3)                                          //> res1: Array[Int] = Array(4, 1, 5, 0, 0, -2, -3)
}

大数据笔记--scala（第三篇）

大数据系统相关栏目本月热门文章

max	返回最大值
min	返回最小值
sum	求和
take	取出前n项，返回到新的集合中
takeRight	取出后n项，返回到新的集合中
drop	去掉前n项，并将剩余元素返回到新的集合中
dropRight	去掉后n项，并将剩余元素返回到新的集合中
head	返回集合头元素
last	返回集合尾元素
mkString	将集合中所有元素以指定方式返回或者返回一个字符串
intersect	取交集
union	取并集
diff	取出差集
distinct	去重
filter	根据指定的匿名函数实现过滤
exists	根据指定的匿名函数判断元素是否存在
map	根据匿名函数规则，将集合中的元素从一个形式映射到另一个形式
reduce	归约方法
sortBy	根据指定的匿名函数规则排序
groupBy	分组
reverse	反转，与sortBy结合实现降序效果可以用负号（-）
foreach	遍历
flatMap	扁平化映射