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

news2024/9/23 21:21:21

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)
  }
}

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

大学搜题软件音乐类？分享三个支持答案和解析的工具 #微信#媒体

大学搜题软件音乐类？分享三个支持答案和解析的工具 #微信#媒体

高效的学习工具可以帮助我们提高记忆力和理解能力&#xff0c;使知识更加深入人心。 1.彩虹搜题 这是个微信公众号 一款专门供全国大学生使用的查题神器!致力于帮助大学生解决学习上的难题,涵盖了大学生学习所需的学习资料。 下方附上一些测试的试题及答案 1、甲、乙合伙开…
阅读更多...
算法工程师需要学习C++的哪些知识？

算法工程师需要学习C++的哪些知识？

在开始前刚好我有一些资料&#xff0c;是我根据网友给的问题精心整理了一份「C的资料从专业入门到高级教程」&#xff0c; 点个关注在评论区回复“888”之后私信回复“888”&#xff0c;全部无偿共享给大家&#xff01;&#xff01;&#xff01;以下是算法工程师需要学习的一些…
阅读更多...
【机器学习】机器学习基础概念与初步探索

【机器学习】机器学习基础概念与初步探索

❀机器学习 &#x1f4d2;1. 引言&#x1f4d2;2. 机器学习概述&#x1f4d2;3. 机器学习基础概念&#x1f389;2.1 机器学习的分类&#x1f389;2.2 数据预处理&#x1f308;数据清洗与整合&#x1f308; 特征选择和特征工程&#x1f308;数据标准化与归一化 &#x1f4d2;4. …
阅读更多...
K8s service 进阶

K8s service 进阶

文章目录 K8s service 进阶Service 工作逻辑Service 具体实现Service 资源类型ClusterIPNodePortLoadBalancerExternalName Service 与 EndpointEndpoint 与 容器探针自定义Endpoint Service 相关字段sessionAffinityexternalTrafficPolicyinternalTrafficPolicypublishNotRead…
阅读更多...
揭秘《庆余年算法番外篇》：范闲通过贝叶斯定理找到太子火烧史家镇的证据

揭秘《庆余年算法番外篇》：范闲通过贝叶斯定理找到太子火烧史家镇的证据

剧情背景 在《庆余年2》中史家镇是李云睿和二皇子向北齐走私的重要通道&#xff0c;太子派人把史家镇烧成灰烬&#xff0c;最后嫁祸于二皇子&#xff0c;加大范闲对二皇子的恨意&#xff0c;坐收渔翁之利&#xff0c;意图销毁所有证据。范闲痛心疾首&#xff0c;但是马上调整&…
阅读更多...
文章一：华为晟腾310b的Atlas 200 AI加速模块进行视频的AI分析，硬件使用的是Oringepi alpro（推荐环境安装）

文章一：华为晟腾310b的Atlas 200 AI加速模块进行视频的AI分析，硬件使用的是Oringepi alpro（推荐环境安装）

1&#xff0c;首先本次我们使用MindxSDK进行视频分析 2&#xff0c;环境安装 主要还是参考官方的安装步骤&#xff0c;安装步骤链接 2.1,安装NPU&#xff0c;检查NPU安装情况 默认的官方的ubuntu是自带安装NPU的driver的&#xff0c;只需要检查一下版本就可以了。 mxVisio…
阅读更多...
两种现货白银资金的管理方法 你喜欢哪一种？

两种现货白银资金的管理方法 你喜欢哪一种？

做现货黄金交易&#xff0c;除了投资者的盘感、市场分析技巧等因素以外&#xff0c;其实对于现货白银资金的管理也是很重要的。下面我们就来介绍两个现货白银资金的管理方法&#xff0c;主要是开仓和加仓方面的。 按照投资者的操作风格&#xff0c;我们可以将现货白银资金管理的…
阅读更多...
防火墙基础基础篇：NAT转发功能之——Easy IP方式详解

防火墙基础基础篇：NAT转发功能之——Easy IP方式详解

防火墙基础基础篇&#xff1a;NAT转发功能之——Easy IP方式详解 1. 概念 Easy IP 是一种简化版的动态NAPT&#xff08;Network Address and Port Translation&#xff09;技术。在Easy IP中&#xff0c;我们只使用一个公网IP地址&#xff0c;无需建立公有IP地址池。这个公网…
阅读更多...
拼多多买家关注店铺 id 导出商品收藏导出查看全店spu_id

拼多多买家关注店铺 id 导出商品收藏导出查看全店spu_id

拼多多买家账号导出关注列表店铺 id、商品 id 登录网页端拼多多界面&#xff0c;清缓存后 F12加载数据&#xff0c;下滑界面自动加载缓存&#xff1b; 查看商品收藏 登录网页端拼多多界面&#xff0c;清缓存后 F12加载数据&#xff0c;下滑界面自动加载缓存&#xff1b; 一…
阅读更多...
现在股票交易佣金标准最低是万0.854，低佣金炒股开户方式和流程！

现在股票交易佣金标准最低是万0.854，低佣金炒股开户方式和流程！

