Scala入门系列（三）：Scala高阶函数大全之Array

Array

数组是一种可变的、可索引的数据集合。在 Scala 中用 Array[T] 的形式来表示 Java 中的数组形式 T[]。

示例：

val arr = Array(1, 2, 3, 4) // 声明一个数组对象
val first = arr(0) // 读取第一个元素
arr(3) = 100 // 替换第四个元素为 100
val newarr = arr.map(_ * 2) // 所有元素乘 2
println(newarr.mkString(",")) // 打印数组，结果为：2,4,6,200

++
定义：def ++ [B] (that: GenTraversableOnce[B]) : Array[B]

描述：合并集合，并返回一个新的数组，新数组包含左右两个集合的内容

示例：

val a = Array(1, 2)
val b = Array(3, 4)
val c = a ++ b
println(c.mkString(",")) // 1,2,3,4

++:
定义：def ++:[B >: A, That] (that: collection.Traversable[B])(implicit bf: CanBuildFrom[Array[T], B, That]): That

描述：这个方法同上一个方法类似，两个加号后面多了一个冒号，但是不同的是右边操纵数的类型决定着返回结果的类型

示例：Array 和 List 结合，返回结果是 List 类型

val a = List(1, 2)
val b = scala.collection.mutable.LinkedList(3, 4)
val c = a ++: b
println(c.getClass().getName()) // c 的类型: scala.collection.mutable.LinkedList

+:
定义：def +:(elem: A): Array[A]

描述：在数组前面添加一个元素，并返回新的数组对象

示例：

val a = List(1, 2)
val b = 0 +: a
println(b.mkString(",")) // 0,1,2

:+
定义：def :+(elem: A): Array[A]

描述：在数组后面添加一个元素，并返回新的数组对象

示例：

val a = List(1, 2)
val b = a :+ 3
println(b.mkString(",")) // 1,2,3

/:
定义：def /:[B] (z: B)(op: (B, T) ⇒ B): B

描述：对数组中所有的元素从左向右遍历，进行相同的迭代操作，foldLeft 的简写

示例：

val a = List(1, 2, 3, 4)
val b = (10 /: a) (_ + _) // (((10+1)+2)+3)+4
val c = (10 /: a) (_ * _) // (((10*1)*2)*3)*4
println("b: " + b) // b: 20
println("c: " + c) // c: 240

:
定义：def :[B] (z: B)(op: (T, B) ⇒ B): B

描述：对数组中所有的元素从右向左遍历，进行相同的迭代操作，foldRight 的简写

示例：

val a = List(1, 2, 3, 4)
val b = (a :\ 10) (_ - _) // 1-(2-(3-(4-10)))
val c = (a :\ 10) (_ * _) // 1*(2*(3*(4*10)))
println("b: " + b) // b: -8
println("c: " + c) // c: 240

addString(b)
定义：def addString(b: StringBuilder): StringBuilder

描述：将数组中的元素逐个添加到 StringBuilder 中

示例：

val a = List(1, 2, 3, 4)
val b = new StringBuilder()
a.addString(b)
println(b) // 1234

addString(b, sep)
定义：def addString(b: StringBuilder, sep: String): StringBuilder

描述：将数组中的元素逐个添加到 StringBuilder 中，每个元素用 sep 分隔符分开

示例：

val a = List(1, 2, 3, 4)
val b = new StringBuilder()
a.addString(b, ",")
println(b) // 1,2,3,4

aggregate
定义：def aggregate[B] (z: ⇒ B)(seqop: (B, T) ⇒ B, combop: (B, B) ⇒ B): B

描述：聚合计算，aggregate 是柯里化方法，参数是两个方法

