Split

Strings can contain sentences. But often they contain lists of structured data. Fields are separated by commas (or other characters). Split helps us process this data.

With split, a Scala method that acts on StringLike values, we specify a delimiter or many delimiters. The method returns an array. We can process the string's fields in this array.

An example

Here we use just one delimiter char, a comma. Our constant string "line" has three parts to it—these are separated by commas. We call split.

object Program {
    def main(args: Array[String]): Unit = {
        // The string we want to split.
        val line = "brick,cement,concrete"

        // Split on each comma.
        val result = line.split(',')

        // Array length.
        println(result.length)

        // Print all elements in array.
        for (v <- result) {
            println(v)
        }
    }
}
3
brick
cement
concrete

Multiple delimiters

Sometimes a string may have more than one delimiter char. This becomes complex, but using multiple delimiters to split can help.

object Program {
    def main(args: Array[String]): Unit = {
        // This has several delimiters.
        val codes = "abc;def,ghi:jkl"

        // Use an Array argument to split on multiple delimiters.
        val result = codes.split(Array(';', ',', ':'))

        // Print result length.
        println(result.length)

        // Display all elements in the array.
        result.foreach(println(_))
    }
}
4
abc
def
ghi
jkl

Substring delimiter

Sometimes we want to split on a longer delimiter (like two chars). Here we split on a two-char substring. We print the results.

object Program {
    def main(args: Array[String]): Unit = {
        // Strings are separated with two-char delimiters.
        val equipment = "keyboard; mouse; screen"

        // Split on substring.
        val result = equipment.split("; ")
        result.foreach(println(_))
    }
}
keyboard
mouse
screen

Regex

A regular expression can separate a string. This can remove empty entries—we can treat two delimiters as one. Here we treat any number of spaces and semicolons as a delimiter.

object Program {
    def main(args: Array[String]): Unit = {
        // This string has an empty item between delimiters.
        val items = "box; ; table; chair"

        // Use a Regex to split the string.
        // ... Any number of spaces or semicolons is a delimiter.
        val result = items.split("[; ]+")

        // Print our results.
        // ... No empty elements are present.
        for (r <- result) {
            println(r)
        }
    }
}
box
table
chair

In Scala we find methods that act on StringLike types. Split is one of these functions. We invoke it to separate structured data within a block of text.