2021-05-09

于 2021-05-09 15:51:55 发布
阅读量146 收藏
点赞数
分类专栏： 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)
  }
}
你看我在笑呢
关注
专栏目录
scala之Array方法
xiaoxionghanhan的博客
10-28 1805
scala之数组 val arr:Array[Int]=Array(1,2,3,4) //声明一个数组对象 val firstValue=arr(0) //读取第一个元素 arr(3)=100 //吧第四个元素替换为100 //所有元素乘2 val big=arr.map(_*2) val big=arr.map(x=>x*2) ++ 合并两个数组的所有元素 val a=Array(1,2) val b=Array(3,4) val c=a++b // (1,2,3,4) ++: 和++类似，多了
scala集合中添加元素_如何在Scala中获得列表的第一个元素？
cumt951045的博客
07-04 2608
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...
scala 列表List常用操作
wz_TXWY的博客
09-16 1571
列表常用操作 以下是列表常用的操作 判断列表是否为空（isEmpty） 拼接两个列表（++ :: ::: ） 获取列表的首个元素（head）和剩余部分(tail) 反转列表（reverse） 获取前缀（take）、获取后缀（drop） 扁平化（flaten） 拉链（zip）和拉开（unzip） 转换字符串（toString） 生成字符串（mkString） 并集（union）(合并,跟++...
scala-6 元组
a3125504x的博客
07-09 231
scala元组scala元组访问元组 scala元组 元组用来存储一组不同类型的值 元组中元素的类型和元组的值可以不同 元组中的元素一旦存储，其值不可以改变。即元组中元素的类型都是val 元组中的第一个元素角标为1 语法 // 使用括号来定义元组 val/var 元组变量名称 = (元素1, 元素2, 元素3....) // 使用箭头来定义元素 元组中每两个元素会组成一个元组 val/var 元组 = 元素1->元素2 示例 scala> val a =(1,"zhangsan",2,"l
Scala 列表 (list) 和 列表常用的操作
hongchenshijie的博客
01-17 3160
文章目录概念不可变列表概念定义语法代码示例可变列表概念定义语法格式代码示例可变列表的操作代码示例列表常用的操作判断列表是否为空代码示例拼接两个列表代码示例获取列表的首个元素和剩余部分代码示例反转列表代码示例获取列表前缀和后缀代码示例扁平化(压平)代码示例转换字符串代码示例生成字符串代码示例并集代码示例交集代码示例差集代码示例 概念 列表是scala中最重要的、也是最常用的数据结构。List具备以...
wegi_nogit_2021-05-09.tar.gz
05-09
在压缩包"wegi_nogit_2021-05-09.tar.gz"中，"home"这个文件名可能代表着EGI的示例或项目目录，通常包含了用于展示EGI功能和用法的代码、资源文件以及配置信息。开发者可以通过解压这个文件，学习如何在实际项目中...
Remake_save_2021-09-16T15.43 05.284Z.json
09-16
本人玩的修仙存档，固定天赋小盒子，重开129次，成就87个，事件50%，天赋75%。休闲次数大概7次，最多一次500岁，但是没渡劫。
** * @email * @date 2021-05-09 09:52:20 */怎么生成
06-17
在C++中，`* @email * @date 2021-05-09 09:52:20` 的格式看起来像是用于记录时间或者注释的一种自定义格式，通常在文档或者源代码中用于标记特定信息。如果你想生成这样的格式，你可能会创建一个简单的函数或宏来...
数据库系统概论(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
配置过的油猴插件
Scala基本语法之List
weixin_41244495的博客
07-02 355
// 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 1029
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...
Scala List使用事项
lingerxu的博客
08-17 1133
把Scala List的几种常见方法梳理汇总如下，日常开发场景基本上够用了。 创建列表 scala> val days = List(“Sunday”, “Monday”, “Tuesday”, “Wednesday”, “Thursday”, “Friday”, “Saturday”) days: List[String] = List(Sunday, Monday, Tuesday,
Scala集合和列表运算（一）
yyf960126的博客
04-27 1888
package aa object TestCollections { def main(args: Array[String]): Unit = { //Nil相当于空列表{ } List()=Nil //可以用head()和tail()方法分别访问一个列表的首元素和其余元素。 var colors=List("aa","bb","cc") println(...
scala List集合的用法
热门推荐
残缺的歌的专栏
07-22 4万+
一、前言： 人们常说，Scala是一个难掌握的语言，一是其面向函数和面向对象结合的原因，二是其丰富的语法和内置函数。 对于Conllection 这一章的内容，更多的是利用内置函数灵活地运用，避免自己重复造轮子（要求性能高除外） 对于集合，通常来说有以下几个常用操作是必须掌握的： 1.增删改查单个元素 2.单个集合的各种遍历方式 3.单个集合分拆组合与翻转
scala获取List中对象的某个字段的和
张音乐的博客
12-21 2491
val list = List[Map[String,String]](Map("id" -> "1","name" -> "李白","age" -> "18"),Map("id" -> "2","name" -> "李白2","age" -> "19"),Map("id" -> "2","name" -> "李白2","age" -> ""...
Scala List基本操作
残缺的孤独
12-15 4425
Scala List基本操作。
Spring Cloud 全面学习案例集，含多种功能示例与教程.zip
最新发布
11-14
1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值