示例：为了方便理解，把 aggregate 的两个参数分别封装成两个方法，并把分区和不分区的计算过程分别打印出来

  def seqno(m: Int, n: Int): Int = {val s = "seq_exp = %d + %d"println(s.format(m, n))m + n}def combine(m: Int, n: Int): Int = {val s = "com_exp = %d + %d"println(s.format(m, n))m + n}def main(args: Array[String]) {val a = List(1, 2, 3, 4)

val b = a.aggregate(5)(seqno, combine) // 不分区
println("b = " + b)
/*** seq_exp = 5 + 1* seq_exp = 6 + 2* seq_exp = 8 + 3* seq_exp = 11 + 4* b = 15*/val c = a.par.aggregate(5)(seqno, combine) // 分区
println("c = " + c)
/*** seq_exp = 5 + 3* seq_exp = 5 + 2* seq_exp = 5 + 4* seq_exp = 5 + 1* com_exp = 6 + 7* com_exp = 8 + 9* com_exp = 13 +17* c = 30*/

通过上面的运算不难发现，不分区时，seqno 是把初始值顺序和每个元素相加，把得到的结果与下一个元素进行运算。

分区时，seqno 是把初始值与每个元素相加，但结果不参与下一步运算，而是放到另一个序列中，由第二个方法 combine 进行处理。

上面过程可以简写为

val b = a.aggregate(5)(+,+) // 不分区
val c = a.par.aggregate(5)(+,+) // 分区

apply
定义：def apply(i: Int): T

描述：获取指定索引处的元素

示例：

val a = List(1, 2, 3, 4)
val b = a.apply(1) // a.apply(i) 同 a(i)
println(b) // 2

canEqual
定义：def canEqual(that: Any): Boolean

描述：判断两个对象是否可以进行比较

示例：基本上所有对象都可以进行比较，我不知道这个方法的意义何在

val a = List(1, 2, 3, 4)
val b = Array('a', 'b', 'c')
println(a.canEqual(b)) // true

charAt
定义：def charAt(index: Int): Char

描述：获取 index 索引处的字符，这个方法会执行一个隐式的转换，将 Array[T] 转换为 ArrayCharSequence，只有当 T 为 Char 类型时，这个转换才会发生

示例：

val chars = Array('a', 'b', 'c')
println(chars.charAt(0)) // a

clone
定义：def clone(): Array[T]

描述：创建一个副本

示例：

val a = Array(1, 2, 3, 4)
val b = a.clone()
println(b.mkString(",")) // 1,2,3,4

collect
定义：def collect[B](pf: PartialFunction[A, B]): Array[B]

描述：通过执行一个并行计算（偏函数），得到一个新的数组对象

示例：通过下面的偏函数，把数组中的小写的 a 转换为大写的 A

val fun: PartialFunction[Char, Char] = {case 'a' => 'A'case x => x
}
val a = Array('a', 'b', 'c')
val b = a.collect(fun)
println(b.mkString(",")) // A,b,c

collectFirst
定义：def collectFirst[B](pf: PartialFunction[T, B]): Option[B]

描述：在序列中查找第一个符合偏函数定义的元素，并执行偏函数计算

示例：定义一个偏函数，当被执行对象为 Int 类型时，进行乘 100 的操作

val fun: PartialFunction[Any, Int] = {case x: Int => x * 100
}
val a = Array(1, 'a', "b")
val b = arr.collectFirst(fun)
println(b) // Some(100)

另一种写法：

b = arr.collectFirst({ case x: Int => x * 100 })

combinations
定义：def combinations(n: Int): collection.Iterator[Array[T]]

描述：combinations 表示组合，这个排列组合会选出所有包含字符不一样的组合，但不考虑顺序，对于 “abc”、“cba”，视为相同组合，参数 n 表示序列长度，就是几个字符为一组

示例：

val a = Array("a", "b", "c")
val b = arr.combinations(2)
b.foreach(x => println(x.mkString(",")))
/*** a,b* a,c* b,c*/

contains
定义：def contains[A1 >: A] (elem: A1): Boolean

描述：判断序列中是否包含指定对象

示例：

val a = List(1, 2, 3, 4)
println(a.contains(1)) // true

containsSlice
定义：def containsSlice[B](that: GenSeq[B]): Boolean

描述：判断当前序列中是否包含另一个序列

示例：

val a = List(1, 2, 3, 4)
val b = List(2, 3)
println(a.containsSlice(b)) // true

copyToArray(xs)
定义：def copyToArray(xs: Array[A]): Unit

描述：将当前数组元素复制到另一个数组中

示例：

val a = Array(1, 2, 3)
val b: Array[Int] = new Array(5)
a.copyToArray(b)
println(b.mkString(",")) // 1,2,3,0,0

copyToArray(xs, start)
定义：def copyToArray(xs: Array[A], start: Int): Unit

描述：将当前数组元素复制到另一个数组中，从 start 位置开始复制

示例：

val a = Array(1, 2, 3)
val b: Array[Int] = new Array(5)
a.copyToArray(b, 1)
println(b.mkString(",")) // 0,1,2,3,0

copyToArray(xs, start, len)
定义：def copyToArray(xs: Array[A], start: Int, len: Int): Unit

描述：将当前数组元素复制到另一个数组中，从 start 位置开始复制，长度为 len

示例：

val a = Array(1, 2, 3)
val b: Array[Int] = new Array(5)
a.copyToArray(b, 1, 2)
println(b.mkString(",")) // 0,1,2,0,0

copyToBuffer
定义：def copyToBuffer[B >: A] (dest: Buffer[B]): Unit

描述：将数组中的元素复制到 Buffer 中

示例：

val a = Array(1, 2, 3, 4)
val b: ArrayBuffer[Int] = ArrayBuffer()
a.copyToBuffer(b)
println(b.mkString(",")) // 1,2,3,4

corresponds
定义：def corresponds[B](that: GenSeq[B])(p: (T, B) ⇒ Boolean): Boolean

描述：判断两个序列的长度以及对应位置元素是否符合某个条件。如果两个序列具有相同的元素数量并且 p(x, y)=true，则返回 true

示例：下面代码检查 a 和 b 长度是否相等，并且 a 中元素是否小于 b 中对应位置的元素

val a = Array(1, 2, 3, 4)
val b = Array(5, 6, 7, 8)
println(a.corresponds(b)(_ < _)) // true

count
定义：def count(p: (T) ⇒ Boolean): Int

描述：统计符合条件的元素个数

示例：下面代码统计数组中大于 2 的元素个数

val a = Array(1, 2, 3, 4)
println(a.count(x => x > 2)) // 2

diff
定义：def diff(that: collection.Seq[T]): Array[T]

描述：计算当前数组与另一个数组的差集，即将当前数组中没有在另一个数组中出现的元素返回

示例：

val a = Array(1, 2, 3, 4)
val b = Array(3, 4, 5, 6)
val c = a.diff(b)
println(c.mkString(",")) // 1,2

distinct
定义：def distinct: Array[T]

描述：去除当前集合中重复的元素，只保留一个

示例：

val a = Array(1, 2, 2, 3, 4, 4)
val b = a.distinct
println(b.mkString(",")) // 1,2,3,4

drop
定义：def drop(n: Int): Array[T]

描述：将当前数组中前 n 个元素去除，返回一个新数组

示例：

val a = Array(1, 2, 3, 4)
val b = a.drop(2)
println(b.mkString(",")) // 3,4

dropRight
定义：def dropRight(n: Int): Array[T]

描述：功能同 drop，去掉尾部的 n 个元素

示例：

val a = Array(1, 2, 3, 4)
val b = a.dropRight(2)
println(b.mkString(",")) // 1,2

dropWhile
定义：def dropWhile(p: (T) ⇒ Boolean): Array[T]

描述：去除当前数组中符合条件的元素，返回剩余的数组，这个需要一个条件，就是从当前数组的第一个元素起，就要满足条件，直到碰到第一个不满足条件的元素结束（即使后面还有符合条件的元素），否则返回整个数组

示例：下面去除数组 a 中大于 2 的元素，第一个元素 3 满足，它后面的元素 2 不满足，所以返回 (2,3,4)

val a = Array(1, 2, 3, 4)
val b = a.dropWhile(x => x < 2)
println(b.mkString(",")) // 2,3,4

如果数组 a 是 (1,2,3,4)，第一个元素就不满足条件，则返回整个数组 (1,2,3,4)

val a = Array(1, 2, 3, 4)
val b = a.dropWhile(x => x > 2)
println(b.mkString(",")) // 1,2,3,4

endsWith
定义：def endsWith[B](that: GenSeq[B]): Boolean

描述：判断当前序列是否以某个序列结尾

示例：

val a = Array(1, 2, 3, 4)
val b = Array(3, 4)
println(a.endsWith(b)) // true

exists
定义：def exists(p: (T) ⇒ Boolean): Boolean

描述：判断当前数组是否包含符合条件的元素

示例：

val a = Array(1, 2, 3, 4)
println(a.exists(x => x == 3)) // true
println(a.exists(x => x == 30)) // false

filter
定义：def exists(p: (T) ⇒ Boolean): Boolean

描述：取得当前数组中符合条件的元素，组成新的数组返回

示例：

val a = Array(1, 2, 3, 4)
val b = a.filter(x => x > 2)
println(b.mkString(",")) // 3,4

find
定义：def find(p: (T) ⇒ Boolean): Option[T]

描述：查找第一个符合条件的元素，返回 Option

示例：

val a = Array(1, 2, 3, 4)
val b = a.find(x => x > 2)
println(b) // Some(3)

flatMap
定义：def flatMap[B] (f: (A) ⇒ GenTraversableOnce[B]): Array[B]

描述：对当前序列的每个元素进行操作，结果放入新序列返回，参数要求是 GenTraversableOnce 及其子类

示例：

val a = Array(1, 2, 3, 4)
val b = a.flatMap(x => 1 to x)
println(b.mkString(","))
/*** 1,1,2,1,2,3,1,2,3,4* 从 1 开始，分别对集合 a 中的每个元素生成一个递增序列，过程如下* 1* 1,2* 1,2,3* 1,2,3,4*/

flatten
定义：def flatten[U] (implicit asTrav: (T) ⇒ collection.Traversable[U], m: ClassTag[U]): Array[U]

描述：扁平化，将二维数组的所有元素组合在一起，形成一个一维数组返回

示例：

val a = Array(Array(1, 2, 3), Array(4, 5, 6))
val b = a.flatten
println(b.mkString(",")) // 1,2,3,4,5,6

fold
定义：def fold[A1 >: A] (z: A1)(op: (A1, A1) ⇒ A1): A1ClassTag[U]): Array[U]

