scala基础(2) 匿名函数 排序 元组 ArrayBuffer ListBuffer Set Map WordCount的步骤和思路

于 2020-06-24 23:31:47 发布
阅读量853 收藏 1
点赞数
分类专栏： Scala 文章标签： scala 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_43139004/article/details/106952756
版权
本文深入探讨Scala的基础知识，包括匿名函数的简写与方法转换，如`def m(x: Int): Int = x * x`与`val f = m _`。此外，介绍了使用`reduce`和`fold`方法处理数据的方法，以及如何在方法中传入函数。讲解了排序的实现，如在`SortDemo`对象中。接着，详细阐述了元组的创建、访问和使用，如`val t = (10, 3.0, "abc", 'cc')`，以及不可变集合`ArrayBuffer`、`List`、`Set`和`Map`的运用。最后，提供了Scala编写WordCount程序的步骤和思路，涉及到元素计数和排序操作。" 84336507,8204939,实现轮播图加载本地图片功能,"['Android开发', 'UI设计', '图片处理', '滑动效果', '适配器']

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

scala shell

匿名函数简写

arr.map(x => x * 10)
arr.map(_ * 10)
arr.filter(x => x% 2 ==0)
arr.filter( _ % 2 == 0)
arr.reduce((x, y) => x + y)
arr.reduce(_ + _)

将方法转成一个新的函数
def m(x: Int) :Int = x * x
val f = m _
f函数会调用m方法

object MethodToFunc {
  def main(args: Array[String]): Unit = {
    val i = m(5)
    val intToInt = m _
    intToInt(5)

    val function = m1 _
    println(function(5,10.1))
  }

  def m(x: Int) : Int={
    println("this method invoked")
    x + x
  }

  def m1(x: Int, y: Double) : Double = {
    println(" this is a method invoked")
    x * y
  }
}

ctrl + alt +v 补全= 前面的变量
alt + t 补全数据类型

方法中传入函数的多种方式

object CallByName {
  def main(args: Array[String]): Unit = {

    val arr = Array(1, 2, 3, 4, 5)
    //将m方法的方法名传入到map方法中
    val arr1: Array[Int] = arr.map(m)
    println(arr1.toBuffer)

    val arr2: Array[Int] = arr.map(x => m(x))
    println(arr2.toBuffer)

    val arr3: Array[Int] = arr.map(m(_))
    println(arr3.toBuffer)

  }

  def m(x: Int)  = x * x

}

reduce方法的使用

object ReduceLeftDemo {
  def main(args: Array[String]): Unit = {

    val arr: Array[Int] = Array(1, 2, 3, 4, 5)
    // val  r1 = arr.sum
    val r1: Int = arr.reduceLeft(_ + _)
    // val r2 = arr.product
    //reduce方法中传入相加函数可以使用sum来代替
    //reduce方法中传入相乘函数可以使用product来代替
    val r2: Int = arr.reduce(_ + _)

    val r3: Int = arr.reduceLeft(_ - _)
    println(r3)
  }
}

object ReduceRight {
  def main(args: Array[String]): Unit = {

    val arr = Array(1, 2, 3, 4,5)
    val r1: Int = arr.reduceRight(_ + _)

    println(r1)

    val r2: Int = arr.reduceRight(_ - _)
    println(r2)
  }

}

fold方法的使用
给定第一值

object FoldDemo {
  def main(args: Array[String]): Unit = {
    val arr: Array[Int] = Array(1, 2, 3, 4, 5)

    val r1 = arr.fold(100)((x, y) => x + y)
    val r2: Int = arr.fold(100)((x, y) => x + y)
    val r3: Int = arr.fold(10)((x, y) => x * y)
    val r4: Int = arr.foldLeft(100)((x, y) => x * y)
    println(r4)
  }

}

排序

