【Scala篇】--Scala中集合数组,list,set,map,元祖

最新推荐文章于 2022-01-22 20:24:03 发布
最新推荐文章于 2022-01-22 20:24:03 发布
阅读量1k 收藏 2
点赞数 1
分类专栏： Scala专栏
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LHWorldBlog/article/details/79223678
版权

一、前述

Scala在常用的集合的类别有数组，List，Set，Map，元祖。

二、具体实现

数组

 

  1、创建数组

  • new Array[Int](10)

        赋值：arr(0) = xxx

       Array[String](“s1”,”s2”,”s3”)

   /**
     * 创建数组两种方式：
     * 1.new Array[String](3)
     * 2.直接Array
     */
    
    //创建类型为Int 长度为3的数组
    val arr1 = new Array[Int](3)
    //创建String 类型的数组，直接赋值
    val arr2 = Array[String]("s100","s200","s300")
    //赋值
    arr1(0) = 100
    arr1(1) = 200
    arr1(2) = 300


2、数组遍历

 

 /**
     * 遍历两种方式
     */
    for(i <- arr1){
    	  println(i)
    }
    arr1.foreach(i => {
      println(i)
    })
    
    for(s <- arr2){
      println(s)
    }
    arr2.foreach { 
      x => println(x) 
    }

 创建二维数组（相当于数组中的每元素是一个数组）

 

 

/**
     * 创建二维数组和遍历
     */
    val arr3 = new Array[Array[String]](3)
    arr3(0)=Array("1","2","3")
    arr3(1)=Array("4","5","6")
    arr3(2)=Array("7","8","9")
    for(i <- 0 until arr3.length){
      for(j <- 0 until arr3(i).length){
        print(arr3(i)(j)+"	")
      }
      println()
    }
    
    var count = 0
    for(arr <- arr3 ;i <- arr){
      if(count%3 == 0){
        println()
      }
      print(i+"	")
      count +=1 
    }
    
    arr3.foreach { arr  => {
      arr.foreach { println }
    }}
    
    
    val arr4 = Array[Array[Int]](Array(1,2,3),Array(4,5,6))
    arr4.foreach { arr => {
      arr.foreach(i => {
        println(i)
      })
    }}
    println("-------")
    for(arr <- arr4;i <- arr){
      println(i)
    }

备注：数组方法
1    
def apply( x: T, xs: T* ): Array[T]
创建指定对象 T 的数组, T 的值可以是 Unit, Double, Float, Long, Int, Char, Short, Byte, Boolean。
2    
def concat[T]( xss: Array[T]* ): Array[T]
合并数组
3    
def copy( src: AnyRef, srcPos: Int, dest: AnyRef, destPos: Int, length: Int ): Unit
复制一个数组到另一个数组上。相等于 Java's System.arraycopy(src, srcPos, dest, destPos, length)。
4    
def empty[T]: Array[T]
返回长度为 0 的数组
5    
def iterate[T]( start: T, len: Int )( f: (T) => T ): Array[T]
返回指定长度数组，每个数组元素为指定函数的返回值。
以上实例数组初始值为 0，长度为 3，计算函数为a=>a+1：
scala> Array.iterate(0,3)(a=>a+1)
res1: Array[Int] = Array(0, 1, 2)
6    
def fill[T]( n: Int )(elem: => T): Array[T]
返回数组，长度为第一个参数指定，同时每个元素使用第二个参数进行填充。
7    
def fill[T]( n1: Int, n2: Int )( elem: => T ): Array[Array[T]]
返回二数组，长度为第一个参数指定，同时每个元素使用第二个参数进行填充。
8    
def ofDim[T]( n1: Int ): Array[T]
创建指定长度的数组
9    
def ofDim[T]( n1: Int, n2: Int ): Array[Array[T]]
创建二维数组
10    
def ofDim[T]( n1: Int, n2: Int, n3: Int ): Array[Array[Array[T]]]
创建三维数组
11    
def range( start: Int, end: Int, step: Int ): Array[Int]
创建指定区间内的数组，step 为每个元素间的步长
12    
def range( start: Int, end: Int ): Array[Int]
创建指定区间内的数组
13    
def tabulate[T]( n: Int )(f: (Int)=> T): Array[T]
返回指定长度数组，每个数组元素为指定函数的返回值，默认从 0 开始。
以上实例返回 3 个元素：
scala> Array.tabulate(3)(a => a + 5)
res0: Array[Int] = Array(5, 6, 7)
14    
def tabulate[T]( n1: Int, n2: Int )( f: (Int, Int ) => T): Array[Array[T]]
返回指定长度的二维数组，每个数组元素为指定函数的返回值，默认从 0 开始。

