Scala编程基础3 数组、映射、元组、集合

Scala编程基础3 数组、映射、元组、集合

小白的Scala学习笔记 2024/5/23 14:20

文章目录

  • Scala编程基础3 数组、映射、元组、集合
    • apply方法
    • 数组
      • yield
    • 数组的一些方法
    • 映射
    • 元组
    • 数据类型转换
    • 求和示例
    • 拉链
    • 集合
      • flatMap方法
    • Set
    • HashMap

apply方法

可以new，也可以不new，不new的时候就调用apply方法

B

class B {

  def add()={
    println("add")
  }
}

object B{
//是一个特殊方法，可以认为是构造方法，当没有new的时候，自动调用这个方法
  def apply()={
    new B()
  }
}

TestB

object TestB {
  def main(args: Array[String]): Unit = {
    val b=new B()
    b.add()

    val b1=B()
    b1.add()
  }
}

结果

在这里插入图片描述

数组

定长、变长

import scala.collection.mutable.ArrayBuffer

object Test14 {
  def main(args: Array[String]): Unit = {
    //定长
    //为什么不用new？ 实现任何都要new,因为有apply方法
    val array=Array("a","f","dd")
    println(array.toBuffer)

    //变长
    val array1 = new ArrayBuffer[String]()
    array1.append("aa1")
    array1.append("aa2")
    array1.append("aa3")
    array1.append("aa4")
    println(array1)
  }
}

用ArrayBuffer实现增删改查，主要目的是熟练语法

import java.util.Scanner
import scala.collection.mutable.ArrayBuffer

object TestArrayBuffer {
  val scanner = new Scanner(System.in)
  var array = new ArrayBuffer[String]()
  def add()={
    var addflag=true
    while (addflag){
      println("输入E退出")
      var input=scanner.nextLine()
      if(input.equals("E"))addflag=false
      else array.append(input)
    }
  }
  def delete()={
    println("请输入要删除的数据：")
    var delval=scanner.nextLine()
    val i = array.indexOf(delval)//找到要删除的值的序号
    if(i != -1)array.remove(i)
    else println("不存在该值")
  }
  def update()={
    println("请输入要修改的数据：")
    var updateval=scanner.nextLine()
    val i = array.indexOf(updateval)//找到要修改的值的序号
    if(i != -1){
      println("请输入新的值：")
      array(i)=scanner.nextLine()
    }
    else println("不存在该值")
  }
  def select()={
    for(elm <- array){
      println(elm)
    }
  }
  def main(args: Array[String]): Unit = {
    var isflag=true

    while (isflag){
      println()
      println("输入“quit”退出系统")
      println("1.添加 2.删除 3.修改 4.查询")
      var choiceType = scanner.nextLine()
      if(choiceType.equals("quit")){
        isflag=false
      }

      if(choiceType.equals("1"))add()
      if(choiceType.equals("2"))delete()
      if(choiceType.equals("3"))update()
      if(choiceType.equals("4"))select()
    }
  }
}

yield

对数组中每一个数进行处理

yield关键字将原始的数组进行转换会产生一个新的数组，原始的数组不变

object Test15 {
  def main(args: Array[String]): Unit = {
    val array = Array(5,6,7,8,9)
    val sm=for(elm <- array) yield elm*2

    sm.foreach(x => println(x))
    println("==============")
    array.foreach(x => println(x))
  }
}

数组的一些方法

object Test16 {
  def main(args: Array[String]): Unit = {
    val array = Array(3,5,34,62,2)
    array.foreach(x => println(x))//输出
    println("=================")
    
    val array2 = array.map(x => x+12)//每个值加12
    array2.foreach(x => println(x))
    println("=================")
    
    val array3 =array.sortBy(x => (-x))//按照-x值排序，结果是降序
    array3.foreach(x=>println(x))
    println("=================")
    
    array.reverse.foreach(x=>println(x))//反转
    println("=================")
    
    array.sorted.foreach(x=>println(x)) //排序
    println("=================")
    
    array.sorted.reverse.foreach(x=>println(x))//排序后反转，实现降序
    println("=================")
    
    println(array.reduce((a, b) => {println(a,b);  a+ b}))//全部值求和
  }
}

object Test18
{
  def main(args: Array[String]): Unit = {
    //没有new的话，不能追加，可以更改
    val array=Array("zhangsan,lisi","wangwu,zhaoliu")
    val stringses = array.map(x => x.split(","))//把每个值按”，“分开
    for (elm <- stringses)
      {
        for (i <- elm){
          println(i)
        }
      }
  }
}

映射

