scala 集合List Array Seq详解

已于 2022-01-27 11:52:17 修改
阅读量1.3k 收藏
点赞数
分类专栏： Scala 文章标签： scala
于 2022-01-25 17:26:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40161254/article/details/122689258
版权

参考Scala 系列（五）—— 集合类型综述

scala> val l=List(1 to 10:_*)
val l: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> val a=Array(1 to 10:_*)
val a: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> val s=Seq(1 to 10:_*)
val s: Seq[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

A

scala> a.a
addString(                 andThen(                   appendedAll(               applyOrElse(               asInstanceOf (universal)
aggregate(  (deprecated)   appended(                  apply(                     array


scala> l.a
addString(                 andThen(                   appendedAll(               applyOrElse(
aggregate(  (deprecated)   appended(                  apply(                     asInstanceOf (universal)

scala> s.a
addString(                 andThen(                   appendedAll(               applyOrElse(
aggregate(  (deprecated)   appended(                  apply(                     asInstanceOf (universal)

addString vs mkString

  • 构造字符串函数
def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
def addString(b: StringBuilder, sep: String): StringBuilder = addString(b, "", sep, "")
def addString(b: StringBuilder): StringBuilder = addString(b, "")

mkString 内部调用了addString 的方法
看源码

 def mkString(start: String, sep: String, end: String): String =
    addString(new StringBuilder(), start, sep, end).toString

  def mkString(sep: String): String = mkString("", sep, "")

  def mkString: String = mkString("")
  • Demo
scala> a.addString(new StringBuilder(),":")
val res415: StringBuilder = 1:2:3:4:5:6:7:8:9:10

scala> a.addString(new StringBuilder(),"start",":","end")
val res416: StringBuilder = start1:2:3:4:5:6:7:8:9:10end

scala> a.addString(new StringBuilder("test"),"start",":","end")
val res417: StringBuilder = teststart1:2:3:4:5:6:7:8:9:10end

andThen

与map基本相同，不同点在于计算是惰性的。

scala> l.map(_*200+9)
val res459: List[Int] = List(209, 409, 609, 809, 1009, 1209, 1409, 1609, 1809, 2009)

scala> s.andThen(_*200+9)
val res460: PartialFunction[Int,Int] = <function1>

scala> s.andThen(_*200+9)(0)
val res461: Int = 209

andThen 是个偏函数

Scala学习笔记(六) Scala的偏函数和偏应用函数

appendedAll vs appended

  • appended append 一个元素
  • appendedAll append一个集合
scala> a.appendedAll(s.toArray)
val res478: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> a.appended(100)
val res481: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100)

applyOrElse

  • 定义
    def applyOrElse[A1 <: A, B1 >: B](x: A1, default: A1 => B1): B1 = if (isDefinedAt(x)) apply(x) else default(x)
  • 功能
    接收2个参数，第一个是调用的参数，第二个是个回调函数。如果第一个调用的参数能匹配，返回匹配的值，否则调用回调函数。（回调函数的输入类型需与调用参数类型一致），就相当于if-else分支调用函数
scala> a.applyOrElse(100,{i=>i+5})
                         ^
      error: missing parameter type

scala> a.applyOrElse(100,{i:Int=>i+5})
val res829: Int = 105

scala> a.applyOrElse(4,{i:Int=>i+5})
val res830: Int = 5

scala> a.apply(4)
val res832: Int = 5

C

scala> l.c
canEqual(                    combinations(                concat(                      copyToArray(                 count(
collect(                     companion     (deprecated)   contains(                    copyToBuffer( (deprecated)
collectFirst(                compose(                     containsSlice(               corresponds(

scala> a.c
canEqual(                    collectFirst(                compose(                     containsSlice(               corresponds(
clone()                      combinations(                concat(                      copyToArray(                 count(
collect(                     companion     (deprecated)   contains(                    copyToBuffer( (deprecated)

scala> s.c
canEqual(                    combinations(                concat(                      copyToArray(                 count(
collect(                     companion     (deprecated)   contains(                    copyToBuffer( (deprecated)
collectFirst(                compose(                     containsSlice(               corresponds(

count

  • 满足某条件的下的元素的个数
  • 同 filter然后size
scala> s.count(x=>x>5)
val res1433: Int = 5

scala> s.filter(x=>x>5).size
val res1435: Int = 5

concat

  • 连接多个Traversable 对象到一个新的Traversable 对象
scala> a.concat(s)
val res600: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

contains vs containsSlice

  • contains 是否包含某个元素
  • containsSlice 是否包含某个子序列
scala> val sli=Seq(3,4,5)
val sli: Seq[Int] = List(3, 4, 5)

scala> a.containsSlice(sli)
val res594: Boolean = true

scala> a.contains(8)
val res596: Boolean = true

collect vs collectFirst

  • 利用偏函数筛选元素
scala> a.collect{case i if i%2==0=>i*i}
val res601: Array[Int] = Array(4, 16, 36, 64, 100)


def filterEven:PartialFunction[Int,Int]={
    case x if x%2==0=>x
  }
l.collect(filterEven)
  • 源码
 def collect[B, That](pf: PartialFunction[A, B])(implicit bf: CanBuildFrom[Repr, B, That]): That = {
    val b = bf(repr)
    foreach(pf.runWith(b += _))
    b.result
  }

  • 使用collect 时，利用偏函数的原理，可以同时实现filter 和map的特性。
    l.collect { case i if i % 2 == 0 => i * i } 等同与
    l.filter(i => i % 2 == 0).map(i => i * i)

  • collectFirst collect的第一个元素

combinations

  • def combinations(n: Int): Iterator[Repr] =
    n个元素的可能组合，返回迭代器
scala> s.combinations(1)
val res633: Iterator[Seq[Int]] = <iterator>

scala> s.combinations(1).toList
val res635: List[Seq[Int]] = List(List(1), List(2), List(3), List(4), List(5), List(6), List(7), List(8), List(9), List(10))

scala> s.combinations(1).toList.flatten
val res638: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> s.combinations(2).toList.flatten
val res639: List[Int] = List(1, 2, 1, 3, 1, 4, 1, 5, 1, 6, 1, 7, 1, 8, 1, 9, 1, 10, 2, 3, 2, 4, 2, 5, 2, 6, 2, 7, 2, 8, 2, 9, 2, 10, 3, 4, 3, 5, 3, 6, 3, 7, 3, 8, 3, 9, 3, 10, 4, 5, 4, 6, 4, 7, 4, 8, 4, 9, 4, 10, 5, 6, 5, 7, 5, 8, 5, 9, 5, 10, 6, 7, 6, 8, 6, 9, 6, 10, 7, 8, 7, 9, 7, 10, 8, 9, 8, 10, 9, 10)

scala> s.combinations(2).toList
val res640: List[Seq[Int]] = List(List(1, 2), List(1, 3), List(1, 4), List(1, 5), List(1, 6), List(1, 7), List(1, 8), List(1, 9), List(1, 10), List(2, 3), List(2, 4), List(2, 5), List(2, 6), List(2, 7), List(2, 8), List(2, 9), List(2, 10), List(3, 4), List(3, 5), List(3, 6), List(3, 7), List(3, 8), List(3, 9), List(3, 10), List(4, 5), List(4, 6), List(4, 7), List(4, 8), List(4, 9), List(4, 10), List(5, 6), List(5, 7), List(5, 8), List(5, 9), List(5, 10), List(6, 7), List(6, 8), List(6, 9), List(6, 10), List(7, 8), List(7, 9), List(7, 10), List(8, 9), List(8, 10), List(9, 10))

compose

count

canEqula

  • 作用判断两个对象是否可以比较

D

scala> a.d
diff(         distinct      distinctBy(   drop(         dropRight(    dropWhile(

scala> l.d
diff(         distinct      distinctBy(   drop(         dropRight(    dropWhile(

scala> s.d
diff(         distinct      distinctBy(   drop(         dropRight(    dropWhile(

diff

  • diff 两个集合的差集

distinct

  • 集合去重
scala> a.concat(a).distinct
val res684: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

distinctBy

  • 方法在应用给定的转换函数后返回序列的所有元素，而忽略重复项：
scala> List(("a", 2.7), ("b", 2.1), ("a", 5.4)).distinctBy(_._2.floor)
val res720: List[(String, Double)] = List((a,2.7), (a,5.4))

scala> List(("a", 2), ("b", 2), ("a", 5)).distinctBy(_._1)
val res721: List[(String, Int)] = List((a,2), (b,2))

scala> List(("a", 2), ("b", 2), ("a", 5)).distinctBy(_._2)
val res722: List[(String, Int)] = List((a,2), (a,5))

drop (n) vs dropRight (n)

  • 丢弃前N个或者后N个元素
scala> a.drop(3)
val res687: Array[Int] = Array(4, 5, 6, 7, 8, 9, 10)

scala> a.dropRight(2)
val res690: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8)

dropWhile

  • dropWhile 丢弃条件所在集合开头的所有项目true,一旦第一项失败，它就会停止丢弃
scala> a.dropWhile(x=>{x>0})
val res713: Array[Int] = Array()

scala> a.dropWhile(x=>{x>4})
val res714: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> a.dropWhile(x=>x<4)
val res718: Array[Int] = Array(4, 5, 6, 7, 8, 9, 10)
  • 跟filter的区别 filter丢弃整个集合中条件不正确的所有元素

E


scala> a.e
elemTag                 empty                   ensuring( (universal)   equals(   (universal)
elementWise             endsWith(               eq(       (universal)   exists(

scala> l.e
elementWise             empty                   endsWith(               ensuring( (universal)   eq(       (universal)   equals(                 exists(

scala> s.e
elementWise             empty                   endsWith(               ensuring( (universal)   eq(       (universal)   equals(                 exists(

val t: Iterable[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> a.e
elemTag                 empty                   ensuring( (universal)   equals(   (universal)
elementWise             endsWith(               eq(       (universal)   exists(

elemTag

返回集合元素的类型

scala> val sss=Array((1,2),(3,4))
val sss: Array[(Int, Int)] = Array((1,2), (3,4))

scala> sss.elemTag
val res805: scala.reflect.ClassTag[(Int, Int)] = scala.Tuple2

scala> a.elemTag
val res808: scala.reflect.ManifestFactory.IntManifest = Int

empty

集合置空

equals vs eq

  • eq 判断两个对象地址是否相同
scala> a.equals(s)
val res902: Boolean = false

scala> l.equals(s)
val res903: Boolean = true


scala> a.eq(s)
val res904: Boolean = false

scala> a.eq(s)
val res905: Boolean = false

endsWith vs startWith

判断集合是否以某个序列开始或者结束

scala> a.endsWith(Array(9,10))
val res812: Boolean = true

scala> a.endsWith(Array(1,9,10))
val res813: Boolean = false

exists

  • 判断当前数组是否包含符合条件的元素
scala> a.exists(x=>x>100)
val res817: Boolean = false

scala> a.exists(x=>x>4)
val res818: Boolean = true

F

scala> t.f
filter(                  find(                    flatten(                 foldLeft(                forall(                  formatted( (universal)
filterNot(               flatMap(                 fold(                    foldRight(               foreach(

filter vs filterNot

  • filter 返回满足条件的元素
  • filterNot 返回不满足条件的元素
scala> a.filterNot(x=>x%2==0)
val res879: Array[Int] = Array(1, 3, 5, 7, 9)

scala> a.filterNot(x=>x%2==0).concat(a.filter(x=>x%2==0))
val res885: Array[Int] = Array(1, 3, 5, 7, 9, 2, 4, 6, 8, 10)

find

scala> a.find(x=>x>1)
val res951: Option[Int] = Some(2)

scala> a.find(x=>x>100)
val res952: Option[Int] = None

flatten

二维数组扁平化

scala> Array(Array(1,2,3),Array(3,4,5),Array(6,7)).flatten
val res914: Array[Int] = Array(1, 2, 3, 3, 4, 5, 6, 7)

forall

  • forall 是否每个元素都满足条件
scala> a.forall(x=>x>3)
val res960: Boolean = false

scala> a.forall(x=>x>0)
val res961: Boolean = true

scala> a.forall(x=>x>1)
val res962: Boolean = false

scala> a.forall(x=>x<100)
val res963: Boolean = true

formatted

flatMap

先map后降维

scala> arr.flatMap(_.map(_+1))
val res936: Array[Int] = Array(2, 3, 4, 4, 5, 6, 7, 8)

等同与一下操作
scala> arr.map(_.map(_+1))
val res937: Array[Array[Int]] = Array(Array(2, 3, 4), Array(4, 5, 6), Array(7, 8))

scala> arr.map(_.map(_+1)).flatten
val res938: Array[Int] = Array(2, 3, 4, 4, 5, 6, 7, 8)

fold vs foldRight nv foldLeft

fold 同foldLeft

scala> str.fold("Z")(_+_)
val res945: String = ZABCD

scala> str.foldLeft("Z")(_+_)
val res947: String = ZABCD

scala> str.foldRight("Z")(_+_)
val res949: String = ABCDZ

foreach

  • 作用 针对每个元素调用函数，并且忽略函数结果
scala> a.foreach(x=>x*x)

scala> a.foreach(print)
12345678910
scala> a.foreach(print(_))
12345678910

G

scala> t.g
getClass() (universal)   groupBy(                 groupMap(                groupMapReduce(          grouped(

groupBy

scala> val t=Array(("Tom",12),("Tim",12),("Tom",12),("Tom",24),("Tim",23),("Penny",12))
val t: Array[(String, Int)] = Array((Tom,12), (Tim,12), (Tom,12), (Tom,24), (Tim,23), (Penny,12))

scala> t.groupBy
def groupBy[K](f: ((String, Int)) => K): scala.collection.immutable.Map[K,Array[(String, Int)]]
scala> t.groupBy(_._1)
val res1014: scala.collection.immutable.Map[String,Array[(String, Int)]] = Map(Penny -> Array((Penny,12)), Tom -> Array((Tom,12), (Tom,12), (Tom,24)), Tim -> Array((Tim,12), (Tim,23)))

scala> t.groupBy(x=>x._1)("Tom")
val res1029: Array[(String, Int)] = Array((Tom,12), (Tom,12), (Tom,24))


scala> t.groupBy(_._2)
val res1015: scala.collection.immutable.Map[Int,Array[(String, Int)]] = Map(23 -> Array((Tim,23)), 24 -> Array((Tom,24)), 12 -> Array((Tom,12), (Tim,12), (Tom,12), (Penny,12)))

scala> a.groupBy(x=>x>5)
val res1025: scala.collection.immutable.Map[Boolean,Array[Int]] = Map(false -> Array(1, 2, 3, 4, 5), true -> Array(6, 7, 8, 9, 10))

groupMap

scala> t.groupMap(_._1)(_._2)
val res1032: scala.collection.immutable.Map[String,Array[Int]] = Map(Penny -> Array(12), Tom -> Array(12, 12, 24), Tim -> Array(12, 23))

grouped

  • 按指定数量分组，每组有 size 个元素，返回一个迭代器
scala> a.grouped(2)
val res982: Iterator[Array[Int]] = <iterator>

scala> a.grouped(2).toList
val res985: List[Array[Int]] = List(Array(1, 2), Array(3, 4), Array(5, 6), Array(7, 8), Array(9, 10))

scala> l.grouped(3).toArray
val res989: Array[List[Int]] = Array(List(1, 2, 3), List(4, 5, 6), List(7, 8, 9), List(10))

scala> str.grouped(3).toSeq
val res994: Seq[Iterable[String]] = List(List(A, B, C), List(D))

groupMapReduce

H

scala> t.h
hasDefiniteSize (deprecated)   hashCode()       (universal)   head                           headOption

head vs lat vs headOption vs lastOption vs find

找到第一个或者最后一个或者满足条件的第一个元素

scala> a.last
val res1050: Int = 10

scala> t.head
val res1052: (String, Int) = (Tom,12)

scala> a.headOption
val res1055: Option[Int] = Some(1)

scala> a.headOption
val res1058: Option[Int] = Some(1)

scala> t.headOption
val res1060: Option[(String, Int)] = Some((Tom,12))

scala> a.find(x=>x>5)
val res1062: Option[Int] = Some(6)

I

scala> t.i
indexOf(                   indices                    intersect(                 isInstanceOf (universal)   iterator
indexOfSlice(              init                       isDefinedAt(               isTraversableAgain
indexWhere(                inits                      isEmpty                    iterableFactory

init vs tail inits vs tails

  • head 和last相对
  • init 和tail相对
  • inits 和tails相对. 返回迭代器
  • take 和drop相对
  • takeWhile和dropWhile相对
scala> a.init
val res1082: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)

scala> a.inits
val res1083: Iterator[Array[Int]] = <iterator>

scala> a.tail
val res1084: Array[Int] = Array(2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> a.inits.toList
val res1086: List[Array[Int]] = List(Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10), Array(1, 2, 3, 4, 5, 6, 7, 8, 9), Array(1, 2, 3, 4, 5, 6, 7, 8), Array(1, 2, 3, 4, 5, 6, 7), Array(1, 2, 3, 4, 5, 6), Array(1, 2, 3, 4, 5), Array(1, 2, 3, 4), Array(1, 2, 3), Array(1, 2), Array(1), Array())

scala> a.tails
val res1087: Iterator[Array[Int]] = <iterator>

scala> a.tails.toList
val res1089: List[Array[Int]] = List(Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10), Array(2, 3, 4, 5, 6, 7, 8, 9, 10), Array(3, 4, 5, 6, 7, 8, 9, 10), Array(4, 5, 6, 7, 8, 9, 10), Array(5, 6, 7, 8, 9, 10), Array(6, 7, 8, 9, 10), Array(7, 8, 9, 10), Array(8, 9, 10), Array(9, 10), Array(10), Array())

isEmpty

判断集合是否是空

intersect

  • 两个集合的交集
scala> a.intersect(Seq(5,6,7,100,23))
val res1095: Array[Int] = Array(5, 6, 7)

indexOf vs indexOfSlice vs indexWhere

存在返回索引 否则返回-1

scala> a.indexOfSlice(Seq(5,6))
val res1110: Int = 4

scala> a.indexOfSlice(Seq(5,6,8))
val res1111: Int = -1

scala> a.indexOfSlice(Seq(9,10))
val res1112: Int = 8

scala> a.indexWhere(x=>x>5)
val res1116: Int = 5

scala> a.indexOf(3)
val res1119: Int = 2

indices

  • 返回索引
scala> arr.indices
val res1123: scala.collection.immutable.Range = Range 0 until 3

scala> arr.indices.toList
val res1126: List[Int] = List(0, 1, 2)

K

knowSize

  • 测试此集合是否已知具有有限大小
scala> a.knownSize
val res1157: Int = 10

scala> s.knownSize
val res1159: Int = -1

scala> l.knownSize
val res1161: Int = -1

L

scala> t.l
last                lastIndexOfSlice(   lastOption          length              lengthIs
lastIndexOf(        lastIndexWhere(     lazyZip(            lengthCompare(      lift

lazyZip

scala> a.lazyZip(s).toList
val res1224: List[(Int, Int)] = List((1,1), (2,2), (3,3), (4,4), (5,5), (6,6), (7,7), (8,8), (9,9), (10,10))

scala> a.zip(s)
val res1225: Array[(Int, Int)] = Array((1,1), (2,2), (3,3), (4,4), (5,5), (6,6), (7,7), (8,8), (9,9), (10,10))

scala> a.lazyZip(s)
val res1226: scala.collection.LazyZip2[Int,Int,Array[Int]] = ArraySeq(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).lazyZip(List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))

lift

last vs lastIndexOf vs lastIndexWhere vs lastIndexOfSlice vs latOption

scala> a.last
val res1166: Int = 10

scala> a.lastIndexOf(9)
val res1174: Int = 8

scala> a.lastIndexOfSlice(Seq(9,10))
val res1188: Int = 8

scala> a.lastIndexOfSlice(Seq(9,10,12))
val res1189: Int = -1

scala> a.lastIndexWhere(x=>x>1)
val res1194: Int = 9

length vs lengthIs

  • 返回个数

lengthCompare

scala> a.lengthCompare(10)
val res1209: Int = 0

scala> a.lengthCompare(9)
val res1210: Int = 1

scala> a.lengthCompare(11)
val res1211: Int = -1

M

scala> t.m
map(           mapInPlace(    max(           maxBy(         maxByOption(   maxOption(     min(           minBy(         minByOption(   minOption(     mkString(

min vs max vs minBy vs maxBy vs minOption vs maxOption vs minByOption vs maxByOption

scala> arr.maxBy(x=>x(1))
val res1276: Array[Int] = Array(6, 7)

scala> arr
val res1277: Array[Array[Int]] = Array(Array(1, 2, 3), Array(3, 4, 5), Array(6, 7))

scala> arr.maxByOption(x=>x(1))
val res1279: Option[Array[Int]] = Some([I@399b7e3d)

scala> arr.minBy(x=>x(0))
val res1284: Array[Int] = Array(1, 2, 3)

scala> l.min
val res1285: Int = 1

scala> l.max
val res1286: Int = 10

scala> l.minOption
val res1288: Option[Int] = Some(1)

mkString

scala> l.mkString("start",":","over")
val res1296: String = start1:2:3:4:5:6:7:8:9:10over

mapConserve

N

scala> t.n
ne(         (universal)   nonEmpty                  notify()    (universal)   notifyAll() (

P

scala> t.p
padTo(                       partitionMap(                permutations                 prepended(                   product(
partition(                   patch(                       prefixLength( (deprecated)   prependedAll(

R

scala> t.r
reduce(                    reduceLeftOption(          reduceRight(               repr        (deprecated)   reverseIterator            runWith(
reduceLeft(                reduceOption(              reduceRightOption(         reverse                    reverseMap( (de

S

scala> t.s
sameElements(               search(                     sizeCompare(                sortBy(                     sortWith(                   startsWith(
scan(                       segmentLength(              sizeIs                      sortInPlace(                sorted(                     stepper(
scanLeft(                   seq          (deprecated)   slice(                      sortInPlaceBy(              span(                       sum(
scanRight(                  size                        sliding(                    sortInPlaceWith(            splitAt(                    synchronized( (uni

T

scala> t.t
tail                         takeWhile(                   toBuffer                     toList                       toStream      (deprecated)   transform(    (deprecated)
tails                        tapEach(                     toIndexedSeq                 toMap(                       toString()     (universal)   transpose(
take(                        to(                          toIterable                   toSeq                        toTraversable (deprecated)
takeRight(                   toArray(                     toIterator    (deprecated)   toSet                        toVector

U

scala> t.u
unapply(              union( (deprecated)   unzip(                unzip3(               update(               updated(

unzip vs unzip

  • unzip将元素拆分，转成2个列表
    -unzip3 转成3个列表
scala> val t=Traversable("a_1","b_2","c_2")
             ^
       warning: value Traversable in package scala is deprecated (since 2.13.0): Use Iterable instead of Traversable
val t: Iterable[String] = List(a_1, b_2, c_2)

scala> t.unzip(x=>(x(0),x.substring(2).toInt))
val res1423: (Iterable[Char], Iterable[Int]) = (List(a, b, c),List(1, 2, 2))

scala> t.unzip3(x=>(x(0),x.substring(2).toInt,x.substring(1)))
val res1428: (Iterable[Char], Iterable[Int], Iterable[String]) = (List(a, b, c),List(1, 2, 2),List(_1, _2, _2))

union 同concat (已经弃用)

update vs updated

  • 更新集合
  • update 更新原集合 updated产生新的结合
scala> a.update(1,200)

scala> a
val res1403: Array[Int] = Array(1, 200, 3, 4, 5, 6, 7, 8, 9, 10)

scala> a.updated(1,1000)
val res1405: Array[Int] = Array(1, 1000, 3, 4, 5, 6, 7, 8, 9, 10)

V

scala> t.view
view( (deprecated)

W


scala> t.w
wait( (universal)   withFilter(

withFilter vs filter

  • filter将采用原始集合并产生一个新集合，但是withFilter将非严格(即懒惰地)将未过滤的值传递给以后的map / flatMap / withFilter调用，从而保存第二次传递通过(过滤的)集合。因此，当传递到这些后续方法调用时，它将更加高效。
scala> l.withFilter(x=>x>5)
val res1370: scala.collection.WithFilter[Int,[_]List[_]] = scala.collection.IterableOps$WithFilter@3f7f71e7

scala> l.withFilter(x=>x>5).map(_+1)
val res1371: List[Int] = List(7, 8, 9, 10, 11)

scala> l.filter(x=>x>5)
val res1373: List[Int] = List(6, 7, 8, 9, 10)

scala> l.filter(x=>x>5).map(_+1)
val res1374: List[Int] = List(7, 8, 9, 10, 11)

Z

scala> t.zip
zip(           zipAll(        zipWithIndex

zip vs zipAll vs zipWithIndex

  • 把两个集合合并为二元数组集合
  • zip 后的长度为两个集合的最小长度
  • zipAll 同zip，区别是可以设置默认值，长度为两个集合的最大长度
  • zipWithIndex 与自己的索引zip
scala> a.zipWithIndex
val res1360: Array[(Int, Int)] = Array((1,0), (2,1), (3,2), (4,3), (5,4), (6,5), (7,6), (8,7), (9,8), (10,9))

scala> a.zipWithIndex(0)
val res1361: (Int, Int) = (1,0)

scala> val l=Seq("A","B","C")
val l: Seq[String] = List(A, B, C)

scala> val m=Seq(3,4,5,6,7,8)
val m: Seq[Int] = List(3, 4, 5, 6, 7, 8)

scala> l.zip(m)
val res1351: Seq[(String, Int)] = List((A,3), (B,4), (C,5))

scala> l.zipAll(m,"Z",800)
val res1353: Seq[(String, Int)] = List((A,3), (B,4), (C,5), (Z,6), (Z,7), (Z,8))
NoOne-csdn
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Scala集合，Scala序列，Scala Seq，Array，ArrayBuffer，元组Tuple，列表，List，ListBuffer，队列QueueScala数组与JavaList的互转
weixin_42217030的博客
09-22 4098
1、Scala集合基本介绍 1.1 有关Scala集合的几个重点 Scala同时支持不可变集合和可变集合，可变集合可以安全的并发访问。 两个主要的包：不可变集合：scala.collection.immutable。可变集合：scala.collection.mutable。 Scala默认采用不可变集合，对于几乎所有的集合类，Scala都同时提供了可变和不可变的版本...
scala Seq Array List 区别
紫蝶侠的博客
06-01 1048
Scala接口架构图: 创建Seq: val s1 = Seq(1,2,3,4,5) val s2 = Seq(6,7,8,9,10) scala Seq Array List 区别 scala Seq Array List 区别 seq()和array() Scala数组与Scala序列是兼容的 - 在需要Seq[T]的地方可由Array[T]代替。最后，Scala数组支持所有的序列操作。 https://www.cnblogs.com/iceelor/p/6039088.html Scala的Se
Scala集合之Seq
花木兰
04-15 1万+
Scala 的集合分为三大类序列Seq,集Set 以及映射Map。所有的集合都扩展自 Iterable 特质在 Scala 中集合有可变（“scala.collection.mutable” 包下存放）和不可变（“scala.collection.immutable” 包下存放）两种类型。 ...
scala 集合总结（Seq、Map、Set、List、Tuple、Option）
nefu_ljw的博客
01-04 1458
从较高的层次来看 Scala 集合，主要有以下三个类别可供选择： Sequences是元素的顺序集合，可以是索引的（如数组）或线性的（如链表）； Maps包含键/值对的集合，类似于Java的Map、Python的dict； Sets是唯一元素的无序集合； 所有这些都是基本类型，并且具有用于特定目的的子类型，例如并发、缓存和流式处理。除了这三个主要类别之外，还有其他有用的集合类型，包括ranges, stacks, queues。
Scala 集合 —— Array、Map、Seq、Set
04-21 1万+
Scala 集合类库很庞大，包括 List，Set，Map，Array等。利用 toList，toSet 和 toArray 方法，各种集合类型可以方便地互相转换。MapScala 的 Map 类没有提供根据内容的键或值排序的方法，当我们可以将 Map 转换为 Scala 的 Seq 类型，而 Seq 支持排序。Scala 的 Seq 类和 Java 的 List 接口类似，都是可迭代集合，即具有确
Scala入门之List使用详解
08-25
Scala入门之List使用详解 Scala是一种函数式风格与面向对象共存的编程语言，在Scala中，List是不可变的对象，具有递归结构，具有协变性。下面将详细介绍Scala中的List使用详解。 List类型定义及特点 在Scala中，...
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的集合算子
01-07
Scala集合提供了丰富的计算算⼦，⽤于实现集合/数组的计算，这些计算⼦⼀般针对于List、Array、Set、Map、Range、Vector、Iterator等都可以适⽤。 排序 ① sorted scala> var a = Array(1,3,4,2,5) a: Array[Int] = ...
头歌Scala中集合的使用
04-13
Scala中集合的使用 大学生 1. List 列表的使用 2. Set 集合的使用 3.Map 映射的使用 4. 元组的使用
Scala 集合数据操作示例
11-13
map[B](f: (A) ? B): List[B] 定义一个变换,把该变换应用到列表的每个元素中,原列表不变，返回一个新的列表数据
【Scala】集合总结（一）——Array、List、Set、Map、Tuple的创建、访问、遍历方法
克里斯的博客
01-19 1010
一、Scala集合简介 （1）Scala 的集合有三大类：序列 Seq、集 Set、映射 Map，所有的集合都扩展自 Iterable 特质。 （2）对于几乎所有的集合类，Scala 都同时提供了可变和不可变的版本，分别位于以下两 个包： 不可变集合：scala.collection.immutable 可变集合： scala.collection.mutable （3）Scala 不可变集合，就是指该集合对象不可修改，每次修改就会返回一个新对象，而 不会对原对象进行修改。类
Fluent_Python_Part2数据结构，02-array-seq，序列类型
anchenhe9360的博客
04-04 246
1. 序列数据 例如字符串、列表、字节序列、元组、XML元素、数据库查询结果等，在Python中用统一的风格去处理。例如，迭代、切片、排序、拼接等。 2. 容器序列与扁平序列 容器序列：容器对象包含任意类型对象的引用。如list、tuple和collections.deque. 但dict和set是容器但并非是序列。 扁平序列：存放的是同一种类型诸如字符、字节和数字而不是引用，是一...
scala常用操作符和Iterable、Seq特质方法
提拉米苏的博客
10-30 7328
用于添加和移除元素的操作符 操作符：coll:+elem 或 elem+:coll 集合类型：Seq var coll = List(1,2,3) val elem = 4 print(coll:+elem) //运行结果 List(1, 2, 3, 4) 操作符：coll+elem 或 coll+(e1,e2,...) 集合类型：Set&amp;amp;Map var coll1 = ...
scala中集合求交集、并集、差集
微步的博客
02-08 1万+
前言：scala中的集合Set，用于存放无序非重复数据对于非Set集合（Array/ArrayBuffer/List/ListBuffer），在做交集、并集、差集时必须转换为Set，否则元素不去重没有意义。而对于非Set类型集合元素去重，也有个很好的方法：distinctscala&gt; List(1,2,2,3).distinct    去重方法一、求交集：使用&amp;或者interset方...
Scala中Array和List的区别
power0405hf的专栏
12-09 1万+
Difference between Array and List in scala Q:什么时候用Array（Buffer）和List（Buffer）? A: Scala中的List是不可变的递归数据（immutable recursive data）,是Scala中的一种基础结构，你应该多用List而不是Array（Array实际上是mutable，不可变（immutable）的Array是
scala中List、Array、ListBuffer、ArrayList、Set、元组区别
热门推荐
赣江
08-21 1万+
1.List列表：不可变 LIst支持在头部快速添加和移除条目，但是不提供快速按下标访问的功能，这个功能需要线性遍历列。 快速的头部添加和移除意味着模式匹配很顺畅 List列表跟数组非常像，2者都是同构的，同一个列表的所有元素必须是相同类型。 但是有2个重要区别 1，List是不可变的，元素不能通过赋值改变。 2.列表的结构是递归的（即链表，linkedList），而数组是平等的。 使...
Java 的 List 与 Scala 的 Seq 相互转换
九师兄
03-13 5843
List 转 Seq： List&lt;String&gt; tmpList = new ArrayList&lt;&gt;(); tmpList.add("abc"); Seq&lt;String&gt; tmpSeq = JavaConverters.asScalaIteratorConverter(tmpList.iterator()).asScala().toSeq(); S...
scala之-——seq和list有什么区别
小白学编程
09-04 7611
seq相当于list list继承自seq
scala中list和array的区别
最新发布
03-29
Scala中的List和Array都是集合类型，但是它们有以下区别： 1. 实现方式不同：List是链表，Array是定长数组。 2. 可变性不同：List是不可变的，一旦创建就不能修改，而Array是可变的，可以随时修改。 3. 内存分配方式不同：List在分配内存时，会按需分配，只分配需要的内存，而Array在创建时就会分配一定大小的内存空间。 4. 访问方式不同：List只能通过head、tail等方法访问元素，而Array可以通过下标访问元素。 5. 功能不同：List提供了丰富的函数式编程方法，如map、filter、fold等，而Array提供了更多的操作，如排序、查找、拷贝等。 总的来说，List适合处理不可变的数据集合，如配置文件、函数返回值等，而Array适合处理需要频繁修改的数据集合，如游戏中的角色状态、图像数据等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值