精华内容
下载资源
问答
  • Scala数组函数

    2020-09-18 23:32:16
    注:因为数组中包含数字也包含字符串,所以会用Any顶级类型接收,如果数组有重复内容,不会去重 2、++: 说明:合并集合,冒号右边的类型决定返回结果的类型 3、+: / :+ 向数组前或者后添加一个元素,并且返回...

    Scala数组函数

    1、++

    方法:def ++[B](that: GenTraversableOnce[B]): Array[B]
    说明:合并集合,不去重,并且返回一个新数组
    代码举例:

    在这里插入图片描述
    :因为数组中包含数字也包含字符串,所以会用Any顶级类型接收

    2、++:

    方法:def ++:[B >: A, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[Array[T], B, That]): That
    说明:合并集合,冒号右边的集合类型决定返回新数组的类型
    代码举例

    在这里插入图片描述

    3、+:

    方法:def +:(elem: A): Array[A]
    说明:在集合前面加一个数,并返回新的数组
    代码举例

    在这里插入图片描述

    4、:+

    方法:def +:(elem: A): Array[A]
    说明:在集合后面加一个数,并返回新的数组
    代码举例

    在这里插入图片描述

    5、/:

    方法:def /:[B](z: B)(op: (B, T) ⇒ B): B
    说明:对数组中所有的元素进行相同的操作,左子树foldLeft的简写
    代码举例

    在这里插入图片描述

    6、:\

    方法:def /:[B](z: B)(op: (T,B) ⇒ B): B
    说明:对数组中所有的元素进行相同的操作,右子树foldRight的简写
    代码举例

    在这里插入图片描述

    7、addString

    7.1

    方法:def addString(b: StringBuilder): StringBuilder
    说明:将数组中的元素逐个添加到b中
    代码举例

    在这里插入图片描述

    7.2

    方法:def addString(b: StringBuilder, sep: String): StringBuilder
    说明:将数组中的元素逐个添加到b中,每个元素用sep分隔符分开
    代码举例

    在这里插入图片描述

    7.3

    方法:def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
    说明:将数组中的元素逐个添加到b中,在首尾各加一个字符串,并指定sep分隔符
    代码举例

    在这里插入图片描述

    8、aggregate

    方法:def aggregate[B](z: ⇒ B)(seqop: (B, T) ⇒ B, combop: (B, B) ⇒ B): B
    说明:聚合函数,aggregate是柯里化方法,参数是两个方法;将aggregate的两个参数分别封装成两个方法,并把计算过程打印出来
    代码举例

    在这里插入图片描述

    9、andThen

    方法
    说明
    代码举例

    10、apply

    方法:def apply(i: Int): T
    说明:取出索引处的元素
    代码举例

    在这里插入图片描述

    11、applyOrElse

    方法
    说明
    代码举例

    12、array

    方法
    说明:显示数组地址
    代码举例

    在这里插入图片描述

    13、canEqual

    方法:def canEqual(that: Any): Boolean
    说明:判断两个对象是否可以进行比较,基本上都是true,因为对象基本上都可以比较
    代码举例

    在这里插入图片描述

    14、charAt

    方法:def charAt(index: Int): Char
    说明:获取index索引处的字符,这个方法会执行一个隐式的转换。将Array[T]转换为 ArrayCharSequence,只有当T为char类型时,这个转换才会发生
    代码举例

    在这里插入图片描述

    15、clone

    方法:def clone(): Array[T]
    说明:创建一个副本,浅拷贝:复制的是地址的引用
    代码举例

    在这里插入图片描述

    16、collect

    方法:def collect[B](pf: PartialFunction[A, B]): Array[B]
    说明:并行计算(偏函数),得到一个新的数组对象,参数为偏函数
    代码举例

    在这里插入图片描述

    17、collectFirst

    方法:def collectFirst[B](pf: PartialFunction[T, B]): Option[B]
    说明:在序列中查找第一次符合偏函数定义的元素,执行偏函数计算
    代码举例

    在这里插入图片描述

    18、combinations

    方法:def combinations(n: Int): collection.Iterator[Array[T]]
    说明:排列组合,选出所有包含字符不一样的组合,包含字符数为n个
    代码举例

    在这里插入图片描述

    19、companion

    20、compose

    21、contains

    方法:def contains[A1 >: A](elem: A1): Boolean
    说明:序列中是否包含指定对象
    代码举例

    在这里插入图片描述

    22、containsSlice

    方法:def containsSlice[B](that: GenSeq[B]): Boolean
    说明:判断当前序列中是否包含另一个序列,并且序列中元素次序要求一致
    代码举例

    在这里插入图片描述

    23、copyToArray

    23.1

    方法:def copyToArray(xs: Array[A]): Unit
    说明:拷贝到一个新数组中,如果新数组长度多长,0补齐
    代码举例

    在这里插入图片描述

    23.2

    方法:copyToArray(xs: Array[A], start: Int, len: Int): Unit
    说明:拷贝到一个新数组中,如果新数组长度多长,0补齐;将拷贝的数据放置xs数组的start索引位置,拷贝len个数据
    代码举例

    在这里插入图片描述

    24、copyToBuffer

    方法:def copyToBuffer[B >: A](dest: Buffer[B]): Unit
    说明:将数据中的内容拷贝到ArrayBuffer中
    代码举例

    在这里插入图片描述

    25、coresponds

    方法:def corresponds[B](that: GenSeq[B])(p: (T, B) ⇒ Boolean): Boolean
    说明:判断两个序列长度以及对应位置元素是否符合某个条件,如果两个序列具有相同的元素数量并且p(x,y)=true,返回true
    代码举例

    在这里插入图片描述

    26、count

    方法:count(p: (T) ⇒ Boolean): Int
    说明:统计符合条件的元素个数
    代码举例

    在这里插入图片描述

    27、deep

    方法
    说明:返回IndexedSeq的类型的数组
    代码举例

    在这里插入图片描述

    28、diff

    方法:def diff(that: collection.Seq[T]): Array[T]
    说明:计算当前数组与另一数组的不同,将当前数组中没有再另一个数组中出现的元素返回,形成一个新数组
    代码举例

    在这里插入图片描述

    29、distinct

    方法:def distinct: Array[T]
    说明:去除当前集合中重复的元素,只保留一个
    代码举例

    在这里插入图片描述

    30、drop

    方法:def drop(n: Int): Array[T]
    说明:将当前序列中的前n个元素去除,返回一个新序列
    代码举例

    在这里插入图片描述

    31、dropRight

    方法:def dropRight(n: Int): Array[T]
    说明:去除当前序列中的后n个元素,并返回一个新序列返回
    代码举例

    在这里插入图片描述

    32、dropWhile

    方法:def dropWhile(p: (T) ⇒ Boolean): Array[T]
    说明:去除当前数组中符合条件的元素,从当前数组的第一个元素就要满足条件,如不满足,直接返回原数组
    代码举例:

    在这里插入图片描述

    33、elemManifest

    34、elemTag

    35、endsWith

    方法:def endsWith[B](that: GenSeq[B]): Boolean
    说明:判断是一个序列否以某个序列结尾
    代码举例

    在这里插入图片描述

    36、exists

    方法:def exists(p: (T) ⇒ Boolean): Boolean
    说明:判断当前数组是否包含符合条件的元素
    代码举例

    在这里插入图片描述

    37、filter

    方法:def filter(p: (T) ⇒ Boolean): Array[T]
    说明:取出当前数组中符合条件的元素,组成新的数组返回
    代码举例

    在这里插入图片描述

    38、filterNot

    方法:def filterNot(p: (T) ⇒ Boolean): Array[T]
    说明:与filter相反,取出当前数组中不符合条件的元素,组成新的数组返回
    代码举例

    在这里插入图片描述

    39、find

    方法:def find(p: (T) ⇒ Boolean): Option[T]
    说明:查找第一个符合条件的元素
    代码举例

    在这里插入图片描述

    40、flatMap

    方法:def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): Array[B]
    说明:先对当前序列的每一个元素进行操作,然后再降维,结果放入新序列返回
    代码举例

    在这里插入图片描述

    41、flatten

    方法:def flatten[U](implicit asTrav: (T) ⇒ collection.Traversable[U], m: ClassTag[U]): Array[U]
    说明:降维,将二维数组的所有元素联合一起,形成一个一维数组
    代码举例

    在这里插入图片描述

    42、fold

    方法:def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1
    说明:对序列中的每个元素进行二元运算,和aggregate有类似的语义
    代码举例

    在这里插入图片描述

    43、foldLeft

    方法:def foldLeft[B](z: B)(op: (B, T) ⇒ B): B
    说明:左子树,从左到右计算,用法与/:相似
    代码举例

    在这里插入图片描述

    43、foldRight

    方法:def foldRight[B](z: B)(op: (B, T) ⇒ B): B
    说明:右子树,从右到左计算,用法与:\相似
    代码举例

    在这里插入图片描述

    44、forall

    方法:def forall(p: (T) ⇒ Boolean): Boolean
    说明:检测序列中的元素是否都满足条件P,如果序列为空,返回true
    代码举例

    在这里插入图片描述

    45、foreach

    方法:def foreach(f: (A) ⇒ Unit): Unit
    说明:遍历序列中的元素,进行f操作
    代码举例

    在这里插入图片描述

    46、genericBuilder

    47、groupBy

    方法:def groupBy[K](f: (T) ⇒ K): Map[K, Array[T]]
    说明:按条件分组,条件由f匹配,返回值是Map类型,每个key对应一个序列
    代码举例

    在这里插入图片描述

    48、grouped

    方法:def grouped(size: Int): collection.Iterator[Array[T]]
    说明:按指定数量分组,每组有size个元素,返回一个集合
    代码举例

    在这里插入图片描述

    49、hasDefiniteSize

    方法:def hasDefiniteSize: Boolean
    说明:检测序列是否存在有限的长度
    代码举例

    在这里插入图片描述

    50、head

    方法:def head: T
    说明:返回序列的第一个元素,如果序列为空,引发错误
    代码举例

    在这里插入图片描述

    51、headOption

    方法:def headOption: Option[T]
    说明:返回Option类对象,就是scala.Some或者None,如果序列为空,必须给数组一个泛型,返回None
    代码举例

    在这里插入图片描述

    52、indexOf

    52.1

    方法:def indexOf(elem: T): Int
    说明:返回指定元素在序列中的索引,找到第一个就返回
    代码举例

    在这里插入图片描述

    52.2

    方法:def indexOf(elem: T, from: Int): Int
    说明:返回elem在序列中的索引,可以指定从某个索引处(from)开始查找,找到第一个就返回
    代码举例

    在这里插入图片描述

    53、indexOfSlice

    53.1

    方法:def indexOfSlice[B >: A](that: GenSeq[B]): Int
    说明:检测当前序列知否包含另一个序列,并返回第一个匹配出现的序列的索引
    代码举例

    在这里插入图片描述

    53.2

    方法:def indexOfSlice[B >: A](that: GenSeq[B], from: Int): Int
    说明:检测当前序列中是否包含另一个序列(that),并返回第一个匹配出现的序列的索引,指定从 from 索引处开始
    代码举例

    在这里插入图片描述

    54、indexWhere

    54.1

    方法:def indexWhere(p: (T) ⇒ Boolean): Int
    说明:返回当前序列中第一个满足条件的元素的索引
    代码举例

    在这里插入图片描述

    54.2

    方法:def indexWhere(p: (T) ⇒ Boolean, from: Int): Int
    说明:返回当前序列中第一个满足 p 条件的元素的索引,可以指定从 from 索引处开始
    代码举例

    在这里插入图片描述

    55、indices

    方法:def indices: collection.immutable.Range
    说明:返回当前序列索引集合
    代码举例

    在这里插入图片描述

    56、init

    方法:def init: Array[T]
    说明:返回当前序列中不包含最后一个元素的序列
    代码举例

    在这里插入图片描述

    57、inits

    方法:def inits: collection.Iterator[Array[T]]
    说明:对集合中的元素进行 init 操作,该操作的返回值中, 第一个值是当前序列的副本,包含当前序列所有的元素,最后一个值是空的,对头尾之间的值进行init操作,上一步的结果作为下一步的操作对象
    代码举例

    在这里插入图片描述

    58、intersect

    方法:def intersect(that: collection.Seq[T]): Array[T]
    说明:取两个集合的交集,返回一个新数组
    代码举例

    在这里插入图片描述

    59、isDefinedAt

    方法:def isDefinedAt(idx: Int): Boolean
    说明:判断序列中是否存在指定索引
    代码举例

    在这里插入图片描述

    60、isEmpty

    方法:def isEmpty: Boolean
    说明:判断当前序列是否为空
    代码举例

    在这里插入图片描述

    61、isTraversableAgain

    方法:def isTraversableAgain: Boolean
    说明:判断序列是否可以反复遍历,对于 Traversables 一般返回true,对于 Iterators 返回 false
    代码举例

    在这里插入图片描述

    62、iterator

    方法:def iterator: collection.Iterator[T]
    说明:对序列中的每一个元素产生一个iterator
    代码举例

    在这里插入图片描述

    63、last

    方法:def last: T
    说明:取得序列中的最后一个元素
    代码举例

    在这里插入图片描述

    64、lastIndexOf

    64.1

    方法:def lastIndexOf(elem: T): Int
    说明:取得序列中最后一个等于elem元素的位置
    代码举例

    在这里插入图片描述

    64.2

    方法:def lastIndexOf(elem: T, end: Int): Int
    说明:取得序列中最后一个等于 elem 的元素的位置,可以指定在 end 之前(包括)的元素中查找
    代码举例

    在这里插入图片描述

    65、lastIndexOfSlice

    65.1

    方法:def lastIndexOfSlice[B >: A](that: GenSeq[B]): Int
    说明:判断当前序列中是否包含序列that,并且返回最后一次出现该序列的位置的索引
    代码举例

    在这里插入图片描述

    65.2

    方法:def lastIndexOfSlice[B >: A](that: GenSeq[B], end: Int): Int
    说明:判断当前序列中是否包含序列 that,并返回最后一次出现该序列的位置处的索引,指定在 end 之前(包括)的元素中查找
    代码举例

    在这里插入图片描述

    66、lastIndexWhere

    66.1

    方法:def lastIndexWhere(p: (T) ⇒ Boolean): Int
    说明:返回当前序列中最后一个满足条件的元素索引
    代码举例

    在这里插入图片描述

    66.2

    方法:def lastIndexWhere(p: (T) ⇒ Boolean, end: Int): Int
    说明:返回当前序列中最后一个满足条件 p 的元素的索引,指定在 end 之前(包括)的元素中查找
    代码举例

    在这里插入图片描述

    67、length

    方法:def length: Int
    说明:返回当前序列中的元素个数
    代码举例

    在这里插入图片描述

    68、lengthCompare

    方法:def lengthCompare(len: Int): Int
    说明:比较序列的长度和参数len,根据两者关系返回不同的值。比较规则:数组的长度-给定的值
    代码举例

    在这里插入图片描述

    69、lift

    70、map

    方法:def map[B](f: (A) ⇒ B): Array[B]
    说明:对序列中的元素进行f操作,相当于java中的foreach
    代码举例

    在这里插入图片描述

    71、max

    方法:def max: A
    说明:返回序列中最大的元素
    代码举例

    在这里插入图片描述

    72、maxBy

    方法:def minBy[B](f: (A) ⇒ B): A
    说明:返回序列中的第一个符合条件的元素
    代码举例

    在这里插入图片描述

    73、min

    方法:def min: A
    说明:返回序列中最小的元素
    代码举例

    在这里插入图片描述

    74、minBy

    方法:def minBy[B](f: (A) ⇒ B): A
    说明:返回序列中的第一个不符合条件的元素
    代码举例

    在这里插入图片描述

    75、mkString

    75.1

    方法:def mkString: String
    说明:将所有元素组合成一个字符串
    代码举例

    在这里插入图片描述

    75.2

    方法:def mkString(sep: String): String
    说明:将所有元素组合成一个字符串,以 sep 作为元素间的分隔符
    代码举例

    在这里插入图片描述

    75.3

    方法:def mkString(start: String, sep: String, end: String): String
    说明:将所有元素组合成一个字符串以start开头,sep作为元素分隔符,end结尾
    代码举例

    在这里插入图片描述

    76、nonEmpty

    方法:def nonEmpty: Boolean
    说明:判断序列不是空
    代码举例

    在这里插入图片描述

    77、orElse

    78、padTo

    方法:def padTo(len: Int, elem: A): Array[A]
    说明:后补齐,如果当前序列长度小于 len,那么新产生的序列长度是 length。多出的几个位置填充 elem,如果当前序列大于等于 len ,则返回当前序列
    代码举例

    在这里插入图片描述

    79、par

    方法:def par: ParArray[T]
    说明:返回一个并行实现,产生的并行序列,不能被修改
    代码举例

    在这里插入图片描述

    80、partition

    方法:def partition(p: (T) ⇒ Boolean): (Array[T], Array[T])
    说明:按条件将序列拆分为两个新数组,满足条件的放到第一个序列中,其余放到第二个序列
    代码举例

    在这里插入图片描述

    81、patch

    方法:def patch(from: Int, that: GenSeq[A], replaced: Int): Array[A]
    说明:批量替换,从原序列的 from 处开始,后面的 replaced 数量个元素,将被替换成序列 that
    代码举例

    在这里插入图片描述

    82、permutations

    方法:def permutations: collection.Iterator[Array[T]]
    说明:排列组合,与combinations不同的是,组合中的内容可以相同,但是顺序不能相同
    代码举例

    在这里插入图片描述

    83、prefixLength

    方法:def prefixLength(p: (T) ⇒ Boolean): Int
    说明:给定一个条件,返回一个前置数列的长度,这个数列中的元素都满足,要求从第一个元素开始,一旦不符合,返回0
    代码举例

    在这里插入图片描述

    84、product

    方法:def product: A
    说明:返回所有元素乘积的值
    代码举例

    在这里插入图片描述

    85、reduce

    方法:def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1
    说明:同fold,不需要初始值
    代码举例

    在这里插入图片描述

    86、reduceLeft

    方法:def reduceLeft[B >: A](op: (B, T) ⇒ B): B
    说明:从左向右计算
    代码举例

    在这里插入图片描述

    87、redueceLeftOption

    方法:def reduceLeftOption[B >: A](op: (B, T) ⇒ B): Option[B]
    说明:如果数组为空,返回None
    代码举例

    在这里插入图片描述

    88、reduceOption

    89、reduceRight

    方法:def reduceRight[B >: A](op: (T, B) ⇒ B): B
    说明:从右向左计算
    代码举例

    在这里插入图片描述

    90、reduceRightOption

    方法:def reduceRightOption[B >: A](op: (T, B) ⇒ B): Option[B]
    说明:如果数组为空,返回None
    代码举例
    在这里插入图片描述

    91、repr

    92、reverse

    方法:def reverse: Array[T]
    说明:反转序列
    代码举例

    在这里插入图片描述

    93、reverseIterator

    方法:def reverseIterator: collection.Iterator[T]
    说明:反向生成迭代
    代码举例

    在这里插入图片描述

    94、reverseMap

    方法:def reverseMap[B](f: (A) ⇒ B): Array[B]
    说明:同 map 方向相反
    代码举例

    在这里插入图片描述

    95、runWith

    96、sameElements

    方法:def sameElements(that: GenIterable[A]): Boolean
    说明:判断两个序列是否顺序和对应位置上的元素都一样
    代码举例

    在这里插入图片描述

    97、scan

    方法:def scan[B >: A, That](z: B)(op: (B, B) ⇒ B)(implicit cbf:CanBuildFrom[Array[T], B, That]): That
    说明:用法同 fold,scan会把每一步的计算结果放到一个新的集合中返回
    代码举例

    在这里插入图片描述

    98、scanLeft

    方法:def scanLeft[B, That](z: B)(op: (B, T) ⇒ B)(implicit bf: CanBuildFrom[Array[T], B, That]): That
    说明:从左向右计算
    代码举例

    在这里插入图片描述

    99、scanRight

    方法:def scanRight[B, That](z: B)(op: (T, B) ⇒ B)(implicit bf: CanBuildFrom[Array[T], B, That]): That
    说明:从右向左计算
    代码举例

    在这里插入图片描述

    100、segmentLength

    方法:def segmentLength(p: (T) ⇒ Boolean, from: Int): Int
    说明:从序列的 from 处开始向后查找,所有满足条件的连续元素的长度,一旦有不符合条件的元素,后面再有符合条件的元素也无关
    代码举例

    在这里插入图片描述

    101、seq

    方法:def seq: collection.mutable.IndexedSeq[T]
    说明:产生一个引用当前序列的 sequential 视图,将数组转换为seq集合
    代码举例

    在这里插入图片描述
    3# 102、size
    方法:def size: Int
    说明:返回序列元素个数,同 length
    代码举例

    在这里插入图片描述

    103、slice

    方法:def slice(from: Int, until: Int): Array[T]
    说明:取出当前序列中,from 到 until 之间的片段
    代码举例

    在这里插入图片描述

    104、sliding

    104.1

    方法:def sliding(size: Int): collection.Iterator[Array[T]]
    说明:从第一个元素开始,每个元素和它后面的 size - 1 个元素组成一个数组,最终组成一个新的集合返回,当剩余元素不够 size 数,则停止
    代码举例

    在这里插入图片描述

    104.2

    方法:def sliding(size: Int, step: Int): collection.Iterator[Array[T]]
    说明:设置步进 step,第一个元素组合完后,下一个从上一个元素位置+step后的位置处的元素开始
    代码举例

    在这里插入图片描述

    105、sortBy

    方法:def sortBy[B](f: (T) ⇒ B)(implicit ord: math.Ordering[B]): Array[T]
    说明:按指定的排序规则排序
    代码举例

    在这里插入图片描述

    106、sortWith

    方法:def sortWith(lt: (T, T) ⇒ Boolean): Array[T]
    说明:自定义排序方法 lt
    代码举例

    在这里插入图片描述

    107、sorted

    方法:def sorted、[B >: A](implicit ord: math.Ordering[B]): Array[T]
    说明:使用默认的排序规则对序列排序
    代码举例

    在这里插入图片描述

    108、span

    方法:def span(p: (T) ⇒ Boolean): (Array[T], Array[T])
    说明:分割序列为两个集合,从第一个元素开始,直到找到第一个不满足条件的元素止,之前的元素放到第一个集合,其它的放到第二个集合
    代码举例

    在这里插入图片描述

    109、splitAt

    方法:def splitAt(n: Int): (Array[T], Array[T])
    说明:从指定位置开始,把序列拆分成两个集合,指定位置上的元素包含在后一个集合中
    代码举例

    在这里插入图片描述

    110、startsWith

    方法:def startsWith[B](that: GenSeq[B], offset: Int): Boolean
    说明:从指定偏移处,是否以某个序列开始
    代码举例

    在这里插入图片描述

    111、stringPrefix

    方法:def stringPrefix: String
    说明:返回 toString 结果的前缀
    代码举例

    在这里插入图片描述

    112、subSequence

    方法:def subSequence(start: Int, end: Int): CharSequence
    说明:返回 start 和 end 间的字符序列,左闭右开
    代码举例

    在这里插入图片描述

    113、sum

    方法:def sum: A
    说明:序列求和,元素需为Numeric[T]类型
    代码举例

    在这里插入图片描述

    114、tail

    方法:def tail: Array[T]
    说明:返回除了当前序列第一个元素的其它元素组成的序列
    代码举例

    在这里插入图片描述

    115、tails

    方法:def tails: collection.Iterator[Array[T]]
    说明:同inits方法
    代码举例:

    在这里插入图片描述

    116、take

    方法:def take(n: Int): Array[T]
    说明:返回当前序列中前 n 个元素组成的序列
    代码举例

    在这里插入图片描述

    117、takeRight

    方法:def takeRight(n: Int): Array[T]
    说明:返回当前序列中,从右边开始,选择 n 个元素组成的序列
    代码举例

    在这里插入图片描述

    118、takeWhile

    方法:def takeWhile(p: (T) ⇒ Boolean): Array[T]
    说明:返回当前序列中,从第一个元素开始,满足条件的连续元素组成的序列,如果第一个元素的就不满足,直接返回空数组
    代码举例

    在这里插入图片描述

    119、toArray

    方法:def toArray: Array[A]
    说明:转换成 Array12 1类型
    代码举例

    120、toBuffer

    方法:def toBuffer[A1 >: A]: Buffer[A1]
    说明:转换成 Buffer 类型,可变长集合
    代码举例

    在这里插入图片描述

    121、toIndexedSeq

    方法:def toIndexedSeq: collection.immutable.IndexedSeq[T]
    说明:转换成 IndexedSeq 类型
    代码举例

    在这里插入图片描述

    122、toIterator

    方法:def toIterator: collection.Iterator[T]
    说明:转换成可迭代的类型;
    代码举例

    在这里插入图片描述

    123、toIterable

    方法:def toIterable: collection.Iterable[T]
    说明:转换成可迭代的类型
    代码举例

    在这里插入图片描述

    124、toList

    方法:def toList: List[T]
    说明:同 List 类型,固定长集合
    代码举例

    在这里插入图片描述

    125、toMap

    方法:def toMap[T, U]: Map[T, U]
    说明:同 Map 类型,需要被转化序列中包含的元素时 Tuple2 类型数据
    代码举例

    在这里插入图片描述

    126、toSeq

    方法:def toSeq: collection.Seq[T]
    说明:同 Seq 类型
    代码举例

    在这里插入图片描述

    127、toStream

    方法:def toStream: collection.immutable.Stream[T]
    说明:同 Stream 类型
    代码举例

    在这里插入图片描述

    128、toTraversable

    129、toVector

    方法:def toVector: Vector[T]
    说明:同 Vector 类型
    代码举例

    在这里插入图片描述

    130、transform

    131、transpose

    方法:def transpose[U](implicit asArray: (T) ⇒ Array[U]): Array[Array[U]]
    说明:矩阵转换,二维数组行列转换
    代码举例

    在这里插入图片描述

    132、union

    方法:def union(that: collection.Seq[T]): Array[T]
    说明:联合两个序列,同操作符 ++,不去重
    代码举例

    在这里插入图片描述

    133、unzip

    方法:def unzip[T1, T2](implicit asPair: (T) ⇒ (T1, T2), ct1: ClassTag[T1], ct2: ClassTag[T2]): (Array[T1], Array[T2])
    说明:将含有两个元素的数组,第一个元素取出组成一个序列,第二个元素组成一个序列
    代码举例

    在这里插入图片描述

    134、unzip3

    方法:def unzip3[T1, T2, T3](implicit asTriple: (T) ⇒ (T1, T2, T3), ct1: ClassTag[T1], ct2:5 ClassTag[T2], ct3: ClassTag[T3]): (Array[T1], Array[T2], Array[T3])
    说明:将含有三个元素的三个数组,第一个元素取出组成一个序列,第二个元素组成一个序列,第三个元素组成一个序列
    代码举例

    在这里插入图片描述

    135、update

    方法:def update(i: Int, x: T): Unit
    说明:将序列中 i 索引处的元素更新为 x
    代码举例

    在这里插入图片描述

    136、updated

    方法:def updated(index: Int, elem: A): Array[A]
    说明:将序列中 i 索引处的元素更新为 x ,并返回替换后的数组
    代码举例

    在这里插入图片描述

    137、view

    方法:def view(from: Int, until: Int): IndexedSeqView[T, Array[T]]
    说明:返回 from 到 until 间的序列,不包括 until 处的元素
    代码举例

    在这里插入图片描述

    138、withFilter

    方法:def withFilter(p: (T) ⇒ Boolean): FilterMonadic[T, Array[T]]
    说明:根据条件 p 过滤元素,返回符合要求的序列
    代码举例

    在这里插入图片描述

    139、zip

    方法:def zip[B](that: GenIterable[B]): Array[(A, B)]
    说明:将两个序列对应位置上的元素组成一个pair序列
    代码举例

    在这里插入图片描述

    140、zipAll

    方法:def zipAll[B](that: collection.Iterable[B], thisElem: A, thatElem: B): Array[(A, B)]
    说明:同 zip ,但是允许两个序列长度不一样,不足的自动填充,如果当前序列端,空出的填充为 thisElem,如果 that 短,填充为 thatElem
    代码举例
    在这里插入图片描述
    在这里插入图片描述

    141、zipWithIndex

    方法:def zipWithIndex: Array[(A, Int)]
    说明:序列中的每个元素和它的索引组成一个序列
    代码举例

    在这里插入图片描述

    展开全文
  • es6 对象扩展

    2020-10-21 10:16:03
    Object.assign() 用来合并对象的2.1 如果属性名有重复,2.2如果只有一个参数,`Object.assign`会直接返回该参数。2.3 由于`undefined`和`null`无法转成对象,所以如果它们作为参数,就会报错。2.4 可以利用这个方法...

    一. 对象简洁语法

    let name = 'doudou';
    let age = 18;
    
    let obj = {
        name,
        age,
        run() {
            console.log('running')
        }
    }
    
    console.log(obj)
    

    二.属性名表达式

    JavaScript 定义对象的属性,有两种方法。

    // 方法一
    obj.foo = true;
    
    // 方法二
    obj['a' + 'bc'] = 123;
    

    但是,如果使用字面量方式定义对象(使用大括号),在 ES5 中只能使用方法一(标识符)定义属性。

    var obj = {
      foo: true,
      abc: 123
    };
    

    ES6 允许字面量定义对象时,用方法二(表达式)作为对象的属性名,即把表达式放在方括号内。

    let propKey = 'foo';
    
    let obj = {
      [propKey]: true,
      ['a' + 'bc']: 123
    };
    

    表达式还可以用于定义方法名。

    let obj = {
      ['h' + 'ello']() {
        return 'hi';
      }
    };
    
    obj.hello() // hi
    

    注意,属性名表达式与简洁表示法,不能同时使用,会报错。

    // 报错
    const foo = 'bar';
    const bar = 'abc';
    const baz = { [foo] };
    
    // 正确
    const foo = 'bar';
    const baz = { [foo]: 'abc'};
    

    三. 对象新增

    1. Object.is() 用来比较两个值是否相等

    ES5 比较两个值是否相等,只有两个运算符:相等运算符(==)和严格相等运算符(===)。它们都有缺点,前者会自动转换数据类型,后者的NaN不等于自身,以及+0等于-0

    JavaScript 缺乏一种运算,在所有环境中,只要两个值是一样的,它们就应该相等。

    ES6 提出同值相等算法,用来解决这个问题。Object.is就是部署这个算法的新方法。它用来比较两个值是否严格相等,与严格比较运算符(===)的行为基本一致。

    对于基本数据类型;我们用户肉眼上看着相等就为true,看着不等就为false

    Object.is(NaN,NaN);   // true
    NaN == NaN;           // false
     
    Object.is(+0,-0);     // false
    +0 == -0              // true
    
    // 引用数据类型还是比较内存地址
    Object.is({}, {})
    // false
    

    2. Object.assign() 用来合并对象的

    用法

    let 新对象 = Object.assign(目标对象,需要合并的对象)

    // 返回目标对象

    let json = {a:1};
    let json2 = {b:2};
    let json3 = {c:3};
    
    // 后面的添加到第一个对象里并返回
    let obj = Object.assign({},json,json2,json3);
    console.log(obj);     // {a: 1, b: 2, c: 3}
    
    // 如果要合并的对象具有相同的的属性,则后面的覆盖前面的
    let json = {a:1};
    let json2 = {b:2 , a:2};   // a属性和json对象重复
    let json3 = {c:3};
    
    let obj = Object.assign({},json,json2,json3);
    console.log(obj);     // {a: 2, b: 2, c: 3}
    
    2.1 如果属性名有重复,

    如果合并的对象的属性名有重复就是后面的覆盖前面的

    let json = {name:'wuwei'}
    let json2 = {name:'haha',age:18}
    let json3 = {name:'xiaxia',age:18,sex:1}
    
    let obj = Object.assign({},json,json2,json3);
    // {name: "xiaxia", age: 18, sex: 1}
    
    2.2如果只有一个参数,Object.assign会直接返回该参数。
    const obj = {a: 1};
    Object.assign(obj) === obj // true
    
    2.4 可以利用这个方法来拷贝数组

    该方法拷贝数组为浅拷贝;
    Object.assign()拷贝的是属性值。假如源对象的属性值是一个对象的引用,那么它也只指向那个引用。也就是说,如果对象的属性值为简单类型(如string, number),通过Object.assign({},srcObj);得到的新对象为深拷贝;如果属性值为对象或其它引用类型,那对于这个对象而言其实是浅拷贝的。

    let arr = [1,2,3]
    let arr2 = Object.assign([],arr);
    console.log(arr2);   // [1, 2, 3]
    arr2.push(4);
    console.log(arr2);   // [1, 2, 3, 4]
    console.log(arr);    // [1, 2, 3]
    

    3. Object.keys() Object.entries() Object.values()

    循环json 和对象

    let json = {
        name: "wuwei",
        age : 18,
        sex: "男"
    }
    // 遍历属性
    for(let key of Object.keys(json)){
        console.log(key);   // name age sex
    }
    
    // 遍历属性值
    for(let val of Object.values(json)){
        console.log(val);   // wuwei  18  男
    }
    
    // 遍历键值对
    for(let item  of Object.entries(json)){
        console.log(item);   // ["name", "wuwei"] ["age", 18] ["sex", "男"]
    }
    
    // 解构遍历的键值对
    for(let [key,value] of Object.entries(json)){
        console.log(key,value);   // name wuwei age 18 sex 男
    }
    

    也可以通过解构将Object身上的是哪个方法解构出来

    // 解构Object身上的方法
    let {keys,values,entries} = Object;
    
    let json = {
        name: "wuwei",
        age : 18,
        sex: "男"
    }
    // 遍历属性
    for(let key of keys(json)){
        console.log(key);   // name age sex
    }
    
    // 遍历属性值
    for(let val of values(json)){
        console.log(val);   // wuwei  18  男
    }
    
    // 遍历键值对
    for(let item of entries(json)){
        console.log(item);   // ["name", "wuwei"] ["age", 18] ["sex", "男"]
    }
    // 解构遍历的键值对
    for(let [key,value] of entries(json)){
        console.log(key,value);   // name wuwei age 18 sex 男
    }
    

    四.对象的扩展运算符

    解构赋值与…运算符

    let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };
    x // 1
    y // 2
    z // { a: 3, b: 4 }
    

    由于解构赋值要求等号右边是一个对象,所以如果等号右边是undefinednull,就会报错,因为它们无法转为对象。

    let { x, y, ...z } = null; // 运行时错误
    let { x, y, ...z } = undefined; // 运行时错误
    

    解构赋值必须是最后一个参数,否则会报错。

    let { ...x, y, z } = obj; // 句法错误
    let { x, ...y, ...z } = obj; // 句法错误
    

    注意,解构赋值的拷贝是浅拷贝,即如果一个键的值是复合类型的值(数组、对象、函数)、那么解构赋值拷贝的是这个值的引用,而不是这个值的副本。

    let obj = { a: { b: 1 } };
    let { ...x } = obj;
    obj.a.b = 2;
    x.a.b // 2
    

    扩展运算符

    扩展运算符(...)用于取出参数对象的所有可遍历属性,拷贝到当前对象之中。

    let z = { a: 3, b: 4 };
    let n = { ...z };
    n // { a: 3, b: 4 }
    
    

    这等同于使用Object.assign方法。

    let aClone = { ...a };
    // 等同于
    let aClone = Object.assign({}, a);
    
    展开全文
  • 合并后的对象如果有重复值,将会对之前的值进行覆盖,以最后一个为准 let obj1 = {name: 'zhang', age: 12, address: '中国'} let obj2 = {school: '北京大学', father: 'li'} let obj3 = {...obj1, ...obj2}...

    ... 扩展运算符
    
    

    对象的使用

    可以对对象进行合并
    
    合并后的对象如果有重复值,将会对之前的值进行覆盖,以最后一个为准
    
    
        let obj1 = {name: 'zhang', age: 12, address: '中国'}
    
        let obj2 = {school: '北京大学', father: 'li'}
    
        let obj3 = {...obj1, ...obj2}
        console.log(obj3) // {name: "zhang", age: 12, address: "中国", school: "北京大学", father: "li"}
    
        let obj4 = {age: 98, school: '清华大学'}
        let obj5 = {...obj3, ...obj4}
        console.log(obj5) // {name: "zhang", age: 98, address: "中国", school: "清华大学", father: "li"}
    

    数组的使用

    可以用于数组的合并 [...arr1,...arr2]
    
    可以用于数组的解构 [num1,num2,...arr3] = [1,2,3,4,5]
    
    用于数组的解构的时候,必须要将 扩展运算放在最后,否则会报错
    
        let arr = [1, 2, 3, 4, 5, 6]
        let arr1 = [11, 12, 13, 14, 15, 16]
    
        let arr2 = [...arr, ...arr1]
        console.log(arr2) // [1, 2, 3, 4, 5, 6, 11, 12, 13, 14, 15, 16]
    
        let arr3 = [1, 2, 3, 4, ...arr1]
        console.log(arr3) // [1, 2, 3, 4, 11, 12, 13, 14, 15, 16]
    
        let arr4 = [...arr1, 1, 2, 3, 4]
        console.log(arr4) // [11, 12, 13, 14, 15, 16, 1, 2, 3, 4]
    
        const [num1, num2, ...arr5] = [1, 2, 3, 4, 5, 6]
        console.log(num1) // 1
        console.log(num2) // 2
        console.log(arr5) // [3, 4, 5, 6]
    
    展开全文
  •  Replace Array with Object 用对象代替数组   Duplicate Observed Data 重复被观察数据   *Change Unidirectional Associationto Bidirectional 将单向关联改为双向   Change Bidirectional Association ...
  •  Replace Array with Object 用对象代替数组   Duplicate Observed Data 重复被观察数据   *Change Unidirectional Associationto Bidirectional 将单向关联改为双向   Change Bidirectional Association ...
  • 8.5 Replace Array with Object(以对象取代数组) 186 8.6 Duplicate Observed Data(复制“被监视数据”) 189 8.7 Change Unidirectional Association to Bidirectional(将单向关联改为双向关联) 197 8.8...
  • 重构——改善既代码的设计

    热门讨论 2011-06-05 01:37:45
     Replace Array with Object 用对象代替数组   Duplicate Observed Data 重复被观察数据   *Change Unidirectional Associationto Bidirectional 将单向关联改为双向   Change Bidirectional Association to ...
  •  Replace Array with Object 用对象代替数组   Duplicate Observed Data 重复被观察数据   *Change Unidirectional Associationto Bidirectional 将单向关联改为双向   Change Bidirectional Association ...
  • 8.5 Replace Array with Object(以对象取代数组) 8.6 Duplicate Observed Data(复制「被监视数据」) 8.7 Change Unidirectional Association to Bidirectional(将单向关联改为双向) 8.8 Change Bidirectional ...
  •  8.5 ReplaceArraywithObject(以对象取代数组)186  8.6 DuplicateObservedData(复制“被监视数据”)189  8.7 ChangeUnidirectionalAssociationtoBidirectional(将单向关联改为双向关联)197  8.8 ...
  •  Replace Array with Object 用对象代替数组   Duplicate Observed Data 重复被观察数据   *Change Unidirectional Associationto Bidirectional 将单向关联改为双向   Change Bidirectional Association to ...
  • 8.5 Replace Array with Object(以对象取代数组) 8.6 Duplicate Observed Data(复制「被监视数据」) 8.7 Change Unidirectional Association to Bidirectional(将单向关联改为双向) 8.8 Change Bidirectional ...
  • 8.5 ReplaceArraywithObject(以对象取代数组)186 8.6 DuplicateObservedData(复制“被监视数据”)189 8.7 ChangeUnidirectionalAssociationtoBidirectional(将单向关联改为双向关联)197 8.8 ...
  •  Replace Array with Object 用对象代替数组   Duplicate Observed Data 重复被观察数据   *Change Unidirectional Associationto Bidirectional 将单向关联改为双向   Change Bidirectional Association to ...
  • 8.5 Replace Array with Object(以对象取代数组) 8.6 Duplicate Observed Data(复制“被监视数据”) 8.7 Change Unidirectional Association to Bidirectional(将单向关联改为双向关联) 8.8 Change ...
  • 8.5 ReplaceArraywithObject(以对象取代数组)186 8.6 DuplicateObservedData(复制“被监视数据”)189 8.7 ChangeUnidirectionalAssociationtoBidirectional(将单向关联改为双向关联)197 8.8 ...
  • 8.5 ReplaceArraywithObject(以对象取代数组)186 8.6 DuplicateObservedData(复制“被监视数据”)189 8.7 ChangeUnidirectionalAssociationtoBidirectional(将单向关联改为双向关联)197 8.8 ...
  • 8.5 ReplaceArraywithObject(以对象取代数组)186 8.6 DuplicateObservedData(复制“被监视数据”)189 8.7 ChangeUnidirectionalAssociationtoBidirectional(将单向关联改为双向关联)197 8.8 ...
  • 8.5 Replace Array with Object(以对象取代数组) 8.6 Duplicate Observed Data(复制“被监视数据”) 8.7 Change Unidirectional Association to Bidirectional(将单向关联改为双向关联) 8.8 Change ...
  • 8.5 ReplaceArraywithObject(以对象取代数组)186 8.6 DuplicateObservedData(复制“被监视数据”)189 8.7 ChangeUnidirectionalAssociationtoBidirectional(将单向关联改为双向关联)197 8.8 ...
  • 8.5 Replace Array with Object(以对象取代数组) 186 8.6 Duplicate Observed Data(复制「被监视数据」) 189 8.7 Change Unidirectional Association to Bidirectional 197 (将单向关联改为双向) 8.8 ...
  • 一个算法题

    2020-11-19 12:45:43
    1-100范围中,1000个可重复的数,以出现次数的多少排序,返回一个新数组? 蹦出来的第一个直观的解法,用一个对象将遍历的数组的出现次数记录下来,然后把记录的排序,反查key,然后合并成一个数组排序处...

    1-100范围中,有1000个可重复的数,以出现次数的多少排序,返回一个新数组?

    • 蹦出来的第一个直观的解法,用一个对象将遍历的数组的出现次数记录下来,然后把记录的值排序,反查key,然后合并成一个数组。值排序处卡壳了一下。反思了下,得到一个有点笨但理解容易的解法。
    /**
     * 根据对象的一个属性排序 
     * @param data 原始数组(数组单个元素为对象)
     * @param sortKey 要根据排序的key
     * @param type desc 倒序, asc 正序
     */
    function sortObjArrByKey(data, sortKey, type) {
        let arr = [...data];
        if (type === 'asc') {
            arr.sort((a, b) => a[sortKey] - b[sortKey]);
        } else if (type === 'desc') {
            arr.sort((a, b) => b[sortKey] - a[sortKey]);
        }
        return arr;
    }
    
    /**
     * 以数字出现的次数排序
     * @param  原始数组
     */
    function sortArrByCount(arr) {
        var countObj = {};
        var originCountArr = [];
        arr.forEach(item => {
            countObj[item] = countObj[item] ? countObj[item] + 1 : 1;
        });
        console.log('countObj', countObj);
        originCountArr = Object.keys(countObj).map(key => {
            return {
                key: key,
                value: countObj[key],
            };
        });
        var sortedCountArr = sortObjArrByKey(
            originCountArr,
            'value',
            'desc'
        );
        let sortedCountNumArr = sortedCountArr.map(item => +item.key);
        console.log('result:', sortedCountNumArr);
        return sortedCountNumArr;
    }
    
    // 用少量数量模拟一下
    var arr = [1, 4, 2, 1, 5, 7, 8, 10, 25, 11, 10, 7, 100, 7, 20];
    let resultArr = sortArrByCount(arr);
    

    输出结果:
    在这里插入图片描述

    应该还有其他更精妙的解法,想到了补充。

    展开全文
  • sku商品选择

    千次阅读 2019-05-07 17:59:40
    需求(商城购物,规格的选择) 商品属性(多种):尺寸,颜色,款式 存在的组合方式是确定的:即就是所存在的库存并且大于0的sku ...重复上述操作。 主要三组数据: ...所有的主规格(去重)数组对象 ma...
  • 69、两个对象值相同(x.equals(y) == true),但却可不同的hash code,这句话对不对? 48 70、TreeSet里面放对象,如果同时放入了父类和子类的实例对象,那比较时使用的是父类的compareTo方法,还是使用的子类的...
  • 2.1.15 SUMX2MY2——计算数组对应值的平方差之和 63 2.1.16 SUMX2PY2——计算数组对应值的平方和之和 63 2.1.17 SERIESSUM——计算基于公式的幂级数之和 64 2.2 舍入计算 65 2.2.1 INT——返回永远小于等于原...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 162
精华内容 64
关键字:

数组对象合并有重复值的