scala 基础

时间：2024-01-12 17:05:26

1.scala一些预热操作

1.1 to 是一个方法，（）可以进行 参数传递，map（）把每一个元素取出来进行相应的操作，

  1.  print(1.to(10).map(_*10))
  2.  结果
  3.  Vector(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)

1.2取数组中的每一个值

  1.  val arr=Array(1,2,3,4,5,6,7,8,9)
  2.  //直接遍历每一个值
  3.  for (i<-arr) print(i+" ")
  4.  //通过下标遍历每一个值 until是取值左闭右开
  5.  for(i <- 0 until arr.length) println(arr(i))

1.3 List的flatten 可以将一个list嵌套list、list嵌套字符串压平

  1.  val ls1=List(1,2,3,4,5,6,7,8,9)
  2.  val ls2=ls1.grouped(5)
  3.  val ls3=ls2.toList
  4.  println(ls3) //List(List(1, 2, 3, 4, 5), List(6, 7, 8, 9))
  5.  println(ls3.flatten) //list套list有压平操作 也可以压平 list中套多个字符串的情况
  6.  结果：list(1, 2, 3, 4, 5, 6, 7, 8, 9)

1.4取一个元组的第n个值

  1.  val t=(1,2,3,4,4,5,6)
  2.  print(t._2) ////去元组的第n个

2.wordcount

  1.  val lines=List("hello tom hello jerry","hello tom hello kitty hello china")
  2.  方法一:
  3.  val wc=lines.flatMap(_.split(" ")).map((_,1)).groupBy(_._1).map(t=>(t._1,t._2.size)).toList.sortBy(_._2).reverse
  4.  方法二：
  5.  val wc2=lines.flatMap(_.split(" ")).map((_,1)).groupBy(_._1).mapValues(_.size)
  6.  方法三：
  7.  val wc3=lines.flatMap(_.split(" ")).map((_,1)).groupBy(_._1).mapValues(_.foldLeft(0)(_+_._2))
  8.  如果是在spark上：
  9.  val wc4=lines.flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_).sortBy(_._2,false).collect

2.1flatMap=map+flatten

  1.  val words=lines.flatMap(_.split(" "))
  2.  结果：
  3.  List(hello, tom, hello, jerry, hello, tom, hello, kitty, hello, china)

可以拆分map过程

  1.  lines.map(_.split(" "))
  2.  拿到每一个元素(字符串)，按照空格切割，切割后返回两个数组，仍放在List中
  3.  res0: List[Array[String]] = List(Array(hello, tom, hello, jerry), Array(hello, tom, hello, kitty, hello, china))

flatten过程

  1.  lines.map(_.split(" ")).flatten
  2.  List(hello, tom, hello, jerry, hello, tom, hello, kitty, hello, china)

2.2 将单词出现一次和1放在一起（放入元组）

  1.  val wordsAndOne=words.map((_,1))
  2.  List((hello,1), (tom,1), (hello,1), (jerry,1), (hello,1), (tom,1), (hello,1), (kitty,1), (hello,1), (china,1))

2.3 groupBy按照单词分组返回map

  1.  第一个_ 表示List中的每一个元组，取元组中的某一个元素用._n,即按照元组中的某一元素分组,返回是一个map
  2.  val grouped =wordsAndOne.groupBy(_._1)
  3.  Map(kitty -> List((kitty,1)), china -> List((china,1)), tom -> List((tom,1), (tom,1)), hello -> List((hello,1), (hello,1), (hello,1), (hello,1), (hello,1)), jerry -> List((jerry,1)))

2.4求和

  1.  t就是每一个对偶元组， 仍返回一个map
  2.  val result = grouped.map(t=>(t._1,t._2.size))
  3.  Map(kitty -> 1, china -> 1, tom -> 2, hello -> 5, jerry -> 1)

直接对第一个单词和list.size 但scala中不予许这样的操作

  1.  第一个_ 拿到一个对偶元组，取元组中的第一个元组。_._2.size即是取对偶元组第二个的大小。
  2.  val result=grouped.map(_._1,_._2.size)

2.5 按出现次数从大到小排序M：默认自然排序, map没有sortBy 先将map.toList

  1.  val finalResult=result.toList.sortBy(_._2).reverse
  2.  List((hello,5), (tom,2), (jerry,1), (china,1), (kitty,1)

3.方法二中：mapValues的_ 指的是元组的值 即v。key 不动，只是对values进行处理  结果 k v 一起返回

val wc2=lines.flatMap(_.split(" ")).map((_,1)).groupBy(_._1).mapValues(_.size)

4.方法三中：

fold(0)(_+_)  0 是初始值
Map(kitty -> List((kitty,1)), china -> List((china,1)), tom -> List((tom,1), (tom,1)), hello -> List((hello,1), (hello,1), (hello,1), (hello,1), (hello,1)), jerry -> List((jerry,1)))
foldLeft(0)(_+_._2)第一个_表示初始值或者上一次累加的结果 中第二个_ ,表示拿到的每一个元组，第三个元组的中第n个值

val wc3=lines.flatMap(_.split(" ")).map((_,1)).groupBy(_._1).mapValues(_.foldLeft(0)(_+_._2))

5.reduce和fold操作

  1.  val a=Array(1,2,3,4,5,6)
  2.  println(a.sum) //求和 21
  3.  println(a.reduce(_+_))//21 聚合操作要求传递两个参数
  4.  println(a.reduce(_-_))//-19 也可以进行减法操作

a.reduce(_+_) 默认调用 a.reduceLift   (((((1+2)+3)+4)+5)+6)



println(a.par.reduce(_+_)) //21  par转化成并行化操作



fold 也支持并行化--并行计算,及柯里化


    

  1.  val b=Array(1,2,3,4,5,6)
    2. 

  2.  println(b.fold(10)(_+_)) //31和cpu核心数无关
    3. 

  3.  println((b.par.fold(10)(_+_))) //61和cpu核心数有关，2核心4线程，所以4*10
    4. 

  4.  println((b.par.fold(0)(_+_))) //21
    5. 

  5. 

    6. 

  6.  println(b.foldLeft(10)(_+_)) //31
    7. 

  7.  println(b.foldRight(10)(_+_)) //31
    8. 

相关文章