Book Overview & Buying
Table Of Contents
Feedback & Rating

Kotlin Standard Library Cookbook

By : Urbanowicz

Buy this Book

Kotlin Standard Library Cookbook

By: Urbanowicz

Buy this Book

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.

Preface

Who this book is for

What this book covers

To get the most out of this book

Sections

Get in touch

Free Chapter

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

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

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

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

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

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

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

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

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

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

5 star

4 star

3 star

2 star

1 star

Implementing delegated class properties

Class properties in Kotlin are more than just plain class fields. The key characteristic of Kotlin properties is the fact that their values are specified by accessor functions automatically. Each class property in Kotlin has a dedicated set of accessor functions available out of the box. By default, the Kotlin compiler generates a field storing the value of the property and its getters or setters as well. Each immutable val property has a corresponding get() function provided and the mutable one declared with var keyword has the set() function in addition to a get() as well. We are also able to override a default implementation of the accessor function, which makes a property highly customizable and powerful. For example, we can override the get() function of the property and provide a custom implementation for it, which can stop the compiler...