Kotlin Programming

  1. The Kotlin Standard Library
    1. Collections
      1. Collection Hierarchy
        1. Collection Types
          1. `List`
            1. `Set`
              1. `Map`
              2. Read-Only vs. Mutable Collections
                1. Creating Collections
                  1. `listOf`
                    1. `mutableListOf`
                      1. `setOf`
                        1. `mutableSetOf`
                          1. `mapOf`
                            1. `mutableMapOf`
                              1. `arrayOf`
                                1. Empty Collections
                                2. Collection Operations
                                  1. Transformations
                                    1. `map`
                                      1. `mapNotNull`
                                        1. `mapIndexed`
                                          1. `flatMap`
                                            1. `flatten`
                                            2. Filtering
                                              1. `filter`
                                                1. `filterNot`
                                                  1. `filterIsInstance`
                                                    1. `filterNotNull`
                                                    2. Predicates
                                                      1. `all`
                                                        1. `any`
                                                          1. `none`
                                                          2. Aggregating
                                                            1. `fold`
                                                              1. `reduce`
                                                                1. `sum`
                                                                  1. `count`
                                                                    1. `maxOrNull`
                                                                      1. `minOrNull`
                                                                      2. Iterating
                                                                        1. `forEach`
                                                                          1. `forEachIndexed`
                                                                            1. `onEach`
                                                                            2. Grouping
                                                                              1. `groupBy`
                                                                                1. `groupingBy`
                                                                                2. Sorting
                                                                                  1. `sorted`
                                                                                    1. `sortedBy`
                                                                                      1. `sortedWith`
                                                                                        1. `sortedDescending`
                                                                                        2. Partitioning and Chunking
                                                                                          1. `partition`
                                                                                            1. `chunked`
                                                                                              1. `windowed`
                                                                                              2. Zipping and Unzipping
                                                                                                1. `zip`
                                                                                                  1. `unzip`
                                                                                                  2. Element Operations
                                                                                                    1. `first`
                                                                                                      1. `last`
                                                                                                        1. `find`
                                                                                                          1. `single`
                                                                                                            1. `elementAt`
                                                                                                          2. Collection Builders
                                                                                                            1. Collection Conversion
                                                                                                            2. Sequences
                                                                                                              1. Lazy Evaluation
                                                                                                                1. Creating Sequences
                                                                                                                  1. `sequenceOf`
                                                                                                                    1. `asSequence`
                                                                                                                      1. `generateSequence`
                                                                                                                      2. Sequence Operations
                                                                                                                        1. Terminal Operations
                                                                                                                          1. Converting Between Collections and Sequences
                                                                                                                            1. Performance Considerations
                                                                                                                            2. Arrays
                                                                                                                              1. Array Types
                                                                                                                                1. Creating Arrays
                                                                                                                                  1. Array Operations
                                                                                                                                    1. Primitive Arrays
                                                                                                                                    2. String Manipulation
                                                                                                                                      1. String Properties and Functions
                                                                                                                                        1. String Comparison
                                                                                                                                          1. String Modification
                                                                                                                                            1. Splitting and Joining Strings
                                                                                                                                              1. String Formatting
                                                                                                                                                1. StringBuilder
                                                                                                                                                  1. Regular Expressions
                                                                                                                                                    1. Creating Regex
                                                                                                                                                      1. Pattern Matching
                                                                                                                                                        1. Finding and Replacing
                                                                                                                                                          1. Groups and Capturing
                                                                                                                                                        2. I/O Operations
                                                                                                                                                          1. Reading from Standard Input
                                                                                                                                                            1. Writing to Standard Output
                                                                                                                                                              1. File I/O Basics
                                                                                                                                                                1. Reading Files
                                                                                                                                                                  1. Writing Files
                                                                                                                                                                    1. File Properties
                                                                                                                                                                    2. Path Operations
                                                                                                                                                                    3. Utility Functions
                                                                                                                                                                      1. Scope Functions
                                                                                                                                                                        1. `let`
                                                                                                                                                                          1. `run`
                                                                                                                                                                            1. `with`
                                                                                                                                                                              1. `apply`
                                                                                                                                                                                1. `also`
                                                                                                                                                                                  1. Choosing the Right Scope Function
                                                                                                                                                                                  2. The `TODO()` Function
                                                                                                                                                                                    1. Preconditions and Assertions
                                                                                                                                                                                      1. `require`
                                                                                                                                                                                        1. `requireNotNull`
                                                                                                                                                                                          1. `check`
                                                                                                                                                                                            1. `checkNotNull`
                                                                                                                                                                                              1. `assert`
                                                                                                                                                                                              2. Standard Functions
                                                                                                                                                                                                1. `repeat`
                                                                                                                                                                                                  1. `takeIf`
                                                                                                                                                                                                    1. `takeUnless`

                                                                                                                                                                                                Previous

                                                                                                                                                                                                5. Advanced Language Features

                                                                                                                                                                                                Go to top

                                                                                                                                                                                                Next

                                                                                                                                                                                                7. Concurrency with Coroutines