Scala学习笔记------数组和集合

最新推荐文章于 2023-01-04 14:01:20 发布

smallworldxyl

最新推荐文章于 2023-01-04 14:01:20 发布

阅读量225

点赞数

文章标签： scala 集合 array

本文链接：https://blog.csdn.net/smallworldxyl/article/details/112389406

版权

Scala 学习笔记2

一. 数组

1.一维数组

与Java中不同的是，Scala中没有数组这一种类型。在Scala中，Array类的功能就与数组类似。
与所有数组一样，Array的长度不可变，里面的数据可以按索引位置访问。

val array1 = new Array[Int](5)
  array1(0)=1
  array1(4/2)=2
  array1.foreach(println)//output:1 0 2 0 0 
val arr=Array[String]("a","b","c")
    arr.foreach(s=>{println(s)})//三种foreach等价，是匿名函数的写法
    arr.foreach(println(_))
    arr.foreach(println)

2.多维数组

var array=new Array[Array[Int]](3)
    array(0)=Array[Int](1,2,3)
    array(1)=Array[Int](4,5,6)
    array(2)=Array[Int](7,8,9)
  for(arr<-array;elem<-arr){
        println(elem)
    }//output:1 2 3 4 5 6 7 8 9

也可以调用 Array.ofDim

val Matrix = Array.ofDim[Int](3, 4)
    for (i <- 0 to 2) {
      for ( j <- 0 to 2) {
        Matrix(i)(j) = j;
      }
    }

矩阵为：[ [0,1,2,0],[0,1,2,0],[0,1,2,0]]

3.数组的一些方法

def apply( x: T, xs: T* ): Array[T]
创建指定对象 T 的数组, T 的值可以是 Unit, Double, Float, Long, Int, Char, Short, Byte, Boolean。
def concat[T]( xss: Array[T]* ): Array[T]
创建指定对象 T 的数组, T 的值可以是 Unit, Double, Float, Long, Int, Char, Short, Byte, Boolean。
def copy( src: AnyRef, srcPos: Int, dest: AnyRef, destPos: Int, length: Int ): Unit
复制一个数组到另一个数组上。相等于 Java’s System.arraycopy(src, srcPos, dest, destPos, length)。
def fill[T]( n: Int )(elem: => T): Array[T]
返回数组，长度为第一个参数指定，同时每个元素使用第二个参数进行填充。
def ofDim[T]( n1: Int ): Array[T]
创建指定长度的数组
def ofDim[T]( n1: Int, n2: Int ): Array[Array[T]]
创建二维数组
def ofDim[T]( n1: Int, n2: Int, n3: Int ): Array[Array[Array[T]]]
创建三维数组
def range( start: Int, end: Int, step: Int ): Array[Int]
创建指定区间内的数组，step 为每个元素间的步长
def iterate[T]( start: T, len: Int )( f: (T) => T ): Array[T]
返回指定长度数组，每个数组元素为指定函数的返回值。

//一些示例
	var arr1=Array[String]("a","b","c")
    var arr2=Array[String]("d","e","f")
    var arr3=Array.concat(arr1,arr2)
    var arr4=Array.fill(5)("hello")
    val result: Array[Int] = iterate(0,3)(a=>a+1)
    result.foreach(println)  //output:0 1 2

4 可变数组

val arr=ArrayBuffer[Int](1,2,3)
          arr.+=(5)     //添加到后面
          arr.+=:(0)    //添加到前面
          arr.append(7,8,9)//追加多个
          arr.foreach(println) //output: 0 1 2 3 4 5 6 7 8 9

二 . 集合

集合类分为immutable和mutable集合。mutable集合可以在适当的地方被更新或扩展。这意味着你可以修改，添加，移除一个集合的元素。而不可变集合类，与之相反，永远不会改变。不过，你仍然可以模拟添加，移除或更新操作。但是这些操作将在每一种情况下都返回一个新的集合，同时使原来的集合不发生改变。

scala.collection包中所有的集合类
在这里插入图片描述

scala.collection.immutable中的所有集合类
在这里插入图片描述 scala.collection.mutable中的所有集合类。

2.1 list

Scala 列表类似于数组，它们所有元素的类型都相同，但是它们也有所不同：列表是不可变的，值一旦被定义了就不能改变，其次列表具有递归的结构（也就是链接表结构）而数组不是。

官方网址—> list详解

// 字符串列表
val site: List[String] = List("Runoob", "Google", "Baidu")
// 整型列表
val nums: List[Int] = List(1, 2, 3, 4)
// 空列表
val empty: List[Nothing] = List()
// 二维列表
val dim: List[List[Int]] =
   List(
      List(1, 0, 0),
      List(0, 1, 0),
      List(0, 0, 1)
   )

var list1 =List[String](xs ="hello_scala","hello_hadoop","hello_spark")
	val result1:List[Array[String]]=list1.map(s => {s.split("_")})
	result1.foreach(arr=>{arr.foreach(println)})

	var result2:List[String]=list1.flatMap(s=>{s.split("_")})
	println(result2)

	val result3: List[String] = list1.filter(s => {"hello_scala".equals(s)})
    println(result3)

	var i:Int=list1.count(s=>{s.length <=11})
	println(i)

输出结果：
hello
scala
hello
hadoop
hello
spark
List(hello, scala, hello, hadoop, hello, spark)
List(hello_scala)
2

2.2 Set

Scala Set(集合)是没有重复的对象集合，所有的元素都是唯一的。

Scala 集合分为可变的和不可变的集合。

默认情况下，Scala 使用的是不可变集合，如果你想使用可变集合，需要引用 scala.collection.mutable.Set 包。

