第7章 Scala集合

这篇具有很好参考价值的文章主要介绍了第7章 Scala集合。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

第7章 Scala集合

7.1 简介

第7章 Scala集合

第7章 Scala集合

  • scala.collection.immutable

    第7章 Scala集合

  • scala.collection.mutable

    第7章 Scala集合

7.2 数组

第7章 Scala集合

  1. 不可变数组

    package chapter07
    
    object Test01_ImmutableArray {
      def main(args: Array[String]): Unit = {
        // 1. 创建数组
        val arr: Array[Int] = new Array[Int](10)
        arr(9) = 9
        println(arr.mkString(","))
    
        // 另一种创建方式
        val arr2 = Array[Int](1, 2, 3, 4, 65)
    
        // 2. 数组操作-(由于是不可变数组,增删不能改变)改查
        // 访问元素
        println(arr2.mkString(","))
        arr2(0) = 100
        println(arr2.apply(0))
        arr2.update(0, 199)
        println(arr2.mkString(","))
    
        // 3. 数组的遍历
        // for循环
        for (i <- arr2.indices) {
          println(arr2(i))
        }
    
        // 增强for循环
        for (ele <- arr2) {
          println(ele)
        }
    
        // 迭代器
        val iterator: Iterator[Int] = arr2.iterator
        println("++++++++++迭代器+++++++++++++++")
        while (iterator.hasNext) {
          println(iterator.next())
        }
    
        // foreach
        arr2.foreach((ele: Int) => {
          println(ele)
        })
        arr2.foreach(println(_))
    
        println(arr2.mkString("----"))
    
        // 3. 添加元素,由于是不可变数组,因此添加元素之后,生成一个新的数组
        // 30------199------2------3------4------65------2
        val array: Array[Any] = arr2.:+(2).+:(30)
        // 往后追加元素 :+,往前追加元素 +:
        2 +: arr2 :+ 10 :+ 10
    
    
        println(array.mkString("------"))
    
        arr2 ++ Array(2)
    
      }
    
    }
    
    
  2. 可变数组

    package chapter07
    
    import scala.collection.mutable
    import scala.collection.mutable.ArrayBuffer
    
    object Test02_mutableArrayBuff {
      def main(args: Array[String]): Unit = {
        // 1. 创建一个可变数组,无任何元素
        val arr = new ArrayBuffer[Int]()
        println(arr.mkString("--"))
        arr += 10
    
        println(arr.mkString("--"))
    
        // 另一种创建方法
        val arr2: ArrayBuffer[Int] = ArrayBuffer(19, 10, 2)
        println(arr2)
        println(arr2.mkString("==="))
    
        // 2. 访问元素
        println(arr2(0))
    
        // 3. 添加元素
        val newArr = arr2 :+ 10
    
    
        println(newArr == arr2)
        println(arr2)
    
        // 不建议这样的操作,建议arr2 += 10
        val arr3 = arr2 += 10
        println(arr3 == arr2)
    
        101 +=: arr3
        println(arr3)
    
        // 可变集合推荐调用方法
        arr3.append(10, 1999)
        arr3.prepend(10092)
        arr3.insert(2, 22222)
    
        println(arr3)
    
        // 添加一个数组
        arr3.insertAll(1, arr)
        println(arr3)
    
        // 4. 删除元素,指定位置
        arr3.remove(1)
        println(arr3)
    
        arr3.remove(1, 2)
        println(arr3)
    
        // 删除特定值
        arr3 -= 10
        println(arr3)
    
        // 5. 可变数组与不可变数组之间的转换
        val arr5 = ArrayBuffer(10, 2, 3, 1)
        val newArr5: Array[Int] = arr5.toArray
        println(newArr5.mkString("-"))
        val buffer: mutable.Buffer[Int] = newArr5.toBuffer
        println(buffer)
        println(newArr5)
      
      }
    
    }
    
  3. 多维度数组

    package chapter07
    
    object Test03_MulArray {
      def main(args: Array[String]): Unit = {
        // 创建2维数组
        val array: Array[Array[Int]] = Array.ofDim[Int](2, 3)
    
        // 访问元素
        array(0)(2) = 10
    
        println(array.mkString("-"))
    
        for (i <- 0 until array.length; j <- 0 until array(i).length) {
          println(array(i)(j))
        }
      
        val array1: Array[Array[String]] = Array.ofDim[String](2, 3)
        for (i <- array1.indices; j <- array1(i).indices) {
          print(array1(i)(j) + "\t")
          if (j == array1(i).length - 1) println()
        }
      
        array.foreach(
          (line) => {
            line.foreach(println(_))
          }
        )
    
        array.foreach(
          _.foreach(println)
        )
    
      }
    
    }
    
    
    