15

Array.concate：合并数组

16

Array.fill(5)(“bjsxt”)：创建初始值的定长数组

 

 

list集合

 

1、创建list

val list = List(1,2,3,4)

/**
     * 创建二维数组和遍历
     */
    val arr3 = new Array[Array[String]](3)
    arr3(0)=Array("1","2","3")
    arr3(1)=Array("4","5","6")
    arr3(2)=Array("7","8","9")
    for(i <- 0 until arr3.length){
      for(j <- 0 until arr3(i).length){
        print(arr3(i)(j)+"	")
      }
      println()
    }
    
    var count = 0
    for(arr <- arr3 ;i <- arr){
      if(count%3 == 0){
        println()
      }
      print(i+"	")
      count +=1 
    }
    
    arr3.foreach { arr  => {
      arr.foreach { println }
    }}
    
    
    val arr4 = Array[Array[Int]](Array(1,2,3),Array(4,5,6))
    arr4.foreach { arr => {
      arr.foreach(i => {
        println(i)
      })
    }}
    println("-------")
    for(arr <- arr4;i <- arr){
      println(i)
    }


Nil长度为0的list

 备注：List方法总结

1    def +(elem: A): List[A]
前置一个元素列表
2    def ::(x: A): List[A]
在这个列表的开头添加的元素。
3    def :::(prefix: List[A]): List[A]
增加了一个给定列表中该列表前面的元素。
4    def ::(x: A): List[A]
增加了一个元素x在列表的开头
5    def addString(b: StringBuilder): StringBuilder
追加列表的一个字符串生成器的所有元素。
6    def addString(b: StringBuilder, sep: String): StringBuilder
追加列表的使用分隔字符串一个字符串生成器的所有元素。
7    def apply(n: Int): A
选择通过其在列表中索引的元素
8    def contains(elem: Any): Boolean
测试该列表中是否包含一个给定值作为元素。
9    def copyToArray(xs: Array[A], start: Int, len: Int): Unit
列表的副本元件阵列。填充给定的数组xs与此列表中最多len个元素，在位置开始。
10    def distinct: List[A]
建立从列表中没有任何重复的元素的新列表。
11    def drop(n: Int): List[A]
返回除了第n个的所有元素。
12    def dropRight(n: Int): List[A]
返回除了最后的n个的元素
13    def dropWhile(p: (A) => Boolean): List[A]
丢弃满足谓词的元素最长前缀。
14    def endsWith[B](that: Seq[B]): Boolean
测试列表是否使用给定序列结束。
15    def equals(that: Any): Boolean
equals方法的任意序列。比较该序列到某些其他对象。
16    def exists(p: (A) => Boolean): Boolean
测试谓词是否持有一些列表的元素。
17    def filter(p: (A) => Boolean): List[A]
返回列表满足谓词的所有元素。
18    def forall(p: (A) => Boolean): Boolean
测试谓词是否持有该列表中的所有元素。
19    def foreach(f: (A) => Unit): Unit
应用一个函数f以列表的所有元素。
20    def head: A
选择列表的第一个元素
21    def indexOf(elem: A, from: Int): Int
经过或在某些起始索引查找列表中的一些值第一次出现的索引。
22    def init: List[A]
返回除了最后的所有元素
23    def intersect(that: Seq[A]): List[A]
计算列表和另一序列之间的多重集交集。
24    def isEmpty: Boolean
测试列表是否为空
25    def iterator: Iterator[A]
创建一个新的迭代器中包含的可迭代对象中的所有元素
26    def last: A
返回最后一个元素
27    def lastIndexOf(elem: A, end: Int): Int
之前或在一个给定的最终指数查找的列表中的一些值最后一次出现的索引
28    def length: Int
返回列表的长度
29    def map[B](f: (A) => B): List[B]
通过应用函数以g这个列表中的所有元素构建一个新的集合
30    def max: A
查找最大的元素
31    def min: A
查找最小元素
32    def mkString: String
显示列表的字符串中的所有元素
33    def mkString(sep: String): String
显示的列表中的字符串中使用分隔串的所有元素
34    def reverse: List[A]
返回新列表，在相反的顺序元素
35    def sorted[B >: A]: List[A]
根据排序对列表进行排序
36    def startsWith[B](that: Seq[B], offset: Int): Boolean
测试该列表中是否包含给定的索引处的给定的序列
37    def sum: A
概括这个集合的元素
38    def tail: List[A]
返回除了第一的所有元素
39    def take(n: Int): List[A]
返回前n个元素
40    def takeRight(n: Int): List[A]
返回最后n个元素
41    def toArray: Array[A]
列表以一个数组变换
42    def toBuffer[B >: A]: Buffer[B]
列表以一个可变缓冲器转换
43    def toMap[T, U]: Map[T, U]
此列表的映射转换
44    def toSeq: Seq[A]
列表的序列转换
45    def toSet[B >: A]: Set[B]
列表到集合变换
46    def toString(): String
列表转换为字符串