描述：对序列中的每个元素进行二元运算，和 aggregate 有类似的语义，但执行过程有所不同

示例：

  def seqno(m: Int, n: Int): Int = {val s = "seq_exp = %d + %d"println(s.format(m, n))m + n}def main(args: Array[String]) {val a = Array(1, 2, 3, 4)

val b = a.fold(5)(seqno) // 不分区
println("b = " + b)
/*** seq_exp = 5 + 1* seq_exp = 6 + 2* seq_exp = 8 + 3* seq_exp = 11 + 4* b = 15*/val c = a.par.fold(5)(seqno) // 分区
println("c = " + c)
/*** seq_exp = 5 + 3* seq_exp = 5 + 2* seq_exp = 5 + 4* seq_exp = 5 + 1* com_exp = 6 + 7* com_exp = 8 + 9* com_exp = 13 + 17* c = 30*/

}

foldLeft
定义：def foldLeft[B] (z: B)(op: (B, T) ⇒ B): BClassTag[U]): Array[U]

描述：从左到右计算，简写方式：def /:[B] (z: B)(op: (B, T) ⇒ B): B

示例：

  def seqno(m: Int, n: Int): Int = {val s = "seq_exp = %d + %d"println(s.format(m, n))m + n}def main(args: Array[String]): Unit = {val a = Array(1, 2, 3, 4)

val b = a.foldLeft(5)(seqno) // 简写: (5 /: a)(_ + _)
println("b = " + b)
/*** seq_exp = 5 + 1* seq_exp = 6 + 2* seq_exp = 8 + 3* seq_exp = 11 + 4* b = 15*/

foldRight
定义：foldRight[B] (z: B)(op: (B, T) ⇒ B): B

描述：从右到左计算，简写方式：def :[B] (z: B)(op: (T, B) ⇒ B): B

示例：

  def seqno(m: Int, n: Int): Int = {val s = "seq_exp = %d + %d"println(s.format(m, n))m + n}def main(args: Array[String]): Unit = {val a = Array(1, 2, 3, 4)

val b = a.foldRight(5)(seqno) // 简写: (a :\ 5)(_ + _)
println("b = " + b)
/*** seq_exp = 4 + 5* seq_exp = 3 + 9* seq_exp = 2 + 12* seq_exp = 1 + 14* b = 15*/

forall
定义：def forall(p: (T) ⇒ Boolean): Boolean

描述：检测序列中的元素是否都满足条件 p，如果序列为空，则返回 true

示例：

val a = Array(1, 2, 3, 4)
println(a.forall(x => x > 0)) // true
println(a.forall(x => x > 2)) // false

foreach
定义：def foreach(f: (A) ⇒ Unit): Unit

描述：遍历序列中的元素，进行 f 操作

示例：

val a = Array(1, 2, 3, 4)
a.foreach(x => println(x * 10))
/*** 10* 20* 30* 40*/

groupBy
定义：def groupBy[K] (f: (T) ⇒ K): Map[K, Array[T]]

描述：按条件分组，条件由 f 匹配，返回值是 Map 类型，每个 key 对应一个数组

示例：把数组中小于 3 的元素分到一组，其他元素的分到另一组，返回 Map[String, Array[Int]]

val a = Array(1, 2, 3, 4)
val b = a.groupBy(x => x match {case x if (x < 3) => "small"case _ => "big"
})
b.foreach(x => println(x._1 + ": " + x._2.mkString(",")))
/*** small: 1,2* big: 3,4*/

grouped
定义：def grouped(size: Int): collection.Iterator[Array[T]]

描述：按指定数量分组，每组有 size 个元素，返回一个迭代器

示例：

val a = Array(1, 2, 3, 4, 5)
val b = a.grouped(3).toList
b.foreach(x => println("第 " + (b.indexOf(x) + 1) + " 组: " + x.mkString(",")))
/*** 第 1 组: 1,2,3* 第 2 组: 4,5*/

hasDefiniteSize
定义：def hasDefiniteSize: Boolean

描述：检测序列是否存在有限的长度，对应 Stream 这样的流数据则返回 false

示例：

val a = Array(1, 2, 3, 4)
println(a.hasDefiniteSize) // true

head
定义：def head: T

描述：返回序列的第一个元素，如果序列为空，将引发错误

示例：

val a = Array(1, 2, 3, 4)
println(a.head) // 1

headOption
定义：def headOption: Option[T]

描述：返回序列的第一个元素的 Option 类型对象，如果序列为空，则返回 None

示例：

val a = Array(1, 2, 3, 4)
println(a.headOption) // Some(1)

indexOf(elem)
定义：def indexOf(elem: T): Int

描述：返回元素 elem 在序列中第一次出现的索引

示例：

val a = Array(1, 3, 2, 3, 4)
println(a.indexOf(3)) // 1

indexOf(elem, from)
定义：def indexOf(elem: T, from: Int): Int

描述：返回元素 elem 在序列中第一次出现的索引，指定从索引 from 开始查找
示例：

val a = Array(1, 3, 2, 3, 4)
println(a.indexOf(3, 2)) // 3

indexOfSlice(that)
定义：def indexOfSlice[B >: A] (that: GenSeq[B]): Int

描述：检测当前序列中是否包含序列 that，并返回第一次出现该序列的索引

示例：

val a = Array(1, 2, 3, 2, 3, 4)
val b = Array(2, 3)
println(a.indexOfSlice(b)) // 1

indexOfSlice(that, from)
定义：def indexOfSlice[B >: A] (that: GenSeq[B], from: Int): Int

描述：检测当前序列中是否包含另一个序列 that，指定从索引 from 开始查找，并返回第一次出现该序列的索引

示例：

val a = Array(1, 2, 3, 2, 3, 4)
val b = Array(2, 3)
println(a.indexOfSlice(b, 2)) // 3

indexWhere§
定义：def indexWhere(p: (T) ⇒ Boolean): Int

描述：返回当前序列中第一个满足条件 p 的元素的索引

示例：

val a = Array(1, 2, 3, 4)
println(a.indexWhere(x => x > 2)) // 2

indexWhere(p, from)
定义：def indexWhere(p: (T) ⇒ Boolean, from: Int): Int

描述：返回当前序列中第一个满足条件 p 的元素的索引，指定从索引 from 开始查找

示例：

val a = Array(1, 2, 3, 4)
println(a.indexWhere(x => x > 2, 3)) // 3

indices
定义：def indices: collection.immutable.Range

描述：返回当前序列索引集合

示例：

val a = Array(1, 2, 3, 4)
val b = a.indices
println(b.mkString(",")) // 0,1,2,3

init
定义：def init: Array[T]

描述：返回当前序列中不包含最后一个元素的序列

示例：

val a = Array(1, 2, 3, 4)
val b = a.init
println(b.mkString(",")) // 1,2,3

inits
定义：def inits: collection.Iterator[Array[T]]

描述：对集合中的元素进行 init 迭代操作，该操作的返回值中，第一个值是当前序列的副本，最后一个值为空，每一步都进行 init 操作，上一步的结果作为下一步的操作对象

示例：

val a = Array(1, 2, 3, 4)
val b = a.inits.toList
for (i <- 0 until b.length) {val s = "第 %d 个值: %s"println(s.format(i + 1, b(i).mkString(",")))
}
/*** 第 1 个值: 1,2,3,4* 第 2 个值: 1,2,3* 第 3 个值: 1,2* 第 4 个值: 1* 第 5 个值: */

intersect
定义：def intersect(that: collection.Seq[T]): Array[T]

描述：取两个集合的交集

示例：

val a = Array(1, 2, 3, 4)
val b = Array(3, 4, 5, 6)
val c = a.intersect(b)
println(c.mkString(",")) // 3,4

isDefinedAt
定义：def isDefinedAt(idx: Int): Boolean

描述：判断序列中是否存在指定索引

示例：

val a = Array(1, 2, 3, 4)
println(a.isDefinedAt(1)) // true
println(a.isDefinedAt(10)) // false

isEmpty
定义：def isEmpty: Boolean

描述：判断序列是否为空

示例：

val a = Array(1, 2, 3, 4)
val b = new Array[Int](0)
println(a.isEmpty) // false
println(b.isEmpty) // true

isTraversableAgain
定义：def isTraversableAgain: Boolean

描述：判断序列是否可以反复遍历，该方法是 GenTraversableOnce 中的方法，对于 Traversables 一般返回 true，对于 Iterators 返回 false，除非被复写

示例：

val a = Array(1, 2, 3, 4)
val b = a.iterator
println(a.isTraversableAgain) // false
println(b.isTraversableAgain) // true

iterator
定义：def iterator: collection.Iterator[T]

描述：生成当前序列的迭代器

示例：

val a = Array(1, 2, 3, 4)
val b = a.iterator
println(b.mkString(",")) // 1,2,3,4

last
定义：def last: T

描述：返回序列的最后一个元素，如果序列为空，将引发错误

示例：

val a = Array(1, 2, 3, 4)
println(a.last) // 4

lastIndexOf(elem)
定义：def lastIndexOf(elem: T): Int

描述：返回元素 elem 在序列中最后一次出现的索引

示例：

val a = Array(1, 3, 2, 3, 4)
println(a.lastIndexOf(3)) // 3

lastIndexOf(elem, end)
定义：def lastIndexOf(elem: T, end: Int): Int

描述：返回元素 elem 在序列中最后一次出现的索引，指定在索引 end 之前（包括）的元素中查找

示例：

val a = Array(1, 3, 2, 3, 4)
println(a.lastIndexOf(3, 2)) // 1

lastIndexOfSlice(that)
定义：def lastIndexOfSlice[B >: A] (that: GenSeq[B]): Int

描述：检测当前序列中是否包含序列 that，并返回最后一次出现该序列的索引

示例：

val a = Array(1, 2, 3, 2, 3, 4)
val b = Array(2, 3)
println(a.lastIndexOfSlice(b)) // 3

lastIndexOfSlice(that, end)
定义：def lastIndexOfSlice[B >: A] (that: GenSeq[B], end: Int): Int

描述：检测当前序列中是否包含序列 that，并返回最后一次出现该序列的索引，指定在索引 end 之前（包括）的元素中查找

示例：

val a = Array(1, 2, 3, 2, 3, 4)
val b = Array(2, 3)
println(a.lastIndexOfSlice(b, 2)) // 1

lastIndexWhere§
定义：ef lastIndexWhere(p: (T) ⇒ Boolean): Int

描述：返回当前序列中最后一个满足条件 p 的元素的索引

示例：

val a = Array(1, 2, 3, 4)
println(a.lastIndexWhere(Int => x > 2)) // 3

lastIndexWhere(p, end)
定义：def lastIndexWhere(p: (T) ⇒ Boolean, end: Int): Int

描述：返回当前序列中最后一个满足条件 p 的元素的索引，指定在索引 end 之前（包括）的元素中查找

示例：

val a = Array(1, 2, 3, 4)
println(a.lastIndexWhere(x => x > 2, 2)) // 2

lastOption
定义：def lastOption: Option[T]

描述：返回序列的最后一个元素的 Option 类型对象，如果序列为空，则返回 None

示例：

val a = Array(1, 2, 3, 4)
println(a.lastOption) // Some(4)

length
定义：def length: Int

描述：返回序列元素个数

示例：

val a = Array(1, 2, 3, 4)
println(a.length) // 4

lengthCompare
定义：def lengthCompare(len: Int): Int

描述：比较序列的长度和参数 len，返回序列的长度 - len

示例：

val a = Array(1, 2, 3, 4)
println(a.lengthCompare(3)) // 1
println(a.lengthCompare(4)) // 0
println(a.lengthCompare(5)) // -1

map
定义：def map[B] (f: (A) ⇒ B): Array[B]

描述：对序列中的元素进行 f 操作，返回生成的新序列

示例：

val a = Array(1, 2, 3, 4)
val b = a.map(x => x * 10)
println(b.mkString(",")) // 10,20,30,40

max
定义：def max: A

描述：返回序列中最大的元素

示例：

val a = Array(1, 2, 3, 4)
println(a.max) // 4

maxBy
定义：def maxBy[B] (f: (A) ⇒ B): A

描述：返回序列中符合条件的第一个元素

示例：

val a = Array(1, 2, 3, 4)
println(a.maxBy(x => x > 2)) // 3

min
定义：def max: A

描述：返回序列中最小的元素

示例：

val a = Array(1, 2, 3, 4)
println(a.min) // 1

minBy
定义：def minBy[B] (f: (A) ⇒ B): A

描述：返回序列中不符合条件的第一个元素

示例：

val a = Array(1, 2, 3, 4)
println(a.minBy(x => x < 2)) // 2

mkString
定义：def mkString: String

描述：将序列中所有元素拼接成一个字符串

示例：

val a = Array(1, 2, 3, 4)
println(a.mkString) // 1234

mkString(sep)
定义：def mkString: String

描述：将序列中所有元素拼接成一个字符串，以 sep 作为元素间的分隔符

示例：

val a = Array(1, 2, 3, 4)
println(a.mkString(",")) // 1,2,3,4

mkString(start, sep, end)
定义：def mkString(start: String, sep: String, end: String): String

描述：将序列中所有元素拼接成一个字符串，以 start 开头，以 sep 作为元素间的分隔符，以 end 结尾

示例：

val a = Array(1, 2, 3, 4)
println(a.mkString("(", ",", ")")) // (1,2,3,4)

nonEmpty
定义：def nonEmpty: Boolean

描述：判断序列是否不为空

示例：

val a = Array(1, 2, 3, 4)
val b = new Array[Int](0)
println(a.nonEmpty) // true
println(b.nonEmpty) // false

padTo
定义：def padTo(len: Int, elem: A): Array[A]

描述：填充序列，如果当前序列长度小于 len，那么新产生的序列长度是 len，多出的几个位值填充 elem，如果当前序列大于等于 len ，则返回当前序列

示例：填充一个长度为 7 的序列，不足位补 8

val a = Array(1, 2, 3, 4)
val b = a.padTo(7, 8)
println(b.mkString(",")) // 1,2,3,4,8,8,8

par
定义：def par: ParArray[T]

描述：返回一个并行实现，产生的并行序列不能被修改

示例：

val a = Array(1, 2, 3, 4)
val b = a.par
println(b.mkString(",")) // 1,2,3,4

partition
定义：def partition(p: (T) ⇒ Boolean): (Array[T], Array[T])

描述：按条件将序列拆分成两个数组，满足条件的放到第一个数组，其余的放到第二个数组，返回的是包含这两个数组的元组

示例：下面以序列元素是否是偶数来拆分

val a = Array(1, 2, 3, 4)
val b: (Array[Int], Array[Int]) = a.partition(x => x % 2 == 0)
println("偶数: " + b._1.mkString(",")) // 偶数: 2,4
println("奇数: " + b._2.mkString(",")) // 奇数: 1,3

patch
定义：def patch(from: Int, that: GenSeq[A], replaced: Int): Array[A]

描述：批量替换，从原序列的 from 处开始，后面的 replaced 个元素，将被替换成序列 that

示例：从 a 的第二个元素开始，取两个元素，即 2 和 3 ，将这两个元素替换为序列 b

val a = Array(1, 2, 3, 4)
val b = Array(7, 8, 9)
val c = a.patch(1, b, 2)
println(c.mkString(",")) // 1,7,8,9,4

permutations
定义：def permutations: collection.Iterator[Array[T]]

描述：permutations 表示排列，这个排列组合会选出所有排列顺序不同的字符组合，permutations 与 combinations 不同的是，相同的组合考虑排列，对于 “abc”、“cba”，视为不同的组合

示例：

val a = Array("a", "b", "c")
val b = a.permutations.toList
b.foreach( x => println(x.mkString(",")))
/*** a,b,c* a,c,b* b,a,c* b,c,a* c,a,b* c,b,a*/

prefixLength
定义：def prefixLength(p: (T) ⇒ Boolean): Int

描述：给定一个条件 p，返回一个前置数列的长度，这个数列中的元素都满足 p

示例：

val a = Array(1, 2, 3, 4)
println(a.prefixLength(x => x < 3)) // 2

product
定义：def product: A

描述：返回所有元素乘积的值

示例：

val a = Array(1, 2, 3, 4)
println(a.product) // 1*2*3*4=24

reduce
定义：def reduce[A1 >: A] (op: (A1, A1) ⇒ A1): A1

描述：同 fold，不需要初始值

示例：

def seqno(m: Int, n: Int): Int = {val s = "seq_exp = %d + %d"println(s.format(m, n))m + n}def main(args: Array[String]) {val a = Array(1, 2, 3, 4)val b = a.reduce(seqno)println("b = " + b)/**seq_exp = 1 + 2seq_exp = 3 + 3seq_exp = 6 + 4b = 10*/}

reduceLeft
定义：def reduceLeft[B >: A] (op: (B, T) ⇒ B): B

描述：同 foldLeft，从左向右计算，不需要初始值

示例：

def seqno(m: Int, n: Int): Int = {val s = "seq_exp = %d + %d"println(s.format(m, n))m + n}def main(args: Array[String]) {val a = Array(1, 2, 3, 4)val b = a.reduceLeft(seqno)println("b = " + b)/**seq_exp = 1 + 2seq_exp = 3 + 3seq_exp = 6 + 4b = 10*/}

reduceRight
定义：def reduceRight[B >: A] (op: (B, T) ⇒ B): B

描述：同 foldRight，从右向左计算，不需要初始值

示例：

  def seqno(m: Int, n: Int): Int = {val s = "seq_exp = %d + %d"println(s.format(m, n))m + n}def main(args: Array[String]) {val a = Array(1, 2, 3, 4)val b = a.reduceRight(seqno)println("b = " + b)/*** seq_exp = 3 + 4seq_exp = 2 + 7* seq_exp = 1 + 9b = 10*/}

reduceLeftOption
定义：def reduceLeftOption[B >: A] (op: (B, T) ⇒ B): Option[B]

描述：同 reduceLeft，返回 Option

示例：

def seqno(m: Int, n: Int): Int = {val s = "seq_exp = %d + %d"println(s.format(m, n))m + n}def main(args: Array[String]) {val a = Array(1, 2, 3, 4)val b = a.reduceLeftOption(seqno)println("b = " + b)/*** seq_exp = 1 + 2seq_exp = 3 + 3* seq_exp = 6 + 4b = Some(10)*/}

reduceRightOption
定义：def reduceRightOption[B >: A] (op: (T, B) ⇒ B): Option[B]

描述：同 reduceRight，返回 Option

示例：

 def seqno(m: Int, n: Int): Int = {val s = "seq_exp = %d + %d"println(s.format(m, n))m + n}def main(args: Array[String]) {val a = Array(1, 2, 3, 4)val b = a.reduceRightOption(seqno)println("b = " + b)/*** seq_exp = 3 + 4seq_exp = 2 + 7* seq_exp = 1 + 9b = Some(10)*/}

reverse
定义：def reverse: Array[T]

描述：反转序列

示例：

val a = Array(1, 2, 3, 4)
val b = a.reverse
println(b.mkString(",")) // 4,3,2,1

reverseIterator
定义：def reverseIterator: collection.Iterator[T]

描述：生成反向迭代器

示例：

val a = Array(1, 2, 3, 4)
val b = a.reverseIterator
b.foreach(x => print(x + " ")) // 4 3 2 1

reverseMap
定义：def reverseMap[B] (f: (A) ⇒ B): Array[B]

描述：同 map，方向相反

示例：

val a = Array(1, 2, 3, 4)
val b = a.reverseMap(x => x * 10)
println(b.mkString(",")) // 40,30,20,10

sameElements
定义：def sameElements(that: GenIterable[A]): Boolean

描述：判断两个序列是否顺序和对应位置上的元素都一样

示例：

val a = Array(1, 2, 3, 4)val b = Array(1, 2, 3, 4)
println(a.sameElements(b)) // trueval c = Array(1, 3, 2, 4)
println(a.sameElements(c)) // false

scan
定义：def scan[B >: A, That] (z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Array[T], B, That]): That

描述：同 fold，scan 会把每一步的计算结果放到一个新的集合中返回，而 fold 返回的是最后的结果

示例：

val a = Array(1, 2, 3, 4)
val b = a.scan(5)(_ + _)
println(b.mkString(",")) // 5,6,8,11,15

scanLeft
定义：def scanLeft[B, That] (z: B)(op: (B, T) ⇒ B)(implicit bf: CanBuildFrom[Array[T], B, That]): That

描述：同 foldLeft，从左向右计算，每一步的计算结果放到一个新的集合中返回

示例：

val a = Array(1, 2, 3, 4)
val b = a.scanLeft(5)(_ + _)
println(b.mkString(",")) // 5,6,8,11,15

scanRight
定义：def scanRight[B, That] (z: B)(op: (T, B) ⇒ B)(implicit bf: CanBuildFrom[Array[T], B, That]): That

描述：同 foldRight，从右向左计算，每一步的计算结果放到（从右向左放）一个新的集合中返回

示例：

val a = Array(1, 2, 3, 4)
val b = a.scanRight(5)(_ + _)
println(b.mkString(",")) // 15,14,12,9,5

segmentLength
定义：def segmentLength(p: (T) ⇒ Boolean, from: Int): Int

描述：从序列的 from 开始向后查找，返回满足条件 p 的连续元素的长度，只返回第一个

示例：

val a = Array(1, 2, 3, 1, 1, 1, 4)
println(a.segmentLength(x => x < 3, 3)) // 3

seq
定义：def seq: collection.mutable.IndexedSeq[T]

描述：产生一个引用当前序列的 sequential 视图

示例：

val a = Array(1, 2, 3, 4)
val b = a.seq
println(b.mkString(",")) // 1,2,3,4

size
定义：def size: Int

描述：返回序列元素个数，同 length

示例：

val a = Array(1, 2, 3, 4)
println(a.size) // 4

e
定义：def slice(from: Int, until: Int): Array[T]

描述：返回当前序列中从 from 到 until 之间的序列，不包括 until 处的元素

示例：

val a = Array(1, 2, 3, 4)
val b = a.slice(1, 3)
println(b.mkString(",")) // 2,3

sliding(size)
定义：def sliding(size: Int): collection.Iterator[Array[T]]

描述：滑动，从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素个数不够 size 时，则结束

示例：

val a = Array(1, 2, 3, 4, 5)
val b = a.sliding(3).toList
for (i <- 0 to b.length - 1) {val s = "第 %d 组: %s"println(s.format(i + 1, b(i).mkString(",")))
}
/*** 第 1 组: 1,2,3* 第 2 组: 2,3,4* 第 3 组: 3,4,5*/

sliding(size, step)
定义：def sliding(size: Int): collection.Iterator[Array[T]]

描述：从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素个数不够 size 时，则结束。该方法可以设置步长 step，每一组元素组合完后，下一组从上一组起始元素位置 + step 后的位置处开始

示例：下面代码，第一组从 1 开始，第二组从 3 开始，因为步长是 2

val a = Array(1, 2, 3, 4, 5)
val b = a.sliding(3, 2).toList
for (i <- 0 to b.length - 1) {val s = "第 %d 组: %s"println(s.format(i + 1, b(i).mkString(",")))
}
/*** 第 1 组: 1,2,3* 第 2 组: 3,4,5*/

sortBy
定义：def sortBy[B] (f: (T) ⇒ B)(implicit ord: math.Ordering[B]): Array[T]

描述：按指定的排序规则对序列排序

示例：

val a = Array(3, 2, 1, 4)val b = a.sortBy(x => x) // 按 x 从小到大，即对原序列升序排列
println("升序: " + b.mkString(",")) // 1,2,3,4val c = a.sortBy(x => 0 - x) // 按 -x 从小到大，即对原序列降序排列
println("降序: " + c.mkString(",")) // 4,3,2,1

sorted
定义：def sorted[B >: A] (implicit ord: math.Ordering[B]): Array[T]]