7.3 列表List

  1. 不可变列表

    package chapter07
    
    object Test04_ImmutableList {
      def main(args: Array[String]): Unit = {
        // 列表
        // 1. 创建List,不能用class创建,只能用伴生对象创建
        // sealed abstract class List 中sealed表示List类的子类只能在本文件创建
        val list1 = List(1, 2, 3, 4, 5, 6)
        println(list1)
    
        // 2. 访问和遍历元素
        println(list1(0))
        // 此处不能像Array更改某个位置的值
        // list1(0) = 10 error
        //
        list1.foreach(println)
    
        // 3. 添加元素
        // 头部添加 10 +: list1
        val list2: List[Int] = list1.+:(10)
        // 尾部添加 list1 :+ 19
        val list3: List[Int] = list1.:+(19)
        println(list2)
        println(list3)
    
        // 双冒号主要用于创建一个列表
        val list4 = list1.::(51)
        println(list4)
        println(52 :: list1)
    
        // 创建一个列表
        val list5 = 32 :: 39 :: Nil
    
    
        // 4. 列表合并
        val list6 = list4 :: list5
        // List(List(51, 1, 2, 3, 4, 5, 6), 32, 39)
        println(list6)
    
        // 3冒号用于列表拼接,扁平化合并
        val list7 = list4 ::: list5
        // List(51, 1, 2, 3, 4, 5, 6, 32, 39)
        println(list7)
        // 等价,列表拼接,扁平化合并
        println(list4 ++ list5)
      }
    
    }
    
    
  2. 可变列表

    package chapter07
    
    import scala.collection.mutable.ListBuffer
    
    object Test05_MutableListBuffer {
      def main(args: Array[String]): Unit = {
        // 1. 创建可变列表
        val list1 = new ListBuffer[Int]()
        val list2 = ListBuffer(12, 13, 29)
        println(list1)
        println(list2)
    
        // 2. 添加元素,使用方法函数
        list1.append(1, 2, 3)
        list1.insert(1, 19, 22)
        list2.prepend(34, 2)
        println(list1)
        println(list2)
    
        // 3. 合并list ++ 会返回新的对象,++= 会更改
        val list3 = list1 ++ list2
        println(list3)
        list1 ++= list2
        println(list1)
    
        // 4. 修改元素
        list2(2) = 3333
        list2.update(0, 99)
        println(list2)
    
        // 5. 删除元素
        // 指定位置删除
        list2.remove(2)
        // 指定元素删除
        list2 -= 29
        println(list2)
    
      }
    
    }
    
    

