Scala学习（集合01）

编程语言 2023-04-09 11:04:08 阅读次数: 0

文章目录

数组

不可变数组

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,7,8)
    //增加数据
    set1.add(5)
    //添加数据
    set1.update(6,true)
    println(set1.mkString(","))
    //删除数据
    set1.update(3,false)
    println(set1.mkString(","))
    set1.remove(2)
    println(set1.mkString(","))
  }
}

1,5,2,6,3,4
1,5,2,6,4
1,5,6,4

package learn04
import scala.collection.mutable
object demo10 {
    
    
  def main(args: Array[String]): Unit = {
    
    
    val set1=mutable.Set(1,2,3,4)
    val set2=mutable.Set(4,5,6,7)
    //交集
    val set3:mutable.Set[Int]=set1&set2
    println(set3.mkString(","))
    //差集
    val set4:mutable.Set[Int]=set1&~set2
    println(set4.mkString(","))
  }
}

4
1,2,3

Map集合

不可变Map

package learn04
object demo11 {
    
    
  def main(args: Array[String]): Unit = {
    
    
    val map1=Map("a"->1,"b"->2,"c"->3)
    val map2=Map("d"->4,"e"->5,"f"->6)
    //添加数据
    val map3=map1+("d"->4)
    //删除数据
    val map4=map3-"d"
    println(map4.mkString(","))
    val map5:Map[String,Int]=map1++map2
    println(map5.mkString)
    val map6:Map[String,Int]=map1++:map2
    println(map6.mkString)
    //修改数据
    val map7:Map[String,Int]=map1.updated("b",5)
    println(map7.mkString(","))
  }
}

a -> 1,b -> 2,c -> 3
e -> 5f -> 6a -> 1b -> 2c -> 3d -> 4
e -> 5f -> 6a -> 1b -> 2c -> 3d -> 4
a -> 1,b -> 5,c -> 3

package learn04
object demo12 {
    
    
  def main(args: Array[String]): Unit = {
    
    
    val map1=Map("a"->1,"b"->2,"c"->3)
    val map2=Map("d"->4,"e"->5,"f"->6)
    //创建空集合
    val empty:Map[String,Int]=Map.empty
    println(empty)
    //获取指定key的值
    val i:Int=map1.apply("c")
    println(map1("c"))
    //获取可能存在的key的值
    val maybeInt:Option[Int]=map1.get("c")
    //判断key值是否存在
    if(!maybeInt.isEmpty){
    
    
      //获取值
      println(maybeInt.get)
    }else{
    
    
      //如果不存在，返回默认值
      println(maybeInt.getOrElse(0))
    }
    //获取可能存在的key值，如果不存在就使用默认值
    println(map1.getOrElse("c",0))
  }
}

Map()
3
3
3

可变Map

package learn04
import scala.collection.mutable
object demo13 {
    
    
  def main(args: Array[String]): Unit = {
    
    
    val map1=mutable.Map("a"->1,"b"->2,"c"->3)
    val map2=mutable.Map("d"->4,"e"->5,"f"->6)
    //添加数据
    map1.put("d",4)
    val map3:mutable.Map[String,Int]=map1+("e"->4)
    println(map3.mkString(","))
    val map4:mutable.Map[String,Int]=map1+=("e"->5)
    println(map4.mkString(","))
    //修改数据
    map1.update("e",8)
    map1("e")=8
    //删除数据
    map1.remove("e")
    val map5:mutable.Map[String,Int]=map1-"e"
    println(map5.mkString(","))
    val map6:mutable.Map[String,Int]=map1-="e"
    println(map6.mkString(","))
    //清除集合
    println("清除前map1:"+map1.mkString(","))
    map1.clear()
    println("清除后map1:"+map1.mkString(","))
  }
}

e -> 4,b -> 2,d -> 4,a -> 1,c -> 3
e -> 5,b -> 2,d -> 4,a -> 1,c -> 3
b -> 2,d -> 4,a -> 1,c -> 3
b -> 2,d -> 4,a -> 1,c -> 3
清除前map1:b -> 2,d -> 4,a -> 1,c -> 3
清除后map1:

package learn04
import scala.collection.mutable
object demo14 {
    
    
  def main(args: Array[String]): Unit = {
    
    
    val map1=mutable.Map("a"->1,"b"->2,"c"->3)
    val map2=mutable.Map("d"->4,"e"->5,"f"->6)
    val set:Set[(String,Int)]=map1.toSet
    val list:List[(String,Int)]=map1.toList
    val seq:Seq[(String,Int)]=map1.toSeq
    val array:Array[(String,Int)]=map1.toArray
    println(map1.mkString(","))
    println(set.mkString(","))
    println(list.mkString(","))
    println(seq.mkString(","))
    println(array.mkString(","))
    println(map1.get("a"))
    println(map1.getOrElse("a",0))
    println(map1.keys)
    println(map1.keySet)
    println(map1.keysIterator)
    println(map1.values)
    println(map1.valuesIterator)
  }
}

b -> 2,a -> 1,c -> 3
(b,2),(a,1),(c,3)
(b,2),(a,1),(c,3)
(b,2),(a,1),(c,3)
(b,2),(a,1),(c,3)
Some(1)
1
Set(b, a, c)
Set(b, a, c)
<iterator>
HashMap(2, 1, 3)
<iterator>

猜你喜欢

转载自blog.csdn.net/weixin_46322367/article/details/125330108
今日推荐
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
周排行
[编程题]学英语
[codeforces 1288A] Deadline 约数+模
Python的web开发
Docker在Centos 7上的部署
python编码
解决Ubuntu16.04 fatal error: json/json.h: No such file or directory
mysql并发插入
rest接口如何适应jsonp的方案
linux 终端上网设置
高数——等号两边同时求导、积分的解释
每日归档
更多
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022