2021-05-09

最新推荐文章于 2022-03-11 15:51:27 发布
最新推荐文章于 2022-03-11 15:51:27 发布
阅读量105 收藏
点赞数
分类专栏： Scala
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57124899/article/details/116565608
版权

@Scala Day05

可变数组:
ArrayBuffer
创建:
1. ArrayBuffer(1,2,3)
2. new ArrayBufferInt

:+
+:
++

一般用于可变集合, 表示原地修改集合
+= 尾部
+=: 头部

++= 把后面的集合的元素合并到前面的集合中
++=:
-= 删除元素, 只删除满足的第一个 (set用的比较多)
–= 求差集

package com.syf.scala1015day05
import scala.collection.mutable.ArrayBuffer

/**
  * Author Amily
  * Date 2021/5/9
  */
object Array2 {
  def main(args: Array[String]): Unit = {
    // ArrayBuffer.apply(1,2,3,4)
    //        val buffer2 = new ArrayBuffer[Int]()

    val buffer1: ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4, 1)
    val buffer2: ArrayBuffer[Int] = ArrayBuffer(1, 2, 30, 40)
//       val b2 = 100 +: buffer1 :+ 10
//        println(buffer1)
// 原地修改buffer1, 在他的尾部添加元素
//        buffer1 += 100
//        200 +=: buffer1  //
//        println(buffer1)

//        val b3 = buffer1 ++ buffer2

//        buffer1 ++= buffer2  // 把buffer2 的集合追加到buffer1的后面, 更新的是buffer1
// buffer2.++:(buffer1)
//        buffer1 ++=: buffer2  // 把buffer1的元素添加到buffer2的前面, 更新的是buffer2

//        buffer1 -= 1

//        buffer1 --= buffer2
//        buffer1 -= (1,2,3)  // 已经不推荐使用了

    //        println(buffer1)


  }
}


package com.syf.scala1015day05
import scala.collection.mutable
import scala.collection.mutable.ArrayBuffer

/**
  * Author Amily
  * Date 2021/5/9
  */
object Array3 {
  def main(args: Array[String]): Unit = {
    //        val arr1 = Array(30, 50, 70, 60, 10, 20)
    //        val buffer: mutable.Buffer[Int] = arr1.toBuffer
    //        println(buffer)

    val b: ArrayBuffer[Int] = ArrayBuffer(10, 20)
    println(b.toArray.mkString(","))
  }
}


package com.syf.scala1015day05
/**
  * Author Amily
  * Date 2021/5/9
  */
object Array4 {
  def main(args: Array[String]): Unit = {
    // 多维数组  (二维数组), 假的, 用一维数组模拟的多维数组
    // 2 * 3的
    val arr: Array[Array[Int]] = Array.ofDim[Int](2, 3)
    //        println(arr(0)(1))
    for (a1 <- arr) {
      for (elem <- a1) {
        println(elem)
      }
    }
  }
}

List
就是列表
默认不可变

List专用:
:: 在头部添加元素
::: 合并两个List

package com.syf.scala1015day05

object List1 {
  def main(args: Array[String]): Unit = {
    // 1.创建有元素的集合
    val l1 = List(1, 2, 3)
    // 2. 空List
    val l2 = List[Int]()
    // 3. 空集合
    val l3 = Nil
    // 4. 向List添加元素
    //        val l4 = 200 +: l1 :+ 100


    val l4 = 200 :: 100 :: l1
    println(l4)
  }
}

package com.syf.scala1015day05

object List2 {
  def main(args: Array[String]): Unit = {
    //        val list1 = List(30, 50, 70, 60, 10, 20)
    //        val list2 = List(3, 5, 7, 6, 1, 2)
    //        val list3 = list1 ++ list2
    //        val list3 = list1 ::: list2  // === list2.:::(list1)
    //        println(list3)
    // 有人用过
    val l1 = ::[Int](1, 1 :: Nil)
    println(l1)
  }
}

+=
++=
一般只能用于可变结合

其实也可以用户不可变集合
是产生换一个新的不可变集合, 然后把新的不可变集合赋值变量

package com.syf.scala1015day05

import scala.collection.mutable.ArrayBuffer

/**
  * Author atguigu
  * Date 2020/3/7 9:48
  */