7.4 Set 集合

  1. 不可变Set

    package chapter07
    
    object Test06_ImmutableSet {
      def main(args: Array[String]): Unit = {
        // 1. 创建Set,new Set()不能创建,Set为特征,因此只能用伴生对象创建
        val set1 = Set(1, 2, 3, 34, 2, 3)
        println(set1)
    
        // 2. 添加元素
        println("=========2. 添加元素============")
        val set2 = set1 + 10 + 10 + 20 + 20 + 30
        println(set2)
    
        // 3. 合并set
        println("=========3. 合并set============")
        val set3 = Set(1, 2, 3, 4, 9, 10)
        val set4 = set2 ++ set3
        println(set4)
    
        // 4. 删除元素
        println("=========4. 删除元素============")
        val set5 = set4 - 30
        println(set4)
        println(set5)
    
    
      }
    
    }
    
    
  2. 可变Set

    package chapter07
    
    import scala.collection.mutable
    
    object Test07_MutableSet {
      def main(args: Array[String]): Unit = {
        // 1. 创建可变set
        val set1: mutable.Set[Int] = mutable.Set(1, 2, 3, 4, 10)
        println(set1)
    
        // 2. 添加元素,使用方法名
        println("============2. 添加元素============")
        val flag1 = set1.add(12)
        println(set1)
        println(flag1)
    
        val flag2 = set1.add(12)
        println(set1)
        println(flag2)
    
        // 3. 删除元素
        println("============3. 删除元素============")
        set1.remove(12)
        println(set1)
    
        // 4. 合并两个set ++=
        println("============4. 合并两个set============")
        val set3 = mutable.Set(111, 222, 3, 4, 101)
        println(set1)
        println(set3)
        set1 ++= set3
        println(set1)
        println(set3)
      }
    
    }
    
    

7.5 Map 集合

第7章 Scala集合

  1. 不可变Map

    package chapter07
    
    object Test08_ImmutableMap {
      def main(args: Array[String]): Unit = {
        // 1. 创建Map
        val map1: Map[String, Int] = Map[String, Int]("scc" -> 18, "hello" -> 10)
        println(map1)
        println(map1.getClass)
    
        val map0 = Map[String, Int]()
        println(map0)
        println(map0.getClass)
    
        // 2. 遍历元素
        map1.foreach(println(_))
        map1.foreach(kv => println(s"key is ${kv._1}, value is ${kv._2}"))
    
        // 3. 取map中所有key或者value
        /**
         * println(s"$key-->${map1.get(key)}")
         * scc-->Some(18)
         * hello-->Some(10)
         */
        for (key <- map1.keys) {
          println(s"$key-->${map1.get(key)}")
          println(s"$key-->${map1.getOrElse(key, 0)}")
        }
    
        for (value <- map1.values) {
          println(value)
        }
    
    
      }
    
    
    }
    
    
  2. 可变Map

    package chapter07
    
    import scala.collection.mutable
    
    object Test09_MutableMap {
      def main(args: Array[String]): Unit = {
        // 1. 创建Map
        val map1 = mutable.Map[String, Int]("scc" -> 18, "hello" -> 10)
        println(map1)
        println(map1.getClass)
    
        // 2. 添加元素
        map1.put("zyy", 19)
        println(map1)
    
        map1 += (("a", 20), ("b", 22))
        println(map1)
    
        // 3. 删除元素
        map1.remove("zyy")
        map1 -= "d"
        println(map1)
    
        // 4. 修改元素
        map1.update("a", 209)
        println(map1)
    
        // 5. 合并两个Map
        val map2 = mutable.Map[String, Int]("x" -> 108, "hello" -> 11)
        println(map1)
        println(map2)
        map1 ++= map2
    
        println(map1)
        println(map2)
    
        val map3: mutable.Map[String, Int] = map1 ++ map2
    
        // 6. immutable.map 和 mutable.map 互转
        val map4: Map[String, Int] = map3.toMap
    
        val map5: mutable.Map[String, Int] = collection.mutable.Map(map4.toSeq: _*)
      }
    
    }
    
    

7.6 元组

第7章 Scala集合

package chapter07

object Test10_Tuple {
  def main(args: Array[String]): Unit = {
    // 1. 创建元组
    val tuple1: (String, Int, Char, Boolean) = ("hello", 100, 'a', true)
    println(tuple1)

    // 2. 访问数据
    println(tuple1._1)
    println(tuple1._2)
    println(tuple1._3)
    println(tuple1._4)

    // 索引从0开始,建议使用下划线_
    println(tuple1.productElement(1))

    // 3. 遍历元组数据
    for (ele <- tuple1.productIterator) {
      println(ele)
    }

    // 4. 嵌套元组
    val mulTuple = (12, 0.3, "hello", (23, "scala"), 29)
    println(mulTuple._1)
    println(mulTuple._4._2)
  }

}

