Scala Vector informational and mathematical methods (syntax, examples)

By Alvin Alexander. Last updated: January 14, 2020

This page contains a collection of examples of how to use Scala Vector class informational and mathematical methods. Note that these same methods will also work with a Scala Seq, including IndexedSeq.

Informational and mathematical methods

As the name implies, these methods let you get information about the contents of a Vector, or perform mathematical expressions on a Vector.

Method	Returns
`contains(e)`	True if the vector contains the element `e`
`containsSlice(s)`	True if the vector contains the sequence `s`
`count(p)`	The number of elements in the vector for which the predicate is true
`endsWith(s)`	True if the vector ends with the sequence `s`
`exists(p)`	True if the predicate returns true for at least one element in the vector
`find(p)`	The first element that matches the predicate `p`, returned as an `Option`
`forall(p)`	True if the predicate `p` is true for all elements in the vector
`hasDefiniteSize`	True if the vector has a finite size
`indexOf(e)`	The index of the first occurrence of the element `e` in the vector
`indexOf(e,i)`	The index of the first occurrence of the element `e` in the vector, searching only from the value of the start index `i`
`indexOfSlice(s)`	The index of the first occurrence of the sequence `s` in the vector
`indexOfSlice(s,i)`	The index of the first occurrence of the sequence `s` in the vector, searching only from the value of the start index `i`
`indexWhere(p)`	The index of the first element where the predicate `p` returns true
`indexWhere(p,i)`	The index of the first element where the predicate `p` returns true, searching only from the value of the start index `i`
`isDefinedAt(i)`	True if the vector contains the index `i`
`isEmpty`	True if the vector contains no elements
`lastIndexOf(e)`	The index of the last occurrence of the element `e` in the vector
`lastIndexOf(e,i)`	The index of the last occurrence of the element `e` in the vector, occurring before or at the index `i`
`lastIndexOfSlice(s)`	The index of the last occurrence of the sequence `s` in the vector
`lastIndexOfSlice(s,i)`	The index of the last occurrence of the sequence `s` in the vector, occurring before or at the index `i`
`lastIndexWhere(p)`	The index of the first element where the predicate `p` returns true
`lastIndexWhere(p,i)`	The index of the first element where the predicate `p` returns true, occurring before or at the index `i`
`max`	The largest element in the vector
`min`	The smallest element in the vector
`nonEmpty`	True if the vector is not empty (i.e., if it contains 1 or more elements)
`product`	The result of multiplying the elements in the collection
`segmentLength(p,i)`	The length of the longest segment for which the predicate `p` is true, starting at the index `i`
`size`	The number of elements in the vector
`startsWith(s)`	True if the vector begins with the elements in the sequence `s`
`startsWith(s,i)`	True if the vector has the sequence `s` starting at the index `i`
`sum`	The sum of the elements in the vector
`fold(s)(o)`	“Fold” the elements of the vector using the binary operator `o`, using an initial seed `s` (see also `reduce`)
`foldLeft(s)(o)`	“Fold” the elements of the vector using the binary operator `o`, using an initial seed `s`, going from left to right (see also `reduceLeft`)
`foldRight(s)(o)`	“Fold” the elements of the vector using the binary operator `o`, using an initial seed `s`, going from right to left (see also `reduceRight`)
`reduce`	“Reduce” the elements of the vector using the binary operator `o`
`reduceLeft`	“Reduce” the elements of the vector using the binary operator `o`, going from left to right
`reduceRight`	“Reduce” the elements of the vector using the binary operator `o`, going from right to left

Examples

First, some sample data:

val evens = Vector(2, 4, 6)
val odds = Vector(1, 3, 5)
val fbb = "foo bar baz"
val firstTen = (1 to 10).toVector          # Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
val fiveToFifteen = (5 to 15).toVector     # Vector(5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)
val empty = Vector[Int]()                  # Vector[Int] = Vector()
val letters = ('a' to 'f').toVector        # Vector(a, b, c, d, e, f)

The examples:

evens.contains(2)                          # true
firstTen.containsSlice(Seq(3,4,5))         # true
firstTen.count(_ % 2 == 0)                 # 5
firstTen.endsWith(Seq(9,10))               # true
firstTen.exists(_ > 10)                    # false
firstTen.find(_ > 2)                       # Some(3)
firstTen.forall(_ < 20)                    # true
firstTen.hasDefiniteSize                   # true
empty.hasDefiniteSize                      # true
letters.indexOf('b')                       # 1 (zero-based)
letters.indexOf('d', 2)                    # 3
letters.indexOf('d', 3)                    # 3
letters.indexOf('d', 4)                    # -1
letters.indexOfSlice(Seq('c','d'))         # 2
letters.indexOfSlice(Seq('c','d'),2)       # 2
letters.indexOfSlice(Seq('c','d'),3)       # -1
firstTen.indexWhere(_ == 3)                # 2
firstTen.indexWhere(_ == 3, 2)             # 2
firstTen.indexWhere(_ == 3, 5)             # -1
letters.isDefinedAt(1)                     # true
letters.isDefinedAt(20)                    # false
letters.isEmpty                            # false
empty.isEmpty                              # true

# lastIndex...
val fbb = "foo bar baz"
fbb.indexOf('a')                           # 5
fbb.lastIndexOf('a')                       # 9
fbb.lastIndexOf('a', 10)                   # 9
fbb.lastIndexOf('a', 9)                    # 9
fbb.lastIndexOf('a', 6)                    # 5
fbb.lastIndexOf('a', 5)                    # 5
fbb.lastIndexOf('a', 4)                    # -1

fbb.lastIndexOfSlice("ar")                 # 5
fbb.lastIndexOfSlice(Seq('a','r'))         # 5
fbb.lastIndexOfSlice(Seq('a','r'), 4)      # -1
fbb.lastIndexOfSlice(Seq('a','r'), 5)      # 5
fbb.lastIndexOfSlice(Seq('a','r'), 6)      # 5

fbb.lastIndexWhere(_ == 'a')               # 9
fbb.lastIndexWhere(_ == 'a', 4)            # -1
fbb.lastIndexWhere(_ == 'a', 5)            # 5
fbb.lastIndexWhere(_ == 'a', 6)            # 5
fbb.lastIndexWhere(_ == 'a', 8)            # 5
fbb.lastIndexWhere(_ == 'a', 9)            # 9

firstTen.max                               # 10
letters.max                                # f
firstTen.min                               # 1
letters.min                                # a
letters.nonEmpty                           # true
empty.nonEmpty                             # false
firstTen.product                           # 3628800
letters.size                               # 6

val x = Vector(1,2,9,1,1,1,1,4)
x.segmentLength(_ < 4, 0)                  # 2
x.segmentLength(_ < 4, 2)                  # 0
x.segmentLength(_ < 4, 3)                  # 4
x.segmentLength(_ < 4, 4)                  # 3

firstTen.startsWith(Seq(1,2))              # true
firstTen.startsWith(Seq(1,2), 0)           # true
firstTen.startsWith(Seq(1,2), 1)           # false
firstTen.sum                               # 55

firstTen.fold(100)(_ + _)                  # 155
firstTen.foldLeft(100)(_ + _)              # 155
firstTen.foldRight(100)(_ + _)             # 155
firstTen.reduce(_ + _)                     # 55
firstTen.reduceLeft(_ + _)                 # 55
firstTen.reduceRight(_ + _)                # 55

firstTen.fold(100)(_ - _)                  # 45
firstTen.foldLeft(100)(_ - _)              # 45
firstTen.foldRight(100)(_ - _)             # 95
firstTen.reduce(_ - _)                     # -53
firstTen.reduceLeft(_ - _)                 # -53
firstTen.reduceRight(_ - _)                # -5

More on fold and reduce

For more information on fold and reduce, see my article, Recursion is great, but ... (fold and reduce)

this post is sponsored by my books:
#1 New Release	FP Best Seller	Learn Scala 3	Learn FP Fast

More information

I created this tutorial to show examples of Scala Vector informational and mathematical methods, but for many more examples of how to work with Vector, see my Scala Vector class syntax and method examples tutorial.

scala

count