映射相当于java中的HashMap

不能追加、修改

object Test17 {
  def main(args: Array[String]): Unit = {
    //没有new的话是不能追加，也不能修改的
    val m=Map("22"->"zhangsan","33"->"lisi")
    println(m("22"))//取key为22的值

    for (elm <- m.keys)
      {
        println(elm,m(elm))
      }
  }
}

可以追加、修改

package com.oracle.jt
import scala.collection.mutable.Map//mutable包下的Map可以追加、修改

object Test19 {
  def main(args: Array[String]): Unit = {
    val map=Map[String,String]()
    map.+=(("22","zhangsan"))//添加值
    map.+=(("33","lisi"))
    map.+=(("44","jjfj"))

    map("44")="nnnn"//修改
    for (elm <- map.keys)
      {
        println(elm,map(elm))
      }

    val value1 = map.get("22")//如果输入的key不存在,就会报错
    println(value1.get)//返回值是Option

    val value2 =map.getOrElse("44","default")// 如果输入的key不存在,会输出default,不会报错
    println(value2)
  }
}

求单词出现次数

package com.oracle.jt
import scala.collection.mutable.Map

object Test21 {
  def main(args: Array[String]): Unit = {
    val str="hello,tom,jerry,tom,hello"
    val strings = str.split(",")//分割

    //变成（键，1）；按键分组，变成（键，（键，1））；变成（键，（键，1）取第二列、求和）
   val res= strings.map(x=>(x,1)).groupBy(x=>x._1).map(x=>(x._1,x._2.map(x=>x._2).sum))
    println(res)

    val tuples: Array[(String, Int)] = strings.map(x => (x, 1))//变成（键，1）
    val stringToTuples: Predef.Map[String, Array[(String, Int)]] = tuples.groupBy(x => x._1)//按键分组，变成（键，（键，1））
    val result: Predef.Map[String, Int] = stringToTuples.map(x => (x._1, x._2.map(x => x._2).sum))//变成（键，（键，1）取第二列、求和）
    println(result)
    
  }
}

元组

package com.oracle.jt

object TestYuanZu {
  def main(args: Array[String]): Unit = {
    val tuple=(2,3,4)
    println(tuple._1,tuple._2,tuple.x)

    val tuple2=(2.22,3.33)
    println(tuple2._2)

    val tuple3=("zhangsan","lisi")
    println(tuple3._2)

    val array=Array("zhangsan",2,44,"lisi",true,2.22)
    println(array(2))
  }
}

数据类型转换

直接to

package com.oracle.jt

object Test22 {
  def main(args: Array[String]): Unit = {
    // 2个元素的元组，可以看成kv对
    val list=Array(("22","zhangsan"),("33","lisi"))
    val map = list.toMap
    println(map)

    val s="444"
    val int = s.toInt
    println(int)

    val lng=3333933L;
    val int1 = lng.toInt
    println(int1)

    val float = lng.toFloat
    println(float)

    val a="23"
    val b="34"
    val sum = a.toInt + b.toInt
    println(sum)
  }
}

求和示例

package com.oracle.jt
import scala.collection.mutable.Map
object TestArray2 {
  def main(args: Array[String]): Unit = {
    //按 键 求和
    val array=Array(("22",12),("33",12),("22",244),("33",19))
    val stringToInt = array.groupBy(x => x._1).map(x => (x._1, x._2.map(x => x._2).sum))
    println(stringToInt)

    //也是求和，跟上面一样
    val map=Array(("2020-12-12",22),("2020-12-12",88),("2020-12-13",333),("2020-12-13",56))
    val stringToInt1 = map.groupBy(x => x._1).map(x => (x._1, x._2.map(x => x._2).sum))
    println(stringToInt1)

    //起始是字符串
    val order="2020-12-12,23#2020-12-12,55#2020-12-14,89#2020-12-14,66"
    val orderArray = order.split("#").map(x => x.split(","))
//    for(elm <- orderArray){
//      println(elm.toBuffer)
//    }
    val tuples: Array[(String, Int)] = orderArray.map(x => (x(0), x(1).toInt))//把Array转换成元组
    val stringToInt2 = tuples.groupBy(x => x._1).map(x => (x._1, x._2.map(x => x._2).sum))
    println(stringToInt2)

    // 求每个城市上网的浏览时间
    val session="济南,火狐,9#济南,谷歌,15#南宁,谷歌,60"
    val stringses: Array[Array[String]] = session.split("#").map(x => x.split(","))
    val stringToInt3: Predef.Map[String, Int] = stringses.map(x => (x(0), x(2).toInt)).groupBy(x => x._1).map(x => (x._1, x._2.map(x => x._2).sum))
    println(stringToInt3)
    val stringToInt4: Predef.Map[String, Int] = stringses.map(x => (x(1), x(2).toInt)).groupBy(x => x._1).map(x => (x._1, x._2.map(x => x._2).sum))
    println(stringToInt4)
  }
}

