Top 10 Kotlin Code Snippets to Keep Handy
Tags: kotlin, programming, beginners
Published: 2024-03-19 16:00:53

Kotlin is the cross-platform, general-purpose, open-source programming language developed by JetBrains. It is fully interoperable with Java. According to Stack Overflow, Kotlin is the 4th most loved language among the developer’s community, and it is the preferred language for Android development.

Google announced first-class support for Kotlin on Android in addition to the existing languages – Java and C++ – at Google I/O in 2017. [Google also announced Kotlin as its preferred language for Android development](https://techcrunch.com/2019/05/07/kotlin-is-now-googles-preferred-language-for-android-app-development/) on May 7, 2019.

Rather than searching through your notes, codebase, and search history endlessly, you can use Pieces for Developers to organize useful code snippets along with useful links, tags, descriptions, anchors, and titles for each snippet, making it a lightning fast task to retrieve one whenever you need it.

In this article we will look at a curated list of the best Kotlin code snippets for beginners and advanced developers who want to enhance their productivity & skills with this powerful language.

Let’s get started!

## 1. Delegated Properties

Delegation is defined as granting authority or power to the person to carry out different tasks. Similarly, Kotlin provides the language support for delegation using Delegation properties.

This feature allows you to create and implement properties only once and then use them continuously to delegate other code work in the application.

Delegation is the design pattern where an object or property delegates the task to the other helper object instead of performing the task itself.

In the code below, a property name in our Demo class delegates the logic for getter and setter to `DelegateHelperClass()`, so anything after that keyword satisfies the conversion for the property delegates to act as a Delegate.

Let's dive into how delegated properties work with a code example:

```
class Demo {var name: String by DelegateHelperClass()}
```

[Save this code](https://sophyia.pieces.cloud/?p=1ed64895be)

## 2. Smart casts

Other programming languages, including Java, require explicit type casting on variables before accessing their properties. However, there is a feature in Kotlin called smart casting that tracks conditions within the if expression.

If the Kotlin compiler discovers a variable that is not null and has a type equal to nullable, only then the compiler will allow access to that variable. The `is` or `!is` operator can be used to check the type of a variable, and the compiler will automatically cast the variable to the target type as shown in the code.

```
fun main(args: Array< String >) 
{val str1: String? = “Hello World”var str2: String? = null 
// prints String is nullif(str1 is String) 
          {// No Explicit type Casting needed.println(“length of String ${str1.length}”)}
else 
          {println(“String is null”)}}
```

[Save this code](https://sophyia.pieces.cloud/?p=3bbe4388ac)

## 3. Elvis Operator (?:)

The Elvis operator in Kotlin, represented as `?:`, offers a concise way to handle nullability. It returns the expression on the left if it's not null, otherwise, it evaluates and returns the expression on the right. This snippet is handy when dealing with nullable types, preventing null pointer exceptions.

```
val result = nullableValue ?: defaultValue
```

[Save this code](https://sophyia.pieces.cloud/?p=da3c4f803c)

Use Case: Use the Elvis operator to provide a default value when dealing with nullable variables, simplifying null checks.

## 4. Safe Call Operator (?.)

The safe call operator, denoted by `?.` in this Kotlin code snippet, allows accessing properties or invoking methods on nullable objects safely. It returns null if the object is null, preventing `NullPointerExceptions`.

```
val length = nullableString?.length
```

[Save this code](https://sophyia.pieces.cloud/?p=a75840a303)

Use Case: Employ the safe call operator Kotlin snippet when working with nullable objects to access their properties or methods without risking null pointer exceptions.

## 5. String Interpolation

Kotlin supports string interpolation, enabling the embedding of expressions directly into strings. Enclose the expression in curly braces preceded by a dollar sign (`${expression}`).

```
val name = "John"
val greeting = "Hello, $name!"
```

[Save this code](https://sophyia.pieces.cloud/?p=496042be9b)

Use Case: Utilize string interpolation for dynamic string construction, enhancing code readability and maintainability.

## 6. Extension Functions

Extension functions allow adding new functionalities to existing classes without modifying their source code. They enhance code reusability and facilitate a more fluent API design.

```
fun String.addExclamation(): String {
                             return "$this!"
                             }
```

[Save this code](https://sophyia.pieces.cloud/?p=d0c24c8572)

Use Case: Employ extension functions to extend the functionality of existing classes, promoting [code organization](https://code.pieces.app/blog/modern-code-organization-techniques) and maintainability.

## 7. Data Classes

In Kotlin, data classes are a special type of class that is primarily used to hold data. They are designed to reduce boilerplate code by automatically generating several standard methods such as `equals()`, `hashCode()`, `toString()`, and `copy()`.

In this Kotlin code snippet below, we define a data class named User with two properties: name of type String and age of type `Int`. By simply declaring the class with the data modifier, Kotlin automatically generates the `equals()`, `hashCode()`, `toString()`, and `copy()` methods for us.

Using data classes simplifies working with immutable data. In the example, we create a User object named user with the name "Alice" and age 30. Since `User` is a data class, we can easily access its properties, compare objects for equality, generate hash codes, and create copies without writing additional boilerplate code.

```
data class User(val name: String, val age: Int)
val user = User("Alice", 30)
```

[Save this code](https://sophyia.pieces.cloud/?p=2254438828)

Use Case: Use data classes to represent immutable data, reducing boilerplate code and enhancing readability.

## 8. Higher-Order Functions

Higher-order functions accept other functions as parameters or return them. They enable concise and expressive code, promoting functional programming paradigms. They can take other functions as parameters or return functions as results. In Kotlin, functions are first-class citizens, meaning they can be treated like any other value, such as integers or strings. This allows for the creation of higher-order functions, which enable more concise and flexible code.

```
fun operateOnNumber(number: Int, operation: (Int) -> Int): Int
{
 return operation(number)
}

val squared = operateOnNumber(5) { it * it }
```

[Save this code](https://sophyia.pieces.cloud/?p=8a3240a0af)

Use Case: Leverage higher-order functions to encapsulate common behaviors and promote [code reuse](https://code.pieces.app/blog/making-code-reuse-and-reference-seamless).

## 9. Null Safety with !! Operator

Although not recommended, the double exclamation mark (`!!`) operator can be used to assert that an expression is not null. It throws a `NullPointerException` if the expression evaluates to null.

```
val length = nullableString!!.length
```

[Save this code](https://sophyia.pieces.cloud/?p=2a06479494)

Use Case: Exercise caution when using the `!!` operator, as it bypasses null safety checks and can lead to runtime exceptions.

## 10. Default Arguments

Default arguments in Kotlin allow you to specify default values for function parameters. This means that when you call a function without providing values for certain parameters, those parameters will be initialized with their default values.

Default arguments, like this Kotlin snippet, provide a convenient way to define functions with a varying number of parameters while allowing callers to omit some of them if they're not necessary. Kotlin supports default arguments in function parameters, allowing the omission of arguments when calling functions.

```
fun greet(name: String = "World") {
 println("Hello, $name!")
}
greet() // Output: Hello, World!
```

[Save this code](https://sophyia.pieces.cloud/?p=b1494295d7)

Use Case: Utilize default arguments to define flexible function interfaces and simplify function calls.

## Bonus Snippet: Inline Functions

Inline functions in Kotlin are marked with the `inline` keyword and are expanded at the call site, reducing the overhead of function calls.

```
inline fun performOperation(value: Int, operation: (Int) -> Int): Int { return operation(value) }

val result = performOperation(5) { it * it }
```

[Save this code snippet](https://sophyia.pieces.cloud/?p=194747aaf4)

Use Case: Use inline functions to improve performance by eliminating the overhead of function calls for small functions or lambdas.

## Conclusion

Kotlin's powerful features empower developers to write concise, expressive, and safe code. By leveraging Kotlin snippets like the Elvis operator, extension functions, and higher-order functions, developers can enhance productivity and maintainability.

Understanding and mastering these features is key to unlocking the full potential of Kotlin and building robust applications efficiently. Experiment with these Kotlin code snippets in your projects, and witness firsthand the elegance and efficiency of Kotlin programming.

With this we conclude our curated selection of top-notch Kotlin boilerplate snippets — a valuable resource for both experienced Kotlin developers and beginners alike.

To streamline your coding journey and enhance your learning curve, the [Pieces Web Extension](https://docs.pieces.app/extensions-plugins/chrome) offers a convenient feature. With just a few clicks, you can effortlessly copy and save any of these Kotlin boilerplate code snippets from our list, ensuring quick access whenever you require them.

What's even more intriguing is that by saving a snippet in Pieces, you'll gain deeper insights into these boilerplate Kotlin snippets, including tags, context, and relevant links. Why not give it a try? Simply click one of the links above to save the code snippets, enriched with tags and all the context you need, saved into a personal, on-device repository. First you need to [install the Pieces Desktop App](https://docs.pieces.app/installation-getting-started/what-am-i-installing).

We trust that this article has provided you with a solid understanding of useful Kotlin boilerplate snippets and when to apply them in your projects. You can find more useful snippets for other languages with our [snippet collections](https://code.pieces.app/collections).