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

一、前述

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)

Nil长度为0的list

 //创建
    val list = List(1,2,3,4,5)
    
    //遍历
    list.foreach { x => println(x)}
//    list.foreach { println}
    //filter
    val list1  = list.filter { x => x>3 }
    list1.foreach { println}
    
    //count
    val value = list1.count { x => x>3 }
    println(value)
    
    //map
    val nameList = List(
    		"hello bjsxt",
    		"hello xasxt",
    		"hello shsxt"
        )
    val mapResult:List[Array[String]] = nameList.map{ x => x.split(" ") }
    mapResult.foreach{println}    
    
    //flatmap
    val flatMapResult : List[String] = nameList.flatMap{ x => x.split(" ") }
    flatMapResult.foreach { println }

 备注: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 返回一个字符串,以对象来表示

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏软件开发 -- 分享 互助 成长

(虚)继承类的内存占用大小

(虚)继承类的内存占用大小 首先,平时所声明的类只是一种类型定义,它本身是没有大小可言的。 因此,如果用sizeof运算符对一个类型名操作,那得到的是具有该类...

22280
来自专栏一直在跳坑然后爬坑

Kotlin之“AbstractMutableList”

打印结果分别为 prefix1:2:3:4:5:6postfix prefix1:2:3:truncatedpostfix

17620
来自专栏程序员互动联盟

【编程基础】c printf知多少

printf()函数是格式输出函数,请求printf()打印变量的指令取决与变量的类型.例如,在打印整数是使用%d符号,在打印字符是用%c 符号.这些符号被称为...

34350
来自专栏Android开发指南

8:String类

30280
来自专栏Nian糕的私人厨房

JavaScript 字符串

toString() 方法,返回一个表示该对象的字符串,可以将所有的数据都转换为字符串,但是要排除掉 null 和 undefined

9470
来自专栏章鱼的慢慢技术路

数据结构与算法笔试面试题整理

b.对每一对相邻的元素做同样的工作,从开始的第一对一致到结尾的最后一对,经过这一步,最后的元素将是最大值;

37430
来自专栏黑泽君的专栏

java基础学习_集合类01_对象数组、集合Collection接口、集合List接口_day15总结

============================================================================= ==...

9410
来自专栏星汉技术

Scala中的集合类型

825100
来自专栏逻辑熊猫带你玩Python

Python | 6大数据类型方法归纳总结(上)

在Python 3里,只有一种整数类型 int,表示为长整型,没有 python2 中的 Long。

70140
来自专栏郭耀华‘s Blog

Java集合框架(一)—— Collection、Iterator和Foreach的用法

1.Java集合概述   在编程中,常常需要集中存放多个数据。当然我们可以使用数组来保存多个对象。但数组长度不可变化,一旦在初始化时指定了数组长度,则这个数组长...

36390

扫码关注云+社区

领取腾讯云代金券