描述：使用默认的排序规则对序列排序

示例：

val a = Array(3, 2, 1, 4)
val b = a.sorted // 默认升序排列
println(b.mkString(",")) // 1,2,3,4

span
定义：def span(p: (T) ⇒ Boolean): (Array[T], Array[T])

描述：将序列拆分成两个数组，从第一个元素开始，直到第一个不满足条件的元素为止，其中的元素放到第一个数组，其余的放到第二个数组，返回的是包含这两个数组的元组

示例：

val a = Array(1, 2, 3, 4)
val b = a.span(x => x < 3)
println(b._1.mkString(",")) // 1,2
println(b._2.mkString(",")) // 3,4

splitAt
定义：def splitAt(n: Int): (Array[T], Array[T])

描述：从指定位置开始，把序列拆分成两个数组

示例：

val a = Array(1, 2, 3, 4)
val b = a.splitAt(2)
println(b._1.mkString(",")) //  1,2
println(b._2.mkString(",")) //  3,4

startsWith(that)
定义：def startsWith[B] (that: GenSeq[B]): Boolean

描述：判断序列是否以某个序列开始

示例：

val a = Array(1, 2, 3, 4)
val b = Array(1, 2)
println(a.startsWith(b)) // true

startsWith(that, offset)
定义：def startsWith[B] (that: GenSeq[B], offset: Int): Boolean