常用方法：

  • filter:过滤元素
  • count:计算符合条件的元素个数
  • map：对元素操作
  • flatmap ：压扁扁平,先map再flat

set集合

 

     1、创建set

 

       注意：set集合会自动去重

 

//创建 
    val set1 = Set(1,2,3,4,4)
    val set2 = Set(1,2,5)
    //遍历
    //注意：set会自动去重
    set1.foreach { println}
   for(s <- set1){
      println(s)
    }
    println("*******")
   /**
    * 方法举例
    */
    
   //交集
   val set3 = set1.intersect(set2)
   set3.foreach{println}
   val set4 = set1.&(set2)
   set4.foreach{println}
   println("*******")
   //差集
   set1.diff(set2).foreach { println }
   set1.&~(set2).foreach { println }
   //子集
   set1.subsetOf(set2)
   
   //最大值
   println(set1.max)
   //最小值
   println(set1.min)
   println("****")
   
   //转成数组，list
   set1.toArray.foreach{println}
   println("****")
   set1.toList.foreach{println}
   
   //mkString
   println(set1.mkString)
   println(set1.mkString("\t"))

 

 Set常用方法：

  • 交集：intersect ,&
  • 差集: diff ,&~
  • 子集:subsetOf
  • 最大:max
  • 最小:min
  • 转成数组，toList
  • 转成字符串：mkString(“~”)

Set方法：

1   
def +(elem: A): Set[A]
为集合添加新元素，x并创建一个新的集合，除非元素已存在
2   
def -(elem: A): Set[A]
移除集合中的元素，并创建一个新的集合
3   
def contains(elem: A): Boolean
如果元素在集合中存在，返回 true，否则返回 false。
4   
def &(that: Set[A]): Set[A]
返回两个集合的交集
5   
def &~(that: Set[A]): Set[A]
返回两个集合的差集
6   
def +(elem1: A, elem2: A, elems: A*): Set[A]
通过添加传入指定集合的元素创建一个新的不可变集合
7   
def ++(elems: A): Set[A]
合并两个集合
8   
def -(elem1: A, elem2: A, elems: A*): Set[A]
通过移除传入指定集合的元素创建一个新的不可变集合
9   
def addString(b: StringBuilder): StringBuilder
将不可变集合的所有元素添加到字符串缓冲区
10   
def addString(b: StringBuilder, sep: String): StringBuilder
将不可变集合的所有元素添加到字符串缓冲区，并使用指定的分隔符
11   
def apply(elem: A)
检测集合中是否包含指定元素
12   
def count(p: (A) => Boolean): Int
计算满足指定条件的集合元素个数
13   
def copyToArray(xs: Array[A], start: Int, len: Int): Unit
复制不可变集合元素到数组
14   
def diff(that: Set[A]): Set[A]
比较两个集合的差集
15   
def drop(n: Int): Set[A]]
返回丢弃前n个元素新集合
16   
def dropRight(n: Int): Set[A]
返回丢弃最后n个元素新集合
17   
def dropWhile(p: (A) => Boolean): Set[A]
从左向右丢弃元素，直到条件p不成立
18   
def equals(that: Any): Boolean
equals 方法可用于任意序列。用于比较系列是否相等。
19   
def exists(p: (A) => Boolean): Boolean
判断不可变集合中指定条件的元素是否存在。
20   
def filter(p: (A) => Boolean): Set[A]
输出符合指定条件的所有不可变集合元素。
21   
def find(p: (A) => Boolean): Option[A]
查找不可变集合中满足指定条件的第一个元素
22   
def forall(p: (A) => Boolean): Boolean
查找不可变集合中满足指定条件的所有元素
23   
def foreach(f: (A) => Unit): Unit
将函数应用到不可变集合的所有元素
24   
def head: A
获取不可变集合的第一个元素
25   
def init: Set[A]
返回所有元素，除了最后一个
26   
def intersect(that: Set[A]): Set[A]
计算两个集合的交集
27   
def isEmpty: Boolean
判断集合是否为空
28   
def iterator: Iterator[A]
创建一个新的迭代器来迭代元素
29   
def last: A
返回最后一个元素
30   
def map[B](f: (A) => B): immutable.Set[B]
通过给定的方法将所有元素重新计算
31   
def max: A
查找最大元素
32   
def min: A
查找最小元素
33   
def mkString: String
集合所有元素作为字符串显示
34   
def mkString(sep: String): String
使用分隔符将集合所有元素作为字符串显示
35   
def product: A
返回不可变集合中数字元素的积。
36   
def size: Int
返回不可变集合元素的数量
37   
def splitAt(n: Int): (Set[A], Set[A])
把不可变集合拆分为两个容器，第一个由前 n 个元素组成，第二个由剩下的元素组成
38   
def subsetOf(that: Set[A]): Boolean
如果集合A中含有子集B返回 true，否则返回false
39   
def sum: A
返回不可变集合中所有数字元素之和
40   
def tail: Set[A]
返回一个不可变集合中除了第一元素之外的其他元素
41   
def take(n: Int): Set[A]
返回前 n 个元素
42   
def takeRight(n: Int):Set[A]
返回后 n 个元素
43   
def toArray: Array[A]
将集合转换为数组
44   
def toBuffer[B >: A]: Buffer[B]
返回缓冲区，包含了不可变集合的所有元素
45   
def toList: List[A]
返回 List，包含了不可变集合的所有元素
46   
def toMap[T, U]: Map[T, U]
返回 Map，包含了不可变集合的所有元素
47   
def toSeq: Seq[A]
返回 Seq，包含了不可变集合的所有元素
48   
def toString(): String
返回一个字符串，以对象来表示