object SortDemo {
def main(args: Array[String]): Unit = {

val arr: Array[Int] = Array(5, 2, 7, 3, 9, 4, 6, 1, 8)

val a1 = arr.sorted
println(a1.toBuffer)

val a2: Array[Int] = arr.sortWith((x, y) => x > y)
println(a2.toBuffer)

val arr2: Array[Int] = Array(11, 20, 10, 30, 2, 88, 30, 3, 25, 100)
val a3: Array[Int] = arr2.sortBy(x => x*(-x))
println(a3.toBuffer)

val a4: Array[Int] = arr2.sortBy(x => x.toString)
println(a4.toBuffer)

}

元组 保存数据的一种结构
val t = (10, 3.0, “abc”, ‘cc’)
t._1
元组的角标是从1开始的
val t3 = Tuple3[String, Int, Int]
Tuple2[T2,T1] = Tuple2(_2, _1)
._1 方法
._2 方法
元组中的元素不能改变
对偶元组 val t = (“name”, “laozhao”)

val t2 = (“abc”, 123)
t2.swap 交换
(123, abc)

object TupleDemo {
def main(args: Array[String]): Unit = {

val t0 = ("abc", 2, 3.0)
val t1: (String, Int, Double) = ("abc", 1, 2.0)
val t2: Tuple3[String, Int, Double] = ("acb", 10, 12.0)

}

}

ArrayBuffer的使用

/**
 * 数组:Array 一旦定义,长度不能改变,但是可以修改数组中的对应位置的数据元素
 * ArrayBuffer 长度可变,并且可以修改ArrayBuffer中的数据,类似java中的ArrayList
 */
object ArrayBufferDemo {
  def main(args: Array[String]): Unit = {

    val ab = new ArrayBuffer[Int]()

    ab.append(3)
    ab.append(5)

    println(ab)
    ab += 7
    ab += 9
    ab += 11
    println(ab)

    /**
     * ArrayBuffer(1, 2)
     * ArrayBuffer(1, 2, 3, 4)
     */
    /**移除数据(从ab指定的位置移除一个元素)
     *ab.remove(1,3) 从 1号位位置开始,移除三个元素
     */
    ab.remove(1,3)
    ab -=11
    println(ab)

    //在指定的位置插入数据
    ab.insert(1, 5, 6, 7, 8)
    println(ab)
    /**
     * 最关键的是添加 append, +=
     * 移除元素: remove(从0号位置开始) , -=
     */
    ab.append(1,2,3,4,5)
    //++= 将一个数组,集合追加到ArrayBuffer
    ab ++= Array(6, 7, 8)
    ab ++= ab
    ab -= 4
    println(ab)
    for (e <- ab) {
      println(e)
    }

    val i = ab(0)
    println(i)

    ab(0) = 1000
    println(ab)

    //将Array转成一个新的ArrayBuffer,原来的没有发生变化
    val arr = Array(1, 2, 3, 4, 5)
    val buffer: mutable.Buffer[Int] = arr.toBuffer
    println(buffer)

    val array:Array[Int] = ab.toArray
    println(array.toBuffer)
  }

}

List的使用
Nil 表示 List() 中没有一个数据

/**
 * 数组:一旦定义,长度就不可以改变,但是数组中的内容可以改变
 * 元组:一旦定义,内容长度不可改变
 */

/**
 * scala 中的集合分为二类 :可变集合 不可变集合
 * 可变集合 :长度和集合中的内容都可以改变
 * 不可变集合:长度和集合中的内容都不可以改变
 */
object ListDemo {
  def main(args: Array[String]): Unit = {
    //不可变的集合
    val lst =List(8, 9, 10, 14, 15)
    val i = lst(0)

    val lst2 = List(5, 6, 7)
    // :+ 将lst 中添加一个新的元素 ,生成一个新的List
    val lis1: List[Int] = lst :+ 1
    //将二个List添加到一起,得到一个新的List
    val lst3: List[Int] = lst ++ lst2
    println(lst3)
    //取出List的Head 第一个元素
    val h: Int = lst.head
    //取出List的tail ,除去head的其他元素
    val tail: List[Int] = lst.tail
    //take 取出lst中的前x个元素
    lst.take(2)
    println(i)

  }

}

不可变集合和可变集合的区别

object ListBuffer {
  def main(args: Array[String]): Unit = {
    val lb: ListBuffer[Int] = new ListBuffer[Int]()
    lb += 1
    lb += 2
    
    val lst = List(4, 5, 8)
    lb ++= lst
    println(lb)
    
    lb -= 4

    //将listBuffer转成一个新的List 不可变
    val buffer: List[Int] = lb.toList
    //将List转成一个新的ListBuffer
    val buffer1: mutable.Buffer[Int] = lst.toBuffer
    
  }
}

Set的使用

/**
 * Set 无序去重
 */
object SetDemo {
  def main(args: Array[String]): Unit = {
    //默认使用的是不可变的Set ,无序去重
    val s1 = Set(100, 2, 8, 9, 2, 550,77, 8)

    //判断是否在set中
    val bool: Boolean = s1.contains(50)
    val s2: Set[Int] = s1.map(_ * 10)
    val s3: Set[Int] = s1.take(3)

    println(s1)
    println(s2)
    println(s3)

    //可变的Set
    val ms1: mutable.HashSet[Int] = new mutable.HashSet[Int]()
    ms1 += 1
    ms1 += 100
    ms1 += 5
    ms1 += (6, 8)
    val s0: mutable.Set[Int] = mutable.Set(110, 119)
    ms1 ++= s0
    println(ms1)

    ms1 -= 6
    //Set 的ms1中是否包含元素5 ms1.contains(5)
    val bool1: Boolean = ms1(5)
  }
}

Map的使用

object MapDemo {
def main(args: Array[String]): Unit = {

//不可变map
val m0 = mutable.Map(("aaa", 111), ("bbb", 222), ("ccc", 333))
val m1 = Map("a" -> 1, "b" -> 2, "spark" -> 3.0, "flink" -> 1.5)
val d = m1("spark")

//可变map
val m2 = new mutable.HashMap[String, Int]()
m2("a") = 10
m2 += ("b" -> 20)
m2 += (("c", 30))
m2.put("spark", 3)
println(m2)

m2 -= "b"
println(m2)
//变量map

for (kv <- m2){
  val key = kv._1
  val value = kv._2
  println(key + value)
}

//将map 转成List
val list: List[(String, Int)] = m2.toList

//将map中的keys取出
val keys: Iterable[String] = m2.keys
for (k <- keys){
  println(k)
}

val values: Iterable[Int] = m2.values
for (v <- values){
  println(v)
}

}
}

Scala编写WordCount的步骤和思路
排序找出每个元素个数

scala> val lines: Array[String] = Array("spark hadoop spark flink", "hadoop flink flink spark flink", "hbase flink")
lines: Array[String] = Array(spark hadoop spark flink, hadoop flink flink spark flink, hbase flink)

scala> val words = lines.flatMap( _.split(" "))
words: Array[String] = Array(spark, hadoop, spark, flink, hadoop, flink, flink, spark, flink, hbase, flink)

scala> val word = words.map((_, 1))
word: Array[(String, Int)] = Array((spark,1), (hadoop,1), (spark,1), (flink,1), (hadoop,1), (flink,1), (flink,1), (spark,1), (flink,1), (hbase,1), (flink,1))

scala> val word1 = words.groupBy(x => x)
word1: scala.collection.immutable.Map[String,Array[String]] = Map(hadoop -> Array(hadoop, hadoop), spark -> Array(spark, spark, spark), flink -> Array(flink, flink, flink, flink, flink), hbase -> Array(hbase))

scala> val wordCount = word1.map(t => (t._1, t._2.length))
wordCount: scala.collection.immutable.Map[String,Int] = Map(hadoop -> 2, spark -> 3, flink -> 5, hbase -> 1)

scala> val wordcountList = wordCount.toList
wordcountList: List[(String, Int)] = List((hadoop,2), (spark,3), (flink,5), (hbase,1))

scala> val WordCount = wordcountList.sortBy(t => t._2)
WordCount: List[(String, Int)] = List((hbase,1), (hadoop,2), (spark,3), (flink,5))

object WordCount {
  def main(args: Array[String]): Unit = {

    val lines: Array[String] = Array("spark hadoop spark flink", "hadoop flink flink spark flink", "hbase flink")
    //将每个元素进行切割并压平
    val words: Array[String] = lines.flatMap(x => x.split(" "))

    //将单词元素与1组合
    val wordAndOne: Array[(String, Int)] = words.map((_, 1))

    //分组
    val grouped: Map[String, Array[(String, Int)]] = wordAndOne.groupBy(_._1)

    //聚合
    val stringToInt: Map[String, Int] = grouped.map(t => (t._1, t._2.length))

    // toList
    val list = stringToInt.toList
    //排序
    val tuples = list.sortBy(t => t._2)
    println(tuples)

  }

}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值