描述：判断序列从指定偏移处是否以某个序列开始

示例：

val a = Array(1, 2, 3, 4)
val b = Array(2, 3)
println(a.startsWith(b, 1)) // true

stringPrefix
定义：def stringPrefix: String

描述：返回 toString 结果的前缀

示例：

val a = Array(1, 2, 3, 4)
println(a.toString()) // [I@3ab39c39
println(a.stringPrefix) // [I

subSequence
定义：def subSequence(start: Int, end: Int): CharSequence

描述：返回 start 和 end 间的字符序列，不包含 end 处的元素

示例：

val a = Array('a', 'b', 'c', 'd')
val b = a.subSequence(1, 3)
println(b.toString) // bc

sum
定义：def sum: A

描述：序列求和，元素需为 Numeric[T] 类型

示例：

val a = Array(1, 2, 3, 4)
println(a.sum) // 10

tail
定义：def tail: Array[T]

描述：返回当前序列中不包含第一个元素的序列

示例：

val a = Array(1, 2, 3, 4)
val b = a.tail
println(b.mkString(",")) // 2,3,4

tails
定义：def tails: collection.Iterator[Array[T]]

描述：同 inits，每一步都进行 tail 操作

示例：

val a = Array(1, 2, 3, 4)
val b = a.tails.toList
for (i <- 0 until b.length) {val s = "第 %d 个值: %s"println(s.format(i + 1, b(i).mkString(",")))
}
/*** 第 1 个值: 1,2,3,4* 第 2 个值: 2,3,4* 第 3 个值: 3,4* 第 4 个值: 4* 第 5 个值: */