map集合

 

1. map创建

Map（1 –>”bjsxt’）

Map((1,”bjsxt”))

 

注意：创建map时，相同的key被后面的相同的key顶替掉，只保留一个

 

2、获取map的值

map.get(“1”).get

map.get(100).getOrElse(“no value”)：如果map中没有对应项，赋值为getOrElse传的值。

 

 //获取值
    println(map.get("1").get)
    val result = map.get(8).getOrElse("no value")
    println(result)

 3、遍历map

 for,foreach

 

 //map遍历
    for(x <- map){
      println("====key:"+x._1+",value:"+x._2)
    }
    map.foreach(f => {
      println("key:"+ f._1+" ,value:"+f._2)
    })


 

 4、遍历key

map.keys

  //遍历key
    val keyIterable = map.keys
    keyIterable.foreach { key => {
      println("key:"+key+", value:"+map.get(key).get)
    } }
    println("---------")


 5、遍历value

map.values

//遍历value
    val valueIterable = map.values
    valueIterable.foreach { value => {
      println("value: "+ value)
    } }


 6、合并map

++  例：map1.++(map2)  --map1中加入map2

 ++:  例：map1.++:(map2) –map2中加入map1

注意：合并map会将map中的相同key的value替换

 

//合并map
    val map1 = Map(
      (1,"a"),    
      (2,"b"),    
      (3,"c")    
    )
    val map2 = Map(
      (1,"aa"),
      (2,"bb"),
      (2,90),
      (4,22),
      (4,"dd")
    )
    map1.++:(map2).foreach(println)


 7、map中的方法举例

 filter:过滤，留下符合条件的记录

 count:统计符合条件的记录数

contains：map中是否包含某个key

 exist：符合条件的记录存在不存在

 

 

 /**
     * map方法
     */
    //count
    val countResult  = map.count(p => {
      p._2.equals("shsxt")
    })
    println(countResult)
    
    //filter
    map.filter(_._2.equals("shsxt")).foreach(println)
    
    //contains
    println(map.contains(2))
   
    //exist
    println(map.exists(f =>{
      f._2.equals("xasxt")
      
    }))

 

 map 方法：