object List3 {
  def main(args: Array[String]): Unit = {
    var arr1 = ArrayBuffer(30, 50, 70, 60, 10, 20)
    println(System.identityHashCode(arr1))
    arr1 :+= 100
    println(System.identityHashCode(arr1))

    println(arr1.mkString(", "))
  }
}

Map映射
默认不可变, 具体的实现是HashMap

scala的Map, 把键和值当做元组(对偶)来处理

package com.syf.scala1015day05
/**
  * Author Amily
  * Date 2021/5/9
  */
object Map1 {
  def main(args: Array[String]): Unit = {
    //        val map1: Map[String, Int] = Map[String, Int](("a", 97), ("b", 98), ("c", 99), ("d", 98))
    /*for (kv <- map1) {
        println(kv)
    }*/

    /*for (kv <- map1) {
        println(kv._1)
    }*/

    /*for ((k, _) <- map1) {
        println(k)
    }*/

    /*for ((k, 98) <- map1) {
        println(k)
    }*/
  }
}

package com.syf.scala1015day05
/**
  * Author Amily
  * Date 2021/5/9
  */
object Map2 {
  def main(args: Array[String]): Unit = {
    val map1: Map[String, Int] = Map[String, Int](
      "a" -> 97,
      "x"-> 0,
      "b" -> 98,
      "c" -> 99)
    val map2: Map[String, Int] = Map[String, Int](
      "a" -> 970,
      "z"->1,
      "b" -> 980,
      "c" -> 990)

    //        val map2 = map1 + ("a" -> 102)
    val map3 = map1 ++ map2
    println(map3)

  }
}

package com.syf.scala1015day05
/**
  * Author Amily
  * Date 2021/5/9
  */
object Map3 {
  def main(args: Array[String]): Unit = {
    val map1: Map[String, Int] = Map[String, Int](
      "a" -> 97,
      "x" -> 0,
      "b" -> 98,
      "c" -> 99)
    // 根据key获取值
    //        val v1: Int = map1("a")
    //        val v1: Int = map1("f")  // 会抛异常
    //        val v1= map1.get("f")
    // 存在就返回对应的value, key不存在, 就返回默认值
    val v1 = map1.getOrElse("f", 100)
    println(v1)
  }
}


package com.syf.scala1015day05

import scala.collection.mutable

/**
  * Author Amily
  * Date 2021/5/9
  */
object Map4 {
  def main(args: Array[String]): Unit = {
    val map1: mutable.Map[String, Int] = mutable.Map[String, Int](
      "a" -> 97,
      "x" -> 0,
      "b" -> 98,
      "c" -> 99)
    //        map1 += (("aa", 100))
    //        map1 += "aa"-> 100
    //        val v1 = map1.getOrElse("f", 100)
    // 如果key'不存在, 则会组合一个新的kv, 添加到可变的map中
    //        val v1 = map1.getOrElseUpdate("f", 100)
    //        println(v1)
    map1("a") = 100  // 更加scala
    map1("f") = 100
    map1.update("dd", 200) // 更加java
    println(map1)
  }
}

拉链:

package com.syf.scala1015day05
/**
  * Author Amily
  * Date 2021/5/9
  */
object Zip1 {
  def main(args: Array[String]): Unit = {
    val list1 = List(30, 50, 70, 60, 10)
    val list2 = List(3, 5, 7, 6, 1, 2)
    // 1. 多余的会被抛弃
    //        val list3: List[(Int, Int)] = list1.zip(list2)
    // 2. 多余会使用默认值来进行匹配
    //        val list3: List[(Int, Int)] = list1.zipAll(list2, -1, -2)
    // 3. 和自己的索引进行zip
    val list3: List[(Int, Int)] = list1.zipWithIndex
    for ((e,i) <- list3) {
      println(i)
    }

    println(list3)
  }
}


package com.syf.scala1015day05
/**
  * Author Amily
  * Date 2021/5/9
  */
package com.atguigu.scalal1015.day05.collections
object Zip2 {
  def main(args: Array[String]): Unit = {
    val list = Map("a" -> 1, "b" -> 2, "c" -> 3)
    // list中存储的是二维的元组的时候, 才能使用unzip
    val t= list.unzip
    println(t)

  }
}

队列:
FIFO
提供了两个专门操作队列的元素:
入队
出队

栈:
FILO
专门操作栈的元素
push 入栈
pop 出栈

 栈顶和栈底

package com.syf.scala1015day05