take
定义：def take(n: Int): Array[T]

描述：返回当前序列中，前 n 个元素组成的序列

示例：

val a = Array(1, 2, 3, 4)
val b = a.take(3)
println(b.mkString(",")) // 1,2,3

takeRight
定义：def takeRight(n: Int): Array[T]

描述：返回当前序列中，从右边开始，后 n 个元素组成的序列

示例：

val a = Array(1, 2, 3, 4)
val b = a.takeRight(3)
println(b.mkString(",")) // 2,3,4

takeWhile
定义：def takeWhile(p: (T) ⇒ Boolean): Array[T]

描述：返回当前序列中，从第一个元素开始，满足条件的连续元素组成的序列

示例：

val a = Array(1, 2, 3, 4)
val b = a.takeWhile(x => x < 3)
print(b.mkString(",")) // 1,2

toArray
定义：def toArray: Array[A]

描述：将序列转换成 Array 类型

toBuffer
定义：def toBuffer[A1 >: A]: Buffer[A1]

描述：将序列转换成 Buffer 类型

toIndexedSeq
定义：def toIndexedSeq: collection.immutable.IndexedSeq[T]

描述：将序列转换成 IndexedSeq 类型

toIterable
定义：def toIterable: collection.Iterable[T]

描述：将序列转换成可迭代的类型