1   
def ++(xs: Map[(A, B)]): Map[A, B]
返回一个新的 Map，新的 Map xs 组成
2   
def -(elem1: A, elem2: A, elems: A*): Map[A, B]
返回一个新的 Map, 移除 key 为 elem1, elem2 或其他 elems。
3   
def --(xs: GTO[A]): Map[A, B]
返回一个新的 Map, 移除 xs 对象中对应的 key
4   
def get(key: A): Option[B]
返回指定 key 的值
5   
def iterator: Iterator[(A, B)]
创建新的迭代器，并输出 key/value 对
6   
def addString(b: StringBuilder): StringBuilder
将 Map 中的所有元素附加到StringBuilder，可加入分隔符
7   
def addString(b: StringBuilder, sep: String): StringBuilder
将 Map 中的所有元素附加到StringBuilder，可加入分隔符
8   
def apply(key: A): B
返回指定键的值，如果不存在返回 Map 的默认方法

10   
def clone(): Map[A, B]
从一个 Map 复制到另一个 Map
11   
def contains(key: A): Boolean
如果 Map 中存在指定 key，返回 true，否则返回 false。
12   
def copyToArray(xs: Array[(A, B)]): Unit
复制集合到数组
13   
def count(p: ((A, B)) => Boolean): Int
计算满足指定条件的集合元素数量
14   
def default(key: A): B
定义 Map 的默认值，在 key 不存在时返回。
15   
def drop(n: Int): Map[A, B]
返回丢弃前n个元素新集合
16   
def dropRight(n: Int): Map[A, B]
返回丢弃最后n个元素新集合
17   
def dropWhile(p: ((A, B)) => Boolean): Map[A, B]
从左向右丢弃元素，直到条件p不成立
18   
def empty: Map[A, B]
返回相同类型的空 Map
19   
def equals(that: Any): Boolean
如果两个 Map 相等(key/value 均相等)，返回true，否则返回false
20   
def exists(p: ((A, B)) => Boolean): Boolean
判断集合中指定条件的元素是否存在
21   
def filter(p: ((A, B))=> Boolean): Map[A, B]
返回满足指定条件的所有集合
22   
def filterKeys(p: (A) => Boolean): Map[A, B]
返回符合指定条件的的不可变 Map
23   
def find(p: ((A, B)) => Boolean): Option[(A, B)]
查找集合中满足指定条件的第一个元素
24   
def foreach(f: ((A, B)) => Unit): Unit
将函数应用到集合的所有元素
25   
def init: Map[A, B]
返回所有元素，除了最后一个
26   
def isEmpty: Boolean
检测 Map 是否为空
27   
def keys: Iterable[A]
返回所有的key/p>
28   
def last: (A, B)
返回最后一个元素
29   
def max: (A, B)
查找最大元素
30   
def min: (A, B)
查找最小元素
31   
def mkString: String
集合所有元素作为字符串显示
32   
def product: (A, B)
返回集合中数字元素的积。
33   
def remove(key: A): Option[B]
移除指定 key
34   
def retain(p: (A, B) => Boolean): Map.this.type
如果符合满足条件的返回 true
35   
def size: Int
返回 Map 元素的个数
36   
def sum: (A, B)
返回集合中所有数字元素之和
37   
def tail: Map[A, B]
返回一个集合中除了第一元素之外的其他元素
38   
def take(n: Int): Map[A, B]
返回前 n 个元素
39   
def takeRight(n: Int): Map[A, B]
返回后 n 个元素
40   
def takeWhile(p: ((A, B)) => Boolean): Map[A, B]
返回满足指定条件的元素
41   
def toArray: Array[(A, B)]
集合转数组
42   
def toBuffer[B >: A]: Buffer[B]
返回缓冲区，包含了 Map 的所有元素
43   
def toList: List[A]
返回 List，包含了 Map 的所有元素
44   
def toSeq: Seq[A]
返回 Seq，包含了 Map 的所有元素
45   
def toSet: Set[A]
返回 Set，包含了 Map 的所有元素
46   
def toString(): String
返回字符串对象

 


元组

 

 

1. 元组定义


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


2. 创建元组与取值


 val  tuple = new Tuple（1） 可以使用new


 val tuple2  = Tuple（1,2） 可以不使用new，也可以直接写成val tuple3 =（1,2,3）


取值用”._XX” 可以获取元组中的值

注意：tuple最多支持22个参数

 

  
 //创建，最多支持22个
    val tuple = new Tuple1(1)
    val tuple2 = Tuple2("zhangsan",2)
    val tuple3 = Tuple3(1,2,3)
    val tuple4 = (1,2,3,4)
    val tuple18 = Tuple18(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18)
    val tuple22 = new Tuple22(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22)

    //使用
    println(tuple2._1 + "\t"+tuple2._2)
    val t = Tuple2((1,2),("zhangsan","lisi"))
    println(t._1._2)

 3、元祖遍历