7.7 集合常用函数

第7章 Scala集合

  1. 通用属性和操作

    package chapter07
    
    object Test11_CommonOp {
      def main(args: Array[String]): Unit = {
        val list: List[Int] = List(1, 2, 3, 4)
        val set = Set(1, 2, 3, 4)
        // 1. 获取集合长度
        println(list.length)
        // 3. 获取集合大小
        println(list.size)
        println(set.size)
    
        // 3. 循环遍历
        for (elem <- list){
          println(elem)
        }
    
    
        // 4. 迭代器
        for (elem <- list.iterator){
          println(elem)
        }
    
        val iterator: Iterator[Int] = list.iterator
        while (iterator.hasNext){
          println(iterator.next())
        }
        // 5. 生成字符串
        println(list)
        println(set)
        println(list.mkString("--"))
    
    
        // 6. 是否包含
        println(list.contains(1))
        println(list.contains(5))
        println(set.contains(2))
      
      }
    
    }
    
    
  2. 衍生集合

    第7章 Scala集合

    package chapter07
    
    object Test12_DerivedCollection {
      def main(args: Array[String]): Unit = {
        val list1: List[Int] = List(1, 3, 5, 7, 2, 89)
        val list2: List[Int] = List(3, 7, 2, 45, 4, 8, 19)
    
        // 1. 获取集合的头
        println("=============1. 获取集合的头=============")
        println(list1.head)
        // 2. 获取集合的尾(不是头的尾)
        println("=============2. 获取集合的尾(不是头的尾)=============")
        println(list1.tail)
        // 3. 获取集合的最后一个元素
        println("=============3. 获取集合的最后一个元素=============")
        println(list1.last)
        // 4. 获取集合初始元素(不包含最后一个)
        println("=============4. 获取集合初始元素(不包含最后一个)=============")
        println(list1.init)
    
        // 5. 翻转
        println("=============5. 翻转=============")
        println(list1.reverse)
    
        // 6. 取前(后)n个元素
        println("=============6. 取前(后)n个元素=============")
        println(list1.take(3))
        println(list1.takeRight(4))
    
        // 7. 去掉前(后)n个元素
        println("=============7. 去掉前(后)n个元素=============")
        println(list1.drop(3))
        println(list1.dropRight(4))
    
        println("=============以下操作,涉及两个集合操作=============")
    
        // 8. 交集
        println("=============8. 交集=============")
        val intersect = list1 intersect list2
        println(intersect)
    
        // 9. 并集
        println("=============9. 并集=============")
        val union = list1 union list2
        println(union)
        println(list1 ::: list2)
    
        // 10. 差集
        println("=============10. 差集=============")
        val diff1: List[Int] = list1.diff(list2)
        val diff2: List[Int] = list2.diff(list1)
        println(diff1)
        println(diff2)
    
        // 11. 拉链,取最小集合长度为准
        println("=============11. 拉链,取最小集合长度为准=============")
        println(s"list1: $list1")
        println(s"list2: $list2")
        val zip1: List[(Int, Int)] = list1.zip(list2)
        val zip2: List[(Int, Int)] = list2.zip(list1)
        println(s"zip1: $zip1")
        println(s"zip2: $zip2")
    
        // 12. 滑窗
        println("=============12. 滑窗=============")
        // List(1, 3, 5, 7, 2, 89)
        println(list1)
    
        /**
         * List(1)
         * List(3)
         * List(5)
         * List(7)
         * List(2)
         * List(89)
         */
        list1.sliding(1).foreach(println)
    
        /**
         * List(1, 3)
         * List(3, 5)
         * List(5, 7)
         * List(7, 2)
         * List(2, 89)
         */
        list1.sliding(2).foreach(println)
    
        /**
         * List(1, 3)
         * List(7, 2)
         */
        list1.sliding(2, 3).foreach(println)
    
        /**
         * 窗口无重复数据,又叫滚动滑动窗口
         * List(1, 3)
         * List(5, 7)
         * List(2, 89)
         */
        list1.sliding(2, 2).foreach(println)
      }
    
    }
    
    
  3. 简单计算函数

    第7章 Scala集合

    package chapter07
    
    object Test13_SimpleOp {
      def main(args: Array[String]): Unit = {
        val list: List[Int] = List(5, 1, 8, 2, -3, 4)
        val list2 = List(("a", 5), ("b", 1), ("c", 8), ("d", 2), ("e", -3), ("f", 4))
        // 1. 求和
        println(list.sum)
        val i: Int = list.reduce((a, b) => {
          a + b
        })
        println(i)
        // 2. 求积
        println(list.product)
        // 3. 最大值
        println(list.max)
        println(list2.max)
        println(list2.maxBy(elem => {
          elem._2
        }))
    
        println(list2.maxBy(_._2))
        // 4. 最小值
        println(list.min)
        // 5. 排序
        // 按照第一个位置元素排序
        /**
         * List(-3, 1, 2, 4, 5, 8)
         * List(8, 5, 4, 2, 1, -3)
         * List((a,5), (b,1), (c,8), (d,2), (e,-3), (f,4))
         * List((f,4), (e,-3), (d,2), (c,8), (b,1), (a,5))
         */
        println(list.sorted) // 从小到大排序
        println(list.sorted(scala.math.Ordering.Int.reverse)) // 从大到小排序
        println(list2.sorted) // 从小到大排序
        println(list2.sorted(scala.math.Ordering.Tuple2[String, Int].reverse)) // 从大到小排序
    
        // 指定位置元素排序,从大到小
        /**
         * List((c,8), (a,5), (f,4), (d,2), (b,1), (e,-3))
         * List((c,8), (a,5), (f,4), (d,2), (b,1), (e,-3))
         */
        println(list2.sortBy(elem => {
          elem._2
        })(scala.math.Ordering[Int].reverse))
    
    
        println(list2.sortBy(
          _._2
        )(scala.math.Ordering.Int.reverse))
    
        // 上面方法太麻烦,使用sortWith进行简化
        println(list.sortWith(_ < _))
        println(list.sortWith(_ > _))
        list2.sortWith((a, b) => {
          a._2 > b._2
        })
    
    
        /**
         * sorted:适合单集合的升降序
         *
         * sortBy:适合对单个或多个属性的排序,代码量比较少,推荐使用这种
         *
         * sortWith:适合定制化场景比较高的排序规则,比较灵活,也能支持单个或多个属性的排序,但代码量稍多,内部实际是通过java里面的Comparator接口来完成排序的。
         *
         */
      }
    
    }
    
    
  4. 高级计算函数

    第7章 Scala集合​​

    第7章 Scala集合

    package chapter07
    
    object Test14_HighLevelFunction_Map {
      def main(args: Array[String]): Unit = {
        /**
         * List(2, 4, 6, 8)
         * List(2, 4, 6, 8, 10, 12, 14, 16, 18)
         * List(List(1, 2, 3), List(4, 5), List(6, 7, 8, 9))
         * List(1, 2, 3, 4, 5, 6, 7, 8, 9)
         * List(Hello, Scala, Hello, World)
         * List(Hello, Scala, Hello, World)
         * Map(1 -> List(1, 3, 5, 7, 9), 0 -> List(2, 4, 6, 8))
         * Map(2 -> List(2, 5, 8), 1 -> List(1, 4, 7), 0 -> List(3, 6, 9))
         * Map(S -> List(Scala), W -> List(World), H -> List(Hello, Hello))
         *
         */
        val list = List(1, 2, 3, 4, 5, 6, 7, 8, 9)
    
        // 1. 过滤
        val evenList: List[Int] = list.filter(_ % 2 == 0)
        println(evenList)
    
        // 2. 转化/映射 map
        val multiply2: List[Int] = list.map(_ * 2)
        println(multiply2)
    
    
        // 3. 扁平化
        val nestedList: List[List[Int]] = List(List(1, 2, 3), List(4, 5), List(6, 7, 8, 9))
        println(nestedList)
        val flattenList: List[Int] = nestedList.flatten
        println(flattenList)
    
    
        // 4. 扁平化和映射 flatMap,先map,再flatten
        // 将一组单词,进行分词,再保存成单词列表
        val strings: List[String] = List("Hello Scala", "Hello World")
        println(strings.map(_.split(" ")).flatten)
        println(strings.flatMap(_.split(" ")))
    
    
        // 5. 分组,groupBy
        // 直接分成奇数和偶数两组
        println(list.groupBy(_ % 2))
        println(list.groupBy(_ % 3))
    
        // 给定一组单词,按照单词的首字母进行分组
        val stringList1: List[String] = List("Hello Scala", "Hello World")
        println(stringList1.flatMap(_.split(" ")).groupBy((elem) => {
          elem.charAt(0)
        }))
    
      }
    
    }
    
    package chapter07
    
    object Test15_HighLevelFunction_Reduce {
      def main(args: Array[String]): Unit = {
        val list = List(1, 2, 3, 4)
    
        // 1. reduce
        println(list.reduce(_ + _))
        println(list.reduceLeft(_ + _))
        println(list.reduceRight(_ + _))
    
        println("===============================")
    
        /**
         * -24
         * -24
         * 6
         */
        val list2 = List(3, 4, 5, 8, 10)
        println(list2.reduce(_ - _))
        println(list2.reduceLeft(_ - _))
        println(list2.reduceRight(_ - _)) // (3-(4-(5-(8-10))))
    
        println("==============2. fold=================")
        // 2. fold
        /**
         * ==============2. fold=================
         * 20
         * 20
         * -5
         */
        println(list.fold(10)(_ + _))
        println(list.foldLeft(10)(_ + _))
        println(list2.foldRight(11)(_ - _)) // (3-(4-(5-(8-(10-10)))))
    
      }
    
    }
    
    
  5. 应用案例-合并Map

    package chapter07
    
    import scala.collection.mutable
    
    object Test16_MergeMap {
      def main(args: Array[String]): Unit = {
        // 遍历map1
        val map1 = Map("a" -> 1, "b" -> 3, "c" -> 6)
        // 更新map2
        val map2 = mutable.Map("a" -> 6, "b" -> 2, "c" -> 9, "d" -> 3)
    
        println(map1)
        println(map2)
    
        map1.foreach(elem => {
          val value1 = elem._2
          val value2 = map2.getOrElse(elem._1, 0)
          map2.update(elem._1, value1 + value2)
        })
    
        println(map2)
    
        map1.foldLeft(map2)(
          (mergedMap, kv) => {
            val key = kv._1
            val value = kv._2
            mergedMap.update(key, mergedMap.getOrElse(key, 0) + value)
            mergedMap
          })
    
        println(map2)
    
    
      }
    
    }
    
    
  6. 队列

    第7章 Scala集合

  7. 并行集合

    第7章 Scala集合文章来源地址https://www.toymoban.com/news/detail-498145.html