toIterator
定义：def toIterator: collection.Iterator[T]

描述：将序列转换成迭代器，同 iterator 方法

toList
定义：def toList: List[T]

描述：将序列转换成 List 类型

toMap
定义：def toMap[T, U]: Map[T, U]

描述：将序列转转换成 Map 类型，需要被转化序列中包含的元素是 Tuple2 类型

toSeq
定义：def toSeq: collection.Seq[T]

描述：将序列转换成 Seq 类型

toSet
定义：def toSet[B >: A]: Set[B]

描述：将序列转换成 Set 类型

toStream
定义：def toStream: collection.immutable.Stream[T]

描述：将序列转换成 Stream 类型

toVector
定义：def toVector: Vector[T]

描述：将序列转换成 Vector 类型

transpose
定义：def transpose[U] (implicit asArray: (T) ⇒ Array[U]): Array[Array[U]]

描述：矩阵转置，二维数组行列转换

示例：

val a = Array(Array("a", "b"), Array("c", "d"), Array("e", "f"))
val b = a.transpose
b.foreach(x => println((x.mkString(","))))
/*** a,c,e* b,d,f*/

union
定义：def union(that: collection.Seq[T]): Array[T]

描述：合并两个序列，同操作符 ++

示例：

val a = Array(1, 2)
val b = Array(3, 4)
val c = a.union(b)
println(c.mkString(",")) // 1,2,3,4

unzip
定义：def unzip[T1, T2] (implicit asPair: (T) ⇒ (T1, T2), ct1: ClassTag[T1], ct2: ClassTag[T2]): (Array[T1], Array[T2])

描述：将含有两个二元组的数组，每个元组的第一个元素组成一个数组，第二个元素组成一个数组，返回包含这两个数组的元组

示例：

val chars = Array(("a", "b"), ("c", "d"))
val b = chars.unzip
println(b._1.mkString(",")) // a,c
println(b._2.mkString(",")) // b,d

unzip3
定义：def unzip3[T1, T2, T3] (implicit asTriple: (T) ⇒ (T1, T2, T3), ct1: ClassTag[T1], ct2: ClassTag[T2], ct3: ClassTag[T3]): (Array[T1], Array[T2], Array[T3])

描述：将含有三个三元组的数组，每个元组的第一个元素组成一个数组，第二个元素组成一个数组，第三个元素组成一个数组，返回包含这三个数组的元组

示例：

val chars = Array(("a", "b", "x"), ("c", "d", "y"), ("e", "f", "z"))
val b = chars.unzip3
println(b._1.mkString(",")) // a,c,e
println(b._2.mkString(",")) // b,d,f
println(b._3.mkString(",")) // x,y,z

update
定义：def update(i: Int, x: T): Unit

描述：将序列中 i 索引处的元素更新为 x

示例：

val a = Array(1, 2, 3, 4)
a.update(1, 7)
println(a.mkString(",")) //1,7,3,4

updated
定义：def updated(index: Int, elem: A): Array[A]

描述：将序列中 i 索引处的元素更新为 x，并返回替换后的数组

示例：

val a = Array(1, 2, 3, 4)
val b = a.updated(1, 7)
println(b.mkString(",")) //1,7,3,4

view
定义：def view(from: Int, until: Int): IndexedSeqView[T, Array[T]]

描述：返回当前序列中从 from 到 until 之间的序列，不包括 until 处的元素

示例：

val a = Array(1, 2, 3, 4)
val b = a.view(1, 3)
println(b.mkString(",")) // 2,3

withFilter
定义：def withFilter(p: (T) ⇒ Boolean): FilterMonadic[T, Array[T]]

描述：根据条件 p 过滤元素

示例：

val a = Array(1, 2, 3, 4)
val b = a.withFilter(x => x > 2).map(x => x)
println(b.mkString(",")) // 3,4

zip
定义：def zip[B] (that: GenIterable[B]): Array[(A, B)]

描述：将两个序列对应位置上的元素组成一个元组数组，要求两个序列长度相同

示例：

val a = Array(1, 2, 3, 4)
val b = Array(4, 3, 2, 1)
val c = a.zip(b)
println(c.mkString(",")) // (1,4),(2,3),(3,2),(4,1)

zipAll
定义：def zipAll[B] (that: collection.Iterable[B], thisElem: A, thatElem: B): Array[(A, B)]

描述：同 zip ，但是允许两个序列长度不同，不足的自动填充，如果当前序列短，不足的元素填充为 thisElem，如果 that 序列短，填充为 thatElem

示例：

val a = Array(1, 2, 3, 4, 5, 6, 7)
val b = Array(5, 4, 3, 2, 1)
val c = a.zipAll(b, 8, 9) // (1,5),(2,4),(3,3),(4,2),(5,1),(6,9),(7,9)
println(c.mkString(","))val x = Array(1, 2, 3, 4)
val y = Array(6, 5, 4, 3, 2, 1)
val z = x.zipAll(y, 8, 9) // (1,6),(2,5),(3,4),(4,3),(8,2),(8,1)
println(z.mkString(","))

zipWithIndex
定义：def zipWithIndex: Array[(A, Int)]

描述：序列中的每个元素和它的索引组成一个元组数组

示例：

val a = Array('a', 'b', 'c', 'd')
val b = a.zipWithIndex
println(b.mkString(",")) // (a,0),(b,1),(c,2),(d,3)

查看全文
如若内容造成侵权/违法违规/事实不符，请联系编程学习网邮箱：809451989@qq.com进行投诉反馈，一经查实，立即删除！

