List

Overview: Lists in Scala are ordered collections of elements of the same type. They are immutable, meaning that their elements cannot be changed after the list is created.

Creating Lists:

val emptyList: List[Nothing] = List()
val singleList: List[Int] = List(1)
val multiList: List[Int] = List(1, 2, 3)

Key Properties:
- Lists are immutable.
- Lists are recursive structures (a head element and a tail list).

Accessing Elements:
- Access by index: val firstElement = multiList(0)
- Head and tail: val head = multiList.head, val tail = multiList.tail
Appending and Prepending Elements:
- Prepend with :: or +:: val newList = 0 :: multiList
- Append with :+ (less efficient): val appendedList = multiList :+ 4
Concatenation:
- Concatenate two lists: val combinedList = List(1, 2) ::: List(3, 4)

Mapping (map): Applying a function to each element.
```
val doubledList = multiList.map(_ * 2)
```
Filtering (filter): Selecting elements based on a condition.
```
val evenList = multiList.filter(_ % 2 == 0)
```
Reducing (reduce): Combining elements using a binary operation.
```
val sum = multiList.reduce(_ + _)
```

flatMap: Applying a function that returns a sequence for each element, and flattening the results into a single list.
foreach: Executing a side-effecting function on each element.
foldLeft and foldRight: Like reduce, but with an initial accumulator value.
zip: Combining two lists into a list of pairs.
reverse: Reversing the list.
Examples for each method will illustrate their utility and usage.

Immutability and Performance: Understanding the implications of list immutability on performance, especially for operations like appending.
Choosing the Right Collection: When to use List vs. other collections (e.g., Vector, Array) based on performance characteristics and use cases.
Functional Transformations Over Mutations: Emphasizing the use of functional transformations (map, filter, etc.) over imperative modifications to embrace Scala's functional programming paradigm.

Keyboard shortcuts