import scala.collection.mutable
/**
  * Author Amily
  * Date 2021/5/9
  */
object Queue1 {
  def main(args: Array[String]): Unit = {
    /*val q1: mutable.Queue[Int] = mutable.Queue[Int](10, 20, 30)
    q1.enqueue(100, 200)
    val v = q1.dequeue()
    println(q1)
    println(v)*/
    val s1: mutable.Stack[Int] = mutable.Stack[Int](10, 20, 30)
    println(s1)
    val p: Int = s1.pop()
    s1.push(100)
    val p2: Int = s1.pop()
    println(p2)

  }
}

foreach和部分应用函数

package com.syf.scala1015day05
/**
  * Author Amily
  * Date 2021/5/9
  */
object ForeachDemo1 {
  def main(args: Array[String]): Unit = {
    val list1 = List(30, 50, 70, 60, 10, 20)
    //        list1.foreach(x => println(x))
    list1.foreach(println)

    list1.foreach(println(_))

  }
}

filter操作

package com.syf.scala1015day05

object FilterDemo1 {
  def main(args: Array[String]): Unit = {
    val list1 = List(30, 5, 7, 60, 1, 20)
    //        val list2 = list1.filter(x => x % 2 == 1)
    val list2 = list1.filter(_ % 2 == 1)
    println(list2)

  }
}

reduce

package com.syf.scala1015day05

object ReduceDemo1 {
  def main(args: Array[String]): Unit = {
    // 聚合操作
    val list1 = List(30, 50, 70, 60, 10, 20)
    //        val result: Int = list1.reduce((x, y) => x + y)
    //        val result: Int = list1.reduce(_ + _)
    val result: Int = list1.reduceRight(_ + _)
    println(result)
  }
}

groupby的使用

package com.syf.scala1015day05
/**
  * Author Amily
  * Date 2021/5/9
  */
object GroupByDemo1 {
  def main(args: Array[String]): Unit = {
    /*val list1 = List(30, 5, 7, 60, 1, 20)
    val map = list1.groupBy(x => if(x % 2 == 0) "偶数" else "奇数")
    println(map)*/

    val list1 = List("hello", "hello", "world", "atguigu", "hello", "world")
    val wordMap: Map[String, List[String]] = list1.groupBy(x => x)
    // 对wordMap做一个结构调整
    val wordCount = wordMap.map(kv => {
      (kv._1, kv._2.size)
    })
    println(wordCount)

  }
}

WordCoun1

package com.syf.scala1015day05
import scala.io.Source
/**
  * Author Amily
  * Date 2021/5/9
  */
object WordCoun1 {
  def main(args: Array[String]): Unit = {
    // 读取一个文件的内容, 统计这个文件中,每个单词出现的次数
    val path =
      """C:\Users\lzc\Desktop\class_code\2019_10_15\01_scala\scala1015\src\main\scala\com\atguigu\scalal1015\day05\high\WordCoun1.scala"""
    // 1. 读文件内容, 放入到集合中   文件中的每一行
    val lines = Source.fromFile(path, "utf-8").getLines().toList
    // 2. 切割单词 使用非单词字符
    val words = lines.flatMap(_.split("\\W+"))
    // 3. 把相同的单词分组
    val wordGrouped = words.groupBy(w => w)
    // 4. 进行map, 计算每个单词的个数
    /*val wordCount = wordGrouped.map(kv => {
        (kv._1, kv._2.size)
    })*/
    //        val wordCount =wordGrouped.mapValues(v => v.size)
    val wordCount = wordGrouped.mapValues(_.size)
    // 按照单词的数量降序, 取top3
    val result = wordCount.toList.sortBy(_._2)(Ordering.Int.reverse).take(3)
    println(result)
  }
}

WordCoun2

package com.syf.scala1015day05

import scala.io.Source

/**
  * Author Amily
  * Date 2021/5/9
  */
object WordCoun2 {
  def main(args: Array[String]): Unit = {
    // 读取一个文件的内容, 统计这个文件中,每个单词出现的次数
    val path = """C:\Users\lzc\Desktop\class_code\2019_10_15\01_scala\scala1015\src\main\scala\com\atguigu\scalal1015\day05\high\WordCoun1.scala"""
    // 1. 读文件内容, 放入到集合中   文件中的每一行
    val lines = Source.fromFile(path, "utf-8").getLines().toList
    // 2. 切割单词 使用非单词字符
    val words = lines.flatMap(_.split("\\W+")).filter(_.length > 0)
    // 3. 把相同的单词分组
    val wordGrouped = words.groupBy(w => w)
    // 4. 进行map, 计算每个单词的个数
    /*val wordCount = wordGrouped.map(kv => {
        (kv._1, kv._2.size)
    })*/
    //        val wordCount =wordGrouped.mapValues(v => v.size)
    val wordCount =wordGrouped.mapValues(_.size)

    println(wordCount)
  }
}