第一次爬取豆瓣电影,纪念下
这里写自定义目录标题爬取豆瓣中的电影学习爬虫,一直只能写简单的爬虫爬取静态页面,今天终于写出一个可以爬取AJAX页面的爬虫,记录一下代码编写的过程,纪念一下目标:爬取豆瓣电影列表中的电影的名称和评分分析页面,触发异步加载响应后在Name一栏可以看到网站实际响应的页面,在…...
2024/4/25 8:43:26
*String[] args*和*String args[]*
原文点击 String[] args和*String args[]*执行效果上没有不同, 但在语法意义上略有不同. 比如, String 与 String[], 前者叫字符串类型而后者叫字符串数组类型. String args[]单从类型上来讲属于字符串类型, 而从变量本身来讲是一个数组类型, 因此组合起来说明此变量为一个字符…...
2024/4/2 11:11:22
leetcode714. 买卖股票的最佳时机含手续费（动态规划）
给定一个整数数组 prices，其中第 i 个元素代表了第 i 天的股票价格；非负整数 fee 代表了交易股票的手续费用。你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。返回获得利润的最大值。注意：这…...
2024/4/28 22:12:32
ssh隧道，sockets转http
场景当前的网络C无法访问对象A，但是可以访问对象B，对象A对B开了白名单或者A和B是在同一局域网中，即B可以访问A。要解决的问题现在的问题是：如何让C能成功访问A。操作步骤B开启22端口，使用ssh连接工具配置ssh隧道。这里我使用的是MobaXterm，xshell同理。打开MobaXterm，在…...
2024/5/5 0:23:11
java 针对抢购功能对比一下悲观锁和乐观锁
抢购功能：在极短的时间内有大量的并发请求，出现因为并发所引起的问题。实例：一个商品50件，一个用户一次购买3件，100个用户同时购买。设计：mysql数据库建表语句：CREATE TABLE `product` (`id` int(11) NOT NULL,`product_id` int(11) DEFAULT NULL,`stock` int(11) DEFAU…...
2024/4/21 15:50:58
7、Cookie、Session
7.1、会话会话：用户打开一个浏览器，点击了很多超链接，访问多个web资源，关闭浏览器，这个过程可以称之为会话；有状态会话：一个同学来过教室，下次再来教室，我们会知道这个同学，曾经来过，称之为有状态会话；你能怎么证明你是西开的学生？你西开发票西开给你发票学校登…...
2024/4/23 0:24:52
SCVMM2019安装
SCVMM（System Center Virtual Machine Manager）是一种虚拟机部署和管理工具。 1.先解压2.找到解压的位置，安装3.勾选VMM管理服务器，VMM控制台会默认勾上4.输入产品秘钥5.同意条款6.下一步7.关闭，不自动更新8.设置安装位置9.使用管理员权限的凭证，选择SCVMM实例10.输入有管…...
2024/4/19 12:24:10
python--基础知识点--cyptes
模块ctypes是Python内建的用于调用动态链接库函数的功能模块，一定程度上可以用于Python与其他语言的混合编程。由于编写动态链接库，使用C/C++是最常见的方式，故ctypes最常用于Python与C/C++混合编程之中。 1. ctypes 的原理以及优缺点从ctypes的文档中可以推断，在各个平台…...
2024/4/2 10:06:54
pytorch学习笔记1：线性回归（含代码）亲测可用
回归VS分类对连续型变量做预测叫回归，对离散型变量做预测叫分类线性回归的主要任务是什么？线性回归的任务是找到一个从特征空间X到输出空间Y的最优的线性映射函数。损失：那既然是找直线，那肯定是要有一个评判的标准，来评判哪条直线才是最好的。OK，道理我们都懂，那咋…...
2024/4/22 2:14:11
LeetCode(中等)组合总和(c#)
题目为给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。 candidates 中的数字可以无限制重复被选取。说明：所有数字（包括 target）都是正整数。解集不能包含重复的组合。DFS直接遍历，代码如下IList<…...
2024/4/21 23:15:19
吃透Docker容器+Kubernetes（K8S）看这份阿里P9笔记就够了
Docker的流行激活了一直不温不火的PaaS,随之，而来的是各类Micro-PaaS的出现，Kubernetes 是其中最具代表性的一一员，它是Google多年大规模容器管理技术的开源版本。越来越多的企业被迫面对互联网规模所带来的各类难题，而Kubernetes以其优秀的理念和设计正在逐步形成新的技术…...
2024/4/10 5:58:05
计算几何总结
1、凸包2、旋转卡壳例1-求凸包直径：https://www.luogu.com.cn/problem/P1452...
2024/4/2 17:37:22
C++利用set排除字眼，Iterator Inserter，Iostream Iterator的使用
利用set将输入到map中的字眼进行排除set<string> exlusion = {"a", "an", "or", "the", "and", "but"}; //排除的字眼map<string, int> words; //被筛选的文本vector<string> out; //将筛选后的…...
2024/5/4 17:10:43
基于JS插件实现 Web网络拓扑图示例记录
最近在弄一个物联网项目，需要用到拓扑图，网上找了很久，没有弄到，后来弄了一个开源的，整理了好久，终于弄出来了，下面是设计界面效果：下面是精简后的一段html可以直接执行： <!DOCTYPE html> <html class="x-admin-sm" lang="zh-CN"> &…...
2024/4/22 8:39:19
ElasticSearch学习（三）—— Java写入数据
7.2.0版本获取客户端连接private static int port = 9200; private static String host = "192.168.1.105";private static RestHighLevelClient getClient() {RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(new HttpHost(host, port, &…...
2024/4/2 16:11:04
瞬子图文解析
瞬子-图文解析作者张嘉年:tai_ning@163.com 瞬子的本质及来源和用途概术如下： 1，瞬子来自于运动方程式的经典解，它是欧氏空间中经典场论运动方程式的解，在量子场论中扮演重要角色，在路径积分中，用于对物理系统的经典效应进行量子修正。瞬子也是爱因斯坦方程和其他场方程…...
2024/5/4 6:44:02
游戏建模师熬夜加班，2年做到首席美术总监，为何还单身狗一条
Ⅰ、次世代场景建模师是否有"钱"途首先，抛开极少数高手，游戏美术普遍前景堪忧。因为：1，在中国游戏美术可替代性太高，中国每年毕业的美术生太多，选择游戏美术的人太多，市场不会管你付出了多少努力，只要和你付出同样努力的人够多，你就是农民工，这一点没得商量…...
2024/4/2 17:36:28
栈的应用1——数制转换
数制一般分为二、八、十、十六这几种常见的（没错就是我现在能见到的） x进制就是0~x-1构成每一位，就如二进制是0、1，八进制是0到7 数制转换数制转换一直是计算机的一个基本问题，目前已经有了很多的解决方法。如果是其他进制转换十进制（因为十进制多数人还是比较熟悉的，…...
2024/4/24 2:00:56
C++策略设计模式
一、策略模式核心思想：Strategy 模式将逻辑（算法）封装到一个类（Context）里面，通过组合的方式将具体算法的实现在组合对象中实现，再通过委托的方式将抽象接口的实现委托给组合对象实现 #include <iostream> #include <cmath> #include <string> using…...
2024/4/2 19:04:47
SPRINGCLOUD五大组件及相关注解整理
四、Zuul-服务网关 a. 简介、功能 Zuul简介 Zuul相当于是第三方调用（app应用端和PC端）和服务提供方之间的防护门。作为前端服务（Edge Service也称边缘服务，前端服务的作用是对后端服务做必要的聚合和裁剪后暴露给外部不同的设备，如PC，Pad或者Phone），Zuul旨在实现动态路…...
2024/4/2 16:59:40

Scala入门系列（三）：Scala高阶函数大全之Array

相关文章

最新文章