tuple.productIterator得到迭代器，进而遍历

 

 //遍历
    val tupleIterator = tuple22.productIterator
    while(tupleIterator.hasNext){
      println(tupleIterator.next())
    }

 

4、swap,toString方法

注意：swap元素翻转，只针对二元组
    /**
     * 方法
     */
    //翻转，只针对二元组
    println(tuple2.swap)
    
    //toString
    println(tuple3.toString())

 备注：一般针对集合的遍历基本都是foreach ,for方法！！！！！

 

 

 

 

 

 

 

 

 

Scala Set 常用方法
下表列出了 Scala Set 常用的方法：
序号    方法及描述
1    
def +(elem: A): Set[A]
为集合添加新元素，x并创建一个新的集合，除非元素已存在
2    
def -(elem: A): Set[A]
移除集合中的元素，并创建一个新的集合
3    
def contains(elem: A): Boolean
如果元素在集合中存在，返回 true，否则返回 false。
4    
def &(that: Set[A]): Set[A]
返回两个集合的交集
5    
def &~(that: Set[A]): Set[A]
返回两个集合的差集
6    
def +(elem1: A, elem2: A, elems: A*): Set[A]
通过添加传入指定集合的元素创建一个新的不可变集合
7    
def ++(elems: A): Set[A]
合并两个集合
8    
def -(elem1: A, elem2: A, elems: A*): Set[A]
通过移除传入指定集合的元素创建一个新的不可变集合
9    
def addString(b: StringBuilder): StringBuilder
将不可变集合的所有元素添加到字符串缓冲区
10    
def addString(b: StringBuilder, sep: String): StringBuilder
将不可变集合的所有元素添加到字符串缓冲区，并使用指定的分隔符
11    
def apply(elem: A)
检测集合中是否包含指定元素
12    
def count(p: (A) => Boolean): Int
计算满足指定条件的集合元素个数
13    
def copyToArray(xs: Array[A], start: Int, len: Int): Unit
复制不可变集合元素到数组
14    
def diff(that: Set[A]): Set[A]
比较两个集合的差集
15    
def drop(n: Int): Set[A]]
返回丢弃前n个元素新集合
16    
def dropRight(n: Int): Set[A]
返回丢弃最后n个元素新集合
17    
def dropWhile(p: (A) => Boolean): Set[A]
从左向右丢弃元素，直到条件p不成立
18    
def equals(that: Any): Boolean
equals 方法可用于任意序列。用于比较系列是否相等。
19    
def exists(p: (A) => Boolean): Boolean
判断不可变集合中指定条件的元素是否存在。
20    
def filter(p: (A) => Boolean): Set[A]
输出符合指定条件的所有不可变集合元素。
21    
def find(p: (A) => Boolean): Option[A]
查找不可变集合中满足指定条件的第一个元素
22    
def forall(p: (A) => Boolean): Boolean
查找不可变集合中满足指定条件的所有元素
23    
def foreach(f: (A) => Unit): Unit
将函数应用到不可变集合的所有元素
24    
def head: A
获取不可变集合的第一个元素
25    
def init: Set[A]
返回所有元素，除了最后一个
26    
def intersect(that: Set[A]): Set[A]
计算两个集合的交集
27    
def isEmpty: Boolean
判断集合是否为空
28    
def iterator: Iterator[A]
创建一个新的迭代器来迭代元素
29    
def last: A
返回最后一个元素
30    
def map[B](f: (A) => B): immutable.Set[B]
通过给定的方法将所有元素重新计算
31    
def max: A
查找最大元素
32    
def min: A
查找最小元素
33    
def mkString: String
集合所有元素作为字符串显示
34    
def mkString(sep: String): String
使用分隔符将集合所有元素作为字符串显示
35    
def product: A
返回不可变集合中数字元素的积。
36    
def size: Int
返回不可变集合元素的数量
37    
def splitAt(n: Int): (Set[A], Set[A])
把不可变集合拆分为两个容器，第一个由前 n 个元素组成，第二个由剩下的元素组成
38    
def subsetOf(that: Set[A]): Boolean
如果集合A中含有子集B返回 true，否则返回false
39    
def sum: A
返回不可变集合中所有数字元素之和
40    
def tail: Set[A]
返回一个不可变集合中除了第一元素之外的其他元素
41    
def take(n: Int): Set[A]
返回前 n 个元素
42    
def takeRight(n: Int):Set[A]
返回后 n 个元素
43    
def toArray: Array[A]
将集合转换为数组
44    
def toBuffer[B >: A]: Buffer[B]
返回缓冲区，包含了不可变集合的所有元素
45    
def toList: List[A]
返回 List，包含了不可变集合的所有元素
46    
def toMap[T, U]: Map[T, U]
返回 Map，包含了不可变集合的所有元素
47    
def toSeq: Seq[A]
返回 Seq，包含了不可变集合的所有元素
48    
def toString(): String
返回一个字符串，以对象来表示

