关键词：
文章目录
数组
不可变数组
package learn04
object ScalaCollection
def main(args: Array[String]): Unit =
//数组定义
val arr01=new Array[Int](4)
println(arr01.length)//4
//数组赋值
//修改某个元素的值
arr01(3)=10
val i=10
arr01(i/3)=20
//采用方法的形式修改数组的值
arr01.update(0,1)
//遍历数组
//查看数组
println(arr01.mkString(","))
//普通遍历
for(i<- arr01)
println(i)
//简化遍历
def printx(elem:Int):Unit=
println(elem)
arr01.foreach(printx)
arr01.foreach((x)=>println(x))
arr01.foreach(println(_))
arr01.foreach(println)
4
1,0,0,20
1
0
0
20
1
0
0
20
1
0
0
20
1
0
0
20
1
0
0
20
package learn04
object ScalaCollection
def main(args: Array[String]): Unit =
//创建数组的另外一种方式
val arr1=Array(1,2,3,4)
val arr2=Array(5,6,7,8)
//添加数组元素，创建新数组
val arr3:Array[Int]=arr1:+4
print("arr3:")
println(arr3.mkString(","))
println(arr1 eq arr3)
val arr4:Array[Int]=arr1++:arr2
//添加集合
val arr5:Array[Int]=arr1++arr2
print("arr4:")
println(arr4.mkString(","))
print("arr5:")
println(arr5.mkString(","))
//多维数组
var myMatrix=Array.ofDim[Int](3,3)
myMatrix.foreach(list=>list.foreach(println))
//合并数组
val arr6:Array[Int]=Array.concat(arr1,arr2)
println(arr6.mkString(","))
//创建指定范围的数组
val arr7:Array[Int]=Array.range(0,2)
println(arr7.mkString(","))
val arr8:Array[Int]=Array.fill[Int](5)(-1)
println(arr8.mkString(","))
arr3:1,2,3,4,4
false
arr4:1,2,3,4,5,6,7,8
arr5:1,2,3,4,5,6,7,8
0
0
0
0
0
0
0
0
0
1,2,3,4,5,6,7,8
0,1
-1,-1,-1,-1,-1
可变数组
package learn04
import scala.collection.mutable.ArrayBuffer
object demo01
def main(args: Array[String]): Unit =
val buffer=new ArrayBuffer[Int]
//增加数组
buffer.append(1,2,3,4)
println(buffer.mkString(","))
//修改数据
buffer.update(0,5)
buffer(1)=6
println(buffer.mkString(","))
//删除数据
buffer.remove(2)
println(buffer.mkString(","))
//查询数据
println(buffer(1))
//循环集合
for(i <- buffer)
print(i+" ")
1,2,3,4
5,6,3,4
5,6,4
6
5 6 4
package learn04
import scala.collection.mutable.ArrayBuffer
object demo01
def main(args: Array[String]): Unit =
val buffer1=ArrayBuffer(1,2,3,4)
val buffer2=ArrayBuffer(5,6,7,8)
val buffer3:ArrayBuffer[Int]=buffer1+=5
print("buffer3:")
println(buffer3.mkString(","))
println(buffer1 eq buffer3)
//使用++运算符会产生新的集合数组
val buffer4:ArrayBuffer[Int]=buffer1++buffer2
print("buffer4:")
println(buffer4.mkString(","))
//使用++=运算符会更新之前的集合，不会产生新的数组
val buffer5:ArrayBuffer[Int]=buffer1++=buffer2
print("buffer5:")
println(buffer5.mkString(","))
println(buffer1 eq buffer4)
println(buffer1 eq buffer5)
buffer3:1,2,3,4,5
true
buffer4:1,2,3,4,5,5,6,7,8
buffer5:1,2,3,4,5,5,6,7,8
false
true
可变数组和不可变数组转换
package learn04
import scala.collection.mutable
import scala.collection.mutable.ArrayBuffer
object demo02
def main(args: Array[String]): Unit =
val buffer=ArrayBuffer(1,2,3,4)
val array=Array(4,5,6,7)
//将不可变数组转换为可变数组
val buffer1:mutable.Buffer[Int]=array.toBuffer
//将可变数组转换为不可变数组
val array1:Array[Int]=buffer.toArray
Seq集合
不可变List
package learn04
object demo03
def main(args: Array[String]): Unit =
//Seq集合
val list=List(1,2,3,4)
println("list:",list)
//增加数据
val list1:List[Int]=list:+1
println("list1:",list1)
println(list1 eq list)
list1.foreach(print)
val list2:List[Int]=1+:list
println()
print("list2:")
list2.foreach(print)
val list3:List[Int]=list.updated(1,5)
println()
println(list eq list3)
print("list3:")
list3.foreach(print)
(list:,List(1, 2, 3, 4))
(list1:,List(1, 2, 3, 4, 1))
false
12341
list2:11234
false
list3:1534
package learn04
object demo04
def main(args: Array[String]): Unit =
//Seq集合
val list1=List(1,2,3,4)
//空集合
val list2:List[Nothing]=List()
val nil=Nil
println(list2.mkString(","))
println(list2 eq nil)
//创建集合
val list3:List[Int]=1::2::3::Nil
val list4:List[Int]=list1:::Nil
println(list3.mkString(","))
println(list4.mkString(","))
//连接集合
val list5:List[Int]=List.concat(list3,list4)
println(list5.mkString(","))
//创建一个指定重复数量的元素列表
val list6:List[String]=List.fill[String](3)("a")
println(list6.mkString(","))
true
1,2,3
1,2,3,4
1,2,3,1,2,3,4
a,a,a
可变List
package learn04
import scala.collection.mutable.ListBuffer
object demo05
def main(args: Array[String]): Unit =
//可变集合
val buffer=new ListBuffer[Int]()
//增加数据
buffer.append(1,2,3,4)
//修改数据
buffer.update(1,3)
//删除数据
println(buffer.mkString(","))
buffer.remove(2,2)//从下标2开始，删除2个元素
//遍历集合
buffer.foreach(println)
1,3,3,4
1
3
package learn04
import scala.collection.mutable.ListBuffer
object demo06
def main(args: Array[String]): Unit =
//可变集合
val buffer1=ListBuffer(1,2,3,4)
val buffer2=ListBuffer(5,6,7,8)
//增加数据
val buffer3:ListBuffer[Int]=buffer1:+5
val buffer4:ListBuffer[Int]=buffer1+=5
val buffer5:ListBuffer[Int]=buffer1++buffer2
val buffer6:ListBuffer[Int]=buffer1++=buffer2
println(buffer3.mkString(","))
println(buffer4.mkString(","))
println(buffer5.mkString(","))
println(buffer6.mkString(","))
println(buffer5 eq buffer1)
println(buffer6 eq buffer1)
val buffer7:ListBuffer[Int]=buffer1-2
val buffer8:ListBuffer[Int]=buffer1-=2
println(buffer7 eq buffer1)
println(buffer8 eq buffer1)
1,2,3,4,5
1,2,3,4,5,5,6,7,8
1,2,3,4,5,5,6,7,8
1,2,3,4,5,5,6,7,8
false
true
false
true
可变集合和不可变集合转换
package learn04
import scala.collection.mutable
import scala.collection.mutable.ListBuffer
object demo07
def main(args: Array[String]): Unit =
val buffer=ListBuffer(1,2,3,4)
val list=List(5,6,7,8)
//可变集合转变为不可变集合
val list1:List[Int]=buffer.toList
//不可变集合转变为可变集合
val buffer1:mutable.Buffer[Int]=list.toBuffer
Set集合
不可变Set
package learn04
object demo08
def main(args: Array[String]): Unit =
val set1=Set(1,2,3,4)
val set2=Set(5,6,7,8)
//增加数据
val set3:Set[Int]=set1+5
val set4:Set[Int]=set1+(5,6,7,8)
println(set1 eq set3)
println(set1 eq set4)
set4.foreach(print)
//删除数据
val set5:Set[Int]=set1-2-3
println()
set5.foreach(print)
val set6:Set[Int]=set1++set2
println()
set6.foreach(print)
val set7:Set[Int]=set2++:set1
println()
set7.foreach(print)
println()
println(set6 eq set7)
false
false
51627384
14
51627384
51627384
false
可变Set
package learn04
import scala.collection.mutable
object demo09
def main(args: Array[String]): Unit =
val set1=mutable.Set(1,2,3,4)
val set2=mutable.Set(5,6,spark基础-scala学习（集合）(代码片段)
集合scala的集合体系结构ListLinkedListSet集合的函数式编程函数式编程综合案例：统计多个文本内的单词总数scala的集合体系结构scala中的集合体系主要包括：Iterable、Seq、Set、Map。其中Iterable是所有集合trait的根trait。这个结构与java... 查看详情
scala学习--其他集合类学习(代码片段)
Scala学习--其他集合类学习一、序列列表缓冲ListBufferList类提供对列表头部快速访问，尾部访问并不高效。使用List类在尾部追加元素往往通过reverse，表头添加，reverse实现。通过ListBuffer可以简单实现。ListBuffer是一个可变对象，包... 查看详情
scala集合通用方法(代码片段)
活动地址：CSDN21天学习挑战赛元组：importscala.Booleanimportscala.collection.mutableobjecttest01defmain(args:Array[String]):Unit=valtuple1:(String,Int,Char,Boolean)=("hello",2,'c& 查看详情
scala集合学习总结(代码片段)
遍历集合可以使用迭代器iterator的那套迭代方式。Seq是一个有先后次序的序列,比如数组或列表。IndexedSeq可以通过下标进行任意元素的访问。例如ArrrayBuffer。Set是一组没有先后次序的值，在SortedSet中，元素以某种排过序的顺序被... 查看详情
scala学习（集合02）(代码片段)
文章目录元组队列并行常用方法常用方法衍生集合计算函数功能函数案例实现-WordCountTopN元组packagelearn04objectdemo15defmain(args:Array[String]):Unit=//创建元组，使用小括号valtuple=(1,"xwk",30)//根据顺序号访问元组的数据println... 查看详情
scala高阶：集合内容汇总（上篇）(代码片段)
...似，但是又有很多的改变，接下来我们开启Scala集合篇的学习历程吧！一、概述在Java中的集合分为三大类：List集合、Set集合、Map集合。其中List集合、Set集合继承自Collection。它们都是接口。Scala的集合有三大类：序列Seq、集Set、... 查看详情
大数据技术之_16_scala学习_08_数据结构(下)-集合操作+模式匹配(代码片段)
第十一章数据结构(下)-集合操作11.1集合元素的映射-map11.1.1map映射函数的操作11.1.2高阶函数基本使用案例1+案例211.1.3使用map映射函数来解决11.1.4模拟实现map映射函数的机制11.1.5课堂练习11.2集合元素的扁平-flatMap11.3集合元素的过滤... 查看详情
scala学习（集合02）(代码片段)
文章目录元组队列并行常用方法常用方法衍生集合计算函数功能函数案例实现-WordCountTopN元组packagelearn04objectdemo15defmain(args:Array[String]):Unit=//创建元组，使用小括号valtuple=(1,"xwk",30)//根据顺序号访问元组的数据println... 查看详情
scala学习面向对象(代码片段)
一，scala单例对象二，scala类 2.1 类定义，主构造器，赋值构造器 2.2 访问权限 2.3 伴生类，apply方法三，特质四，抽象类五，继承 5.1 final关键字 5.2 type关键字六，样例类，样例对象七，匹配模... 查看详情
scala的集合(代码片段)
1.集合基础概念?(1)集合的相关介绍??Scala的集合有三大类：序列（seq）、集合（set）、映射（map）所有的集合都扩展自Iterable特质，在Scala中集合有可变和不可变两种类型，可变集合可以在适当的地方被更新或者扩展，这意味着可... 查看详情
scala：集合常用函数(代码片段)
目录基本属性和常用操作衍生集合集合计算简单函数集合计算高级函数基本属性和常用操作objectSetTest01defmain(args:Array[String]):Unit=//创建集合vallist:List[Int]=List(1,2,3,4,5,6,7,8)println(list)//获取长度println(list.length)//获取集合大小prin... 查看详情
scala学习之scala集合类(代码片段)
文章目录SCALACOLLECTIONSThemainScalacollectionsclassesTHEARRAYBUFFERCLASSMorewaystoworkwith`ArrayBuffer`THELISTCLASSCreatingListsAddingelementstoaListHowtorememberthemethodnamesHowtoloopoverlistsA 查看详情
scala集合总结（seqmapsetlisttupleoption）(代码片段)
文章目录scala集合的三大类型scala.collection.immutable（不可变集合）scala.collection.mutable（可变集合）常用集合总结使用时应该选择哪个Seq子类Vector与List的比较Seq与List的关系Seq与Array的关系https://docs.scala-lang.org/scala3/b 查看详情
scala数据结构(代码片段)
一、概述1，特点1)Scala同时支持不可变集合和可变集合2)两个主要的包：不可变集合：scala.collection.immutable可变集合：scala.collection.mutable3)Scala默认采用不可变集合，对于几乎所有的集合类，Scala都同时提供了可变(mutable)和不可变(im... 查看详情
scala笔记整理：scala集合库(代码片段)
[TOC]Scala主要集合结构1、Scala中的集合体系主要包括：Iterable、Seq（IndexSeq）、Set（SortedSet）、Map（SortedMap）。其中Iterable是所有集合trait的根trait。实际上Seq、Set、和Map都是子traitSeq是一个有先后次序的值的序列，比如数组或列表... 查看详情
scala集合类型详解(代码片段)
...以及轻应用开发最近开发了一款移动办公软件狐小E1.Scala集合 Scala提供了一套很好的集合实现，提供了一些集合类型的抽象。 Scala集合分为可变的和不可变的集合。 可变集合可以在适当的地方被更新或扩... 查看详情
scala高阶：集合内容汇总（下篇）(代码片段)
@TOC在上一篇集合的分享中，讲解了Scala中集合的基本概述以及常用集合的基本操作，本次住要分享Scala中集合更高级的操作。一、集合常用函数基本操作获取集合长度和大小：线性集合length，所有集合都有size循环遍历：for(elem&... 查看详情
scala学习（变量和数据类型流程控制）(代码片段)
文章目录变量和数据类型注释变量字符串输入输出数据类型类型转换标识符流程控制分支控制循环控制forwhile循环中断变量和数据类型注释packagelearn02objectdemo01defmain(args:Array[String]):Unit=//单行注释/*多行注释*//***文档注释*/变量p... 查看详情