默认引用 scala.collection.immutable.Set

官网详解–>set api文档

	val set =Set[Int](1,2,3,4)
    val set1 =Set[Int](3,4,5,6)
    val result =set.intersect(set1)  //求交集
    val result3=set & set1  //运算符求交集
    println(result)
    //result.foreach(println)
    val result1 =set.diff(set1) //求差集
    //result1.foreach(s=>{print(s+" ")})
    println(result1)
    val result2 = set1.diff(set)
    //result2.foreach(s=>{print(s+" ")})
    println(result2)
    val set3: Set[Int] = set.filter(elem=>{elem>2})
    //set3.foreach(println) // output:3 4

输出：
Set(3, 4)
Set(1, 2)
Set(5, 6)

可变set

import scala.collection.mutable
    val set5 =mutable.Set[String]("a","b")
    set5.+=("c") 
    println(set5)
    val set6 = set5.++("d") //输出到一个新的集合
    println(set6)

Set(c, a, b)
Set(c, d, a, b)

2.3 Map

Map(映射)是一种可迭代的键值对（key/value）结构。

所有的值都可以通过键来获取。 Map 中的键都是唯一的。Map 也叫哈希表（Hash tables）。

Map 有两种类型，可变与不可变，区别在于可变对象可以修改它，而不可变对象不可以。默认情况下 Scala 使用不可变 Map。如果你需要使用可变集合，你需要显式的引入 import scala.collection.mutable.Map 类

官网详解 map api文档

val map=Map[String,Int]("a"->100,"b"->200,("c",300),("c",400))//自带去重
    println(map)
    map.foreach(println)
    val value =map.get("a")
    println(value)
    val value1 =map.get("a").get
    println(value1)
    val value2=map.get("aaa").getOrElse("no value")
    println(value2)

output:
Map(a -> 100, b -> 200, c -> 400)
(a,100)
(b,200)
(c,400)
Some(100)
100
no value

val map =Map[String,Int]("a"->100,"b"->200,("c",300))
    val keys: Iterable[String] = map.keys //获取所有key
    keys.foreach(key=>{
      val value=map.get(key).get
      println(s"key=$key,value=$value")
    })
    val map1=Map[String,Int]("a"->100,"b"->200,("d",300))
    val map2=Map[String,Int]("a"->1,"b"->2,("c",4))
    val result1=map1.++(map2) //用map2去更新map1
    val result2=map1.++:(map2)//用map1去更新map2
    println(result1)
    println(result2)

key=a,value=100
key=b,value=200
key=c,value=300
Map(a -> 1, b -> 2, d -> 300, c -> 4)
Map(a -> 100, b -> 200, c -> 4, d -> 300)

可变map

import scala.collection.mutable
    val map=mutable.Map[String,Int]()
    map.put("a",100)
    map.put("b",200)
    val result:mutable.Map[String,Int]=map.filter(tp=>{
      val key=tp._1
      val value=tp._2
      value==200
    })
    println(result)

输出：Map(b -> 200)

2.4 元组Tuple

与列表一样，元组也是不可变的，但与列表不同的是元组可以包含不同类型的元素。元组的值是通过将单个的值包含在圆括号中构成的

val tuple1: Tuple1[String] = new Tuple1("hello")
val tuple2: (String, Int) = new Tuple2("a",100)
val tuple4: (Int, Double, String, Boolean) = Tuple4(1,3.4,"abc",true)
//tuple 无法用for来遍历
val iter: Iterator[Any] = tuple4.productIterator
    iter.foreach(println)

//下标访问
val t: (Int, Int, Int, Int) = (4, 3, 2, 1)
val sum = t._1 + t._2 + t._3 + t._4
println(sum)
//swap交换
val t2 =  Tuple2("hello", "welcome")
println("交换后的元组: " + t2.swap )
//转为字符串
val t3 = new Tuple3(1, "hello", "scala")
println("连接后的字符串为: " + t3.toString() )

output:
10
交换后的元组: (welcome,hello)
连接后的字符串为: (1,hello,scala)

2.5 迭代器 Iterator

Scala Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法。

迭代器 it 的两个基本操作是 next 和 hasNext。

调用 it.next() 会返回迭代器的下一个元素，并且更新迭代器的状态。

调用 it.hasNext() 用于检测集合中是否还有元素。

让迭代器 it 逐个返回所有元素最简单的方法是使用 while 循环

官方详解–>iterator api

val it = Iterator("Baidu", "Google", "Runoob", "Taobao")
    while (it.hasNext)
      println(it.next())

    val it1 = Iterator(20,40,2,50,69, 90)
    val it2 = Iterator(20,40,2,50,69, 90)
    println("最大元素是：" + it1.max )
    println("最小元素是：" + it2.min )

    val it3 = Iterator(20,40,2,50,69, 90)
    val it4 = Iterator(20,40,2,50,69, 90)
    println("ita.size 的值: " + it3.size )
    println("itb.length 的值: " + it4.length )

Baidu
Google
Runoob
Taobao
最大元素是：90
最小元素是：2
ita.size 的值: 6
itb.length 的值: 6

smallworldxyl

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Scala学习笔记------数组和集合

Scala 学习笔记2一. 数组1.一维数组与Java中不同的是，Scala中没有数组这一种类型。在Scala中，Array类的功能就与数组类似。与所有数组一样，Array的长度不可变，里面的数据可以按索引位置访问。val array1 = new Array[Int](5) array1(0)=1 array1(4/2)=2 array1.foreach(println)//output:1 0 2 0 0 val arr=Array[String]("a","b","c")
复制链接

扫一扫