WordCoun3

package com.syf.scala1015day05
/**
  * Author Amily
  * Date 2021/5/9
  */
object WordCount3 {
  def main(args: Array[String]): Unit = {
    val tupleList = List(
      ("Hello hello Scala Spark World", 4),
      ("Hello Scala Spark", 3),
      ("Hello Scala", 2),
      ("Hello", 1))
    // Map(hello-> .., scala->...)
    // 方法: 1
    /*val result = tupleList
        .map(kv => (kv._1 + " ") * kv._2)
        .flatMap(_.split(" "))
        .filter(_.length > 0)
        .groupBy(x => x)
        .mapValues(_.length)*/

    // 方法2: (hello,4), (hello, 4), ...
    val wordCoun1: List[(String, Int)] = tupleList.flatMap(kv => {
      val line = kv._1 // "Hello hello Scala Spark World"
      val count = kv._2 // 4
      //            line.split(" ").map(x => (x, count))
      line.split(" ").map((_, count))
    })
    println(wordCoun1)
    val wordCount1Group = wordCoun1.groupBy(_._1.toLowerCase)

    val result = wordCount1Group.mapValues(wordCountList => {
      wordCountList.foldLeft(0)(_ + _._2)
    })
    println(result)
  }
}
你看我在笑呢
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
scala集合中添加元素_如何在Scala中获得列表的第一个元素？
cumt951045的博客
07-04 2551
scala集合中添加元素 清单 (List) A list is a linear data structure. It is a collection of elements of the same data types. 列表是线性数据结构。 它是相同数据类型的元素的集合。 Scala libraries have many functions to support the functio...
wegi_nogit_2021-05-09.tar.gz
05-09
EGI是一款开源嵌入式GUI, 简单好玩。用它可以来开发一些简单图形小界面,同时支持加入声效背景，GIF动画等。EGI是在WidoraNEO硬件环境下开发的，也可以在其它Linux系统下运行。
Scala基本语法之List
weixin_41244495的博客
07-02 320
// List代表一个不可变的列表// List的创建，val list = List(1, 2, 3, 4)// List有head和tail，head代表List的第一个元素，tail代表第一个元素之后的所有元素，list.head，list.tail// List有特殊的::操作符，可以用于将head和tail合并成一个List，0 :: list// ::这种操作符要清楚，在spark源码...
scala之list用法史上最全
热门推荐
JasonLee实时计算
12-09 1万+
Scala 列表类似于数组，它们所有元素的类型都相同，但是它们也有所不同：列表是不可变的，值一旦被定义了就不能改变，其次列表 具有递归的结构（也就是链接表结构）而数组不是 下面是list的常用方法,当然了这不是所有的.但都是最常用的.具体看下面的demo.具体可以看代码里面的注释 package test object listDemo { def main(args: Array[S...
set scala添加元素_如何从Scala中的Set获取第一个元素？
cumubi7552的博客
07-03 983
set scala添加元素 Scala集 (Scala Set) A set in Scala is a collection of unique elements i.e. duplicate elements are not allowed in the Set. Scala中的集合是唯一元素的集合，即，集合中不允许重复元素。 Example: 例： Set(10, 3, 21...
2021-05-05
樊金良的博客
05-05 646
你需要努力，fighting！
2021-09-05
leopardpig的博客
03-11 2898
机器学习随记 用densenet深度学习 进行到最后训练模型时
2021-01-18
weixin_54641072的博客
01-18 1728
找程序猿哥哥！！！！编制App或者小程序
格式化时间 将2021-09-05T09:08:03.000Z 转换成 YYYY-MM-DD HH:mm:ss 格式
m0_58861443的博客
09-05 3747
格式化时间 将2021-09-05T09:08:03.000Z 转换成 YYYY-MM-DD HH:mm:ss 格式 1.引入第三方包 dayjs (一个轻量的处理时间和日期的javascript库) （1）下载 npm install/ i dayjs --save (2). main.js 中全局引入 `import dayjs from 'dayjs Vue.prototype.dayjs=dayjs' 2 时间转换函数 timeTranslate (val) {
js中new Date()获取的标准时间 转换成 例如: 2021-05-07
wei80231996的博客
05-07 4648
//调用 let valueData = this.timeFormat(new Data()) console.log(valueData,'当前时间字符串') timeFormat(time) { // 时间格式化 2019-09-08 let year = time.getFullYear(); let month = time.getMonth() + 1 > 10 ? time.getMonth()+1 : '0'+(time.getMonth()+1.
Remake_save_2021-09-16T15.43 05.284Z.json
09-16
本人玩的修仙存档，固定天赋小盒子，重开129次，成就87个，事件50%，天赋75%。休闲次数大概7次，最多一次500岁，但是没渡劫。
数据库系统概论(2021-09-07-22-05-14).mmap
09-07
数据库系统概论(2021-09-07-22-05-14).mmap
tampermonkey-backup-chrome-2021-11-27T01-27-17-766Z.zip
11-27
配置过的油猴插件
查询所有Redis集群配置信息-data-2021-05-06 09_56_40.zip
05-06
查询所有Redis集群配置信息-data-2021-05-06 09_56_40.zip
一个c语言编写的sock5代理工具.zip
06-13
一个c语言编写的sock5代理工具
基于PHP的同城拼车平台（完整带PHP后台）.zip
06-13
基于PHP的同城拼车平台（完整带PHP后台） 在繁忙的都市生活中，同城拼车已成为一种既环保又经济的出行方式。为了满足广大用户的需求，我们推出了这款基于PHP的同城拼车平台，旨在为用户提供一个便捷、安全、可靠的拼车服务体验。 平台特色： 完整后台系统：平台配备了完整的PHP后台管理系统，管理员可以轻松管理用户信息、拼车订单、车辆信息等，确保平台的稳定运行和数据的准确性。 用户友好界面：简洁明了的界面设计，使用户能够快速上手并享受拼车服务。用户可以轻松发布拼车需求，查找合适的拼车伙伴，实现快速出行。 安全可靠：平台采用先进的加密技术和严格的数据管理措施，确保用户信息和交易数据的安全。同时，平台还设有严格的用户审核机制，确保拼车伙伴的可靠性。 智能匹配：平台通过智能算法，根据用户的出发地、目的地、时间等信息，为用户推荐最合适的拼车伙伴，提高拼车成功率。 实时通讯：平台支持用户之间的实时通讯功能，方便用户在拼车过程中进行交流和沟通，确保行程的顺利进行。 总结： 这款基于PHP的同城拼车平台以其完整的后台系统、用户友好界面、安全可靠的性能、智能匹配和实时通讯功能，为广大用户提供了一个优质
一个用C语言编写的学生信息管理系统，学生数据保存在文本文件中.zip
最新发布
06-13
一个用C语言编写的学生信息管理系统，学生数据保存在文本文件中
pyzmq-22.1.0-cp38-cp38-manylinux2010_i686.whl
06-13
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
逗号分隔的多个数据，每个数据项由#分隔的四个小项构成。 # 第一个为题号；第二个为时间；第三个为操作类型，可能的取值：12、11、10--读题，空值-作答；第四个为科目。 data = '''1#2021-05-18 14:31:55##初级会计实务,2#2021-05-18 14:31:57#12#初级会计实务,2#2021-05-18 14:32:08##初级会计实务,3#2021-05-18 14:32:09#12#初级会计实务,4#2021-05-18 14:32:34#12#初级会计实务,4#2021-05-18 14:32:45##初级会计实务,5#2021-05-18 14:32:46#12#初级会计实务,5#2021-05-18 14:32:57##初级会计实务,6#2021-05-18 14:33:00#12#初级会计实务,7#2021-05-18 14:33:44#12#初级会计实务,7#2021-05-18 14:34:42##初级会计实务,8#2021-05-18 14:34:43#12
06-10
data = '''1#2021-05-18 14:31:55##初级会计实务,2#2021-05-18 14:31:57#12#初级会计实务,2#2021-05-18 14:32:08##初级会计实务,3#2021-05-18 14:32:09#12#初级会计实务,4#2021-05-18 14:32:34#12#初级会计实务,4#...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值