L先生AI课堂
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Scala集合、数组Array、List、Set、Map
zr19305489的博客
07-13 612
Scala集合、数组Array、List、Set、Map 作者介绍：小赵，狐小E资深开发工程师，专注移动协同办公平台的SAAS软件开发以及轻应用开发 最近开发了一款移动办公软件狐小E Scala集合 Scala提供了一套很好的集合实现，提供了一些集合类型的抽象。 Scala 集合分为可变的和不可变的集合。 可变集合可以在适当的地方被更新或扩展。这意味着随时可以修改，添加，移除一个集合的元素。 而不可变集合类永远不会改变。但是，你仍然可以模拟添加，移除或更新操作。但这些操作将在每一种情况下都返回一个新的集合
Scala 【 5 数组常见操作和 Map 】
Mercury_Lc的博客
02-14 295
数组的常见操作 val a = Array(1,2,3,4,5) //数组求和 val sum = a.sum //获取数组的最大值 val max = a.max //对数组进行排序 scala.until.Sorting.quickSort(a) //获取数据的所有元素内容 a.mkString //用符号分隔开 a.mkString(",") //加上左右符号 a.mkString("&lt...
快学Scala-元祖、集合
成都往右的博客
11-24 589
会java的集合操作，再学Scala的元祖和集合就很快了
Scala之数组、元组、映射Map、Set集合和List列表
fengge18306的博客
04-14 399
1. 数组 scala中数组的概念是和Java类似，可以用数组来存放同类型的一组数据； scala中，有两种数组，一种是定长数组，另一种是变长数组。 1.1 定长数组 定长数组指的是数组的长度是不允许改变的； 数组的元素是可以改变的； 语法： // 通过指定长度定义数组val/var变量名 = newArray[元素类型](数组长度)// 用元素直接初始化数组val/var变量名...
Scala：元祖的使用
编程学习者的博客
06-28 783
1.声明 当前内容主要用于本人学习和复习，当前的内容主要为元祖的使用 当前内容借鉴：菜鸟教程 2.元祖的使用 1.创建元祖： var 变量=(值1，值2，....) (可以添加最多22个元素) var 变量=new Tuple3(必须添加三个数据) 当前元祖允许的最大值元素为：22个 // 1.创建tuple的实例 var tuple = (1, 2); // 使用这种方式创建时可以使用一个或者多个 // 元祖类型的数据一旦创建就不可以改变，不能添加和修改数据了 var tuple2 =
Scala 数组集合
01-07
Scala 常用数组集合简单总结 数组 Array-数组 //伴⽣对象创建数组 var a1=Array(1,2,3,5,4) //创建⻓度为5的数组，所有值都是0 var a2=new Array[Int](5) //获取⻓度 a1.length a2.size //修改 a1(1) = -1 a1.update...
scala-compiler-2.11.8-API文档-中英对照版.zip
06-20
赠送jar包：scala-compiler-2.11.8.jar； 赠送原API文档：scala-compiler-2.11.8-javadoc.jar； 赠送源代码：scala-compiler-2.11.8-sources.jar； 赠送Maven依赖信息文件：scala-compiler-2.11.8.pom； 包含翻译后...
scala-burst-trie:Scala 中通用 Burst Trie 的实现
07-11
< artifactId>scala-burst-trie_${scala.binary.version} < version>0.2 注意：此工件针对多个版本的 Scala 进行交叉编译，并遵循最新的 Scala 版本命名约定。 入门 def indexContent ( getKey : T => String ,...
scala3-for-scala2-developers
05-29
适用于 Scala 2 开发人员的 Scala 3 这是Scala 2 Developers类Scala 3的存储库，包含教学材料和研讨会练习。 下载 要将此存储库下载到您的机器上，请确保您已安装 。 然后打开终端，将目录更改为要存储此存储库中...
scala-maven-plugin-4.4.0.jar
08-18
maven的scala编译包
scala中Set,Map.元组的使用
张不帅
07-28 394
文章目录SetMap元组 Set Set不可重复,不可变 HashSet 不可重复,可变 对于里面添加元素 .+= 删除元素用 .-= Map 定义 val map = Map[String,Int]("a" -> 97) 同理可以用元祖的方式定义 val map = scala.collection.mutable.HashMap(("a",97)) 也可以用 .+= ...
2020-10-03
champships的博客
10-03 138
容器解析 容器：python官方提供的几种容器 list：列表 set：集合 tuple：元组 dict：字典 列表： ls = [] ls = list() 通过下标访问元素 遍历 常见的线性表：栈（stack）、队列（queue）、数组（array）、链表（List） 列表的常见方法： [ ‘append’, ‘clear’, ‘copy’, ‘count’, ‘extend’, ‘index’, ‘insert’, ‘pop’, ‘remove’, ‘reverse’, ‘sort’] |-- ap
Scala之集合
lslslslslss的博客
01-22 1089
一、集合简介 （1）Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质。 （2）对于几乎所有的集合类，Scala都同时提供了可变和不可变的版本，分别位于以下两个包。 不可变集合：scala.collection.immutable 可变集合： scala.collection.mutable （3）不可变集合，就是指该集合对象不可修改，每次修改就会返回一个新对象，而不会对原对象进行修改。类似于java中的String对象 （4）可变集合，就是这个.
Scala数组Array/ArrayBuffer和集合Set
大数据跟我学i
04-07 479
文章目录数组分类 数组 概述 数组就是用来存储多个同类型元素的容器, 每个元素都有编号(也叫: 下标, 脚标, 索引), 且编号都是从0开始数的. 分类 定长数组 特点 数组的长度不允许改变 数组 语法 格式一：通过制定长度定义数组 val/var 变量名 = new Array[元素类型](数组长度) 格式二：通过添加数组元素定义数据 val/var 变量名 = Array(元素1,元素2,元素3...) 注： ...
scala学习笔记之Set
zyc2913的博客
09-18 147
Set的创建、赋值、取值和遍历 package com.zyc.scala import scala.collection.mutable /** * Created with IntelliJ IDEA. * Author: zyc2913@163.com * Date: 2020/9/18 15:08 * Version: 1.0 * Description:Set的创建、赋值、取值和遍历 */ object StudySet { def main(args: Array[String]):.
Scala集合
dhyaishuai的博客
07-09 100
1.数组 创建数组的两种方式 直接Array一个指定类型的数组并赋值 直接new一个定长的Array[ ] //创建类型为Int 长度为3的数组 val arr1 = new Array[Int](3) //创建String 类型的数组，直接赋值 val arr2 = Array[String]("s100","s200","s300") 遍历数组的两种方...
Scala之Array，List,Tuple,Set,Map
08-09 2256
package com.scala.study /** * Created by Administrator on 2016/8/8. */ object Test { def max(x:Int,y:Int):Int={ if(x>y) x else y } /** * 函数只有一条语句时，可以不用花括号{ }
scala中List、Array、ListBuffer、ArrayList、Set、元组区别
赣江
08-21 1万+
1.List列表：不可变 LIst支持在头部快速添加和移除条目，但是不提供快速按下标访问的功能，这个功能需要线性遍历列。 快速的头部添加和移除意味着模式匹配很顺畅 List列表跟数组非常像，2者都是同构的，同一个列表的所有元素必须是相同类型。 但是有2个重要区别 1，List是不可变的，元素不能通过赋值改变。 2.列表的结构是递归的（即链表，linkedList），而数组是平等的。 使...
Scala集合类型详解
热门推荐
Tao_cuichen的博客
04-08 1万+
Scala集合类型详解       Scala集合 Scala提供了一套很好的集合实现，提供了一些集合类型的抽象。 Scala 集合分为可变的和不可变的集合。 可变集合可以在适当的地方被更新或扩展。这意味着你可以修改，添加，移除一个集合的元素。而不可变集合类永远不会改变。不过，你仍然可以模拟添加，移除或更新操作。但是这些操作将在每一种情况下都返回一个新的集合，同时使原来的集合不发生改
如何在scala ArrayBuffer数组中添加Map类型的元素
最新发布
04-26
您可以使用 ArrayBuffer 的 +=() 方法将 Map 类型的元素添加到 Scala ArrayBuffer 数组中。例如，假设您要将以下 Map 对象添加到 ArrayBuffer 中： val map = Map("key1" -> "value1", "key2" -> "value2") 您可以...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

L先生AI课堂

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值