股票交易佣金的最低标准是万分之0.854&#xff1b; 证券公司股票交易佣金默认是万分之3&#xff1b; 无门槛的股票交易佣金是万分之1&#xff1b; 万分之0.854的佣金要求投资者资产达到一定规模&#xff0c;不同的证券公司规定不一样。 如果没有经过证券公司客户经理协商开…
阅读更多...
Java时间类--JDK8

Java时间类--JDK8

为什么JDK8会又新增时间相关类呢&#xff1f; ① JDK7的时间对象如果需要比较大小的话&#xff0c;必须都先转换成毫秒值&#xff1b;JDK8则不需要&#xff0c;可以直接比较。 ② JDK7的时间对象可以修改&#xff0c;在多线程环境下就会导致数据不安全&#xff1b;JDK8不能修改…
阅读更多...
Linux 进程相关概念

Linux 进程相关概念

用以下指令查找正在运行的进程&#xff0c;并使用 grep 过滤出包含 "int" 的行。 "ps -aux" 显示当前系统上所有用户的进程列表&#xff0c;而 grep 命令则筛选出包含 "int" 的行。 ps -aux|grep int p代表process进程 1.什么是程序&#xff…
阅读更多...
JavaScript（ES6）入门

JavaScript（ES6）入门

ES6 1、介绍 ECMAScript 6&#xff08;简称ES6&#xff09;是于2015年6月正式发布的JavaScript 语言的标准&#xff0c;正式名为ECMAScript 2015&#xff08;ES2015&#xff09;。它的目标是使得JavaScript语言可以用来编写复杂的大型应用程序&#xff0c;成为企业级开发语言。…
阅读更多...
unity回到低版本报错解决

unity回到低版本报错解决

用高版本2022打开过后的再回到2020就报了一个错。 报错如下&#xff1a; Library\PackageCache\com.unity.ai.navigation1.1.5\Runtime\NavMeshSurface.cs 看了一下是Library&#xff0c;然后我删除了整个Library文件夹&#xff0c;重启启动生成Library&#xff0c;然后还是…
阅读更多...
【全开源】在线题库微信小程序系统源码（ThinkPHP+FastAdmin+UniApp）

【全开源】在线题库微信小程序系统源码（ThinkPHP+FastAdmin+UniApp）

打造个性化学习平台 一、引言&#xff1a;在线学习的未来趋势 在数字化时代&#xff0c;线上学习已逐渐成为主流。随着移动互联网的普及&#xff0c;小程序以其轻便、快捷、无需安装的特点&#xff0c;成为用户日常学习的新选择。为了满足广大用户对于在线学习的需求&#xf…
阅读更多...
分治法（棋盘覆盖问题）

分治法（棋盘覆盖问题）

目录 前言 一、棋盘覆盖 二、图示解析 三、代码实现 四、具体分析 总结 前言 有一个 x &#xff08;k>0&#xff09;的棋盘&#xff0c;恰好有一个方格与其他方格不同&#xff0c;称之为特殊方格。现在要用L形骨牌覆盖除了特殊方格以外的其他全部方格&#xff0c;骨牌可以…
阅读更多...
2.8万字总结：金融核心系统数据库升级路径与场景实践

2.8万字总结：金融核心系统数据库升级路径与场景实践

OceanBase CEO 杨冰 谈及数字化转型&#xff0c;如果说过去还只是头部金融机构带动效应下的“选择题”。那么现在&#xff0c;我相信数字化转型已经成为不论大、中、小型金融机构的“必答题”。 本文为OceanBase最新发布的《万字总结&#xff1a;金融核心系统数据库升级路径…
阅读更多...
【ARM+Codesys案例】基于全志T3+Codesys的快递物流单件分离器控制系统

【ARM+Codesys案例】基于全志T3+Codesys的快递物流单件分离器控制系统

物流涉及国计民生&#xff0c;是在社会发展中不可或缺的一环。随着社会的改革开放&#xff0c;工业发展迅猛&#xff0c;此时也伴随着物流业的快速发展。电商、快递等行业业务量爆发以及人工成本的不断上涨&#xff0c;自动化输送分拣设备市场呈现井喷式发展。物流行业从传统方…
阅读更多...
Linux——Docker容器虚拟化平台

Linux——Docker容器虚拟化平台

安装docker 安装 Docker | Docker 从入门到实践https://vuepress.mirror.docker-practice.com/install/ 不需要设置防火墙 docker命令说明 docker images #查看所有本地主机的镜像 docker search 镜像名 #搜索镜像 docker pull 镜像名 [标签] #下载镜像&…
阅读更多...
navicat连接过的库忘记密码

navicat连接过的库忘记密码

1、点击文件->导出连接 2、勾选想要知道密码的库 3、打开导出的文件搜索Password 4、复制Password解密 把下面的php代码复制到在线运行php的网站&#xff0c;替换最下面的decrypt(‘B7246A6E64D4F50A563FA20427A47991’)括号里的内容&#xff0c;然后执行php代码&#xff0…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023