拉链

两个数组，下标相同的数据合成一个元组，形成一个新的数组

package com.oracle.jt

object TestLaLian {
  def main(args: Array[String]): Unit = {
    val array1=Array("zhangsan","lisi")
    val array2=Array("你好","你坏")
    val tuples: Array[(String, String)] = array1.zip(array2)
    tuples.foreach(x=>println(x))
  }
}

集合

Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质

在Scala中集合有可变（mutable）和不可变（immutable）两种类型，immutable类型的集合初始化后就不能改变了（注意与val修饰的变量进行区别）

flatMap方法

object TestList1 {
  def main(args: Array[String]): Unit = {
    //拉平，把每个元素分隔开，存到一个新的List中
    val list = List("hello,tom","hello,jerry","tom,marry")
    val strings: List[String] = list.flatMap(x => x.split(","))
    strings.foreach(x=>println(x))
    //结果：hello,tom,hello,jerry,tom,marry

    println("+++++++++++++++++")
    //分割成每个元素后，每个元素变成kv对（元组）
    val array=List("hello#tom","hello#jerry","tom#marry")
    val tuples: List[(String, Int)] = array.flatMap(x => x.split("#")).map(x => (x, 1))
    tuples.foreach(x=>println(x))
    //结果：(hello,1)
    //(tom,1)
    //(hello,1)
    //(jerry,1)
    //(tom,1)
    //(marry,1)
  }
}

import scala.collection.mutable.ListBuffer

object TestList2 {
  def main(args: Array[String]): Unit = {
    val listBuffer = new ListBuffer[String]()//能追加元素
    listBuffer.+=("hello jerry")
    listBuffer.++=(Array("hello marry","tom jerry"))
    listBuffer.foreach(x=>println(x))

    //统计单词出现次数
    val tuples: ListBuffer[(String, Int)] = listBuffer.flatMap(x => x.split(" ")).map(x => (x, 1))
    val res = tuples.groupBy(x => x._1).map(x => (x._1, x._2.map(x => x._2).sum))
    res.foreach(x=>println(x))
  }
}

Set

object TestSet1 {
  def main(args: Array[String]): Unit = {
    val set=Set(1,1,2,90,2)//去重了，所以只有1,2,90
    println(set.sum)
    //93
    println("=======================")
    set.foreach(x=>println(x))
    //1
    //2
    //90
    println("=======================")
    set.map(x=>x*3).foreach(x=>println(x))
    //3
    //6
    //270
    println("=======================")
    println(set.reduce((a, b) => a * b))//累乘的结果
    //180
  }
}

import scala.collection.mutable

object TestSet2 {
  def main(args: Array[String]): Unit = {
    val set: mutable.HashSet[String] = new mutable.HashSet[String]()
    set.+=("u01,zhangsan")
    set.+=("u02,lisi")
    set.+=("u01,zhangsan")
    set.foreach(x=>println(x))
    val uNumber: mutable.HashSet[String] = set.map(x => x.split(",")).map(x => x(0))//把用户id取出来
    println(uNumber.size)
    println(set.size)

    println("=================")
    val ss=new mutable.HashSet[Int]()
    ss.add(4)//添加元素
    ss.+=(9)//添加元素
    ss.foreach(x=>println(x))
    ss.-=(9)//删除元素
    ss.foreach(x=>println(x))

  }
}

HashMap

