Book Image

Kotlin Standard Library Cookbook

By : Samuel Urbanowicz
Book Image

Kotlin Standard Library Cookbook

By: Samuel Urbanowicz

Overview of this book

For developers who prefer a more simplistic approach to coding, Kotlin has emerged as a valuable solution for effective software development. The Kotlin standard library provides vital tools that make day-to-day Kotlin programming easier. This library features core attributes of the language, such as algorithmic problems, design patterns, data processing, and working with files and data streams. With a recipe-based approach, this book features coding solutions that you can readily execute. Through the book, you’ll encounter a variety of interesting topics related to data processing, I/O operations, and collections transformation. You’ll get started by exploring the most effective design patterns in Kotlin and understand how coroutines add new features to JavaScript. As you progress, you'll learn how to implement clean, reusable functions and scalable interfaces containing default implementations. Toward the concluding chapters, you’ll discover recipes on functional programming concepts, such as lambdas, monads, functors, and Kotlin scoping functions, which will help you tackle a range of real-life coding problems. By the end of this book, you'll be equipped with the expertise you need to address a range of challenges that Kotlin developers face by implementing easy-to-follow solutions.

Related Content you might be interested in

Current Title:

Small book image
Kotlin Standard Library Cookbook
Samuel Urbanowicz
Jul, 2018 | 242 pages
Small book image
Android Development with Kotlin
Igor Wojda | Marcin Moskala
Aug, 2017 | 440 pages
Small book image
Mastering Kotlin
Nate Ebel
Oct, 2019 | 434 pages
Small book image
Kotlin Quick Start Guide
Marko Devcic
Aug, 2018 | 178 pages
Table of Contents (11 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Sections
Get in touch
Free Chapter
1
Ranges, Progressions, and Sequences
Ranges, Progressions, and Sequences
Introduction
Exploring the use of range expressions to iterate through alphabet characters
Traversing through ranges using progression with a custom step value
Building custom progressions to traverse dates
Using range expressions with flow control statements
Discovering the concept of sequences
Applying sequences to solve algorithmic problems
2
Expressive Functions and Adjustable Interfaces
Expressive Functions and Adjustable Interfaces
Introduction
Declaring adjustable functions with default parameters
Declaring interfaces containing default implementations
Extending functionalities of classes
Destructuring types
Returning multiple data
Inlining parameters of closure type
Infix notations for functions
Smart types checking with generic reified parameters
Overloading operators
3
Shaping Code with Kotlin Functional Programming Features
Shaping Code with Kotlin Functional Programming Features
Introduction
Working effectively with lambda expressions
Discovering basic scoping functions – let, also, apply
Initializing objects the clean way using the run scoping function
Working with higher-order functions
Functions currying
Function composition
Implementing the Either Monad design pattern
Approach to automatic functions memoization
4
Powerful Data Processing
Powerful Data Processing
Introduction
Composing and consuming collections the easy way
Filtering datasets
Automatic null removal
Sorting data with custom comparators
Building strings based on dataset elements
Dividing data into subsets
Data transformation with map and flatMap
Folding and reducing data sets
Grouping data
5
Tasteful Design Patterns Adopting Kotlin Concepts
Tasteful Design Patterns Adopting Kotlin Concepts
Introduction
Implementing the Strategy pattern
Exploring the power of the Delegation pattern
Implementing delegated class properties
Tracking state with the Observer pattern
Restricting property updates with the Vetoable delegate
Implementing the advanced Observer pattern by defining a custom property delegate
Working with the Lazy delegate
Implementing builders the smart way
6
Friendly I/O Operations
Friendly I/O Operations
Introduction
Reading the contents of a file
Ensuring stream closing with the use function
Reading the contents of a file line by line
Writing the contents to a file
Appending a file
Easy file copying
Traversing files in a directory
7
Making Asynchronous Programming Great Again
Making Asynchronous Programming Great Again
Introduction
Executing tasks in the background using threads
Background threads synchronization
Using coroutines for asynchronous, concurrent execution of tasks
Using coroutines for asynchronous, concurrent tasks execution with results handling
Applying coroutines for asynchronous data processing
Easy coroutine cancelation
Building a REST API client with Retrofit and a coroutines adapter
Wrapping third-party callback-style APIs with coroutines
8
Best Practices for the Android, JUnit, and JVM UI Frameworks
Best Practices for the Android, JUnit, and JVM UI Frameworks
Introduction
Clean and safe view-binding with the Android Extensions plugin
Applying coroutines for asynchronous UI programming on Android, JavaFX, and Swing
Easy class serialization on Android using the @Parcelize annotation
Implementing a custom property delegate that provides lifecycle-aware values
Easy operations on SharedPreferences
Less boilerplate Cursor data parsing
Mocking dependencies with the Mockito Kotlin library
Verifying function invocations
Unit tests for Kotlin coroutines
9
Miscellaneous
Miscellaneous
Introduction
Kotlin and Java interoperability
Kotlin and JavaScript interoperability
Renaming generated functions
Decompiling Kotlin code to Java and JVM bytecode
Adding custom names for imports
Wrapping complex type declarations with type aliases
Expressive try...catch declarations
Safe type-casting
10
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think

Declaring adjustable functions with default parameters

When creating new functions, we often need to allow some of their parameters to be optional. This forces us to use method overloading to create multiple function declarations with the same name but different sets of arguments related to different use cases and scenarios. Usually, under the hood, each variant of the function is calling the base function with the default implementation. Let's consider a simple example of a function that calculates a displacement of an object moving with a constant acceleration rate:

fun calculateDisplacement(initialSpeed: Float, 
                          acceleration: Float, 
                          duration: Long): Double =
    initialSpeed * duration + 0.5 * acceleration * duration * duration

We might also need to provide a displacement calculation for the scenario where the initial speed...

Previous Section
End of Section 3
Next Section