---
# System prepended metadata

title: Kotlin Split String
tags: [String, Kotlin, Split]

---

# Kotlin Split String / List

###### tags: `Kotlin` `Split`


# Split String

## Reference:

* [Kotlin Split String example](http://kotlination.com/kotlin/kotlin-split-string-example)
* [Kotlin – Split String to Lines – String.lines() function](https://www.tutorialkart.com/kotlin/split-string-to-lines/)


### 1. split() with Regex
This overload of split() method requires a value of Regex type, not String:

```
inline fun CharSequence.split(regex: Regex, limit: Int = 0): List<String>
```
Kotlin not only uses the same regular expression syntax and APIs as Java, 
but also has extension function toRegex() to convert a string into a regular expression.


example:
```
val str = "Kotlination.com = Be Kotlineer - Be Simple - Be Connective"
val separate1 = str.split("=|-".toRegex())
println(separate1)
```
Result:
```
[Kotlination.com ,  Be Kotlineer ,  Be Simple ,  Be Connective]
```

### 2. split() with plain-text characters/strings
Instead of using Regex, you can specify character/string arguments:

```
fun CharSequence.split(vararg delimiters: String, ignoreCase: Boolean = false, limit: Int = 0): List<String>
```

example:
```
val str = "Kotlination.com = Be Kotlineer - Be Simple - Be Connective"
val separate2 = str.split(" = "," - ")
println(separate2)
```

Result:
```
[Kotlination.com, Be Kotlineer, Be Simple, Be Connective]
```

### 3 ``lines()``
```
fun CharSequence.lines(): List<String>
```

example:
```
// string to be split to lines
val str: String = "Kotlin Tutorial.\nLearn Kotlin Programming with Ease.\rLearn Kotlin Basics."
 
// splitting string using lines() function
val lines = str.lines()
 
// printing lines
lines.forEach { println(it) }
```

Result:
```
Kotlin Tutorial.
Learn Kotlin Programming with Ease.
Learn Kotlin Basics.
```

---

# [Split a List into Parts in Kotlin](https://www.baeldung.com/kotlin/split-list-into-parts)

## 1. Introduction

Let’s say we have an array like ``[a, b, c, d, e, f]`` and 
we want to split the elements up into separate groups, like 
```
[[a, b], [c, d], [e, f]] or [[a, b, c], [d], [e,f]].
```

In this tutorial, we’ll achieve this 
while examining some differences between Kotlin’s 
``groupBy``, ``chunked``, and ``windowed``.

## 2. Splitting a List Into a List of Pairs
For our examples, we’ll use two lists – 
one with an even number of elements and one with an odd number of elements:

```
val evenList = listOf(0, "a", 1, "b", 2, "c");
val unevenList = listOf(0, "a", 1, "b", 2, "c", 3);
```

Clearly, we can divide our evenList into exactly three pairs. 
However, our ``unevenList`` will __have one extra element__.

In the remainder of this section, 
we’ll see various implementations for splitting our two lists, 
including __how they deal with the extra element in ``unevenList``__.

### 2.4. Using chunked
But, we can do this more elegantly with chunked. 
So, let’s apply the method to our evenList:

```
evenList.chunked(2)
```

The ``evenList`` provides us with the pairs we want:

```
[[0, "a"], [1, "b"], [2, "c"]]
```

While the ``unevenList`` gives us the pairs and the extra element:

```
[[0, "a"], [1, "b"], [2, "c"], [3]]
```

### 2.5. Using ``windowed``
And ``chunked`` works really well, 
__but sometimes we need a bit more control__.

For instance, we may need to specify if we want only pairs, 
or if we want to include the extra element. 
The ``windowed`` method provides us with a ``partialWindows`` ``Boolean``, 
which indicates if we want the partial result or not.

__By default, ``partialWindows`` is ``false``__. 
So, the following statements produce the same result:

```
evenList.windowed(2, 2)
unevenList.windowed(2, 2, false)
```

Both return the list without the separate element:

```
[[0, "a"], [1, "b"], [2, "c"]]

```

Finally, when we set ``partialWindows`` to ``true`` to include the partial result:

```
unevenList.windowed(2, 2, true)
```

We’ll get the list of pairs plus the separate element:

```
[[0, "a"], [1, "b"], [2, "c"], [3]]
```

看 Source code, ``chunked()`` 其實是引用 ``windowed()``

```
public fun <T> Iterable<T>.chunked(size: Int): List<List<T>> {
    return windowed(size, size, partialWindows = true)
}
```

## 3. A Few Words About the ``partition()`` Function
We’ve solved our problem using 
``groupBy()``, ``chunked()``, and ``windowed()``. 
``partition()`` is another function that can split a list into parts. 
As such, it can be pretty convenient for solving some similar problems.

Kotlin’s ``partition()`` function can 
split a list into a pair of two lists by a given predicate function.

An example can clarify this quickly. 
Let’s say we have a list of unsorted integers and 
we’d like to split it into two lists – 
one containing numbers less than ``42``, 
and the other holding numbers greater than or equal to ``42``.

If we solve this problem using ``partition()``, it’s pretty easy:

```
val numbers = listOf(42, 1984, 1, 0, -4, 23, 100, 6, 8)
val aPairOfList = numbers.partition { it < 42 }
with(aPairOfList) {
    assertEquals(listOf(1, 0, -4, 23, 6, 8), first)
    assertEquals(listOf(42, 1984, 100), second)
}
```

As the example above shows, 
we provided ``it < 42`` as the predicate function. 
In the resulting pair, the first list carries all elements 
for which the predicate function yielded ``true``, 
and the second list holds elements 
for which the predicate function returns ``false``.

Sometimes, we want to use the split lists as variables directly 
instead of using them like ``thePair.first`` and ``thePair.second``. 
In this case, we can use a deconstructing declaration 
to assign ``partition()``‘s result to two list variables in one shot:

```
val (lessThan42, greaterThanOrEq42) = numbers.partition { it < 42 }

assertEquals(listOf(1, 0, -4, 23, 6, 8), lessThan42)
assertEquals(listOf(42, 1984, 100), greaterThanOrEq42)
```

原來 kotlin 愈來愈像 python