import scala.collection.mutable
object TestHashMap1 {
  def main(args: Array[String]): Unit = {
    val map = new mutable.HashMap[String,Int]()
    map.+=(("22",1))//添加数据
    map.+=(("23",44))
    map.put("21",99)
    map.foreach(x=>println(x))
    val ints: mutable.Iterable[Int] = map.map(x => x._2)
    ints.foreach(x=>println(x))
    val tuple: (String, Int) = map.reduce((x, y) => (x._1, x._2 + y._2))
    println(tuple)
  }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/662145.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

《STM32Cube高效开发教程基础篇》- 安装软件/Demo3_1LED

《STM32Cube高效开发教程基础篇》- 安装软件/Demo3_1LED

文章目录 下载两个软件安装问题记录在STM32CubeMX中新建项目编辑代码在CudeMX中完成图形化设置在CudeIdea中编码在CLion中编码&#xff08;智能化&#xff09; 效果图 下载两个软件 百度网盘链接&#xff1a;https://pan.baidu.com/s/1uXLWIIVCJbF4ZdvZ7k11Pw 提取码&#xff1…
阅读更多...
Vue3使用Composition API实现响应式

Vue3使用Composition API实现响应式

title: Vue3使用Composition API实现响应式 date: 2024/5/29 下午8:10:24 updated: 2024/5/29 下午8:10:24 categories: 前端开发 tags: Vue3CompositionRefsReactiveWatchLifecycleDebugging 1. 介绍 Composition API是Vue.js 3中新增的一组API&#xff0c;用于在组件中组…
阅读更多...
DNF手游攻略：开荒必备攻略！

DNF手游攻略：开荒必备攻略！

DNF手游马上就要开服了&#xff0c;今天给大家带来最完整的DNF手游入门教程。这篇攻略主要讲述了 DNF手游开服第一天要注意的事项&#xff0c;这是一个新手必备的技能书&#xff0c;可以让你在开服的时候&#xff0c;少走一些弯路&#xff0c;让你更快完成任务&#xff01;废话…
阅读更多...
深度学习创新点不大但有效果，可以发论文吗？

深度学习创新点不大但有效果，可以发论文吗？

深度学习中创新点比较小&#xff0c;但有效果&#xff0c;可以发论文吗&#xff1f;当然可以发&#xff0c;但如果想让编辑和审稿人眼前一亮&#xff0c;投中更高区位的论文&#xff0c;写作永远都是重要的。 那么怎样“讲故事”才能让论文更有吸引力&#xff1f;我总结了三点…
阅读更多...
富途面试题：用面向对象的思想设计人关门的场景

富途面试题：用面向对象的思想设计人关门的场景

我工作两年后&#xff0c;有一次不成功的富途证券的面试&#xff0c;印象非常深刻&#xff0c;面试官提出了一个看似简单实则充满深意的问题&#xff1a;如何用面向对象的思想设计一个人关门的场景&#xff1f; 我当时是这样设计的&#xff0c;创建两个类&#xff1a;Person和D…
阅读更多...
多语言印度红绿灯系统源码带三级分销代理功能

多语言印度红绿灯系统源码带三级分销代理功能

前端为2套UI&#xff0c;一套是html写的&#xff0c;一套是编译后的前端 后台功能很完善&#xff0c;带预设、首充返佣、三级分销机制、代理功能。 东西很简单&#xff0c;首页就是红绿灯的下注页面&#xff0c;玩法虽然单一&#xff0c;好在不残缺可以正常跑。
阅读更多...
短视频脚本创作的五个方法 沈阳短视频剪辑培训

短视频脚本创作的五个方法 沈阳短视频剪辑培训

说起脚本&#xff0c;我们大概都听过影视剧脚本、剧本&#xff0c;偶尔可能在某些综艺节目里听过台本。其中剧本是影视剧拍摄的大纲&#xff0c;用来指导影视剧剧情的走向和发展&#xff0c;而台本则是综艺节目流程走向的指导大纲。 那么&#xff0c;短视频脚本是什么&#xf…
阅读更多...
XV7011BB可为智能割草机的导航系统提供新的解决方案

XV7011BB可为智能割草机的导航系统提供新的解决方案

智能割草机作为现代家庭和商业草坪维护保养的重要工具&#xff0c;其精确的定位和导航系统对于提高机器工作效率和确保安全运行至关重要。在智能割草机的发展历程中&#xff0c;定位和导航技术一直是关键的创新点。 传统的基于RTK(实时动态差分定位技术)技术的割草机虽然在…
阅读更多...
mysql连接不上可能的原因：防火墙放行mysql的3306端口 全库复制：data目录替换即可 mysql查看版本

mysql连接不上可能的原因：防火墙放行mysql的3306端口 全库复制：data目录替换即可 mysql查看版本

1.看本地localhost能否连接 2.在本地看IP能否连接 能说明本地正常 权限也够 都能的话&#xff0c;ip能否ping通 能就说明可能是防火墙原因了。关闭防火墙及杀毒试试。 我这里关防火墙就能访问了。 windows如何开启防火墙&#xff0c;又放行mysql的3306端口&#xff1f; 在 …
阅读更多...
可视化大屏也在卷组件化设计了？分享一些可视化组件

可视化大屏也在卷组件化设计了？分享一些可视化组件

hello&#xff0c;我是大千UI工场&#xff0c;这次分享一些可视化大屏的组件&#xff0c;供大家欣赏。&#xff08;本人没有源文件提供&#xff09;
阅读更多...
微前端（无界）入门

微前端（无界）入门

主应用通过props给子应用传值 父子应用通过eventBus通信 通过路由同步实现记录子应用的路由状态 主应用 main.ts: import ./assets/main.cssimport { createApp } from vue import { createPinia } from pinia import WujieVue from wujie-vue3import App from ./App.vue impo…
阅读更多...
STM32 OTA需要注意问题

STM32 OTA需要注意问题

一、OTA设计思路&#xff08;问题&#xff09; 1、根据stm32f405 flash分布&#xff0c;最初将flash划分为四个区域&#xff0c;分别是Bootloader、APP1、APP2、参数区&#xff0c;设备上电后&#xff0c;进入Bootloader程序&#xff0c;判断OTA参数&#xff0c;根据参数来确定…
阅读更多...
长方形边框 上方中间有缺口 css

长方形边框 上方中间有缺口 css

<div class"text_6">大234234师掌4234柜</div><div class"text-wrapper_1"><span class"paragraph_1">四川慧创云戈科技有限公司推出的“大师掌柜”&#xff0c;是一个以餐饮外卖为切入口&#xff0c;专注实体小店新零售…
阅读更多...
实验七 RTP、DSPP协议的配置

实验七 RTP、DSPP协议的配置

一、实验目的 掌握 RIP 动态路由协议的配置、诊断方法。 二、实验步骤 1、 运行 Cisco Packet Tracer 软件&#xff0c;在逻辑工作区放入两台路由器、两台工作站 PC&#xff0c;分别点击各路由器&#xff0c;打开其配置窗口&#xff0c;关闭电源&#xff0c;分别加入一个 2 …
阅读更多...
PowerPivot-跨表取值

PowerPivot-跨表取值

在PowerPivot中&#xff0c;跨表取值通常涉及创建关系和使用DAX&#xff08;数据分析表达式&#xff09;函数。 以下是一些基本步骤和常用的DAX函数&#xff0c;帮助你在PowerPivot中实现跨表取值&#xff1a; 步骤1&#xff1a;创建关系 加载数据&#xff1a;确保你已将需要…
阅读更多...
吃透一道题day2：Java算法中的“如何找到给定字符串中的不同字符“

吃透一道题day2：Java算法中的“如何找到给定字符串中的不同字符“

写在开头&#xff1a;很久没有开启有关算法的内容了,在正式开启开启今天这段算法之旅之前,跟大家谈一谈上周五歌手也就是第二期我的一些直观感受:相比第一期(chante moore的if i aint got you和faouzia的crazy带给我的经验)没有任何特别的惊艳之处,很平淡甚至可以说是心如止水,…
阅读更多...
E. Binary Deque[双指针好思维题]

E. Binary Deque[双指针好思维题]

Binary Deque 题面翻译 有多组数据。 每组数据给出 n n n 个数&#xff0c;每个数为 0 0 0 或 1 1 1 。你可以选择从两边删数&#xff0c;求至少删几个数才可以使剩下的数总和为 s s s 。 如果不能达到 s s s &#xff0c;则输出 − 1 -1 −1 。 题目描述 Slavic h…
阅读更多...
性能测试（基于Jmeter）

性能测试（基于Jmeter）

性能指标 RT&#xff08;Response Time&#xff09;响应时间&#xff1a;指的是用户从客户端发起请求开始到服务端返回结束&#xff0c;整个过程所耗费的时间 HPS&#xff08;Hits Per Second&#xff09;&#xff1a; 每秒点击次数&#xff0c;单位&#xff1a;次/秒 TPS&am…
阅读更多...
Element-Plus中表格及分页功能

Element-Plus中表格及分页功能

导入Element-Plus 具体步骤如下&#xff1a;&#xff08;内容参照官网&#xff1a;安装 | Element Plus&#xff09; # 选择一个你喜欢的包管理器# NPM $ npm install element-plus --save# Yarn $ yarn add element-plus# pnpm $ pnpm install element-plus 在main.js文件的…
阅读更多...
树与图的深度优先遍历

树与图的深度优先遍历

数和图的存储方式与遍历 数和图的存储方式&#xff1a; 一般有两种 树是一种特殊的图&#xff08;即无环联通图&#xff09;。所以下面只讲图。 图的话分为两种&#xff1a;①有向图&#xff08;边是有方向的&#xff1a;a➡️b&#xff09;和 ②无向图&#xff08;边是无方…
阅读更多...
最新文章

Copyright @ 2022~2023