到了这里,关于第7章 Scala集合的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Scala集合 - List

    水善利万物而不争,处众人之所恶,故几于道💦 一、不可变List   1. 创建List   2. 取指定的数据   3. 向List中添加元素   4. 遍历List   5. 集合间合并 - 扁平化处理 二、可变List   1. 创建可变集合对象   2. 添加元素   3. 修改元素   4. 删除元素 1. 创建List   创建一个L

    2024年02月15日
    浏览(45)
  • 【Scala】集合

    目录 类型 不可变集合 可变集合 数组 不可变 可变数组 不可变数组与可变数组的转换 多维数组 List list运算符 可变 ListBuffer Set 集合 不可变 Set 可变 mutable.Set Map 集合 可变 Map 元组 操作 通用操作 衍生集合操作 计算函数 排序 sorted sortBy sortWith 计算高级函数 实例 WordCount 案例

    2023年04月09日
    浏览(40)
  • Scala集合

    scala中的集合分为两种 ,可变集合和不可变集合, 不可变集合可以安全的并发的访问! 集合的类主要在一下两个包中 可变集合包 scala.collection.mutable 不可变集合包 scala.collection.immutable 默认的 Scala 不可变集合,就是指该集合对象不可修改,每次修改就会返回一个新对象,而不会对

    2024年01月20日
    浏览(41)
  • Scala集合继承体系图

    1) Scala 的集合有三大类:序列 Seq、集Set、映射 Map,所有的集合都扩展自 Iterable特质。 2) 对于几乎所有的集合类,Scala 都同时提供了可变和不可变的版本,分别位于以下两个包 不可变集合:scala.collection.immutable 可变集合: scala.collection.mutable 3) Scala 不可变集合,就是指该

    2024年02月10日
    浏览(65)
  • Scala的队列与并行集合

    在 Scala 中,队列和并行集合是常用的数据结构和并发编程工具。 Scala 提供了可变和不可变两种队列。可变队列通过 scala.collection.mutable.Queue 类来实现,而不可变队列通过 scala.collection.immutable.Queue 类来实现。 可变队列可以动态添加、移除和检索元素,常用的方法包括 enqueue 和

    2024年02月10日
    浏览(43)
  • Scala集合常用函数 - 高级计算函数

    水善利万物而不争,处众人之所恶,故几于道💦   1. 过滤 - filter   2. 转换/映射 - map   3. 扁平化 - flatten   4. 扁平化+映射 - flatMap   5. 分组 - groupBy   6. 简化(规约) - reduce   7. 折叠 - fold   8. 函数小练习 1. 过滤 - filter  遍历一个集合并从中获取满足指定

    2024年02月17日
    浏览(44)
  • Scala集合常用函数 - 初级计算函数

    水善利万物而不争,处众人之所恶,故几于道💦   1. 求和   2. 求乘积   3. 最大值   4. 最小值   5. 排序     sorted     sortBy()     sortWith() 以List集合为例: 1. 求和 2. 求乘积 3. 最大值 4. 最小值 5. 排序 1. sorted  对一个集合进行自然排序,通过传递隐式的

    2024年02月16日
    浏览(36)
  • 认识spark,Scala简介

    Spark是一种基于内存的快速、通用、可扩展的大数据分析计算引擎。 是加州大学伯克利分校AMP实验室(Algorithms, Machines, and People Lab)开发的通用内存并行计算框架Spark得到了众多大数据公司的支持,这些公司包括Hortonworks、IBM、Intel、Cloudera、MapR、Pivotal、百度、阿里、腾讯、京

    2024年03月20日
    浏览(45)
  • 大数据之Scala简介

    学习Scala是因为Spark框架就是有Scala编写的,想学习Spark,首先需要对Scala有一定的了解。 Scala的语言特点: Scala是一门以Java虚拟机(JVM)为运行环境并将面向对象和函数式编程的最佳特性结合在一起的静态类型编程语言(静态语言需要提前编译的如:Java、c、c++等,动态语言如

    2024年02月02日
    浏览(36)
  • Scala简介和安装

    Scala是一种多范式的编程语言(多范式:多种编程方法的意思。有面向过程、面向对象、泛型、函数式四种程序设计方法),其设计的初衷是要集成面向对象编程和函数式编程的各种特性。Scala运行于Java平台(Java虚拟机),并兼容现有的Java程序 官网:https://www.scala-lang.org/

    2024年02月08日
    浏览(38)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包